SpringBoot自动配置底层核心源码

探究SpringBoot的自动配置原理，我们可以自己写一个启动类的注解。

一、工程创建

首先创建一个工程，工程目录如下：

• 自定义一个启动函数：

  package org.springboot;public class GuoShaoApplication {public static void run(Class clazz){}
  }
  

• GuoShaoSpringBootApplication 注解：
  自定义一个启动类注解

  package org.springboot;import java.lang.annotation.ElementType;
  import java.lang.annotation.Retention;
  import java.lang.annotation.RetentionPolicy;
  import java.lang.annotation.Target;@Target(ElementType.TYPE)
  @Retention(RetentionPolicy.RUNTIME)
  public @interface GuoShaoSpringBootApplication {
  }

• 一个Controller类：
  UserController .class

  package com.guo.user.controller;import org.springframework.web.bind.annotation.GetMapping;
  import org.springframework.web.bind.annotation.RestController;@RestController
  public class UserController {@GetMapping("/test")public String test(){return "GuoShao123";}
  }

• MyApplication.class：
  自定义一个SpringBoot启动类

  package com.guo.user;import org.springboot.GuoShaoApplication;
  import org.springboot.GuoShaoSpringBootApplication;@GuoShaoSpringBootApplication
  public class MyApplication {public static void main(String[] args){GuoShaoApplication.run(MyApplication.class);}}
  

二、进一步改造

接下来思考SpringBoot在启动的时候，应该会做哪些事情呢？

---

