SpringBoot

蜡笔小新丶henry
74 阅读5分钟

持续创作，加速成长！这是我参与「掘金日新计划 · 10 月更文挑战」的第30 天

SpringBoot笔记

1.自动配置原理初探

1.1pom.xml

  • Spring-boot-dependencies:核心依赖在父工程中
  • 我们在写或者引入springboot依赖的时候，不需要指定版本，因为有这些版本仓库

启动器

 <!--启动器-->
 <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter</artifactId>
 </dependency>
 ​
  • 启动器：说白了就是Springboot的启动场景
  • 比如spring-boot-starter-web，他就会帮我们自动导入web环境所有的依赖
  • springboot会将所有的功能场景，都变成一个个的启动器
  • 我们要使用什么功能，就值需要找到对应的启动器starter

1.2主程序

@SpringBootApplication

 //标注这个类是一个springboot的应用
 @SpringBootApplication
 public class SpringbootStudyApplication {
 ​
     public static void main(String[] args) {
         //将springboot应用启动
         SpringApplication.run(SpringbootStudyApplication.class, args);
     }
 }
 ​

在这个里面最重要的就是@SpringBootApplication这个注解了让我们点进去看看，发现他是一个派生注

image-20221027171248178

而这个注解也是一个派生注解，其中的关键功能由@Import提供，其导入的AutoConfigurationImportSelector的selectImports()方法通过SpringFactoriesLoader.loadFactoryNames()扫描所有具有META-INF/spring.factories的jar包。spring-boot-autoconfigure-x.x.x.x.jar里就有一个这样的spring.factories文件。

注解

 //springboot的配置
 @SpringBootConfiguration
 ​
     //spring配置类
   @Configuration 
 ​
     //说明这也是一个spring的组件
   @Component    
 ​
 //自动配置
 @EnableAutoConfiguration
 ​
     //自动配置包
     @AutoConfigurationPackage 
 ​
     //自动配置  
         @Import(AutoConfigurationPackages.Registrar.class)
 ​
     //自动配置导入选择
     @Import(AutoConfigurationImportSelector.class)
 ​
 //获取所有的配置
 List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
 ​
 ​

获取候选的配置：

 protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
   List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
                                                                        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;
 }
 ​

但是一个简单的启动类并不简单！ 我们来分析一下这些注解都干了什么

1.3@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 {
     // ......
 }
 ​

1.3.1@ComponentScan

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

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

1.3.2@SpringBootConfiguration

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

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

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

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

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

我们回到 SpringBootApplication 注解中继续看，而在这些个注解中最重要的就是@EnableAutoConfiguration，我们继续点进去看，在这些个注解中最重要的就是@EnableAutoConfiguration，我们继续点进去看

1.3.3@EnableAutoConfiguration

1.4@EnableAutoConfiguration

@EnableAutoConfiguration ：开启自动配置功能

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

点进注解继续查看： image-20221027172212562

1.4.1@AutoConfigurationPackage

翻译：自动配置包

 @Import({Registrar.class})
 //利用Registrar导入一系列组件
 //将指定的一个包下的所有组件导入进来？是主程序所在的包下
 public @interface AutoConfigurationPackage {
 }
 ​

@import ：Spring底层注解@import ， 给容器中导入一个组件

Registrar.class 作用：将主启动类的所在包及包下面所有子包里面的所有组件扫描到Spring容器 ；

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

1.4.2@Import({AutoConfigurationImportSelector.class})

给容器导入组件 ；

而这个注解也是一个派生注解，其中的关键功能由 @Import提供，其导入的AutoConfigurationImportSelector的selectImports()方法通过SpringFactoriesLoader.loadFactoryNames()扫描所有具有META-INF/spring.factories的jar包。spring-boot-autoconfigure-x.x.x.x.jar里就有一个这样的spring.factories文件。

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 类的静态方法！我们进入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);
         }
     }
 }
 ​

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

spring.factories 文件里面写死了spring-boot一启动就要给容器中加载的所有配置类

我们根据源头打开spring.factories ， 看到了很多自动配置的文件；这就是自动配置根源所在！ 这个spring.factories文件也是一组一组的key=value的形式，其中一个key是EnableAutoConfiguration类的全类名，而它的value是一个xxxxAutoConfiguration的类名的列表，这些类名以逗号分隔，如下图所示：

image-20221027172339849

这个@EnableAutoConfiguration注解通过@SpringBootApplication被间接的标记在了Spring Boot的启动类上。在SpringApplication.run(…)的内部就会执行selectImports()方法，找到所有JavaConfig自动配置类的全限定名对应的class，然后将所有自动配置类加载到Spring容器中。

WebMvcAutoConfiguration image-20221027172400102

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

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

avatar
文章
阅读
粉丝