SpringBoot——starter启动器、SpringBoot自动配置原理、@Conditional、run方法执行流程图

目录

• 一、pom.xml文件
  • 1、父依赖
  • 2、启动器 spring-boot-starter
• 二、默认主启动类的分析原理(重点)
  • 1、@SpringBootApplication
  • 2、@ComponentScan
  • 3、@SpringBootConfiguration
  • 4、@EnableAutoConfiguration
  • 5、spring-factories
• 三、分析自动配置原理 (接着上面继续)(重点)
  • 1、以HttpEncodingAutoConfiguration (Http编码自动配置) 为例解释自动配置原理；
  • 2、@Conditional派生注解
• 四、SpringBoot自动配置原理流程( 结合二、三)(重点)
• 五、SpringApplication主方法执行
  • 1、不简单的方法
  • 2、SpringApplication
  • 3、run方法流程图

一、pom.xml文件

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

1、父依赖

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

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

点进去,发现还有一个父依赖

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

这里才是真正管理SpringBoot应用里面所有依赖版本的地方，SpringBoot的版本控制中心；

以后我们导入依赖默认是不需要写版本号; 但是如果导入的包没有在依赖中管理着就需要手动配置版本了

2、启动器 spring-boot-starter

跳转到目录

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

• springboot-boot-starter-xxx：就是spring-boot的场景启动器
• spring-boot-starter-web：帮我们导入了web模块正常运行所依赖的组件；

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

二、默认主启动类

跳转到目录

/**
 * 程序的主入口
 */
// 本身就是一个Spirng的组件, 就是一个Spring的配置类
@SpringBootApplication
public class SpringBootApplication {

    public static void main(String[] args) {
        // 将springboot 应用启动
        SpringApplication.run(FirstSpringBoot.class, args);
    }
}

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

---

1、@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 {
}

2、@ComponentScan

跳转到目录
这个注解在Spring中很重要 ,它对应XML配置中的元素。
作用：自动扫描并加载符合条件的组件或者bean ，将这个bean定义加载到IOC容器中

3、@SpringBootConfiguration

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

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

@Configuration
public @interface SpringBootConfiguration {
}

@Component
public @interface Configuration {
}

• 这里的 @Configuration，说明这是一个配置类 ，配置类就是对应Spring的xml 配置文件；
• 里面的 @Component 这就说明，启动类本身也是Spring中的一个组件而已，负责启动应用！
• 我们回到 SpringBootApplication 注解中继续看。

4、@EnableAutoConfiguration

跳转到目录

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

点进注解继续查看：

• @AutoConfigurationPackage ：自动配置包

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

• @import ：Spring底层注解@import ， 给容器中导入一个组件(将Registear导入容器)
  Registrar.class 作用：将主启动类的所在包(com.zy)及包下面所有子包里面的所有组件扫描到Spring容器 ；
  
  这个分析完了，退到上一步，继续看

• @Import({AutoConfigurationImportSelector.class}) ：给容器导入组件； AutoConfigurationImportSelector ：自动配置导入选择器，那么它会导入哪些组件的选择器呢？我们点击去这个类看源码：

将所有需要导入的组件以全类名的方式返回; 这些组件就被添加到容器中了, 也就是上图selectImports方法返回的String数组,该数组中存放的就是要被添加组件的全类名!

从这里就可以看出, 这个String[] 数组 返回了124 个自动配置类(xxxAutoConfiguration), 将这些以全类名的组件(这些组件就是各个场景所需要的)导入到容器中, 并配置好这些组件;

有了自动配置类, 就免去了我们手动编写配置注入功能组件等工作!

这些124个配置类, SpringBoot是从哪得到的呢? 看下面的getCandidateConfigurations方法

1、这个类中有一个这样的方法 getCandidateConfigurations

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    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;
}

• this.getSpringFactoriesLoaderFactoryClass, 返回EnableAutoConfiguration字节码, 也就是说, 从properties中获取EnableAutoConfiguration.class类对应的值,然后把他们添加到容器中

protected Class<?> getSpringFactoriesLoaderFactoryClass() {
        return EnableAutoConfiguration.class;
    }

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

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
    String factoryTypeName = factoryType.getName();
    return (List)loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
}

3、我们继续点击查看 loadSpringFactories 方法

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
        MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
        if (result != null) {
            return result;
        } else {
            try {
                Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
                LinkedMultiValueMap result = new LinkedMultiValueMap();

                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 factoryTypeName = ((String)entry.getKey()).trim();
                        String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        int var10 = var9.length;

                        for(int var11 = 0; var11 < var10; ++var11) {
                            String factoryImplementationName = var9[var11];
                            result.add(factoryTypeName, factoryImplementationName.trim());
                        }
                    }
                }

                cache.put(classLoader, result);
                return result;
            } catch (IOException var13) {
                throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
            }
        }
    }

