第十章 springboot源码系列-依赖管理和自动配置

「爱情、让人受尽委屈。」 2022-10-13 05:17 176阅读 0赞

**目录**

前言

一、依赖管理

1.1 spring-boot-starter-parent

1.2 spring-boot-starter-web

二、自动配置

2.1 引入@EnableAutoConfiguration

2.2 准备了解@EnableAutoConfiguration

2.2.1 导入普通类

2.2.2 导入配置类

2.2.3 导入ImportSelector 的实现类

2.2.4 导入ImportBeanDefinitionRegistrar

2.3 @EnableAutoConfiguration

2.3.1 @AutoConfigurationPackage

2.3.2 @Import(AutoConfigurationImportSelector.class)

--------------------

# 前言 #

关于springboot,我们使用它的主要原因是配置极其简单，其中配置我们过去主要工作一是配置依赖，有时候甚至还要解决依赖冲突；二是需要进行大量的文件配置。springboot正是凭借着依赖管理和自动配置来实现这些功能，大大简化开发成本，当然springboot还有其他很多强大功能。今天我们就可以研究一下这两个功能是怎么实现的。

# 一、依赖管理 #

在Spring Boot入门程序中，项目pom.xml文件有两个核心依赖，分别是spring-boot-starter-  
parent和spring-boot-starter-web。你会发现有了这两个导入就可以跑起来一个web服务，依赖一些常用第三方框架在导入dependency时不需要指定版本。实际上spring-boot-starter-parent父依赖启动器的主要作用是进行版本统一管理，spring-boot-starter-web依赖启动器的主要作用是基于依赖传递打包了Web开发场景所需的底层所有依赖（springboot的引入第三方框架starter都是相同原理，这里以spring-boot-starter-web举例剖析）。

## 1.1 spring-boot-starter-parent ##

项目中的pom.xml文件中找到spring-boot-starter-parent依赖，示例代码如下:

<parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.2.9.RELEASE</version>
      <relativePath/> 
    </parent>

上述代码中，将spring-boot-starter-parent依赖作为Spring Boot项目的统一父项目依赖管理，使用“Ctrl+鼠标左键”进入并查看spring-boot-starter-parent底层源文件。

首先看 spring-boot-starter-parent 的 properties 节点：

<properties>
       <main.basedir>${basedir}/../../..</main.basedir>
       <java.version>1.8</java.version>
       <resource.delimiter>@</resource.delimiter>
        
       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
       <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
       <maven.compiler.source>${java.version}</maven.compiler.source>
       <maven.compiler.target>${java.version}</maven.compiler.target>
    </properties>

在这里 spring-boot-starter-parent 定义了：

*  工程的Java版本为 1.8
 *  工程代码的编译源文件编码格式为 UTF-8
 *  工程编译后的文件编码格式为 UTF-8
 *  Maven打包编译的版本

最后来看spring-boot-starter-parent的父依赖 spring-boot-dependencies，spring-boot dependencies的properties节点，这个才是SpringBoot项目的真正管理依赖的项目，里面定义了SpringBoot相关的版本。

spring-boot-starter-parent 通过继承 spring-boot-dependencies 从而实现了SpringBoot的版本依  
赖管理,所以我们的SpringBoot工程继承spring-boot-starter-parent后已经具备版本锁定等配置了,这也就是在 Spring Boot 项目中部分依赖不需要写版本号的原因。

## 1.2 spring-boot-starter-web ##

spring-boot-starter-parent父依赖启动器的主要作用是进行版本统一管理，那么项目运行依赖的JAR包是从何而来的？

查看spring-boot-starter-web依赖文件源码，核心代码具体如下：

<dependencies>
        <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter</artifactId>
          <version>2.2.9.RELEASE</version>
          <scope>compile</scope>
        </dependency>
        <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-json</artifactId>
          <version>2.2.9.RELEASE</version>
          <scope>compile</scope>
        </dependency>
        <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-tomcat</artifactId>
          <version>2.2.9.RELEASE</version>
          <scope>compile</scope>
        </dependency>
        <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-validation</artifactId>
          <version>2.2.9.RELEASE</version>
          <scope>compile</scope>
          <exclusions>
            <exclusion>
              <artifactId>tomcat-embed-el</artifactId>
              <groupId>org.apache.tomcat.embed</groupId>
            </exclusion>
          </exclusions>
        </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-web</artifactId>
          <version>5.2.8.RELEASE</version>
          <scope>compile</scope>
        </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-webmvc</artifactId>
          <version>5.2.8.RELEASE</version>
          <scope>compile</scope>
        </dependency>
      </dependencies>