• run方法跑完后，就能通过8080端口，通过/test接收浏览器的请求。
  那么这里可能会使用到Tomcat，所以涉及到Tomcat的启动

  • 所以首先引入tomcat相关的jar包：

            <dependency><groupId>javax.servlet</groupId><artifactId>javax.servlet-api</artifactId><version>4.0.1</version></dependency><dependency><groupId>org.apache.tomcat.embed</groupId><artifactId>tomcat-embed-core</artifactId><version>9.0.60</version></dependency>
    

  • 然后在run()方法中，添加启动Tomcat的相关代码：

        public static void run(Class clazz){startTomcat();
    }private static void startTomcat() {try {// 创建 Tomcat 实例Tomcat tomcat = new Tomcat();// 获取 Tomcat 的 Server 对象Server server = tomcat.getServer();// 获取 Service 对象Service service = server.findService("Tomcat");// 创建 Connector，并设置端口Connector connector = new Connector();connector.setPort(8081);// 创建 Engine，并设置默认主机Engine engine = new StandardEngine();engine.setDefaultHost("localhost");// 创建 Host，并设置名称Host host = new StandardHost();host.setName("localhost");// 设置 Context 的路径和监听器String contextPath = "";Context context = new StandardContext();context.setPath(contextPath);context.addLifecycleListener(new Tomcat.FixContextListener());// 将 Context 添加到 Hosthost.addChild(context);// 将 Host 添加到 Engineengine.addChild(host);// 设置 Service 的容器和连接器service.setContainer(engine);service.addConnector(connector);// 启动 Tomcattomcat.start();tomcat.getServer().await();} catch (LifecycleException e) {e.printStackTrace();}
    }
    

  • 尝试运行我们的SpringBoot启动类，多了一些信息：
    

---

• 接下来，浏览器请求/test路径，我们需要能够找到相应的controller指定的方法。
  这个是spring mvc给我们提供的一个功能，所以需要引入spring mvc

  • 引入maven 依赖：

        <dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>5.3.18</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-aop</artifactId><version>5.3.18</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-web</artifactId><version>5.3.18</version></dependency>
    

  • 在tomcat(tomcat.start();)启动前，添加相关代码：

    DispatcherServlet dispatcherServlet = new DispatcherServlet(appContext);
    tomcat.addServlet(contextPath, "dispatcher", dispatcherServlet);
    context.addServletMappingDecoded("/*", "dispatcher");
    

    • DispatcherServlet 是什么：

      1. DispatcherServlet 是 Spring MVC 的核心组件，充当前端控制器（Front Controller）。
      2. 它拦截所有进入应用的 HTTP 请求，并将其分发给适当的处理器（如 Controller）。
      3. 这里的appContext是spring的Ioc容器。因为你要找到@Controller方法并处理请求，需要从容器去获取相应的bean。因此需要传入一个Ioc容器

    • 将 DispatcherServlet 添加到 Tomcat：

      1. addServlet 方法：将 DispatcherServlet 以 dispatcher 为名称注册到指定的上下文路径。
      2. contextPath：应用的上下文路径（可以是空字符串，表示根路径 “/”）。

    • addServletMappingDecoded 方法：

      1. 用于定义某个 Servlet 的 URL 映射规则。
         参数：“/*”：URL 路径匹配规则，表示匹配所有请求。
      2. “dispatcher”：前面注册的 Servlet 名称。
      3. 作用：指定所有匹配 /* 的请求都由 “dispatcher”（即 DispatcherServlet）处理。

  • 创建Ioc容器：

    //创建 AnnotationConfigWebApplicationContext 实例
    AnnotationConfigWebApplicationContext applicationContext = new AnnotationConfigWebApplicationContext();
    applicationContext.register(clazz);
    applicationContext.refresh();
    

    • AnnotationConfigWebApplicationContext：

      1. 它是 Spring 提供的一个专门支持注解配置的应用上下文。
      2. 继承自 GenericWebApplicationContext，支持 Spring 容器中的所有功能，尤其适合基于 Java 配置的应用。
      3. 作用：创建一个新的 Spring 应用上下文实例，供后续注册配置类和管理 Bean。

    • register(Class<?>… annotatedClasses)：

      1. 注册一个或多个配置类（通常用 @Configuration 注解标注）。

      2. 配置类是基于 Java 的配置文件，替代传统的 XML 配置文件。

      3. 作用：将指定的配置类加载到 Spring 容器中，用于定义 Bean 和其他容器相关的配置。

      4. 会解析配置类里面@bean，后续会加入到容器中。且会解析配置类头上的注解，拿到注解后还会再进一步解析注解里面有什么东西。
         比如说，SpringBootApplication这个注解就会带有ComponentScan，那么也就会扫描到这个注解并生效
         
         在这里，照猫画虎，在我们的注解里也加上。

         @Target(ElementType.TYPE)
         @Retention(RetentionPolicy.RUNTIME)
         @ComponentScan
         public @interface GuoShaoSpringBootApplication {
         }
         

         如果ComponentScan没有加上扫描路径，Spring会默认的把配置类所在的包路径当作扫描路径。
         UserController和配置类在同一个包下面，所以是能够扫描到的。

    • refresh()：

      1. 启动或重新刷新应用上下文，触发容器的初始化或刷新过程。
      2. 它会加载所有 Bean 定义，启动单例 Bean 的初始化，初始化资源（如事件、多线程任务等）。

  • 完成以上操作后，tomcat容器中已经添加了拦截器，相关的浏览器请求都会传到DispatcherServlet 中进行处理。然后spring mvc会扫描注配置类解，加载相应的BeanDefinitin，刷新启动spring Ioc容器。然后从Ioc容器获取到UserController bean对象，调用其方法进行处理。

  • 我们尝试启动容器，并发送请求：请求成功
    

  ---

目前已经实现了简单的SpringBoot，现在的问题是：如果我们不想要tomcat，想要其他的服务器。

在SpringBoot中，我们只需要修改pom配置文件即可：

        <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId><exclusions><exclusion><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-tomcat</artifactId></exclusion></exclusions></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jetty</artifactId></dependency>

所以接下来，我们也要实现这个功能。

可以使用策略模式的方式来实现。

首先，添加一个接口类：

package org.springboot;public interface WebServer {public void start();
}

然后实现两个具体的实现类：

package org.springboot;public class JettyWebServer implements WebServer{@Overridepublic void start() {System.out.println("tomcat start");}
}

package org.springboot;public class TomcatWebServer implements WebServer{@Overridepublic void start() {System.out.println("tomcat start");}
}

在这里我们获得的是Ioc容器的bean，所以添加一个函数用于从容器中获取一个服务器bean，并启动：

    public static WebServer getWebServer(WebApplicationContext applicationContext) {// 从 ApplicationContext 中获取所有 WebServer 类型的 Bean，返回一个 MapMap<String, WebServer> webServers = applicationContext.getBeansOfType(WebServer.class);// 如果 Map 为空，抛出 NullPointerException，表明没有找到任何 WebServer 实例if (webServers.isEmpty()) {throw new NullPointerException("No WebServer beans found in the application context.");}// 如果 Map 中的实例数量大于 1，抛出 IllegalStateException，表示有多个实例if (webServers.size() > 1) {throw new IllegalStateException("Multiple WebServer beans found: " + webServers.keySet());}// 返回唯一的 WebServer 实例return webServers.values().stream().findFirst().get();}

启动类的run方法：

    public static void run(Class clazz){AnnotationConfigWebApplicationContext applicationContext = new AnnotationConfigWebApplicationContext();applicationContext.register(clazz);applicationContext.refresh();WebServer webServer = getWebServer(applicationContext);webServer.start();}

此时，我们可以通过webserver bean的创建来实现服务器的切换。

如，定义了一个bean：

    @Beanpublic WebServer webServerFactory(){return new TomcatWebServer();}

启动启动类，输出：

但离springboot还差一些，我们希望能够通过修改pom文件就能实现服务器的切换：

• 编写配置类：

  package org.springboot;import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Conditional;
  import org.springframework.context.annotation.Configuration;@Configuration
  public class WebServerAutoConfiguration {@Bean@Conditional(TomcatCondition.class)public TomcatWebServer tomcatWebServer(){return new TomcatWebServer();}@Bean@Conditional(JettyCondition.class)public JettyWebServer jettyWebServer(){return new JettyWebServer();}
  }
  

这里使用@Conditional去做一个条件判断，创建相应的服务器bean

• 接下来要去实现这两个Conditional的逻辑判断。
  如何根据pom是否引入相关依赖，来动态的创建不同的服务器bean呢？
  这里能想到的是使用类加载器去加载指定的类，如果tomcat引入了，那么相关的类就能被加载到；反正就不会被加载到。
  有了以上思路，编写Conditional的逻辑判断

  • TomcatCondition.class

    package org.springboot;import org.springframework.context.annotation.Condition;
    import org.springframework.context.annotation.ConditionContext;
    import org.springframework.core.type.AnnotatedTypeMetadata;public class TomcatCondition implements Condition {@Overridepublic boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {try{context.getClassLoader().loadClass("org.apache.catalina.startup.Tomcat");return true;}catch (ClassNotFoundException e){return false;}}
    }
    

  • JettyCondition.class

    package org.springboot;import org.springframework.context.annotation.Condition;
    import org.springframework.context.annotation.ConditionContext;
    import org.springframework.core.type.AnnotatedTypeMetadata;public class JettyCondition implements Condition {@Overridepublic boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {try{context.getClassLoader().loadClass("org.eclipse.jetty.server.Server");return true;}catch (ClassNotFoundException e){return false;}}
    }
    

• 当前还存在一个问题，这个webservice配置类和spring启动加载时需要的配置类不在同一个包路径下，所以是扫描不到的
  
  所以需要让自定义的springboot能够扫描到它：
  加上一个import注解

  package com.guo.user;import org.springboot.*;
  import org.springframework.context.annotation.Import;@GuoShaoSpringBootApplication
  @Import(WebServerAutoConfiguration.class)
  public class MyApplication {public static void main(String[] args){GuoShaoApplication.run(MyApplication.class);}}
  

  当然，为了简化开发，将这个注解加到@GuoShaoSpringBootApplication注解中：

  package org.springboot;import org.springframework.context.annotation.ComponentScan;
  import org.springframework.context.annotation.Import;import java.lang.annotation.ElementType;
  import java.lang.annotation.Retention;
  import java.lang.annotation.RetentionPolicy;
  import java.lang.annotation.Target;@Target(ElementType.TYPE)
  @Retention(RetentionPolicy.RUNTIME)
  @Import(WebServerAutoConfiguration.class)
  @ComponentScan
  public @interface GuoShaoSpringBootApplication {
  }
  

---

三、自动配置

原版springboot的SpringBootApplication注解中有一个重要的注解和依赖：

@EnableAutoConfiguration 是 Spring Boot 中的一个核心注解，用于启用 Spring Boot 的自动配置功能。

它的作用就是，会根据应用程序的依赖（如类路径中的库）和环境（如配置文件）自动配置 Spring 应用程序的基础设施。

以RabbitMQ 为例，当你引入 RabbitMQ 的相关依赖时，Spring Boot 会自动配置与之相关的 Bean。

我们来看这个引入的jar包中有什么东西

这里面放了很多相关组件的配置类，如rabbit的配置类。
点击配置类查看：

这里和我们之前的一样，会通过检测配置类是否存在来判断依赖是否加入。
若存在则会自动配置，创建相应的bean。

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";Class<?>[] exclude() default {};String[] excludeName() default {};
}

@Import({AutoConfigurationImportSelector.class})这是自动配置的核心，通过 AutoConfigurationImportSelector 类动态地选择和导入自动配置的类。

下面看AutoConfigurationImportSelector.class相关代码，

其中核心代码为：

/*** 从注解元数据中选择需要导入的配置类。* 这是自动配置的核心方法，用于决定哪些配置类会被加载到 Spring 应用上下文中。** @param annotationMetadata 当前类的注解元数据（通常是被注解了 @EnableAutoConfiguration 的类）。* @return 配置类的全限定类名数组。*/
public String[] selectImports(AnnotationMetadata annotationMetadata) {// 1. 判断自动配置功能是否被启用if (!this.isEnabled(annotationMetadata)) {// 如果自动配置被禁用（例如 `spring.boot.enableautoconfiguration=false`），则返回空数组return NO_IMPORTS;}// 2. 获取自动配置条目，包括符合条件的自动配置类列表AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(annotationMetadata);// 3. 将获取到的配置类列表转换为字符串数组返回// `getConfigurations()` 返回经过筛选的配置类名列表return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}

这个函数会返回符合条件的相关配置类的名字，交给spring进行bean的创建。

继续看 AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(annotationMetadata);：

/*** 获取自动配置的条目。* 包括加载候选的自动配置类、去重、排除、过滤等逻辑。** @param annotationMetadata 当前注解元数据，表示被 @EnableAutoConfiguration 注解的类。* @return 自动配置条目，包含符合条件的配置类和排除的配置类。*/
protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {// 1. 检查是否启用了自动配置功能if (!this.isEnabled(annotationMetadata)) {// 如果禁用，则返回一个空的自动配置条目return EMPTY_ENTRY;} else {// 2. 获取 @EnableAutoConfiguration 注解的属性AnnotationAttributes attributes = this.getAttributes(annotationMetadata);// 3. 加载所有候选的自动配置类List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);// 4. 移除重复的配置类，确保列表唯一configurations = this.removeDuplicates(configurations);// 5. 获取需要排除的配置类（通过 exclude 和 excludeName 属性）Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);// 6. 检查排除类是否存在于候选配置中（避免配置错误）this.checkExcludedClasses(configurations, exclusions);// 7. 从候选配置类中移除排除的配置类configurations.removeAll(exclusions);// 8. 根据条件过滤配置类，例如检查 @ConditionalOnClass、@ConditionalOnMissingBean 等注解configurations = this.getConfigurationClassFilter().filter(configurations);// 9. 发布事件，用于通知其他组件当前的自动配置加载情况this.fireAutoConfigurationImportEvents(configurations, exclusions);// 10. 返回最终的自动配置条目，包含符合条件的配置类和排除的配置类return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);}
}

核心代码是List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);：

/*** 获取候选自动配置类列表。* 通过 SpringFactoriesLoader 从 META-INF/spring.factories 文件中加载配置类的完整类名。** @param metadata   当前注解元数据。* @param attributes 注解属性（从 @EnableAutoConfiguration 提取）。* @return 候选配置类列表。*/
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {// 1. 使用 SpringFactoriesLoader 从 spring.factories 文件加载配置类列表。List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(),  // 获取加载器的工厂类（通常为 EnableAutoConfiguration）this.getBeanClassLoader()                    // 获取当前使用的类加载器);// 2. 确保加载的配置类列表非空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.");// 3. 返回候选配置类的完整类名列表return configurations;
}

先讨论一个问题，这么多Jar包，难道要一个一个的去遍历判断是不是配置类吗？

这样复杂度很高，所以spring boot做了优化。在每个jar包中，会有一个文件META-INF/spring.factories :

这个文件存了很多key-value，其中org.springframework.boot.autoconfigure.EnableAutoConfiguration记录了该jar包下的配置类。

所以通过读取这个文件，就能够避免遍历整个jar包寻找配置类。

接下来继续看代码：

List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());

