SpringBoot的自动装配

• • • • 大致流程
      • 完整流程（结合源码）
      • • 启动类
        • SpringApplication的构造方法
        • run方法
        • prepareContext()方法
        • load()方法
        • refreshContext()方法
        • refresh()方法
        • invokeBeanFactoryPostProcessors()方法
        • ConfigurationClassPostProcessor类中的processConfigBeanDefinitions()方法
        • ConfigurationClassParser类中的parse()方法
        • ConfigurationClassParser类中的doProcessConfigurationClass()方法
        • AutoConfigurationImportSelector类中的process()方法
        • 至此，springboot的自动装配就完成了

大致流程

1. 当启动SpringBoot应用程序的时候，会先创建SpringApplication对象，在构造方法中会进行一些参数的初始化工作，比如会加载Spring.factories文件，将文件的内容放到缓存对象中，方便后续获取

2. SpringApplication对象创建完成后，开始调用run方法，启动过程中最主要有两个方法，第一个叫prepareContext()，第二个叫refreshContext()方法

3. 在prepareContext()方法主要是对上下文对象ConfigurableApplicationContext的初始化操作，在整个过程中有个非常重要的方法就是load()方法，它会将当前启动类作为一个BeanDefinition注册到BeanDefinitionMap中，方便后续在进行BeanFactoryPostProcessor调用执行的时候，找到对应的启动类，来完成对应注解的解析工作

4. 在refreshContext()方法会进行整个Spring容器的刷新refresh操作，会调用spring的refresh()方法，自动装配过程是在invokeBeanFactoryPostProcessor方法()中进行（也就是执行BeanFactory的后置处理器），在此方法主要是针对ConfigurationClassPostProcessor类的处理

5. 在执行BeanFactory后置处理器的时候会调用ConfigurationClassPostProcessor类中的parse()方法去解析处理各种注解比如@CompomentScan、@Import等等

6. 在解析@Import注解的时候比较特别，会有一个collectImports()方法，从主类开始递归解析注解，把所有包含@Import的注解都解析到BeanDefinitionMap中

7. 调用AutoConfigurationImportSelector类（相当于一个处理器）中的process()方法进而触发getCandidateConfigurations()方法获取Spring.factories文件下的key为EnableAutoConfiguration的所有value，所以这就是为什么很多人的文章中都说Springboot的自动装配就是调用@EnableAutoConfiguration注解下的@Import中的AutoConfigurationImportSelector类，主要就是通过这种不断解析注解的方法去调用的

8. 将所有解析到的注解的类都注册到BeanDifinitionMap中

9. 至此就完成了SpringBoot的自动装配

完整流程（结合源码）

启动类

@SpringBootApplication
public class Test {
    public static void main(String[] args) {
        SpringApplication.run(Test.class, args);
        System.out.println("启动成功");
    }
}

SpringApplication的构造方法

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
    // 初始化
    this.resourceLoader = resourceLoader;
    Assert.notNull(primarySources, "PrimarySources must not be null");
    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
    this.webApplicationType = WebApplicationType.deduceFromClasspath();
    // 加载Spring.factories文件，将文件的内容放到缓存对象中，方便后续获取
    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
    // 设置监听器
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    // 将mainApplicationClass属性设置为当前类Test的Clas对象
    this.mainApplicationClass = deduceMainApplicationClass();
}

run方法

public ConfigurableApplicationContext run(String... args) {
    // 省略代码
    try {
        // 准备环境，这里的environment环境包括系统环境，比如jvm的参数等等
        ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
        // 准备Banner，即每次启动项目的时候控制台都会出现一个很大的图像
        Banner printedBanner = printBanner(environment);
        // 创建上下文对象
        context = createApplicationContext();
        // 准备上下文对象
        prepareContext(context, environment, listeners, applicationArguments, printedBanner);
        // 刷新上下文对象
        refreshContext(context);
        // 省略代码
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, exceptionReporters, listeners);
        throw new IllegalStateException(ex);
    }
}

prepareContext()方法

准备上下文对象，将springApplicationArguments对象和springBootBanner对象放入Spring一级缓存singletonObjects中

private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment,
                            SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
    // 省略代码
    
    // 获取Beanfactory对象
    ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
    // 将springApplicationArgusments放到一级缓存中
    beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
    // 将springBootBanner放到一级缓存中
    if (printedBanner != null) {
        beanFactory.registerSingleton("springBootBanner", printedBanner);
    }
    // 加载资源，也就是将当前的启动类Test Class对象放到Set中
    Set<Object> sources = getAllSources();
    // 见下
    load(context, sources.toArray(new Object[0]));
    // 将上下文加载到监听器中
    listeners.contextLoaded(context);
}

load()方法

将当前启动类作为一个BeanDefinition加载到BeanDefinitionMap中，方便后续在进行BeanFactoryPostProcessor调用执行的时候，找到对应的启动类，来完成对应注解的解析工作

private int load(Class<?> source) {
    // 判断启动类上有没有@Component注解
    if (isComponent(source)) {
        // 若有则将当前启动类作为一个BeanDefinition注册到BeanDifinitionMap中
        this.annotatedReader.register(source);
        return 1;
    }
    return 0;
}