从上述代码可以发现，spring-boot-starter-web依赖启动器的主要作用是打包了Web开发场景所需的底层所有依赖（基于依赖传递，当前项目也存在对应的依赖jar包）正是如此，在pom.xml中引入spring-boot-starter-web依赖启动器时，就可以实现Web场景开发，而不需要额外导入Tomcat服务器以及其他Web依赖文件等。

Spring Boot除了提供有上述介绍的Web依赖启动器外，还提供了其他许多开发场景的相关依赖：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tpbmcxMzEyNw_size_16_color_FFFFFF_t_70][]

Spring Boot官方并不是针对所有场景开发的技术框架都提供了场景启动器，各类第三方技术框架所在的开发团队主动与Spring Boot框架进行了整合，实现了各自的依赖启动器。在starter命名规范上一般可以区分,一般springboot整合的框架名称在后面，如spring-boot-starter-web，第三方命名自己框架名称在前（如druid-spring-boot-starter）。

# 二、自动配置 #

## 2.1 引入`@EnableAutoConfiguration` ##

大家都知道启动springboot，只需要在主启动类上标注 `@SpringBootApplication` 注解。下面我们看下他的源码。

@Target({ElementType.TYPE}) //注解的适用范围,Type表示注解可以描述在类、接口、注解或枚举中
    @Retention(RetentionPolicy.RUNTIME) //表示注解的生命周期，Runtime运行时
    @Documented //表示注解可以记录在javadoc中
    @Inherited  //表示可以被子类继承该注解
    @SpringBootConfiguration   // 标明该类为配置类
    @EnableAutoConfiguration   // 启动自动配置功能
    @ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes =
    TypeExcludeFilter.class),
    @Filter(type = FilterType.CUSTOM, classes =AutoConfigurationExcludeFilter.class) })
    public @interface SpringBootApplication {
    。。。。
    }

实际这个注解是一个组合注解，包括3个主要注解。标注它之后就会触发自动配置（`@EnableAutoConfiguration`）和组件扫描（`@ComponentScan`）。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tpbmcxMzEyNw_size_16_color_FFFFFF_t_70 1][]

`@ComponentScan` 默认扫描当前配置类所在包及子包下的所有组件， `exclude` 属性会将主启动类、自动配置类屏蔽掉。

```@SpringBootConfiguration` 并没有对`@Configuration` 其做实质性扩展，仅仅还是标注一个配置类，被spring当做配置文件使用。

实际做自动配置的是`@EnableAutoConfiguration，下面我们重点说一下这个注解。`

## 2.2 准备了解`@EnableAutoConfiguration` ##

在了解 `@EnableAutoConfiguration` 之前，先了解 SpringFramework 的原生手动装配机制，这对后续阅读 `@EnableAutoConfiguration` 有很大帮助，因为它运用了这块的装配机制。

在原生的 SpringFramework 中，装配组件有三种方式：

*  使用模式注解 `@Component` 等（Spring2.5+）
 *  使用配置类 `@Configuration` 与 `@Bean` （Spring3.0+）
 *  使用模块装配 `@EnableXXX` 与 `@Import` （Spring3.1+）

`@Component` 及衍生注解很常见，咱开发中常用的套路，不再赘述，但模式注解只能在自己编写的代码中标注，无法控制是否装配jar包中的组件。为此可以使用 `@Configuration` 与 `@Bean`，手动装配组件，但这种方式不是自动的装配，一旦注册过多，会导致编码成本高，维护不灵活等问题。SpringFramework 提供了模块装配功能，通过给配置类标注 `@EnableXXX` 注解，再在注解上标注 `@Import` 注解，即可完成组件自动装配的效果，如果第三方框架使用的是这种方式加载一些类，需要时加上注解就可以，不需要不加注解，就不会装配进容器。

