关于springboot:SpringBoot自动装配流程

SpringBoot重要的几个注解
SpringBootApplication外面包含 EnableAutoConfiguration、SpringBootConfiguration、ComponentScan

EnableAutoConfiguration：启动主动拆卸
AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class) 主动拆卸导入类
ComponentScan：包扫描,默认是启动类以后包

SpringBoot启动 –SpringApplication.run(<以后启动类>,arg)–以后主动类(primarySource)–prepareContext()容器事后初始化工作–load 加载以后启动类
–refreshContext(相熟的refresh办法,Spring容器创立以及初始化相干操作)– invokeBeanFactoryPostProcessors(beanFactory);
执行BeanFactoryPostProcessors办法
执行
invokeBeanFactoryPostProcessors中重要一步 BeanDefinitionRegistryPostProcessor bean定义信息处理器 实现类
ConfigurationClassPostProcessor（重要）实现了 postProcessBeanDefinitionRegistry
processConfigBeanDefinitions 配置Bean的定义信息
doProcessConfigurationClass 解析Configuration注解

processImports(configClass, sourceClass, getImports(sourceClass), true);
// 递归的解析配置类的注解 蕴含import
private void collectImports(SourceClass sourceClass, Set<SourceClass> imports, Set<SourceClass> visited)
            throws IOException {

        if (visited.add(sourceClass)) {
            for (SourceClass annotation : sourceClass.getAnnotations()) {
                String annName = annotation.getMetadata().getClassName();
                if (!annName.equals(Import.class.getName())) {
                    collectImports(annotation, imports, visited);
                }
            }
            imports.addAll(sourceClass.getAnnotationAttributes(Import.class.getName(), "value"));
        }
    }
    
///执行
this.deferredImportSelectorHandler.process();
    
    public void process() {
            List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
            this.deferredImportSelectors = null;
            try {
                if (deferredImports != null) {
                    DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
                    deferredImports.sort(DEFERRED_IMPORT_COMPARATOR);
                    deferredImports.forEach(handler::register);
                    //开始执行Import注解
                    handler.processGroupImports();
                }
            }
            finally {
                this.deferredImportSelectors = new ArrayList<>();
            }
        }

    }
//执行办法    
public void processGroupImports() {
            for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {      //这步
                grouping.getImports().forEach(entry -> {
                    ConfigurationClass configurationClass = this.configurationClasses.get(
                            entry.getMetadata());
                    try {
                        processImports(configurationClass, asSourceClass(configurationClass),
                                asSourceClasses(entry.getImportClassName()), false);
                    }
                    catch (BeanDefinitionStoreException ex) {
                        throw ex;
                    }
                    catch (Throwable ex) {
                        throw new BeanDefinitionStoreException(
                                "Failed to process import candidates for configuration class [" +
                                        configurationClass.getMetadata().getClassName() + "]", ex);
                    }
                });
            }
        }
//下一步
public Iterable<Group.Entry> getImports() {
            for (DeferredImportSelectorHolder deferredImport : this.deferredImports) {
//实现类     AutoConfigurationImportSelector            this.group.process(deferredImport.getConfigurationClass().getMetadata(),
                        deferredImport.getImportSelector());
            }
            return this.group.selectImports();
        }            

//AutoConfigurationImportSelector 实现类
@Override
        public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
            Assert.state(deferredImportSelector instanceof AutoConfigurationImportSelector,
                    () -> String.format("Only %s implementations are supported, got %s",
                            AutoConfigurationImportSelector.class.getSimpleName(),
                            deferredImportSelector.getClass().getName()));
            AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
//获取         AutoConfigurationEntry            .getAutoConfigurationEntry(getAutoConfigurationMetadata(), annotationMetadata);
            this.autoConfigurationEntries.add(autoConfigurationEntry);
            for (String importClassName : autoConfigurationEntry.getConfigurations()) {
                this.entries.putIfAbsent(importClassName, annotationMetadata);
            }
        }
//下一步 这步就开始清晰了
    protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
            AnnotationMetadata annotationMetadata) {
        if (!isEnabled(annotationMetadata)) {
            return EMPTY_ENTRY;
        }
        AnnotationAttributes attributes = getAttributes(annotationMetadata);
        //主动拆卸开始
        List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
        configurations = removeDuplicates(configurations);
        Set<String> exclusions = getExclusions(annotationMetadata, attributes);
        checkExcludedClasses(configurations, exclusions);
        configurations.removeAll(exclusions);
        configurations = filter(configurations, autoConfigurationMetadata);
        fireAutoConfigurationImportEvents(configurations, exclusions);
        return new AutoConfigurationEntry(configurations, exclusions);
    }        
// getCandidateConfigurations办法
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
        List<String> configurations = 
//getSpringFactoriesLoaderFactoryClass 就是获取 EnableAutoConfiguration.class这个主动拆卸类
//SpringFactoriesLoader    加载默认目录 META-INF/spring.factories 上面 加载主动拆卸EnableAutoConfiguration 这种类型的bean 此时加载的只是作为bean的定义信息    SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
                getBeanClassLoader());
        Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you "
                + "are using a custom packaging, make sure that file is correct.");
        return configurations;
    }

加载bean的定义信息到beanfactory 
接下来就是 Beanfactory 执行bean的生命周期流程    
                
                                

总结：SpringBoot启动 SpringApplication.run办法传入以后启动类primarySources
加载以后配置类 在refreshContext中invokeBeanFactoryPostProcessors 执行BeanFactoryPostProcessors(ConfigurationClassPostProcessor) 加载那些主动配置的bean的定义信息、加载实现 执行后续的beanfactory创立bean的流程