SpringBoot的starter启动机制分析

Bertha 。 2021-11-02 06:08 294阅读 0赞

## 一、引言 ##

使用过SpringBoot的应该知道，SpringBoot通过默认配置很多框架的使用方式，帮我们大大简化了项目初始搭建以及开发过程。

下面将一步步分析SpringBoot的启动过程，着重分析SpringBoo的特性，自动装配。

首先回想一下用Spring框架是如何搭建Web项目的，通常要搭建一个基于Spring的Web应用，我们需要做以下一些工作：

*  pom文件中引入相关jar包，包括spring、springmvc、redis、mybaits、log4j等相关jar包
 *  配置web.xml，加入Listener配置、Filter配置、Servlet配置、log4j配置、error配置等
 *  配置数据库连接、配置spring事务
 *  配置视图解析器
 *  开启注解、自动扫描功能
 *  配置完成后部署tomcat、启动调试
 *  ……

对于熟悉这些流程的人来说，搭建一个初始项目，可能一个小时或者半天就过去了，不熟的可能就……但是用了SpringBoot之后一切都会变得非常便捷，下面首先来分析一下SpringBoot的起步依赖以及自动配置。

## 二、起步依赖 ##

### 1、pom文件 ###

在SpringBoot项目中，pom文件里面会引入以下jar：

<modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.4.RELEASE</version>
        <relativePath /> 
    </parent>
    
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>
    
    <properties>
        <java.version>1.8</java.version>
    </properties>
    
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        
            
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    
        
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>
    
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

> spring-boot-starter-web包自动帮我们引入了web模块开发需要的相关jar包  
> mybatis-spring-boot-starter包自动帮我们引入了dao开发相关的jar包

注：像`spring-boot-starter-xxx`这样的包是官方提供的starter，而像`xxx-spring-boot-starter`这样的包是第三方提供的starter

下面看一下mybatis-spring-boot-starter依赖  
![在这里插入图片描述][20190810120816911.png]  
可以看出`mybatis-spring-boot-starter`并没有任何源码，只有一个pom文件，它的作用就是帮我们引入其它jar

### 2、配置数据源 ###

spring:
     datasource:
        type: com.zaxxer.hikari.HikariDataSource
        url: jdbc:mysql://127.0.0.1:3306/mybatis_test
        username: root
        password: root
        driver-class-name: com.mysql.jdbc.Driver
        hikari:
         # 最小空闲连接数量
         minimum-idle: 5
         # 连接池最大连接数，默认是10
         maximum-pool-size: 60
         # 此属性控制从池返回的连接的默认自动提交行为,默认值：true
         auto-commit: true
         # 一个连接idle状态的最大时长（毫秒），超时则被释放（retired），缺省:10分钟
         idle-timeout: 600000
         # 此属性控制池中连接的最长生命周期，值0表示无限生命周期，默认1800000即30分钟
         max-lifetime: 1800000
         # 数据库连接超时时间,默认30秒，即30000
         connection-timeout: 60000

stater机制帮我们完成了项目起步所需要的的相关jar包。那问题来了，在传统的Spring应用中，我们要在`application.xml`中配置很多Bean，比如：dataSource的配置，transactionManager的配置……那SpringBoot是如何帮我们完成这些Bean的配置的呢？下面我们来分析这个过程……

## 三、自动配置 ##

### 1、基于java代码的Bean配置 ###

以mybatis为例，观察`mybatis-spring-boot-starter`这个包的依赖关系，可以发现`mybatis-spring-boot-starter`这个包帮我们自动引入了`mybatis-spring-boot-autoconfigure`这个包，这个包是干嘛呢？顾名思义，是起自动配置作用的，如下图：  
![在这里插入图片描述][20190810120928911.png]  
里面有`MybatisAutoConfiguration`这个类，打开这个类看看有些什么东西。  
![在这里插入图片描述][20190810120951225.png]  
熟悉@Configuration、@Bean这两个注解的人或许已经知道了，这两个注解一起使用就可以创建一个基于java代码的配置类，可以用来替代相应的xml配置文件。

