SpringBoot的自动装配机制（最新SpringBoot 2.6.3）

​SpringBoot3.0都要出了，据说JDK最低要求17？？？我滴乖乖，JDK8还没整明白呢，先学习一下SpringBoot压压惊。

一、什么是SpringBoot

官方描述：

翻译：

通过Spring Boot，可以轻松地创建独立的，基于生产级别的基于Spring的应用程序，并且可以“运行”它们其实Spring Boot的设计是为了让你尽可能快的跑起来Spring应用程序并且尽可能减少你的配置文件。

二、SpringBoot的特征

①SpringBoot Starter：他将常用的依赖分组进行了整合，将其合并到一个依赖中，这样就可以一次性添加到项目的Maven或Gradle构建中。

②使编码变得简单，SpringBoot采用 JavaConfig的方式对Spring进行配置，并且提供了大量的注解，极大地提高了工作效率。

③自动配置：SpringBoot的自动配置特性利用了Spring对条件化配置的支持，合理地推测应用所需的bean并自动化配置他们。

④使部署变得简单，SpringBoot内置了三种Servlet容器，Tomcat，Jetty，undertow。我们只需要一个Java的运行环境就可以跑SpringBoot的项目，SpringBoot的项目可以打成一个jar包。

三、SpringBoot的项目搭建

学习SpringBoot的自动装配必然从Spring的主入口类开始进行。建立一个SpringBoot的测试项目SpringBootTest，并导入SpringMVC的起步依赖，观察如何进行的自动装配。

@RestControllerpublic class TestController {    @RequestMapping("/test")    public String testMethod() {        return "测试SpringBoot";    }}

四、SpringBoot的自动装配机制

    想要分析SpringBoot的自动装配机制，必然要从SpringBoot的主启动类入手，主启动类只有一个run方法和一个@SpringBootApplication注解，我们先分析一下@SpringBootApplication注解，方便后续源码的解读。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
    @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication { 
  
  /**
  * 根据class来排除特定的类，使其不能加入spring容器，传入参数value类型是class类型。
  */
  @AliasFor(annotation = EnableAutoConfiguration.class)
  Class<?>[] exclude() default {};
​
  /**
  * 根据classname来排除特定的类，使其不能加入spring容器，传入参数value类型是class的全类名字符串数组。
  */
  @AliasFor(annotation = EnableAutoConfiguration.class)
  String[] excludeName() default {};
​
  /**
  * 指定扫描包，参数是包名的字符串数组。
  */
  @AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
  String[] scanBasePackages() default {};
  
  /**
  * 扫描特定的包，参数类似是Class类型数组。
  */
  @AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")
  Class<?>[] scanBasePackageClasses() default {};
}

其中@Target、@Retention、@Documented、@Inherited是自定义注解的四个元注解。

@Target：表示注解的适用范围

@Retention：表示注解的生命周期

@Document：表示注解可以记录在javadoc中

@Inherited：表示子类可以继承该注解

@SpringBootConfiguration：表示该类为一个配置类

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration  //实际上就是一个配置类
@Indexed
public @interface SpringBootConfiguration {
  ...
}

@EnableAutoConfigration：启动自动装配功能

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage 
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
  ...
}
​
​
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {
  ...
}

在EnableAutoConfiguration中有两个注解分别使用了@Import注解导入相应的类。@Import注解是Spring提供的注解，用来导入配置类或者一些需要前置加载的类。

@ComponentSacn：扫描路径，默认扫描该类的包及其子包
五、run方法的执行流程

简单介绍完@SpringBootApplication注解后，我们开始介绍SpringBoot的run方法。

Tips：本文采用SpringBoot2.6.3。小伙伴可以自身调整，但总体流程变化不大。可以边看边跟着一步一步Debug。

public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
  return run(new Class<?>[] { primarySource }, args);
}
​
public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
  return new SpringApplication(primarySources).run(args);
}

我们可以看到执行run方法有两个步骤：第一步实例化SpringApplication对象，第二步执行run方法。

（1）实例化SpringApplication：

