Spring Boot 自动装配流程

Spring Boot 自动装配流程

本文以 mybatis-spring-boot-starter 为例简单分析 Spring Boot 的自动装配流程。

Spring Boot 发现自动配置类

这里说的自动配置类指的是在 META-INF/spring.factories 文件中声明的 XXXAutoConfiguration 类。

首先，我们从 @SpringBootApplication 注解的定义中，我们可以发现有一个叫做 @EnableAutoConfiguration 的注解，这也是 SpringBoot 实现自动装配最关键的注解。

//@EnableAutoConfiguration 注解的定义
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

    Class<?>[] exclude() default {};

    String[] excludeName() default {};
}

@Target @Retention @Documented @Inherited 都是 jdk 提供的注解，有兴趣可以去查查看，这里就不做分析了。这里主要分析 @AutoConfigurationPackage 和 @Import({AutoConfigurationImportSelector.class}) 究竟起到什么作用。

//@AutoConfigurationPackage 注解的定义
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import({Registrar.class})
public @interface AutoConfigurationPackage {
}

在 @AutoConfigurationPackage 注解的定义中，我们又发现一个 @Import 注解。@Import 注解是由 Spring 提供的，作用是将某个类实例化并加入到 Spring IoC 容器中。所以我们要想知道 @Import({Registrar.class}) 究竟做了什么就需要了解 Registrar 这个类里包含了哪些方法。

//Registrar 类的定义
static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
    Registrar() {
    }

    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        AutoConfigurationPackages.register(registry, (new AutoConfigurationPackages.PackageImport(metadata)).getPackageName());
    }

    public Set<Object> determineImports(AnnotationMetadata metadata) {
        return Collections.singleton(new AutoConfigurationPackages.PackageImport(metadata));
    }
}

Registrar 类里一共有两个方法，分别是 determineImports 和 registerBeanDefinitions 。

determineImports 方法在我的项目的启动过程中并没有触发断点，官方的文档描述这个方法返回的是一组代表要导入项的对象。

registerBeanDefinitions 方法触发断点后发现

new AutoConfigurationPackages.PackageImport(metadata)).getPackageName() 方法返回的就是 @SpringBootApplication 注解所在的类的包名。

所以 @AutoConfigurationPackage 注解的作用应该是扫描与 @SpringBootApplication 标注的类同一包下的所有组件。

了解了 @AutoConfigurationPackage 注解后，我们回到 @EnableAutoConfiguration 的定义，还有一个 @Import({AutoConfigurationImportSelector.class}) 需要我们了解。AutoConfigurationImportSelector 类定义的内容很多，我们着重了解其中一个重要的方法

public String[] selectImports(AnnotationMetadata annotationMetadata) {
    if (!this.isEnabled(annotationMetadata)) {
        return NO_IMPORTS;
    } else {
        AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
        AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata);
        return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
    }
}

这个方法中，除了 loadMetadata 获取注解元数据之外，就是 getAutoConfigurationEntry 获取自动配置条目。

//getAutoConfigurationEntry 的定义
protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata) {
    if (!this.isEnabled(annotationMetadata)) {
        return EMPTY_ENTRY;
    } else {
        AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
        List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
        configurations = this.removeDuplicates(configurations);
        Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
        this.checkExcludedClasses(configurations, exclusions);
        configurations.removeAll(exclusions);
        configurations = this.filter(configurations, autoConfigurationMetadata);
        this.fireAutoConfigurationImportEvents(configurations, exclusions);
        return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
    }
}

然后我们再进入到这个叫做 getCandidateConfigurations 的方法中，这个方法名告诉我们这个方法的作用是获取候选配置。

//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;
}

从这个方法中的 Assert.notEmpty() 中我们可以反推得出，Spring Boot 除了扫描自己 jar 包中 META-INF/spring.factories 之外，还会去找别的 jar 包中是否存在 META-INF/spring.factories 。这也为第三方开发自己的 spring-boot-starter 提供了便利。

@Conditional 系列注解

在研究 mybatis-spring-boot-starter 之前，我们还需要了解一下 Spring 为提供的强大的 @Conditional 系列注解。

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

表格中的系统指的是项目本身，而非操作系统。

mybatis-spring-boot-starter

在 mybatis-spring-boot-starter 中，我们可以看到内容很少，仅有一个 pom.xml 文件用于引入依赖，所以 mybatis-spring-boot-starter 并不直接起作用，而是利用其它依赖完成自动配置。

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-autoconfigure</artifactId>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
    </dependency>
</dependencies>

我们可以发现 mybatis-spring-boot-starter 的依赖项中有一个叫做 mybatis-spring-boot-autoconfigure 的依赖项。这很有可能就是 mybatis 对自己完成自动装配真正起作用的工具。

果然在 mybatis-spring-boot-autoconfigure 的 META-INF 中我们找到了 spring.factories 文件。

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.mybatis.spring.boot.autoconfigure.MybatisLanguageDriverAutoConfiguration,\
org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration

MybatisLanguageDriverAutoConfiguration 类是对各种语言的支持，如 Thymeleaf 、FreeMarker 等。配置 Mybatis 核心组件的是 MybatisAutoConfiguration 类。

//MybatisAutoConfiguration 类定义
@Configuration
@ConditionalOnClass({SqlSessionFactory.class, SqlSessionFactoryBean.class})
@ConditionalOnSingleCandidate(DataSource.class)
@EnableConfigurationProperties({MybatisProperties.class})
@AutoConfigureAfter({DataSourceAutoConfiguration.class,
                     MybatisLanguageDriverAutoConfiguration.class})
public class MybatisAutoConfiguration implements InitializingBean {
    //....
}

首先 MybatisAutoConfiguration 类是一个被 @Configuration 标记了的配置类。这不难理解，MybatisAutoConfiguration 类会为 Mybatis 配置一些关键的 Bean 并加入到容器中去。

接着就是两个 @Conditional 系列的注解，表示当项目中存在 SqlSessionFactory.class 与 SqlSessionFactoryBean.class 并且存在 DataSource.class 的单例实例或者首选实例时，MybatisAutoConfiguration 才会被加入到容器中去。

@EnableConfigurationProperties({MybatisProperties.class}) 这个注解的作用是将配置文件（ .propertyies 和 .yml）与 MybatisProperties 类关联起来，也就是说这个注解能让 Spring Boot 从配置文件中读取数据。

@AutoConfigureAfter({DataSourceAutoConfiguration.class, MybatisLanguageDriverAutoConfiguration.class}) 这个注解的作用也非常明显，就是要求 Spring Boot 在装配 MybatisAutoConfiguration 之前先完成 DataSourceAutoConfiguration 和 MybatisLanguageDriverAutoConfiguration 的装配。这样可以保证 Mybatis 在装配时，所有的依赖项都已经到位。

除了 MybatisAutoConfiguration 本身之外，类中也定义了一些按条件生成的 Bean，保证 Mybatis 能在各种条件下成功的自动装配。

总结

1. Spring Boot 在启动时除了扫描与启动类同一包下的组件之外，还会检查各个 jar 包中是否存在 META-INF/spring.factories 文件，为自动装配做准备。
2. 第三方的 spring-boot-starter 会通过将自己的自动装配类写到 META-INF/spring.factories 中让 Spring Boot 加载到容器中，使自动装配类能够生效。
3. 第三方的自动装配类会通过利用 @Conditional 系列注释保证自己能在各种环境中成功自动装配。