> 被@Configuration注解修饰的类，可以看作是能生产让Spring IoC容器管理的Bean实例的工厂
> 
> 被@Bean注解修饰的方法，是告诉Spring，一个带有@Bean的注解方法将返回一个对象，该对象应该被注册到spring容器中

所以上面的`MybatisAutoConfiguration`这个类，自动帮我们生成了`SqlSessionFactory`这些Mybatis的重要实例并交给Spring容器管理，从而完成Bean的自动注册

### 2、自动配置条件依赖 ###

从`MybatisAutoConfiguration`这个类中使用的注解可以看出，要完成自动配置是有依赖条件的

@Configuration
    @ConditionalOnClass({  SqlSessionFactory.class, SqlSessionFactoryBean.class })
    @ConditionalOnBean(DataSource.class)
    @EnableConfigurationProperties(MybatisProperties.class)
    @AutoConfigureAfter(DataSourceAutoConfiguration.class)
    public class MybatisAutoConfiguration { 
    
     private static final Logger logger = LoggerFactory.getLogger(MybatisAutoConfiguration.class);
    
     private final MybatisProperties properties;
     private final Interceptor[] interceptors;
     private final ResourceLoader resourceLoader;
     private final DatabaseIdProvider databaseIdProvider;
     private final List<ConfigurationCustomizer> configurationCustomizers;
    
     ......

首先看一下SpringBoot常用的条件依赖注解：

*  @ConditionalOnBean：仅在当前上下文中存在某个bean时，才会实例化这个Bean
 *  @ConditionalOnClass：在类路径上，能找到某个class，才会实例化这个Bean
 *  @ConditionalOnExpression：当表达式为true的时候，才会实例化这个Bean
 *  @ConditionalOnMissingBean，仅在当前上下文中不存在某个bean时，才会实例化这个Bean
 *  @ConditionalOnMissingClass，某个class在类路径上不存在的时候，才会实例化这个Bean
 *  @ConditionalOnNotWebApplication：不是web应用时才会实例化这个Bean
 *  @AutoConfigureAfter，在某个bean完成自动配置后实例化这个bean
 *  @AutoConfigureBefore，在某个bean完成自动配置前实例化这个bean

根据这些依赖条件，所以要完成Mybatis的自动配置，需要在类路径中存在`SqlSessionFactory.class`、`SqlSessionFactoryBean.class`这两个类，在spring容器中，需要存在DataSource这个bean且这个bean完成自动注册。

再看下这个注解条件：

@AutoConfigureAfter(DataSourceAutoConfiguration.class)

这个注解的意思是：在`DataSourceAutoConfiguration`这个类完成自动配置后，再去实例化这个`MybatisAutoConfiguration`，进入`DataSourceAutoConfiguration`这个类，可以看到这个类属于这个包：

org.springframework.boot.autoconfigure.jdbc

这个包又属于`spring-boot-autoconfigure-2.0.4.RELEASE.jar`这个包，这个自动配置包帮我们引入了jdbc、kafka、logging、mail、mongo等包。很多包需要我们引入相应jar后自动配置才生效。  
![在这里插入图片描述][20190810121115228.png]

### 3、Bean参数的获取 ###

至此，我们已经知道了Bean的配置过程，但是还没有看到SpringBoot是如何读取yml或者properites配置文件的属性来创建数据源的？

在`DataSourceAutoConfiguration`类里面，我们注意到使用了`EnableConfigurationProperties`这个注解。

> 这个@EnableConfigurationProperties注解是干嘛的，可以参考另一篇文章：
> 
> https://blog.csdn.net/zxd1435513775/article/details/103661672

@Configuration
    @ConditionalOnClass({  DataSource.class, EmbeddedDatabaseType.class })
    @EnableConfigurationProperties(DataSourceProperties.class)
    @Import({  DataSourcePoolMetadataProvidersConfiguration.class,
            DataSourceInitializationConfiguration.class })
    public class DataSourceAutoConfiguration { 
    
        @Configuration
        @Conditional(EmbeddedDatabaseCondition.class)
        @ConditionalOnMissingBean({  DataSource.class, XADataSource.class })
        @Import(EmbeddedDataSourceConfiguration.class)
        protected static class EmbeddedDatabaseConfiguration { 
    
        }
    ......

进入`DataSourceProperties`中，可以看到，它封装了数据源的各个属性，且使用了注解`ConfigurationProperties`指定了配置文件的前缀。

@ConfigurationProperties(prefix = "spring.datasource")
    public class DataSourceProperties implements BeanClassLoaderAware, InitializingBean { 
    
        private ClassLoader classLoader;
    
        // Name of the datasource. Default to "testdb" when using an embedded database.
        private String name;
    
        // Whether to generate a random datasource name.
        private boolean generateUniqueName;
    
        /** * Fully qualified name of the connection pool implementation to use. By default, it * is auto-detected from the classpath. */
        private Class<? extends DataSource> type;
    
        // Fully qualified name of the JDBC driver. Auto-detected based on the URL by default.
        private String driverClassName;
    
        // JDBC URL of the database.
        private String url;
    
        // Login username of the database.
        private String username;
    
        // Login password of the database.
         private String password;
    
        // JNDI location of the datasource. Class, url, username & password are ignored when set.
        private String jndiName;
    
        // Initialize the datasource with available DDL and DML scripts.
        private DataSourceInitializationMode initializationMode =
        									 DataSourceInitializationMode.EMBEDDED;
    
        /** * Platform to use in the DDL or DML scripts (such as schema-${platform}.sql or * data-${platform}.sql). */
        private String platform = "all";
    
        // Schema (DDL) script resource references.
        private List<String> schema;
    
        // Username of the database to execute DDL scripts (if different).
        private String schemaUsername;
    
        // Password of the database to execute DDL scripts (if different).
        private String schemaPassword;
    
        // Data (DML) script resource references.
        private List<String> data;
    
        ......

> 下面简单说一下几个注解作用：
> 
> @ConfigurationProperties注解的作用：是把yml或者properties配置文件转化为Bean
> 
> @EnableConfigurationProperties注解的作用：是使@ConfigurationProperties注解生效。
> 
> 如果只配置@ConfigurationProperties注解，在spring容器中是获取不到yml或者properties配置文件转化的bean的

通过这种方式，把yml或者properties配置参数转化为Bean，这些Bean又是如何被发现与加载的？

### 4、Bean的发现 ###

SpringBoot默认扫描启动类所在的包下的主类与子类的所有组件，但并没有包括依赖包的中的类，那么依赖包中的Bean是如何被发现和加载的？

我们通常在启动类上加@SpringBootApplication这个注解，进入这个注解看一下

@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 { 
    
        /** * Exclude specific auto-configuration classes such that they will never be applied. * @return the classes to exclude */
        @AliasFor(annotation = EnableAutoConfiguration.class)
        Class<?>[] exclude() default { };
    
        /** * Exclude specific auto-configuration class names such that they will never be * applied. * @return the class names to exclude * @since 1.3.0 */
         ......

实际上重要的只有三个注解：

*  @Configuration（@SpringBootConfiguration里面还是应用了@Configuration）
 *  @EnableAutoConfiguration
 *  @ComponentScan

@Configuration的作用上面我们已经知道了，被注解的类将成为一个bean配置类。

@ComponentScan的作用就是自动扫描并加载符合条件的组件，比如@Component和@Repository等，最终将这些Bean定义加载到Spring容器中。

@EnableAutoConfiguration 这个注解的功能很重要，借助@Import的支持，收集和注册依赖包中相关的bean定义。

> 对于@Import注解的使用，可以参考另一篇文章：
> 
> https://blog.csdn.net/zxd1435513775/article/details/100625879?spm=1001.2014.3001.5501

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @AutoConfigurationPackage
    @Import(AutoConfigurationImportSelector.class)
    public @interface EnableAutoConfiguration { 
    
        String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
    
        /** * Exclude specific auto-configuration classes such that they will never be applied. * @return the classes to exclude */
        Class<?>[] exclude() default { };
    
        /** * Exclude specific auto-configuration class names such that they will never be * applied. * @return the class names to exclude * @since 1.3.0 */
        String[] excludeName() default { };
    
    }

如上源码，`@EnableAutoConfiguration`注解引入了`@AutoConfigurationPackage`和`@Import`这两个注解。

`@AutoConfigurationPackage`的作用就是自动配置的包，`@Impor`t导入需要自动配置的组件。

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @Import(AutoConfigurationPackages.Registrar.class)
    public @interface AutoConfigurationPackage { 
    
    }

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports { 
    
        @Override
        public void registerBeanDefinitions(AnnotationMetadata metadata,
                BeanDefinitionRegistry registry) { 
            register(registry, new PackageImport(metadata).getPackageName());
        }
    
        @Override
        public Set<Object> determineImports(AnnotationMetadata metadata) { 
            return Collections.singleton(new PackageImport(metadata));
        }
    
    }

那问题又来了，要搜集并注册到Spring容器的那些Beans来自哪里？

进入`AutoConfigurationImportSelector`类，我们可以发现\`\`SpringFactoriesLoader.loadFactoryNames`方法调用`loadSpringFactories\`方法从所有的jar包中读取META-INF/spring.factories文件信息。

下面是`spring-boot-autoconfigure`这个jar中`spring.factories`文件部分内容，其中有一个key为`org.springframework.boot.autoconfigure.EnableAutoConfiguration`的值定义了需要自动配置的Bean，通过读取这个配置获取一组@Configuration类。

org.springframework.boot.autoconfigure.AutoConfigurationImportListener=\
    org.springframework.boot.autoconfigure.condition.ConditionEvaluationReportAutoConfigurationImportListener
    
    # Auto Configuration Import Filters
    org.springframework.boot.autoconfigure.AutoConfigurationImportFilter=\
    org.springframework.boot.autoconfigure.condition.OnClassCondition
    
    # Auto Configure
    org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
    org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
    org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
    org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
    org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\

每个xxxAutoConfiguration都是一个基于java的bean配置类。实际上，这些xxxAutoConfiguration不是所有都会被加载，会根据xxxAutoConfiguration上的@ConditionalOnClass等条件判断是否加载，通过反射机制将spring.factories中@Configuration类实例化为对应的java实列。

到此我们已经知道怎么发现要自动配置的Bean了，最后一步就是怎么样将这些Bean加载到spring容器。

### 5、Bean 加载 ###

如果要让一个普通类交给Spring容器管理，通常有以下方法：

*  使用 @Configuration与@Bean 注解
 *  使用@Controller、@Service、@Repository、@Component 注解标注该类，然后启用@ComponentScan自动扫描
 *  使用@Import方法

SpringBoot中使用了@Import 方法，\`@EnableAutoConfiguration\`注解中使用了\`@Import(\{AutoConfigurationImportSelector.class\})\`注解。

`AutoConfigurationImportSelector`实现了`DeferredImportSelector`接口，`DeferredImportSelector`接口继承了`ImportSelector`接口，`ImportSelector`接口只有一个selectImports方法。

> selectImports方法返回一组Bean，`@EnableAutoConfiguration`注解借助@Import注解将这组Bean注入到Spring容器中，SpringBoot正式通过这种机制来完成Bean的注入的

## 四、总结 ##

我们可以将自动配置的关键几步以及相应的注解总结如下：

*  @Configuration与@Bean------>基于java代码的bean配置
 *  @Conditional------>设置自动配置条件依赖
 *  @EnableConfigurationProperties与@ConfigurationProperties------>读取配置文件转换为bean。
 *  @EnableAutoConfiguration、@AutoConfigurationPackage 与@Import------>实现bean发现与加载。

[20190810120816911.png]: /images/20211102/3a6e86dcda6240e8987d38f16692a827.png
[20190810120928911.png]: /images/20211102/35a187f65e1a44cf8844ff56e96df143.png
[20190810120951225.png]: /images/20211102/6e35378e362f431b8af820f7db03012f.png
[20190810121115228.png]: /images/20211102/2244d83e615340f8845dc26512a4ffbc.png