likes
comments
collection
share

Spring Boot核心原理（下）-- 自动配置与启动解析

作者站长头像
站长
· 阅读数 29

自动配置原理

原理解析 

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

其中 @SpringBootApplication开启组件扫描和自动配置，而 SpringApplication.run则负责启动引导应用程序。 @SpringBootApplication是一个复合 Annotation，它将三个有用的注解组合在一起：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { 
    @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class), 
    @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class)
})
public @interface SpringBootApplication { // ......}

@SpringBootConfiguration就是 @Configuration，它是Spring框架的注解，标明该类是一个 JavaConfig配置类。而 @ComponentScan启用组件扫描，这里着重关注 @EnableAutoConfiguration。

@EnableAutoConfiguration注解表示开启Spring Boot自动配置功能，Spring Boot会根据应用的依赖、自定义的bean、classpath下有没有某个类 等等因素来猜测你需要的bean，然后注册到IOC容器中。那 @EnableAutoConfiguration是如何推算出你的需求？首先看下它的定义：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(EnableAutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration { 
    // ......
}

关注点应该集中在 @Import(EnableAutoConfigurationImportSelector.class)上了，@Import注解用于导入类，并将这个类作为一个bean的定义注册到容器中，这里它将把EnableAutoConfigurationImportSelector作为bean注入到容器中，而这个类会将所有符合条件的@Configuration配置都加载到容器中。

那 @EnableAutoConfiguration是如何推算出你的需求？首先看下它的定义：

public String[] selectImports(AnnotationMetadata annotationMetadata) { 
    // 省略了大部分代码，保留一句核心代码 
    // 注意：SpringBoot最近版本中，这句代码被封装在一个单独的方法中 
    // SpringFactoriesLoader相关知识请参考前文 
    List<String> factories = new ArrayList<String>(new LinkedHashSet<String>(  
      SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class, this.beanClassLoader)));
}

这个类会扫描所有的jar包，将所有符合条件的@Configuration配置类注入的容器中，何为符合条件，看看 META-INF/spring.factories的文件内容：

// 来自 org.springframework.boot.autoconfigure下的META-INF/spring.factories
// 配置的key = EnableAutoConfiguration，与代码中一致
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,
\org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration\.....

自动配置示例

DataSourceAutoConfiguration为例，看看Spring Boot是如何自动配置的：

@Configuration
@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
@EnableConfigurationProperties(DataSourceProperties.class)
@Import({ Registrar.class, DataSourcePoolMetadataProvidersConfiguration.class })
public class DataSourceAutoConfiguration {}

分别说一说：

@ConditionalOnClass({DataSource.class,EmbeddedDatabaseType.class})：当Classpath中存在DataSource或者EmbeddedDatabaseType类时才启用这个配置，否则这个配置将被忽略。

@EnableConfigurationProperties(DataSourceProperties.class)：将DataSource的默认配置类注入到IOC容器中，DataSourceproperties定义为：

// 提供对datasource配置信息的支持，所有的配置前缀为：
spring.datasource@ConfigurationProperties(prefix = "spring.datasource")
public class DataSourceProperties { 
    private ClassLoader classLoader; 
    private Environment environment; 
    private String name = "testdb"; 
    ......
}

@Import({Registrar.class,DataSourcePoolMetadataProvidersConfiguration.class})：导入其他额外的配置，就以 DataSourcePoolMetadataProvidersConfiguration为例吧。

@Configuration
public class DataSourcePoolMetadataProvidersConfiguration { 

@Configuration 
@ConditionalOnClass(org.apache.tomcat.jdbc.pool.DataSource.class) 
static class TomcatDataSourcePoolMetadataProviderConfiguration { 
    @Bean 
    public DataSourcePoolMetadataProvider tomcatPoolDataSourceMetadataProvider() { 
        ..... }
    } 
......
}

DataSourcePoolMetadataProvidersConfiguration是数据库连接池提供者的一个配置类，即Classpath中存在 org.apache.tomcat.jdbc.pool.DataSource.class，则使用tomcat-jdbc连接池，如果Classpath中存在 HikariDataSource.class则使用Hikari连接池。

这里仅描述了DataSourceAutoConfiguration的冰山一角，但足以说明Spring Boot如何利用条件话配置来实现自动配置的。

回顾一下， @EnableAutoConfiguration中导入了EnableAutoConfigurationImportSelector类，而这个类的 selectImports()通过SpringFactoriesLoader得到了大量的配置类，而每一个配置类则根据条件化配置来做出决策，以实现自动配置。

整个流程很清晰，但漏了一个大问题： EnableAutoConfigurationImportSelector.selectImports()是何时执行的？其实这个方法会在容器启动过程中执行： AbstractApplicationContext.refresh()，更多的细节在下一小节中说明。

启动引导：Spring Boot应用启动的秘密

SpringApplication初始化

SpringBoot整个启动流程分为两个步骤：初始化一个SpringApplication对象、执行该对象的run方法。看下SpringApplication的初始化流程，SpringApplication的构造方法中调用initialize(Object[] sources)方法，其代码如下：

private void initialize(Object[] sources) { 
    if (sources != null && sources.length > 0) { 
        this.sources.addAll(Arrays.asList(sources));
    }
    // 判断是否是Web项目 
    this.webEnvironment = deduceWebEnvironment();
    // 各种对象初始化
    setInitializers((Collection) 
    getSpringFactoriesInstances(ApplicationContextInitializer.class)); 
    setListeners((Collection) 
    getSpringFactoriesInstances(ApplicationListener.class)); 
    // 找到入口类 
    this.mainApplicationClass = deduceMainApplicationClass();}

初始化流程中最重要的就是通过SpringFactoriesLoader找到 spring.factories文件中配置的ApplicationContextInitializer和 ApplicationListener两个接口的实现类名称，以便后期构造相应的实例。

ApplicationContextInitializer的主要目的是在 ConfigurableApplicationContext做refresh之前，对ConfigurableApplicationContext实例做进一步的设置或处理。ConfigurableApplicationContext继承自ApplicationContext，其主要提供了对ApplicationContext进行设置的能力。

实现一个ApplicationContextInitializer非常简单，因为它只有一个方法，但大多数情况下我们没有必要自定义一个ApplicationContextInitializer，即便是Spring Boot框架，它默认也只是注册了两个实现，毕竟Spring的容器已经非常成熟和稳定，你没有必要来改变它。

而 ApplicationListener的目的就没什么好说的了，它是Spring框架对Java事件监听机制的一种框架实现，具体内容在前文Spring事件监听机制这个小节有详细讲解。这里主要说说，如果你想为Spring Boot应用添加监听器，该如何实现？

Spring Boot提供两种方式来添加自定义监听器：

通过 SpringApplication.addListeners(ApplicationListener<?>...listeners)或者 SpringApplication.setListeners(Collection<?extendsApplicationListener<?>>listeners)两个方法来添加一个或者多个自定义监听器

既然SpringApplication的初始化流程中已经从 spring.factories中获取到 ApplicationListener的实现类，那么我们直接在自己的jar包的 META-INF/spring.factories文件中新增配置即可：

org.springframework.context.ApplicationListener=\cn.moondev.listeners.xxxxListener\

Spring Boot启动流程

Spring Boot应用的整个启动流程都封装在SpringApplication.run方法中，其整个流程真的是太长太长了，但本质上就是在Spring容器启动的基础上做了大量的扩展，按照这个思路来看看源码：

public ConfigurableApplicationContext run(String... args) { 
    StopWatch stopWatch = new StopWatch(); 
    stopWatch.start(); 
    ConfigurableApplicationContext context = null;
    FailureAnalyzers analyzers = null; 
    configureHeadlessProperty(); 
    // ① 
    SpringApplicationRunListeners listeners = getRunListeners(args);
    listeners.starting(); 
    try { 
        // ② 
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args); 
        ConfigurableEnvironment environment = prepareEnvironment(listeners,applicationArguments); 
        // ③ 
        Banner printedBanner = printBanner(environment); 
        // ④ 
        context = createApplicationContext(); 
        // ⑤ 
        analyzers = new FailureAnalyzers(context); 
        // ⑥ 
        prepareContext(context, environment, listeners, applicationArguments,printedBanner); 
        // ⑦  
        refreshContext(context); 
        // ⑧ 
        afterRefresh(context, applicationArguments); 
        // ⑨ 
        listeners.finished(context, null); 
        stopWatch.stop(); return context;
      } catch (Throwable ex) { 
        handleRunFailure(context, listeners, analyzers, ex); throw new IllegalStateException(ex);
      }
 }