1. SpringFactoriesLoader.loadFactoryNames(…):
   SpringFactoriesLoader 是 Spring 框架中的一个工具类，它用于从 META-INF/spring.factories 文件中加载指定的工厂类（即自动配置类）。

2. this.getSpringFactoriesLoaderFactoryClass():
   这个方法返回一个 Class 类型，它告诉 SpringFactoriesLoader 应该加载哪些自动配置类。
   这里就是传入进来的EnableAutoConfiguration.class，即告诉要去读META-INF/spring.factories中那个key的value。

3. this.getBeanClassLoader():
   该方法返回当前线程的 ClassLoader，用于加载类。ClassLoader 是用于加载 Java 类和资源文件的对象。Spring 使用它来加载 META-INF/spring.factories 文件。

读取到配置类的路径名字后，需要做一个去冲突操作：

configurations = this.removeDuplicates(configurations);

这个代码比较简单，就是传入到HashSet再转回来：

    protected final <T> List<T> removeDuplicates(List<T> list) {return new ArrayList(new LinkedHashSet(list));}

接下来到重点，这么多的配置类难道都需要进行返回吗。

答案是否定的，所以需要进行过滤.

有一个想法，去加载相应的配置类，然后去获取Condition这个注解上面的相关class文件，然后判断是否存在即可判断pom中是否引入了相关的依赖。