public SpringApplication(Class<?>... primarySources) {
  this(null, primarySources);
}
​
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
  //设置资源加载器为null
  this.resourceLoader = resourceLoader;
  //断言资源类不可以为null 此时使我们传递的SpringbootTestApplication.class
  Assert.notNull(primarySources, "PrimarySources must not be null");
  //封装到一个linkedHashSet中
  this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
  //推断当前的应用类型 一般都是servlet
  this.webApplicationType = WebApplicationType.deduceFromClasspath();
  //初始化classpath下 META-INF/spring.factories中已配置的
  //key是BootstrapRegistryInitializer的类
  this.bootstrapRegistryInitializers = new ArrayList<>(
      getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
  //初始化classpath下 META-INF/spring.factories中已配置的
  //key是ApplicationContextInitializer的类
  setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
  //初始化classpath下 META-INF/spring.factories中已配置的
  //key是ApplicationListener的类
  setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
  //根据调用栈，推断出 main 方法的类名
  this.mainApplicationClass = deduceMainApplicationClass();
}

在SpringApplication的构造方法中，有一个最重要的方法就是：getSpringFactoriesInstances，最终会调用loadSpringFactories拿到所有的key和value封装到一个Map<String, List<String>>容器中，通过想要的key获取所有的value，然后创建Spring的工厂实例排序后返回。

查看一下META-INF下的spring.factories文件，就是key和value组成的键值对。

我们可以Debug看一下loadSpringFactories执行结果

（2）执行run方法

/**
 * 运行spring应用，并刷新一个新的ApplicationContext（Spring的上下文）
 * ConfigurableApplicationContext是ApplicationContext接口的子接口。
 * 在ApplicationContext基础上增加了配置上下文的工具。
 */
public ConfigurableApplicationContext run(String... args) {
  //记录程序运行时间
  long startTime = System.nanoTime();
  //创建一个默认的上下文
  DefaultBootstrapContext bootstrapContext = createBootstrapContext();
  //创建spring的上下文
  ConfigurableApplicationContext context = null;
  configureHeadlessProperty();
  //从META-INF/spring.factories中获取监听器
  //key为 SpringApplicationRunListener.class
  SpringApplicationRunListeners listeners = getRunListeners(args);
  //启动监听器
  listeners.starting(bootstrapContext, this.mainApplicationClass);
  try {
    ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
    //构造应用上下文环境
    ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
    //处理需要忽略的bean
    configureIgnoreBeanInfo(environment);
    //打印banner 就是SpringBoot的启动图标，可以自定义
    Banner printedBanner = printBanner(environment);
    //初始化应用上下文
    context = createApplicationContext();
    context.setApplicationStartup(this.applicationStartup);
    //刷新应用上下文前的准备阶段
    prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
    //刷新应用上下文
    refreshContext(context);
    //刷新应用上下文后的扩展接口 模板模式的体现，此处是空实现
    afterRefresh(context, applicationArguments);
    Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
    if (this.logStartupInfo) {
      new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
    }
    //发布容器启动完成事件
    listeners.started(context, timeTakenToStartup);
    callRunners(context, applicationArguments);
  }
  catch (Throwable ex) {
    handleRunFailure(context, ex, listeners);
    throw new IllegalStateException(ex);
  }
  try {
    Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
    listeners.ready(context, timeTakenToReady);
  }
  catch (Throwable ex) {
    handleRunFailure(context, ex, null);
    throw new IllegalStateException(ex);
  }
  return context;
}

在run方法中，大致分为六步：获取并启动监听器、构造应用上下文环境、初始化应用上下文环境、刷新应用上下文文前的准备工作、刷新应用上下文、刷新应用上下文后的扩展方法。下面我们分别进行分析：

①获取并启动监听器getRunListeners。

事件机制在Spring是很重要的一部分内容，通过事件机制我们可以监听Spring容器中正在发生的一些事件，同样也可以自定义监听事件。

private SpringApplicationRunListeners getRunListeners(String[] args) {
  Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };
  return new SpringApplicationRunListeners(logger,
      getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args),
      this.applicationStartup);
}

观察发现还是调用getSpringFactoriesInstances方法，对META-INF的spring.factories文件进行读取。

②构建应用上下文环境prepareEnvironment。

