4. Spring Boot运行原理

4. Spring Boot运行原理

4.1 父依赖

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

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

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

Spring Boot版本控制中心

  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-dependencies</artifactId>
  <version>2.3.3.RELEASE</version>

所以我们导入依赖默认是不需要写版本的，如果版本控制中心没有该依赖的话，那就需要手动配置版本了；

4.2 启动器

说白了，就是Spring Boot 的启动场景

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

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

4.3 主启动类

Springboot01HelloworldApplication.java

// 标注这个类是一个Spring Boot应用
@SpringBootApplication
public class Springboot01HelloworldApplication {

    public static void main(String[] args) {
        //启动
        SpringApplication.run(Springboot01HelloworldApplication.class, args);
    }

}

@SpringBootApplication	//标注在某个类上说明这个类是SpringBoot的主配置类，启动类下的所有资源导入

	@SpringBootConfiguration	//Spring Boot的配置
		@Configration	//Spring配置类
		@Component	//说明这是一个Spring组件

	@EnableAutoConfiguration	//自动导入配置
		@AutoConfigurationPackage	//自动配置包
			@Import(AutoConfigurationPackages.Registrar.class)	//自动注册包		

		@Import(AutoConfigurationImportSelector.class)	//核心：自动导入选择器

核心源码解析

1. AutoConfigurationImportSelector.class

   //获得自动配置的实体
   protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
          if (!isEnabled(annotationMetadata)) {
               return EMPTY_ENTRY;
           }
           AnnotationAttributes attributes = getAttributes(annotationMetadata);
           List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
           configurations = removeDuplicates(configurations);
           Set<String> exclusions = getExclusions(annotationMetadata, attributes);
           checkExcludedClasses(configurations, exclusions);
           configurations.removeAll(exclusions);
           configurations = getConfigurationClassFilter().filter(configurations);
           fireAutoConfigurationImportEvents(configurations, exclusions);
           return new AutoConfigurationEntry(configurations, exclusions);
   }
   
   // 获得候选的配置
   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.class

   //获取所有的加载配置
   public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
       String factoryClassName = factoryClass.getName();
       //这里它又调用了 loadSpringFactories 方法
       return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
   }
   
   
   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);
           }
       }
   }
   

3. 最后发现spring.factories多次出现

4. 找到spring.factories

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DfCm4FiO-1599310385077)(C:\Users\New\AppData\Roaming\Typora\typora-user-images\1598708892849.png)]

5. 打开后发现有很多自动配置的文件，这就是自动配置的根源

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BBvqL4Pm-1599310385079)(C:\Users\New\AppData\Roaming\Typora\typora-user-images\1598708978820.png)]

6. 随便打开一个，例如WebMvcAutoConfiguration，可以看到这些一个个的都是JavaConfig配置类，而且都注入了一些Bean

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fuPQKVnM-1599310385082)(C:\Users\New\AppData\Roaming\Typora\typora-user-images\1598709295661.png)]

核心注解：@ConditionalOnXXX

​ 只有里面的条件都满足，该注解才会生效

4.4 流程

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

4.5 结论

Spring Boot所有的自动配置都是在启动的时候扫描并加载，所有的自动配置类都在spring.factories里面，但是不一定生效，要判断条件是否成立，而这个条件就是，对应的start是否导入，导入了start之后，就有对应的启动器，有了启动器，自动装备就会生效，然后就配置成功了。

4.6 SpringApplication

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

4.7 分析

该方法主要分两部分组成，SpringApplication的实例化、run方法的执行；

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

SpringApplication主要做了以下几件事情

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