refreshContext()方法

执行完prepareContext()方法后，调用Spring的刷新容器方法refresh()

private void refreshContext(ConfigurableApplicationContext context) {
    // 调用Spring的刷新容器方法
    refresh(context);
}

refresh()方法

这个方法相信大家非常熟悉了吧，那完成Springboot自动装配过程是在哪个阶段发生的呢？其实就是在invokeBeanFactoryPostProcessors()方法实现的

// 伪代码，方法在AbstractApplicationContext类中
public void refresh() throws BeansException, IllegalStateException {
    // 执行BeanFactory的后置处理器，自动装配中此方法主要是针对ConfigurationClassPostProcessor类的处理
    invokeBeanFactoryPostProcessors(beanFactory);
}

invokeBeanFactoryPostProcessors()方法

这里主要就是处理BeanFactory后置处理器，也就是直接或者间接实现BeanFactoryPostProcessor的接口的类，主要调用的是ConfigurationClassPostProcessor中的postProcessBeanDefinitionRegistry()方法

public static void invokeBeanFactoryPostProcessors(
    ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

    if (beanFactory instanceof BeanDefinitionRegistry) {
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;

        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                BeanDefinitionRegistryPostProcessor registryProcessor =
                    (BeanDefinitionRegistryPostProcessor) postProcessor;
                // 主要就是这个方法
                registryProcessor.postProcessBeanDefinitionRegistry(registry);
            }
        }
    }
}

ConfigurationClassPostProcessor类中的processConfigBeanDefinitions()方法

此方法作用就是去解析处理各种注解比如@CompomentScan、@Import等等注解

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
    // ...
    
    List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
    // 获取对应的BeanDifinitionMap中的BeanDefinitionName
    String[] candidateNames = registry.getBeanDefinitionNames();

    // 创建注解解析器
    ConfigurationClassParser parser = new ConfigurationClassParser(
        this.metadataReaderFactory, this.problemReporter, this.environment,
        this.resourceLoader, this.componentScanBeanNameGenerator, registry);

    Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
    Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
    do {
        // 进行注解解析
        parser.parse(candidates);
    } while (!candidates.isEmpty());
    
    // ...
}

ConfigurationClassParser类中的parse()方法

解析注解的入口

public void parse(Set<BeanDefinitionHolder> configCandidates) {
    for (BeanDefinitionHolder holder : configCandidates) {
        BeanDefinition bd = holder.getBeanDefinition();
        if (bd instanceof AnnotatedBeanDefinition) {
            // 具体的解析注解的方法
            parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
        }
    }

    this.deferredImportSelectorHandler.process();
}

ConfigurationClassParser类中的doProcessConfigurationClass()方法

到达解析注解的最终方法，将解析到的Bean注册到BeanDifinitionMap中

protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
    throws IOException {

    // 解析@PropertySource注解
    for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
        sourceClass.getMetadata(), PropertySources.class,
        org.springframework.context.annotation.PropertySource.class)) {
        if (this.environment instanceof ConfigurableEnvironment) {
            processPropertySource(propertySource);
        }
        else {
            logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
                        "]. Reason: Environment must implement ConfigurableEnvironment");
        }
    }

    // 解析@ComponentScan注解
    Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
        sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
    if (!componentScans.isEmpty() &&
        !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
        for (AnnotationAttributes componentScan : componentScans) {
            // The config class is annotated with @ComponentScan -> perform the scan immediately
            Set<BeanDefinitionHolder> scannedBeanDefinitions =
                this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
            // Check the set of scanned definitions for any further config classes and parse recursively if needed
            for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
                BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
                if (bdCand == null) {
                    bdCand = holder.getBeanDefinition();
                }
                if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
                    parse(bdCand.getBeanClassName(), holder.getBeanName());
                }
            }
        }
    }

    // 解析@Import注解
    processImports(configClass, sourceClass, getImports(sourceClass), true);

    // 解析@ImportResource注解
    AnnotationAttributes importResource =
        AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
    if (importResource != null) {
        String[] resources = importResource.getStringArray("locations");
        Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
        for (String resource : resources) {
            String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
            configClass.addImportedResource(resolvedResource, readerClass);
        }
    }

    // 解析@Bean注解
    Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
    for (MethodMetadata methodMetadata : beanMethods) {
        configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
    }

    return null;
}

AutoConfigurationImportSelector类中的process()方法

这里的作用是读取Spring.factories文件中的内容，将所有的第三方的starter装载到BeanDefinitionMap中

public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
    
    // getAutoConfigurationEntry()方法读取Spring.factories文件中的内容入口
    AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
        .getAutoConfigurationEntry(getAutoConfigurationMetadata(), annotationMetadata);
    
    this.autoConfigurationEntries.add(autoConfigurationEntry);
    for (String importClassName : autoConfigurationEntry.getConfigurations()) {
        this.entries.putIfAbsent(importClassName, annotationMetadata);
    }
}

至此，springboot的自动装配就完成了

创作不易，希望大家能够点个赞，也希望大家能帮忙指出问题，一起进步！！！谢谢大家~~