包括计算机的环境，Java环境，Spring的运行环境，还有咱们自己的application.yml(application.properties)配置文件

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
    DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
  // Create and configure the environment
  //创建并配置相应的环境
  ConfigurableEnvironment environment = getOrCreateEnvironment();
  //根据用户配置，配置environment系统环境 就是封装一下我们传入的args  configureEnvironment(environment, applicationArguments.getSourceArgs());
  ConfigurationPropertySources.attach(environment);
  //启动相应的监听器，其中最重要的
  //EnvironmentPostProcessorApplicationListener加载配置文件
  listeners.environmentPrepared(bootstrapContext, environment);
  DefaultPropertiesPropertySource.moveToEnd(environment);
  Assert.state(!environment.containsProperty("spring.main.environment-prefix"),
      "Environment prefix cannot be set via properties.");
  bindToSpringApplication(environment);
  if (!this.isCustomEnvironment) {
    environment = convertEnvironment(environment);
  }
  ConfigurationPropertySources.attach(environment);
  return environment;
}

我们Debug来看一下效果。

没有执行listeners.environmentPrepared

执行完之后，多了我们的配置文件中的属性。

在启动监听器时，

SpringBoot2.4.0之后废弃了ConfigFileApplicationListener，3.0就会被移除。

/**
 * @deprecated since 2.4.0 for removal in 3.0.0 in favor of
 * {@link ConfigDataEnvironmentPostProcessor}
 */
@Deprecated
public class ConfigFileApplicationListener

然后改用了EnvironmentPostProcessorApplicationListener来加载我们的配置文件。小伙伴可以在此处进行深入Debug探究，此处就主线来说已经结束了。

③初始化应用上下文createApplicationContext。

在SpringBoot工程中，应用类型分为三种，如下代码所示。

public enum WebApplicationType {
​
  /**
   * 应用程序不是web应用，也不应该用web服务器去启动
   * The application should not run as a web application and should not start an
   * embedded web server.
   */
  NONE,
​
  /**
   * 应用程序应作为基于servlet的web应用程序运行，并应启动嵌入式servlet web（tomcat）服务器。
   * The application should run as a servlet-based web application and should start an
   * embedded servlet web server.
   */
  SERVLET,
​
  /**
   * 应用程序应作为 reactive web应用程序运行，并应启动嵌入式 reactive web服务器。
   * The application should run as a reactive web application and should start an
   * embedded reactive web server.
   */
  REACTIVE;
}

对应三种应用类型，SpringBoot项目有三种对应的应用上下文，我们以web工程为例，即其应用上下文为：

AnnotationConfigServletWebServerApplicationContext。

ApplicationContextFactory DEFAULT = (webApplicationType) -> {
  try {
    switch (webApplicationType) {
    case SERVLET:
      return new AnnotationConfigServletWebServerApplicationContext();
    case REACTIVE:
      return new AnnotationConfigReactiveWebServerApplicationContext();
    default:
      return new AnnotationConfigApplicationContext();
    }
  }
  catch (Exception ex) {
    throw new IllegalStateException("Unable create a default ApplicationContext instance, "
        + "you may need a custom ApplicationContextFactory", ex);
  }
};

应用上下文可以理解成IoC容器的高级表现形式，应用上下文确实是在IoC容器的基础上丰富了一些高级功能。应用上下文对IoC容器是持有的关系。属性beanFactory就是IoC容器DefaultListableBeanFactory。所以他们之间是持有和扩展的关系。

类AnnotationConfigServletWebServerApplicationContext继承了类GenericApplicationContext，GenericApplicationContext的构造方法中实例化了beanFactory（DefaultListableBeanFactory）。所以在此处也创建了IoC容器。我们Debug观察执行createApplicationContext()方法。

执行前：

执行后：

④刷新应用上下文前的准备工作prepareContext()

