SpringBoot 自动配置的加载过程

项目探究

我们之前写的 HelloSpringBoot，到底是怎么运行的呢，Maven 项目，我们一般从 pom.xml 文件探究起；

依赖

• 其中它主要是依赖一个父项目，主要是管理项目的资源过滤及插件！

  <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.2.5.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
  </parent>v

• 点进去，发现还有一个父依赖，这里才是真正管理 SpringBoot 应用里面所有依赖版本的地方，SpringBoot 的版本控制中心；

  <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-dependencies</artifactId>
      <version>2.2.5.RELEASE</version>
      <relativePath>../../spring-boot-dependencies</relativePath>
  </parent>

• spring-boot-dependencies 中定义了依赖的信息，以后我们导入依赖默认是不需要写版本；但是如果导入的包没有在依赖中管理着就需要手动配置版本了

启动器

• springboot-boot-starter-xxx：就是 spring-boot 的场景启动器

• spring-boot-starter-web：帮我们导入了 web 模块正常运行所依赖的组件；

• SpringBoot 将所有的功能场景都抽取出来，做成一个个的 starter （启动器），只需要在项目中引入这些 starter 即可，所有相关的依赖都会导入进来 ， 我们要用什么功能就导入什么样的场景启动器即可 ；我们未来也可以自己自定义 starter；

  <dependency>    
      <groupId>org.springframework.boot</groupId>    
      <artifactId>spring-boot-starter-web</artifactId>
  </dependency>

主启动类

• 默认的主启动类

  //@SpringBootApplication 来标注一个主程序类，说明这是一个 Spring Boot 应用
  @SpringBootApplication
  public class SpringbootApplication {
      public static void main(String[] args) {     
          // 启动了 run 方法，会启动了一个 Tomcat 服务      
          SpringApplication.run(SpringbootApplication.class, args);   
      }
  }

注解分析

@SpringBootApplication

• 作用：标注在某个类上说明这个类是 SpringBoot 的主配置类 ， SpringBoot 就应该运行这个类的 main 方法来启动 SpringBoot 应用；

• 进入这个注解：可以看到上面还有很多其他注解！

  @SpringBootConfiguration
  @EnableAutoConfiguration
  @ComponentScan(
      excludeFilters = {@Filter(
      type = FilterType.CUSTOM,
      classes = {TypeExcludeFilter.class}
  ), @Filter(
      type = FilterType.CUSTOM,
      classes = {AutoConfigurationExcludeFilter.class}
  )}
  )
  public @interface SpringBootApplication {
      // ......
  }

@ComponentScan

• 这个注解在 Spring 中很重要 , 它对应 XML 配置中的元素。

• 作用：自动扫描并加载符合条件的组件或者 bean ， 将这个 bean 定义加载到 IOC 容器中

@SpringBootConfiguration

• 作用：SpringBoot 的配置类 ，标注在某个类上 ， 表示这是一个 SpringBoot 的配置类；

• 我们继续进去这个注解查看

  // 点进去得到下面的 @Component
  @Configuration
  public @interface SpringBootConfiguration {}
  
  // Configuration 注解
  @Component
  public @interface Configuration {}

• 这里的 @Configuration，说明这是一个配置类 ，配置类就是对应 Spring 的 xml 配置文件；

• 里面的 @Component 这就说明，启动类本身也是 Spring 中的一个组件而已，负责启动应用！

@EnableAutoConfiguration

• @EnableAutoConfiguration ：开启自动配置功能

• 以前我们需要自己配置的东西，而现在 SpringBoot 可以自动帮我们配置 ；EnableAutoConfiguration 告诉 SpringBoot 开启自动配置功能，这样自动配置才能生效；

• 点进注解接续查看：

@AutoConfigurationPackage

• 自动配置包

  • @import ：Spring 底层注解@import ， 通过全类名给容器中导入一个组件
  • Registrar.class 作用：将主启动类的所在包及包下面所有子包里面的所有组件扫描到 Spring 容器 ；

  @Import({Registrar.class})
  public @interface AutoConfigurationPackage {
  }

• 分析完了，退到上一步，继续看

@Import({AutoConfigurationImportSelector.class})

• 给容器导入组件 ；

• AutoConfigurationImportSelector ：自动配置导入选择器，那么它会导入哪些组件的选择器呢？

