[Java知识库] SpringBoot的自动装配

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> SpringBoot的自动装配 -> 正文阅读

[Java知识库]SpringBoot的自动装配

SpringBoot的自动装配

大致流程

当启动SpringBoot应用程序的时候，会先创建SpringApplication对象，在构造方法中会进行一些参数的初始化工作，比如会加载Spring.factories文件，将文件的内容放到缓存对象中，方便后续获取
SpringApplication对象创建完成后，开始调用run方法，启动过程中最主要有两个方法，第一个叫prepareContext()，第二个叫refreshContext()方法
在prepareContext()方法主要是对上下文对象ConfigurableApplicationContext的初始化操作，在整个过程中有个非常重要的方法就是load()方法，它会将当前启动类作为一个BeanDefinition注册到BeanDefinitionMap中，方便后续在进行BeanFactoryPostProcessor调用执行的时候，找到对应的启动类，来完成对应注解的解析工作
在refreshContext()方法会进行整个Spring容器的刷新refresh操作，会调用spring的refresh()方法，自动装配过程是在invokeBeanFactoryPostProcessor方法()中进行（也就是执行BeanFactory的后置处理器），在此方法主要是针对ConfigurationClassPostProcessor类的处理
在执行BeanFactory后置处理器的时候会调用ConfigurationClassPostProcessor类中的parse()方法去解析处理各种注解比如@CompomentScan、@Import等等
在解析@Import注解的时候比较特别，会有一个collectImports()方法，从主类开始递归解析注解，把所有包含@Import的注解都解析到BeanDefinitionMap中
调用AutoConfigurationImportSelector类（相当于一个处理器）中的process()方法进而触发getCandidateConfigurations()方法获取Spring.factories文件下的key为EnableAutoConfiguration的所有value，所以这就是为什么很多人的文章中都说Springboot的自动装配就是调用@EnableAutoConfiguration注解下的@Import中的AutoConfigurationImportSelector类，主要就是通过这种不断解析注解的方法去调用的

在这里插入图片描述

将所有解析到的注解的类都注册到BeanDifinitionMap中
至此就完成了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);
    }
}