configurations = this.getConfigurationClassFilter().filter(configurations);

这行代码的作用是对 configurations 列表中加载的类名进行筛选，只保留满足条件的自动配置类。

看过滤过程：

/*** 过滤自动配置类列表，根据多个过滤器的规则筛选出有效的类。* * @param configurations 原始的自动配置类列表* @return 过滤后的有效配置类列表*/
protected List<String> filter(List<String> configurations) {// 记录开始时间，用于统计过滤操作的耗时long startTime = System.nanoTime();// 将配置类列表转换为数组，便于逐项操作String[] candidates = StringUtils.toStringArray(configurations);// 标记是否有配置类被过滤掉boolean skipped = false;// 遍历所有过滤器Iterator<AutoConfigurationImportFilter> iterator = this.filters.iterator();while (iterator.hasNext()) {AutoConfigurationImportFilter filter = iterator.next();// 调用当前过滤器的匹配方法，返回每个类是否通过过滤器的布尔结果boolean[] match = filter.match(candidates, this.autoConfigurationMetadata);// 遍历匹配结果，将未通过过滤的类标记为 nullfor (int i = 0; i < match.length; i++) {if (!match[i]) {candidates[i] = null; // 将不符合条件的类设置为 nullskipped = true;       // 设置标记，表示发生了过滤}}}// 如果没有类被过滤，直接返回原始列表if (!skipped) {return configurations;}// 构建过滤后的列表，跳过所有被设置为 null 的类List<String> result = new ArrayList<>(candidates.length);for (String candidate : candidates) {if (candidate != null) {result.add(candidate); // 将非 null 的类添加到结果列表}}// 如果日志级别为 TRACE，记录过滤掉的类数量和耗时if (AutoConfigurationImportSelector.logger.isTraceEnabled()) {int numberFiltered = configurations.size() - result.size(); // 计算被过滤的类数量AutoConfigurationImportSelector.logger.trace("Filtered " + numberFiltered + " auto configuration class in " + TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime) + " ms");}// 返回过滤后的有效配置类列表return result;
}