• 我们点击去这个类看源码：

  1. 这个类中有一个这样的方法

     // 获得候选的配置
     protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
         //这里的 getSpringFactoriesLoaderFactoryClass（）方法
         //返回的就是我们最开始看的启动自动导入配置文件的注解类；EnableAutoConfiguration
         List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.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;
     }

  2. 这个方法又调用了 SpringFactoriesLoader 类的静态方法 loadFactoryNames！我们进入 SpringFactoriesLoader 类 loadFactoryNames() 方法

     public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
         String factoryClassName = factoryClass.getName();
         //这里它又调用了 loadSpringFactories 方法
         return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
     }

  3. 继续点击查看 loadSpringFactories 方法

     private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
         //获得 classLoader ， 我们返回可以看到这里得到的就是 EnableAutoConfiguration 标注的类本身
         MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
         if (result != null) {
             return result;
         } else {
             try {
                 //去获取一个资源 "META-INF/spring.factories"
                 Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
                 LinkedMultiValueMap result = new LinkedMultiValueMap();
     
                 //将读取到的资源遍历，封装成为一个 Properties
                 while(urls.hasMoreElements()) {
                     URL url = (URL)urls.nextElement();
                     UrlResource resource = new UrlResource(url);
                     Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                     Iterator var6 = properties.entrySet().iterator();
     
                     while(var6.hasNext()) {
                         Entry<?, ?> entry = (Entry)var6.next();
                         String factoryClassName = ((String)entry.getKey()).trim();
                         String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                         int var10 = var9.length;
     
                         for(int var11 = 0; var11 < var10; ++var11) {
                             String factoryName = var9[var11];
                             result.add(factoryClassName, factoryName.trim());
                         }
                     }
                 }
     
                 cache.put(classLoader, result);
                 return result;
             } catch (IOException var13) {
                 throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
             }
         }

• 发现一个多次出现的文件：spring.factories，全局搜索spring.factories

spring.factories

• 打开 spring.factories ， 看到了很多自动配置的文件；这就是自动配置根源所在！

  

• 自动配置类随便找一个打开看看，如 ：WebMvcAutoConfiguration

  • 可以看到这些一个个的都是 JavaConfig 配置类，而且都注入了一些 Bean，可以找一些自己认识的类，看着熟悉一下！

  • 所以，自动配置真正实现是从 classpath 中搜寻所有的 META-INF/spring.factories 配置文件 ，并将其中对应的 org.springframework.boot.autoconfigure. 包下的配置项，通过反射实例化为对应标注了 @Configuration 的 JavaConfig 形式的 IOC 容器配置类 ， 然后将这些都汇总成为一个实例并加载到 IOC 容器中。

    

小结

1. SpringBoot 在启动的时候从类路径下的 META-INF/spring.factories 中获取 EnableAutoConfiguration 指定的值
2. 将这些值作为自动配置类导入容器 ， 自动配置类就生效 ， 帮我们进行自动配置工作；
3. 整个 J2EE 的整体解决方案和自动配置都在 springboot-autoconfigure 的 jar 包中；
4. 它会给容器中导入非常多的自动配置类 （xxxAutoConfiguration）, 就是给容器中导入这个场景需要的所有组件 ， 并配置好这些组件 ；
5. 有了自动配置类 ， 免去了我们手动编写配置注入功能组件等的工作；

SpringApplication.run 方法

• 该方法主要分两部分，一部分是 SpringApplication 的实例化，二是 run 方法的执行；

  @SpringBootApplication
  public class SpringbootApplication {
      public static void main(String[] args) {
          SpringApplication.run(SpringbootApplication.class, args);
      }
  }

SpringApplication

• 这个类主要做了以下四件事情：

  1. 推断应用的类型是普通的项目还是 Web 项目
  2. 查找并加载所有可用初始化器 ， 设置到 initializers 属性中
  3. 找出所有的应用程序监听器，设置到 listeners 属性中
  4. 推断并设置 main 方法的定义类，找到运行的主类

• 查看构造器：

  public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
      // ......
      this.webApplicationType = WebApplicationType.deduceFromClasspath();
      this.setInitializers(this.getSpringFactoriesInstances();
      this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
      this.mainApplicationClass = this.deduceMainApplicationClass();
  }

run 方法流程分析

• 跟着源码和这幅图就可以一探究竟了

  

本文作者： 凉月
发布时间： 2020-03-23
最后更新： 2022-02-12
本文标题： SpringBoot 自动配置的加载过程
本文链接： https://fulsun.github.io/post/47ae80c7.html
版权声明： 本作品采用 CC BY-NC-SA 4.0 许可协议进行许可。转载请注明出处！