private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context,
    ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
    ApplicationArguments applicationArguments, Banner printedBanner) {
  //设置上下文环境
  context.setEnvironment(environment);
  //执行后置处理器
  postProcessApplicationContext(context);
  //执行上下文中的ApplicationContextInitializer
  applyInitializers(context);
  //向各个监听器发送上下文已经准备好的事件
  listeners.contextPrepared(context);
  bootstrapContext.close(context);
  if (this.logStartupInfo) {
    logStartupInfo(context.getParent() == null);
    logStartupProfileInfo(context);
  }
  // Add boot specific singleton beans
  //将main函数中的args参数封装成单例Bean，注册进容器
  ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
  beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
  //将printedBanner也封装成单例，注册进容器
  if (printedBanner != null) {
    beanFactory.registerSingleton("springBootBanner", printedBanner);
  }
  if (beanFactory instanceof AbstractAutowireCapableBeanFactory) {
    //设置是否允许循环引用
    ((AbstractAutowireCapableBeanFactory) beanFactory).setAllowCircularReferences(this.allowCircularReferences);
    if (beanFactory instanceof DefaultListableBeanFactory) {
      //设置是否允许覆盖bean
      ((DefaultListableBeanFactory) beanFactory)
          .setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
    }
  }
  //懒加载
  if (this.lazyInitialization) {
    context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
  }
  // Load the sources
  Set<Object> sources = getAllSources();
  Assert.notEmpty(sources, "Sources must not be empty");
  //加载启动类，将启动类注入容器
  load(context, sources.toArray(new Object[0]));
  //发布容器已加载事件
  listeners.contextLoaded(context);
}

getAllSources就是获取我们的主启动类

load(context, sources.toArray(new Object[0]))将我们的启动类注入到容器中。load方法将我们的对象封装为一个BeanDefinition后最终调用registerBeanDefinition()方法将对象注册到beanDefinitionMap中。

protected void load(ApplicationContext context, Object[] sources) {
  if (logger.isDebugEnabled()) {
    logger.debug("Loading source " + StringUtils.arrayToCommaDelimitedString(sources));
  }
  BeanDefinitionLoader loader = createBeanDefinitionLoader(getBeanDefinitionRegistry(context), sources);
  if (this.beanNameGenerator != null) {
    loader.setBeanNameGenerator(this.beanNameGenerator);
  }
  if (this.resourceLoader != null) {
    loader.setResourceLoader(this.resourceLoader);
  }
  if (this.environment != null) {
    loader.setEnvironment(this.environment);
  }
  loader.load();
}

load前：

load后：

⑤刷新应用上下文refreshContext()，也就是对IoC容器进行初始化。

对IoC容器进行初始化大致分为三步：BeanDefinitiond的Resource定位、BeanDefinition的载入、将BeanDefinition注册到IoC容器中。

在执行refreshContext，就是执行Spring的refresh方法，此时SpringBoot就是将Spring进行了一次封装，最终执行的还是refresh方法。

private void refreshContext(ConfigurableApplicationContext context) {
  if (this.registerShutdownHook) {
    shutdownHook.registerApplicationContext(context);
  }
  refresh(context);
}
​
protected void refresh(ConfigurableApplicationContext applicationContext) {
  applicationContext.refresh();
}
​
public void refresh() throws BeansException, IllegalStateException {
  synchronized (this.startupShutdownMonitor) {
    StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
    //刷新上下文环境
    prepareRefresh();
    
    //这里是在子类中启动refreshBeanFactory()的地方
    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
    //准备bean工厂，以便在此上下文中使用
    prepareBeanFactory(beanFactory);
    try {
      //设置 beanFactory 的后置处理器
      postProcessBeanFactory(beanFactory);
      StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
      //调用BeanFactory的后处理器，这些处理器是在Bean定义中向容器注册的
      invokeBeanFactoryPostProcessors(beanFactory);
      
      //注册Bean的后处理器，在Bean创建过程中调用
      registerBeanPostProcessors(beanFactory);
      beanPostProcess.end();
      
      //对上下文中的消息源进行初始化
      initMessageSource();
      
      //初始化上下文中的事件机制
      initApplicationEventMulticaster();
​
      //初始化其他特殊的Bean
      onRefresh();
​
      //检查监听Bean并且将这些监听Bean向容器注册
      registerListeners();
​
      //实例化所有的（non-lazy-init）单例
      finishBeanFactoryInitialization(beanFactory);
​
      //发布容器事件，结束Refresh过程
      finishRefresh();
    }
​
    catch (BeansException ex) {
      if (logger.isWarnEnabled()) {
        logger.warn("Exception encountered during context initialization - " +
            "cancelling refresh attempt: " + ex);
      }
​
      // Destroy already created singletons to avoid dangling resources.
      destroyBeans();
​
      // Reset 'active' flag.
      cancelRefresh(ex);
​
      // Propagate exception to caller.
      throw ex;
    }
​
    finally {
      // Reset common introspection caches in Spring's core, since we
      // might not ever need metadata for singleton beans anymore...
      resetCommonCaches();
      contextRefresh.end();
    }
  }
}