• SpringFactoriesLoader.loadFactoryNames() 扫描所有jar包类路径下 META-INF/spring.factories
• 把扫描到的这些文件的内容包装成properties对象; 从properties中获取到EnableAutoConfiguration.class类（类名）对应的值，然后把他们添加在容器中

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

5、spring-factories

跳转到目录
我们根据源头打开spring.factories ， 看到了很多自动配置的文件；这就是自动配置根源所在！

• 将每一个这样的 xxxAutoConfiguration类都是容器中的一个组件，都加入到容器中；用他们来做自动配置；

WebMvcAutoConfiguration
我们在上面的自动配置类随便找一个打开看看，比如 ：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. 有了自动配置类 ， 免去了我们手动编写配置注入功能组件等的工作(以前再学Spring的时候都要写大量的配置文件, 此时用配置类替代了!)；

在没有学习springboot之前,在spring中我们要写很多的配置文件,这些配置文件其实都可以写成配置类的形式, 通过配置类的形式来管理类的实例; 而在springboot的自动装配中,全部都使用的是配置类的形式,这些配置类都帮我们写好了. 通过上面每一层的深入最终的目的就是为了通过一些途径来找到这些配置类的位置;然后进行自动装配!

分析结果：

@SpringBootApplication 注解原理 主要通过两个@Import 注解，将配置的组件加载到 Spring 容器中，最终得以让 Spring 容器启动，其实底层还是通过 Spring 来实现的，你如果了解 Spring 容器底层实现，这块就会一目了然。

​ ①会将 @SpringBootApplication 标注的主配置类，所在包及下面所有子包里面的所有组件扫描到 Spring 容器中；（这个注解：@Import(AutoConfigurationPackages.Registrar.class) ）

​ ②会将 SpringBoot 为 J2EE 企业级开发的默认配置，全部加载到 Spring 容器中。（这个注解：@Import(EnableAutoConfigurationImportSelector.class) ）

三、分析自动配置原理 (接着上面继续)

跳转到目录

• 在SpringBoot全局配置文件(yml/properties) 中到底该写什么, 或者应该怎么写呢?
• SpringBoot官方文档中有大量的配置，我们无法全部记住;

1、以HttpEncodingAutoConfiguration (Http编码自动配置) 为例解释自动配置原理；

跳转到目录

进入该配置类, 下面是该配置类的注解

• @Configuration
  作用: 表示这是一个配置类，以前编写的配置文件一样，也可以给容器中添加组件

• @EnableConfigurationProperties(HttpEncodingProperties.class)
  作用: 启动指定类(这里指HttpEncodingProperties)的ConfigurationProperties功能；将SpringBoot配置文件(yml/properties)中对应的值和HttpEncodingProperties绑定起来；并把HttpEncodingProperties加入到IoC容器中; 此时在配置文件中能写的就是HttpEncodingProperties类的属性, 然后给该类属性赋值

• @ConditionalOnWebApplication(当前应用是否是web应用)
  作用: Spring底层@Conditional注解（Spring注解版），根据不同的条件，如果满足指定的条件，整个配置类里面的配置就会生效; 判断当前应用是否是web应用，如果是，当前配置类生效

• @ConditionalOnClass(CharacterEncodingFilter.class)
  作用: 判断当前项目有没有这个类CharacterEncodingFilter；SpringMVC中进行乱码解决的过滤器；

• @ConditionalOnProperty(prefix = “spring.http.encoding”, value = “enabled”, matchIfMissing = true)
  作用: 判断配置文件中是否存在某个配置 spring.http.encoding.enabled；如果不存在，判断也是成立的
  即使我们配置文件中不配置pring.http.encoding.enabled=true，也是默认生效的；

• @ConditionalOnMissingBean(CharacterEncodingFilter.class)
  作用: 判断容器有没有CharacterEncodingFilter这个组件

public class HttpEncodingAutoConfiguration {
  
  	//它已经和SpringBoot的配置文件映射了(因为已经通过@ConditionalOnProperty绑定了)也就是说,通过yml/properties注入进来的
  	private final HttpEncodingProperties properties;
  
   //只有一个有参构造器的情况下，参数的值就会从容器中拿
  	public HttpEncodingAutoConfiguration(HttpEncodingProperties properties) {
		this.properties = properties;
	}
  
    @Bean   //给容器中添加一个组件，这个组件的某些值需要从properties中获取
	@ConditionalOnMissingBean(CharacterEncodingFilter.class) //判断容器没有CharacterEncodingFilter这个组件
	public CharacterEncodingFilter characterEncodingFilter() {
		CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
		filter.setEncoding(this.properties.getCharset().name());
		filter.setForceRequestEncoding(this.properties.shouldForce(Type.REQUEST));
		filter.setForceResponseEncoding(this.properties.shouldForce(Type.RESPONSE));
		return filter;
	}

上面@Condition注解根据当前不同的条件判断，决定这个配置类是否生效？

一但这个配置类生效；这个配置类就会给容器中添加各种组件；这些组件的属性是从对应的XxxProperties类中获取的，因为通过@ConfigurationProperties(prefix = 'xxx')将这些类里面的每一个属性又是和配置文件绑定的；

@ConfigurationProperties(prefix = "spring.http.encoding")  //从配置文件中获取指定的值和bean的属性进行绑定
public class HttpEncodingProperties {