① 通过SpringFactoriesLoader查找并加载所有的 SpringApplicationRunListeners，通过调用starting()方法通知所有的SpringApplicationRunListeners：应用开始启动了。

SpringApplicationRunListeners其本质上就是一个事件发布者，它在SpringBoot应用启动的不同时间点发布不同应用事件类型(ApplicationEvent)，如果有哪些事件监听者(ApplicationListener)对这些事件感兴趣，则可以接收并且处理。还记得初始化流程中，SpringApplication加载了一系列ApplicationListener吗？这个启动流程中没有发现有发布事件的代码，其实都已经在SpringApplicationRunListeners这儿实现了。

简单的分析一下其实现流程，首先看下SpringApplicationRunListener的源码：

public interface SpringApplicationRunListener { 
    // 运行run方法时立即调用此方法，可以用户非常早期的初始化工作 
    void starting(); 
    // Environment准备好后，并且ApplicationContext创建之前调用 
    void environmentPrepared(ConfigurableEnvironment environment); 
    // ApplicationContext创建好后立即调用 
    void contextPrepared(ConfigurableApplicationContext context); 
    // ApplicationContext加载完成，在refresh之前调用 
    void contextLoaded(ConfigurableApplicationContext context); 
    // 当run方法结束之前调用 
    void finished(ConfigurableApplicationContext context, Throwable exception);
}