由于上述代码是Spring的源码，本次不进行解读，小伙伴感兴趣可继续深入研究细节，本人直接跳到和SpringBoot自动装配有关的方法invokeBeanFactoryPostProcessors进行解读。

在invokeBeanFactoryPostProcessors方法中，完成了对IoC容器的初始化。大致分为三步：

1>Resource资源定位

在SpringBoot中，我们知道包扫描是从主类开始的，在prepareContext方法中，已经将主类封装为BeanDefinition，然后在此方法中解析主类的BeanDefinition获取basePackage的路径，完成了资源的定位。其次SpringBoot的starter通过SPI机制实现自动装配，还有@Import注解指定的类也进行了定位加载。

2>BeanDefinition的载入

所谓载入就是通过上述定位的basePackage，SpringBoot将路径拼接为：classpath:com/study/**/.class这样的形式，然后进行加载，判断有没有@Component注解，有就装载BeanDefinition。

3>注册BeanDefinition

注册过程就是把载入过程中解析得到的BeanDefinition向IoC容器进行注册。一路跟踪会进入到ConfigurationClassParser的parse方法（由于Spring源码篇幅太多，不是本次的重点，直接给出调用栈）

public void parse(Set<BeanDefinitionHolder> configCandidates) {
  for (BeanDefinitionHolder holder : configCandidates) {
    BeanDefinition bd = holder.getBeanDefinition();
    try {
      if (bd instanceof AnnotatedBeanDefinition) {
        parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
      }
      else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
        parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
      }
      else {
        parse(bd.getBeanClassName(), holder.getBeanName());
      }
    }
    catch (BeanDefinitionStoreException ex) {
      throw ex;
    }
    catch (Throwable ex) {
      throw new BeanDefinitionStoreException(
          "Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
    }
  }
  //加载配置 （SpringBoot项目则 此处为SpringBoot自动装配的入口）
  this.deferredImportSelectorHandler.process();
}

再进入parse方法

protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
  processConfigurationClass(new ConfigurationClass(metadata, beanName), DEFAULT_EXCLUSION_FILTER);
}
​
protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
  if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
    return;
  }
​
  ConfigurationClass existingClass = this.configurationClasses.get(configClass);
  if (existingClass != null) {
    if (configClass.isImported()) {
      if (existingClass.isImported()) {
        existingClass.mergeImportedBy(configClass);
      }
      // Otherwise ignore new imported config class; existing non-imported class overrides it.
      return;
    }
    else {
      // Explicit bean definition found, probably replacing an import.
      // Let's remove the old one and go with the new one.
      this.configurationClasses.remove(configClass);
      this.knownSuperclasses.values().removeIf(configClass::equals);
    }
  }
​
  // Recursively process the configuration class and its superclass hierarchy.
  SourceClass sourceClass = asSourceClass(configClass, filter);
  do {
    sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
  }
  while (sourceClass != null);
​
  this.configurationClasses.put(configClass, configClass);
}

看到do开头的方法，有经验的小伙伴已经知道了这个方法是真正干活的方法(doProcessConfigurationClass)。

//此方法很长，小伙伴可以打开源码浏览，此处只截取片段
protected final SourceClass doProcessConfigurationClass(
    ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
    throws IOException {
    ...
    // Process any @ComponentScan annotations
    //根据 @ComponentScan 注解，扫描项目中的Bean（SpringBoot 启动类上有该注解）
    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
        //立即执行扫描，（SpringBoot项目为什么是从主类所在的包扫描，这就是关键 了）
        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 注解
    // Process any @Import annotations
    processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
    ...
}

在doProcessConfigurationClass方法中会对主类的@Component注解和@Import注解进行读取执行响应的逻辑。我们继续往下看

this.componentScanParser.parse方法

public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, String declaringClass) {
  ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
      componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);
  ...
  if (basePackages.isEmpty()) {
    basePackages.add(ClassUtils.getPackageName(declaringClass));
  }    
  ...
  return scanner.doScan(StringUtils.toStringArray(basePackages));
}