   public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

• @ConfigurationProperties(prefix = “spring.http.encoding”) 表示从配置文件中获取指定的值和bean的属性进行绑定;
• 也就是说, 在SpringBoot全局配置文件中只能写, HttpEncodingProperties中拥有的属性; 因为二者已经通过@ConfigurationProperties(prefix = "spring.http.encoding")绑定了
• 也就是说所有在SpringBoot配置文件中能配置的属性都是在xxxxProperties类中封装者；配置文件能配置什么就可以参照某个功能对应的这个属性类;

精髓:

• SpringBoot启动会加载大量的自动配置类;

• 我们看我们需要的功能有没有SpringBoot默认写好的自动配置类. (也就是META-INF/spring.factories中有没有写这个自动配置类)

• 我们再来看这个自动配置类中到底配置了哪些组件;（只要我们要用的组件有，我们就不需要再来配置了)

• 给容器中自动配置类添加组件的时候，会从properties类中获取某些属性。我们就可以在SpringBoot配置文件中指定这些属性的值; (因为它们已经绑定起来了)

xxxxAutoConfigurartion：自动配置类；给容器中添加组件

xxxxProperties: 封装配置文件中相关属性；

2、@Conditional派生注解

跳转到目录

• 作用：必须是@Conditional指定的条件成立，才给容器中添加组件，配置配里面的所有内容才生效;

@Conditional扩展注解	作用（判断是否满足当前指定条件）
@ConditionalOnJava	系统的java版本是否符合要求
@ConditionalOnBean	容器中存在指定Bean；
@ConditionalOnMissingBean	容器中不存在指定Bean；
@ConditionalOnExpression	满足SpEL表达式指定
@ConditionalOnClass	系统中有指定的类
@ConditionalOnMissingClass	系统中没有指定的类
@ConditionalOnSingleCandidate	容器中只有一个指定的Bean，或者这个Bean是首选Bean
@ConditionalOnProperty	系统中指定的属性是否有指定的值
@ConditionalOnResource	类路径下是否存在指定资源文件
@ConditionalOnWebApplication	当前是web环境
@ConditionalOnNotWebApplication	当前不是web环境
@ConditionalOnJndi	JNDI存在指定项

我们怎么知道哪些自动配置类生效；

我们可以通过启用 debug=true属性；来让控制台打印自动配置报告，这样我们就可以很方便的知道哪些自动配置类生效；

=========================
AUTO-CONFIGURATION REPORT
=========================


Positive matches:（自动配置类启用的）
-----------------

   DispatcherServletAutoConfiguration matched:
      - @ConditionalOnClass found required class 'org.springframework.web.servlet.DispatcherServlet'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition)
      - @ConditionalOnWebApplication (required) found StandardServletEnvironment (OnWebApplicationCondition)
        
    
Negative matches:（没有启动，没有匹配成功的自动配置类）
-----------------

   ActiveMQAutoConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required classes 'javax.jms.ConnectionFactory', 'org.apache.activemq.ActiveMQConnectionFactory' (OnClassCondition)

   AopAutoConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required classes 'org.aspectj.lang.annotation.Aspect', 'org.aspectj.lang.reflect.Advice' (OnClassCondition)

四、SpringBoot自动配置原理流程( 结合二、三)

跳转到目录

1. SpringBoot启动的时候通过@EnableAutoConfiguration内的AutoConfigurationImportSelector选择器中的String[] selectImports方法, 找到META-INF/spring.factorie文件中的所有配置类并加载到容器中;
2. 我们在全局配置文件(yml/properties)中通过@ConfigurationProperties绑定到相对应的XxxProperties的配置类
3. 最后通过@EnableConfigurationProperties({XxxProperties.class})将XxxProperties的组件添加到Spring容器中; 这样就可以在配置文件中写XxxProperties中对应的属性(有些属性可能定义在了内部类中)了;

五、SpringApplication

跳转到目录

1、不简单的方法

跳转到目录
我最初以为就是运行了一个main方法，没想到却开启了一个服务；

@SpringBootApplication
public class FirstSpringBoot {

    public static void main(String[] args) {
        // 将springboot 应用启动
        SpringApplication.run(FirstSpringBoot.class, args);
    }
}

SpringApplication.run分析
分析该方法主要分两部分

• 一部分是SpringApplication的实例化
• 二是run方法的执行；

2、SpringApplication

跳转到目录
这个类主要做了一下四件事情:

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

查看构造器

3、run方法流程分析

跳转到目录