SpringApplicationRunListener只有一个实现类： EventPublishingRunListener。①处的代码只会获取到一个EventPublishingRunListener的实例，我们来看看starting()方法的内容：

public void starting() { 
    // 发布一个ApplicationStartedEvent
    this.initialMulticaster.multicastEvent(new ApplicationStartedEvent(this.application, this.args));
}

② 创建并配置当前应用将要使用的Environment，Environment用于描述应用程序当前的运行环境，其抽象了两个方面的内容：配置文件(profile)和属性(properties)，开发经验丰富的同学对这两个东西一定不会陌生：不同的环境(eg：生产环境、预发布环境)可以使用不同的配置文件，而属性则可以从配置文件、环境变量、命令行参数等来源获取。因此，当Environment准备好后，在整个应用的任何时候，都可以从Environment中获取资源。

总结起来，②处的两句代码，主要完成以下几件事：

  • 判断Environment是否存在，不存在就创建（如果是web项目就创建 StandardServletEnvironment，否则创建 StandardEnvironment）
  • 配置Environment：配置profile以及properties
  • 调用SpringApplicationRunListener的 environmentPrepared()方法，通知事件监听者：应用的Environment已经准备好

③、SpringBoot应用在启动时会输出Banner等信息。

④、根据是否是web项目，来创建不同的ApplicationContext容器。

⑤、创建一系列 FailureAnalyzer，创建流程依然是通过SpringFactoriesLoader获取到所有实现FailureAnalyzer接口的class，然后在创建对应的实例。FailureAnalyzer用于分析故障并提供相关诊断信息。

⑥、初始化ApplicationContext，主要完成以下工作：

  • 将准备好的Environment设置给ApplicationContext
  • 遍历调用所有的ApplicationContextInitializer的 initialize()方法来对已经创建好的ApplicationContext进行进一步的处理
  • 调用SpringApplicationRunListener的 contextPrepared()方法，通知所有的监听者：ApplicationContext已经准备完毕
  • 将所有的bean加载到容器中
  • 调用SpringApplicationRunListener的 contextLoaded()方法，通知所有的监听者：ApplicationContext已经装载完毕

⑦、调用ApplicationContext的 refresh()方法，完成IoC容器可用的最后一道工序。

⑧、查找当前context中是否注册有CommandLineRunner和ApplicationRunner，如果有则遍历执行它们。

⑨、执行所有SpringApplicationRunListener的finished()方法。

这就是Spring Boot的整个启动流程，其核心就是在Spring容器初始化并启动的基础上加入各种扩展点，这些扩展点包括：ApplicationContextInitializer、ApplicationListener以及各种BeanFactoryPostProcessor等等。你对整个流程的细节不必太过关注，甚至没弄明白也没有关系，你只要理解这些扩展点是在何时如何工作的，能让它们为你所用即可。

转载自:https://juejin.cn/post/6844904082071633934
评论
请登录