​

在进入doScan方法，将有@Component的类注入到容器中。

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
  Assert.notEmpty(basePackages, "At least one base package must be specified");
  Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
  for (String basePackage : basePackages) {
    //从指定的包中扫描需要装载的Bean
    Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
    for (BeanDefinition candidate : candidates) {
      ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
      candidate.setScope(scopeMetadata.getScopeName());
      String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
      if (candidate instanceof AbstractBeanDefinition) {
        postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
      }
      if (candidate instanceof AnnotatedBeanDefinition) {
        AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
      }
      if (checkCandidate(beanName, candidate)) {
        BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
        definitionHolder =
            AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
        beanDefinitions.add(definitionHolder);
        //将该 Bean 注册进 IoC容器（beanDefinitionMap）
        registerBeanDefinition(definitionHolder, this.registry);
      }
    }
  }
  return beanDefinitions;
}

我们看到解析完com.study包之后，testController被封装加载到。

然后就是重要的@Import解析

private Set<SourceClass> getImports(SourceClass sourceClass) throws IOException {
  Set<SourceClass> imports = new LinkedHashSet<>();
  Set<SourceClass> visited = new LinkedHashSet<>();
  collectImports(sourceClass, imports, visited);
  return imports;
}
​
//递归找到@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"));
  }
}

这里只是解析了@import，并没有进行处理。

我们回到ConfigurationClassParser的parse方法，在方法的最后会执行

// 去执行组件类 
this.deferredImportSelectorHandler.process();

进入process后一直进入到方法processGroupImports()

public void processGroupImports() {
  for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {
    Predicate<String> exclusionFilter = grouping.getCandidateFilter();
    grouping.getImports().forEach(entry -> {
      ConfigurationClass configurationClass = this.configurationClasses.get(entry.getMetadata());
      try {
        processImports(configurationClass, asSourceClass(configurationClass, exclusionFilter),
            Collections.singleton(asSourceClass(entry.getImportClassName(), exclusionFilter)),
            exclusionFilter, false);
      }
      catch (BeanDefinitionStoreException ex) {
        throw ex;
      }
      catch (Throwable ex) {
        throw new BeanDefinitionStoreException(
            "Failed to process import candidates for configuration class [" +
                configurationClass.getMetadata().getClassName() + "]", ex);
      }
    });
  }
}

此处调用了getImports()。

public Iterable<Group.Entry> getImports() {
  //遍历DeferredImportSelectorHolder对象集合deferredImports，
  //deferredImports集合装了各种ImportSelector，
  //当然这里装的是AutoConfigurationImportSelector
  for (DeferredImportSelectorHolder deferredImport : this.deferredImports) {
    //利用AutoConfigurationGroup的process方法来处理自动配置
    //的相关逻辑，决定导入哪些配置类
    this.group.process(deferredImport.getConfigurationClass().getMetadata(),
        deferredImport.getImportSelector());
  }
  //经过上面的处理后，然后再进行选择导入哪些配置类
  return this.group.selectImports();
}

然后就会调用类AutoConfigurationImportSelector中的内部类AutoConfigurationGroup中的process和selectImports方法。

@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()));
  //调用getAutoConfigurationEntry方法得到自动配置类放入 autoConfigurationEntry对象中       
  AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
      .getAutoConfigurationEntry(getAutoConfigurationMetadata(), annotationMetadata);
  //又将封装了自动配置类的autoConfigurationEntry对象装进 autoConfigurationEntries集合
  this.autoConfigurationEntries.add(autoConfigurationEntry);
  for (String importClassName : autoConfigurationEntry.getConfigurations()) {
    //这里符合条件的自动配置类作为key，annotationMetadata作为值放进entries集合
    this.entries.putIfAbsent(importClassName, annotationMetadata);
  }
}
​
@Override
public Iterable<Entry> selectImports() {
  if (this.autoConfigurationEntries.isEmpty()) {
    return Collections.emptyList();
  }
  Set<String> allExclusions = this.autoConfigurationEntries.stream()
      .map(AutoConfigurationEntry::getExclusions).flatMap(Collection::stream).collect(Collectors.toSet());
  Set<String> processedConfigurations = this.autoConfigurationEntries.stream()
      .map(AutoConfigurationEntry::getConfigurations).flatMap(Collection::stream)
      .collect(Collectors.toCollection(LinkedHashSet::new));
  processedConfigurations.removeAll(allExclusions);
​
  return sortAutoConfigurations(processedConfigurations, getAutoConfigurationMetadata()).stream()
      .map((importClassName) -> new Entry(this.entries.get(importClassName), importClassName))
      .collect(Collectors.toList());
}