`@Import` 可以传入四种类型：

*  普通类
 *  配置类
 *  `ImportSelector` 的实现类
 *  `ImportBeanDefinitionRegistrar` 的实现类

### 2.2.1 导入普通类 ###

@Import({Red.class})
    public @interface EnableColor {
        
    }
    
    @EnableColor
    @Configuration
    public class ColorConfiguration {
        
    }
    
    public class App {
        public static void main(String[] args) throws Exception {
            AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(ColorConfiguration.class);
            String[] beanDefinitionNames = ctx.getBeanDefinitionNames();
            Stream.of(beanDefinitionNames).forEach(System.out::println);
        }
    }

### 2.2.2 导入配置类 ###

@Configuration
    public class ColorRegistrarConfiguration {
        
        @Bean
        public Yellow yellow() {
            return new Yellow();
        }  
    }
    
    @Import({Red.class,ColorRegistrarConfiguration.class})
    public @interface EnableColor {
        
    }
    
    
    ColorConfiguration类和APP同2.2.1

这样Red、ColorRegistrarConfiguration 和 Yellow 都已注册到IOC容器中。

### 2.2.3 导入`ImportSelector` 的实现类 ###

public class ColorImportSelector implements ImportSelector {
        
        @Override
        public String[] selectImports(AnnotationMetadata importingClassMetadata) {
            return new String[] {Blue.class.getName(), Green.class.getName()};
        }
    }
    
    @Import({Red.class, ColorRegistrarConfiguration.class, ColorImportSelector.class})
    public @interface EnableColor {
        
    }

**ColorImportSelector** 没有注册到IOC容器中，两个新的颜色类被注册。

### 2.2.4 导入ImportBeanDefinitionRegistrar ###

public class ColorImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
        
        @Override
        public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
            registry.registerBeanDefinition("black", new RootBeanDefinition(Black.class));
        } 
    }
    
    @Import({Red.class, ColorRegistrarConfiguration.class, ColorImportSelector.class, ColorImportBeanDefinitionRegistrar.class})
    public @interface EnableColor {
        
    }

ColorImportBeanDefinitionRegistrar 没有注册到IOC容器中，black类被注册。

以上就是 SpringFramework 的手动装配方法。那 SpringBoot 又是如何做自动装配的呢？

## 2.3 @EnableAutoConfiguration ##

我们先来看下@EnableAutoConfiguration的源码：

// 自动配置包
    @AutoConfigurationPackage
    // Spring的底层注解@Import，给容器中导入一个组件；
    // 导入的组件是AutoConfigurationPackages.Registrar.class
    @Import(AutoConfigurationImportSelector.class)
    // 告诉SpringBoot开启自动配置功能，这样自动配置才能生效。
    public @interface EnableAutoConfiguration {
          。。。。
    }

这里我们看到@EnableAutoConfiguration也是一个组合注解。

### 2.3.1 @AutoConfigurationPackage ###

@Import(AutoConfigurationPackages.Registrar.class) // 导入Registrar中注册的组件
    public @interface AutoConfigurationPackage {
    }

咱从一开始学 SpringBoot 就知道一件事：主启动类必须放在所有自定义组件的包的最外层，以保证Spring能扫描到它们。由此可知是它起的作用。它的实现原理是在注解上标注了 `@Import`，导入了一个 `AutoConfigurationPackages.Registrar` 。

/**
     * {@link ImportBeanDefinitionRegistrar} to store the base package from the importing
     * configuration.用于保存导入的配置类所在的根包。
     */
    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));
        }
    
    }

很明显，它就是实现把主配置所在根包保存起来以便后期扫描用的。分析源码：

`Registrar` 实现了 `ImportBeanDefinitionRegistrar` 接口，它向IOC容器中要手动注册组件。

在重写的 `registerBeanDefinitions` 方法中，它要调用外部类 `AutoConfigurationPackages` 的register方法，这里传入的参数就是主启动类的所在包。再看register方法：