就是逐个使用实现了 AutoConfigurationImportFilter 接口的过滤器进行过滤操作

关键代码：

boolean[] match = filter.match(candidates, this.autoConfigurationMetadata);

• candidates：一个包含候选配置类的数组。

• this.autoConfigurationMetadata：

  • 自动配置元数据。
  • 包含有关自动配置类的额外信息，例如类的条件、依赖等。
  • 用于辅助过滤器判断某个类是否应该被加载。

public boolean[] match(String[] autoConfigurationClasses, AutoConfigurationMetadata autoConfigurationMetadata) {// 尝试获取条件评估报告对象，用于记录自动配置类的条件评估结果ConditionEvaluationReport report = ConditionEvaluationReport.find(this.beanFactory);// 获取所有候选类的条件评估结果ConditionOutcome[] outcomes = this.getOutcomes(autoConfigurationClasses, autoConfigurationMetadata);// 初始化匹配结果数组，长度与候选类数组相同boolean[] match = new boolean[outcomes.length];// 遍历每个候选类的评估结果for (int i = 0; i < outcomes.length; ++i) {// 如果结果为 null 或匹配条件（isMatch=true），则设置为 truematch[i] = outcomes[i] == null || outcomes[i].isMatch();// 如果当前类不匹配并且评估结果不为 null，则记录相关信息if (!match[i] && outcomes[i] != null) {// 记录不匹配的评估结果到日志中，方便调试this.logOutcome(autoConfigurationClasses[i], outcomes[i]);// 如果存在条件评估报告，则将不匹配的评估结果记录到报告中if (report != null) {report.recordConditionEvaluation(autoConfigurationClasses[i], this, outcomes[i]);}}}// 返回匹配结果数组return match;
}