进入getAutoConfigurationEntry方法

protected AutoConfigurationEntry getAutoConfigurationEntry(
        AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata) {
    //获取是否有配置spring.boot.enableautoconfiguration属性，默认返回true
    if (!isEnabled(annotationMetadata)) {
        return EMPTY_ENTRY;
    }
    //获得@Congiguration标注的Configuration类
    AnnotationAttributes attributes = getAttributes(annotationMetadata);
    //得到spring.factories文件配置的所有自动配置类
    List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
    //利用LinkedHashSet移除重复的配置类
    configurations = removeDuplicates(configurations);
    //得到要排除的自动配置类，比如注解属性exclude的配置类
    Set<String> exclusions = getExclusions(annotationMetadata, attributes);
    checkExcludedClasses(configurations, exclusions);
    //将要排除的配置类移除
    configurations.removeAll(exclusions);
    //因为从spring.factories文件获取的自动配置类太多，
    //如果有些不必要的自动配置类都加载 进内存，会造成内存浪费，
    //因此这里需要进行过滤,这里会调用AutoConfigurationImportFilter
    //的match方法来判断是否符合 @ConditionalOnBean,
    //@ConditionalOnClass或@ConditionalOnWebApplication
    configurations = filter(configurations, autoConfigurationMetadata);
    fireAutoConfigurationImportEvents(configurations, exclusions);
    //将符合条件和要排除的自动配置类封装进AutoConfigurationEntry对象
    return new AutoConfigurationEntry(configurations, exclusions);
}

在getCandidateConfigurations方法中就会调用loadFactoryNames方法加载位于META-INF下的spring.factories文件

本次的key是EnableAutoConfiguration。

AutoConfigurationImportSelector可以帮助Springboot应用将所有符合条件的@Configuration配置都加载到当前SpringBoot创建并使用的IOC 容器( ApplicationContext )中。

在spring.factories中有很多的自动装配类，但是不是所有的都会进行装载，只有符合条件的才会被加载到IoC容器中。

过滤前：

过滤后：

因为在spring.factories文件中有很多的配置类并不是我们所需要的，比如下图的RabbitAutoConfiguration，我们没有使用就不会被装配，我们导入了SpringMVC，则DispatcherServlet和HttpEncoding就会被装配，只有满足自动装配类上的Condition才会被装配。

我们来看一下执行refreshContext方法的效果。

执行前：

执行后：

此时符合自动装配的所有bean就会被自动装载到Spring的IoC容器中。

⑥刷新应用上下文后的扩展方法afterRefresh

protected void afterRefresh(ConfigurableApplicationContext context, ApplicationArguments args) {
}

扩展方法，设计模式中的模板方法，默认为空实现。如果有自定义需求，可以重写该方法。

至此，SpringBoot的自动装配全部完成。

六、总结

SpringBoot自动配置的原理，主要做了以下事情：

①从spring.factories配置文件中加载自动配置类

②加载的自动配置类中排除掉@EnableAutoConfiguration注解的 exclude 属性指定的自动配置类

③然后再用AutoConfigurationImportFilter接口去过滤自动配置类是否符合其标注注解@ConditionalOnClass , @ConditionalOnBean 和 @ConditionalOnWebApplication的条件，若都符合的话则返回匹配结果。

④然后触发 AutoConfigurationImportEvent 事件

告诉ConditionEvaluationReport条件评估报告器对象来分别记录符合条件和exclude的自动配置类。

⑤最后由spring将最后筛选后的自动配置类导入IOC容器中

今天的分享就到此结束啦，喜欢的小伙伴记得点赞呦。

关注公众号JavaGrowUp，回复【面试】获取面试题，备战金三银四，我们下期再见。