private static final String BEAN = AutoConfigurationPackages.class.getName();
    
    public static void register(BeanDefinitionRegistry registry, String... packageNames) {
        // 判断 BeanFactory 中是否包含 AutoConfigurationPackages
        if (registry.containsBeanDefinition(BEAN)) {
            BeanDefinition beanDefinition = registry.getBeanDefinition(BEAN);
            ConstructorArgumentValues constructorArguments = beanDefinition.getConstructorArgumentValues();
            // addBasePackages：添加根包扫描包
            constructorArguments.addIndexedArgumentValue(0, addBasePackages(constructorArguments, packageNames));
        }
        else {
            GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
            beanDefinition.setBeanClass(BasePackages.class);
            beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(0, packageNames);
            beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
            registry.registerBeanDefinition(BEAN, beanDefinition);
        }
    }

AutoConfigurationPackages.Registrar这个类就干一个事，注册一个 Bean ，这个 Bean 就是org.springframework.boot.autoconfigure.AutoConfigurationPackages.BasePackages ，它有一个参数，这个参数是使用了 @AutoConfigurationPackage 这个注解的类所在的包路径,保存自动配置  
类以供之后的使用。

### 2.3.2 @Import(AutoConfigurationImportSelector.class) ###

这里@Import导入的就是一个ImportSelector类，我们来看这个AutoConfigurationImportSelector。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tpbmcxMzEyNw_size_16_color_FFFFFF_t_70 2][]

它的核心部分，就是实现的 `ImportSelector` 的 `selectImport` 方法，然后里面重要的方法`getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata)` 。

/**
     * Return the {@link AutoConfigurationEntry} based on the {@link AnnotationMetadata}
     * of the importing {@link Configuration @Configuration} class.
     * 
     * 根据导入的@Configuration类的AnnotationMetadata返回AutoConfigurationImportSelector.AutoConfigurationEntry。
     */
    protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
             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 = filter(configurations, autoConfigurationMetadata);
        fireAutoConfigurationImportEvents(configurations, exclusions);
        return new AutoConfigurationEntry(configurations, exclusions);
    }

这个方法里有一个非常关键的集合：**configurations，**这个 集合的数据，都是通过 `getCandidateConfigurations` 方法来获取：

protected Class<?> getSpringFactoriesLoaderFactoryClass() {
        return EnableAutoConfiguration.class;
    }
    
    protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
        // SPI机制加载自动配置类
        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;
    }

我们继续跟踪这个loadFactoryNames方法：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tpbmcxMzEyNw_size_16_color_FFFFFF_t_70 3][]

源码中使用 classLoader 去加载了指定常量路径下的资源： `FACTORIES_RESOURCE_LOCATION` ，而这个常量指定的路径实际是：**META-INF/spring.factories** ，这个文件内容：

# Initializers
    org.springframework.context.ApplicationContextInitializer=\
    org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
    org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener
    
    # Application Listeners
    org.springframework.context.ApplicationListener=\
    org.springframework.boot.autoconfigure.BackgroundPreinitializer
    
    # Auto Configuration Import Listeners
    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.OnBeanCondition,\
    org.springframework.boot.autoconfigure.condition.OnClassCondition,\
    org.springframework.boot.autoconfigure.condition.OnWebApplicationCondition
    
    # 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,\
    ......

之后拿到这个资源文件，以 Properties 的形式加载，并取出 `org.springframework.boot.autoconfigure.EnableAutoConfiguration` 指定的所有自动配置类（是一个很大的字符串，里面都是自动配置类的全限定类名），装配到IOC容器中，之后自动配置类就会通过 `ImportSelector` 和 `@Import` 的机制被创建出来，之后就生效了。

这也就解释了为什么 **即便没有任何配置文件，SpringBoot的Web应用都能正常运行，实际就是采取了SPI的机制**。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tpbmcxMzEyNw_size_16_color_FFFFFF_t_70]: /images/20221005/8f1d776a47e44c9583949c6037bf4fe6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tpbmcxMzEyNw_size_16_color_FFFFFF_t_70 1]: /images/20221005/dc7b7a2495304769a5c07abc9b97bf60.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tpbmcxMzEyNw_size_16_color_FFFFFF_t_70 2]: /images/20221005/3fbfbde7ec4e42fb97b9cf4636648faa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tpbmcxMzEyNw_size_16_color_FFFFFF_t_70 3]: /images/20221005/5140256be203478f9509193b92130f7a.png