核心代码是：

ConditionOutcome[] outcomes = this.getOutcomes(autoConfigurationClasses, autoConfigurationMetadata);

继续深入：

protected final ConditionOutcome[] getOutcomes(String[] autoConfigurationClasses, AutoConfigurationMetadata autoConfigurationMetadata) {// 如果候选的自动配置类数量大于 1 且 CPU 核心数大于 1，则使用多线程方式处理if (autoConfigurationClasses.length > 1 && Runtime.getRuntime().availableProcessors() > 1) {// 多线程方式解析候选类的条件结果return this.resolveOutcomesThreaded(autoConfigurationClasses, autoConfigurationMetadata);} else {// 创建单线程的条件解析器，解析所有候选类的条件结果OnClassCondition.OutcomesResolver outcomesResolver = new OnClassCondition.StandardOutcomesResolver(autoConfigurationClasses, // 自动配置类名数组0,                        // 开始索引autoConfigurationClasses.length, // 结束索引autoConfigurationMetadata,       // 自动配置元数据this.getBeanClassLoader()        // Bean 类加载器);// 解析并返回条件评估结果return outcomesResolver.resolveOutcomes();}
}

这里springboot使用了多线程去过滤配置类，提升效率。这里会将配置类分层两份，用两个线程分别去做过滤工作。

下面是多线程处理过程的代码：

private ConditionOutcome[] resolveOutcomesThreaded(String[] autoConfigurationClasses, AutoConfigurationMetadata autoConfigurationMetadata) {// 将自动配置类列表分为两半int split = autoConfigurationClasses.length / 2;// 创建解析器处理前半部分OnClassCondition.OutcomesResolver firstHalfResolver = this.createOutcomesResolver(autoConfigurationClasses,  // 自动配置类名数组0,                         // 前半部分的起始索引split,                     // 前半部分的结束索引autoConfigurationMetadata  // 自动配置元数据);// 创建解析器处理后半部分OnClassCondition.OutcomesResolver secondHalfResolver = new OnClassCondition.StandardOutcomesResolver(autoConfigurationClasses,  // 自动配置类名数组split,                     // 后半部分的起始索引autoConfigurationClasses.length, // 后半部分的结束索引autoConfigurationMetadata, // 自动配置元数据this.getBeanClassLoader()  // Bean 类加载器);// 解析后半部分的条件结果ConditionOutcome[] secondHalf = secondHalfResolver.resolveOutcomes();// 解析前半部分的条件结果（可以并发执行）ConditionOutcome[] firstHalf = firstHalfResolver.resolveOutcomes();// 合并前半部分和后半部分的结果到一个结果数组ConditionOutcome[] outcomes = new ConditionOutcome[autoConfigurationClasses.length];System.arraycopy(firstHalf, 0, outcomes, 0, firstHalf.length); // 复制前半部分的结果System.arraycopy(secondHalf, 0, outcomes, split, secondHalf.length); // 复制后半部分的结果// 返回合并后的条件评估结果return outcomes;
}

查看核心代码：

    // 解析后半部分的条件结果ConditionOutcome[] secondHalf = secondHalfResolver.resolveOutcomes();

深入查看：

public ConditionOutcome[] resolveOutcomes() {return this.getOutcomes(this.autoConfigurationClasses, this.start, this.end, this.autoConfigurationMetadata);
}

• autoConfigurationClasses：
  包含所有需要解析的自动配置类的全限定类名列表。即META-INF/spring.factories 文件。
• start 和 end：
  决定处理的区间范围：
  • start: 当前线程处理的起始索引。
  • end: 当前线程处理的结束索引。
• autoConfigurationMetadata
  • 一个优化的数据结构，提供了每个自动配置类的元数据信息（如条件注解的存在性）。
  • 减少了通过反射直接解析类的开销。

第三个参数，又是springboot的一个优化手段。如果要判断过滤结构，需要两步：

• 加载配置类
• 解析里面的ConditionalOnClass注解，判断是否满足条件

springboot通过一个文件优化了以上步骤：META-INF\spring-autoconfigure-metadata.properties

内容如下：

其实就是将每个配置类的ConditionalOnClass条件都集中记录在这个文件中，这样就可以不加载解析配置类文件，就能进行判断其pom中是否引入相关坐标，是否需要将这个配置类返回给spring实例化

继续深入看代码验证上面所说的：

/*** 根据指定范围的自动配置类名和元数据，解析其条件并返回结果数组。** @param autoConfigurationClasses 自动配置类的名称数组* @param start 起始索引（包含）* @param end 结束索引（不包含）* @param autoConfigurationMetadata 自动配置的元数据，用于快速查询条件* @return 每个类的条件评估结果数组*/
private ConditionOutcome[] getOutcomes(String[] autoConfigurationClasses, int start, int end, AutoConfigurationMetadata autoConfigurationMetadata) {// 初始化结果数组，大小为指定范围的长度ConditionOutcome[] outcomes = new ConditionOutcome[end - start];// 遍历指定范围的类名for (int i = start; i < end; ++i) {String autoConfigurationClass = autoConfigurationClasses[i]; // 当前类名// 如果类名不为 null，则继续处理if (autoConfigurationClass != null) {// 从元数据中获取当前类的 ConditionalOnClass 条件值String candidates = autoConfigurationMetadata.get(autoConfigurationClass, "ConditionalOnClass");// 如果存在条件值，调用 getOutcome 方法评估条件，并保存结果if (candidates != null) {outcomes[i - start] = this.getOutcome(candidates);}}}// 返回评估结果数组return outcomes;
}

感兴趣的可以继续往autoConfigurationMetadata.get去深入，可以看到最后是从一个properties文件里去读取相应的key-value。验证了之前所说的。

以上就是spring boot自动配置的原理，对你有帮助，给个关注和点赞吧。【欢迎交流】