SpringBoot自动装配原理

一般我们搭建一个SpringBoot框架的时候，我们肯定是要有一个启动类，并且为其添加上注解@SpringBootApplication，启动类主要负责SpringBoot项目的启动。以下案例是一个标准的启动类：

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

那么接下来来说一说，在SpringBoot项目启动的时候，SpringBoot是如何完成自动装配的。

一. @SpringBootApplication注解

注解@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 

再开始讲自动装配流程之前，这里先对上面涉及到的个别注解进行一个补充。

1.1 @Target注解

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target

@Target主要用来设定注解的适用范围，并且通过ElementType枚举类来指定注解可以使用的范围。包含的值有：

属性	注解使用范围
TYPE	类，接口上或者枚举申明
FIELD	字段申明和枚举常量
METHOD	方法
PARAMETER	参数
CONSTRUCTOR	构造方法
LOCAL_VARIABLE	局部变量
ANNOTATION_TYPE	注解类型上
PACKAGE	安装包申明
TYPE_PARAMETER	类型参数申明
TYPE_USE	使用一种类型

1.2 @Retention注解

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention 

@Retention主要是用来设置注解保留的时间，主要通过RetentionPolicy来设置注解的生命周期，其中值有三种：

属性	注解使用范围
SOURCE	注解只保留在源文件，当Java文件编译成class文件的时候，注解被遗弃
CLASS	注解被保留到class文件，但jvm加载class文件时候被遗弃，这是默认的生命周期
RUNTIME	注解不仅被保存到class文件中，jvm加载class文件之后，仍然存在

1.3 @Documented注解

@Documented注解表明这个注解是由 javadoc记录的。 如果一个类型声明被文档化，它的注解成为公共API的一部分。

@SpringBootApplication注解中和自动配置有关的最重要的注解有两个：

1. @EnableAutoConfiguration。
2. @Import({AutoConfigurationImportSelector.class})。

接下来从@EnableAutoConfiguration注解开始分析。

二. @EnableAutoConfiguration

@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 {};
}

可以发现，他的前缀名是Enable。一般情况下，如果是基于JavaConfig的形式对Bean实现装载，那么必须要使用以下两个注解：

1. @Configuration
2. @Bean

而@Enable的本质就是对上面两个注解进行封装。 这里举个例子，拿Spring自带的定时器@EnableScheduling来说:

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Import({SchedulingConfiguration.class})
@Documented
public @interface EnableScheduling {
}

最重要的是@Import注解，他负责将大括号里面的类进行导入，从而实现自动装配，那么做一个类比可以发现，SpringBoot自动装配的原理大致如下：

1. 启动类上带有一个@SpringBootApplication注解。
2. @SpringBootApplication中包含@EnableAutoConfiguration注解。（Enable开头）
3. @EnableAutoConfiguration通过@Import注解将各种项目中应用到的类进行导入。（比如@EnableScheduling中导入SchedulingConfiguration.class）这里是AutoConfigurationImportSelector类，负责筛选。

2.1 @AutoConfigurationPackage注解

@EnableAutoConfiguration中还引入了@AutoConfigurationPackage注解。
以下是该注解的完整结构：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import({Registrar.class})
public @interface AutoConfigurationPackage {
    String[] basePackages() default {};

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

这里可以发现，该注解通过@Import导入了Registrar类，在项目启动的时候，主要调用了Registrar类的registerBeanDefinitions()方法，我们来看一下这个类：

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
	// 空构造器
    Registrar() {
    }
	/**
	 * metadata 启动类的元信息
	 * registry Bean注册器
	 */
	// 该方法主要是用来注册Bean的，注意，Bean一般都是封装成BeanDefinition来使用的
	// 封装成BeanDefinition有利于对Bean进行一些操作，比如Name的设置、生命周期的设置等等
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        AutoConfigurationPackages.register(registry, (String[])(new AutoConfigurationPackages.PackageImports(metadata)).getPackageNames().toArray(new String[0]));
    }

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

这里我们根据一个案例来理解这个类：

案例1：Registrar的注册

// 启动类
@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}
// Controller
@Controller
public class MyController {
}

目录结构如下：

打下断点后发现：
元信息如下：

再来看下这个方法：

AutoConfigurationPackages.register(registry, (String[])(new AutoConfigurationPackages.PackageImports(metadata)).getPackageNames().toArray(new String[0]));

这里就通过getPackageNames()方法来获取元信息中启动类所在路径的包名:

那AutoConfigurationPackages.register这个方法的作用可以用一句话来概括：根据传入的注册器和包名来注册该包名及其子包下所有需要注册并且实例化的Bean。

如下图，该方法将项目中所需用到的所有Bean都放到一个Map中：

这里对@AutoConfigurationPackage注解进行一个小总结就是：

1. 该类的主要作用是用作包扫描自动配置。
2. 通过导入Registrar类，将包路径（及子路径）下的Bean扫描并且注册到BeanFactory中。

2.2 AutoConfigurationImportSelector类

接下来再看看@EnableAutoConfiguration注解中导入的类：AutoConfigurationImportSelector。
AutoConfigurationImportSelector实现了ImportSelector接口，这个接口中有一个抽象方法：

public interface ImportSelector {
	// 指定需要装配到IOC容器的类，当在@Import中导入一个ImportSelector的实现类后
	// 就会把该实现类中返回的Class名称都装载到IOC容器里。
	// 通过以String[] 数组的形式，意义为：支持Bean的批量装配。
	// 并且可以通过上下文来决定哪些类能够被IOC容器初始化。
    String[] selectImports(AnnotationMetadata var1);
}

这里再通过案例的形式来了解这个选择器的使用：

案例2：ImportSelector的使用

项目结构如下：

定义两个Bean：

public class FirstBean {
    private String name = "张三";
    private Integer age = 10;

    @Override
    public String toString() {
        return "FirstBean{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class SecondBean {
    private String name = "李四";
    private Integer age = 20;

    @Override
    public String toString() {
        return "FirstBean{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

自定义的Selector：

public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        return new String[]{FirstBean.class.getName(), SecondBean.class.getName()};
    }
}

自定义注解：

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

启动类：

@SpringBootApplication
@MyEnableAutoImport
public class DemoApplication {

    public static void main(String[] args) {
    	// 获取上下文对象
        ConfigurableApplicationContext context = SpringApplication.run(DemoApplication.class, args);
        // 获得容器中的Bean
        FirstBean bean1 = context.getBean(FirstBean.class);
        SecondBean bean2 = context.getBean(SecondBean.class);
        System.out.println(bean1.toString());
        System.out.println(bean2.toString());
    }
}

结果如下：

在了解这个ImportSelector的用法后，回归自动装配，我们可以推测：自动装配这个过程也就是通过扫描，将指定包下的所有符合条件的Bean，通过Selector进行批量的自动装配即可。

2.2 小总结

那么在这里再做一个小总结，对于SpringBoot的自动装配也就是：

1. 通过@EnableAutoConfiguration注解引入两个功能。
2. 引入@AutoConfigurationPackage注解实现包的扫描并实现注册。
3. 导入AutoConfigurationImportSelector类（实现的顶层接口为ImportSelector，实现方法selectImports()），将扫描到的Bean实现批量装配。

三. 自动装配原理分析

上面通过两个案例来分析自动装配过程中的两个环节：Bean的注册和Bean的装配。接下来从SpringBoot本身的代码角度来对自动装配的原理进行分析。

进入到AutoConfigurationImportSelector类中,快速定位到selectImports()方法。（tips：idea上面会显示当前所在的类，点击类的图标，直接键盘上搜索即可出来）

来看看这个方法：

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

该方法主要的作用是：

• 从META-INF/spring-autoconfigure-metadata.properties中加载自动装配所需的条件元数据。（只有满足条件的Bean才能够被自动装配）

接下来重点分析下else分支中的getAutoConfigurationEntry()方法

protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
    if (!this.isEnabled(annotationMetadata)) {
        return EMPTY_ENTRY;
    } else {
    	// 1.获得@EnableAutoConfiguration注解的属性，如exclude、excludeName等。
        AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
        // 2.获得所有自动装配的配置类
        List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
        // 3.将所有配置类进行一个去重的筛选
        configurations = this.removeDuplicates(configurations);
        // 4.根据前者获得的属性exclude，将不需要进行自动装配的类进行剔除
        Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
        this.checkExcludedClasses(configurations, exclusions);
        configurations.removeAll(exclusions);
        configurations = this.getConfigurationClassFilter().filter(configurations);
        // 5.进行事件广播
        this.fireAutoConfigurationImportEvents(configurations, exclusions);
        // 6.返回经过多重的判断、筛选、过滤而得到的最终自动装配的集合
        return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
    }
}

这里的exclude、excludeName是在启动类上配置的，如下图：

此外，该方法中最终要的是第二步：获得所有的自动配置类，也就是getCandidateConfigurations()方法：

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
	// 扫描classpath下的META-INF/spring.factories文件。
    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;
}

这里说明几点：

1. 上面的方法用到了SpringFactoriesLoader，它是Spring内部提供的一种约定俗成的加载方式。
2. spring.factories文件中的数据以Key=Value的形式存储，因此SpringFactoriesLoader.loadFactoryNames()根据Key来获得对应的Value值。

而对于自动装配而言，在项目启动的时候，这里的Key是EnableAutoConfiguration，Value为多个配置类

返回的Value集合：

案例3：RedisAutoConfiguration自动配置类

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnClass({RedisOperations.class})
@EnableConfigurationProperties({RedisProperties.class})
@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})
public class RedisAutoConfiguration {
    public RedisAutoConfiguration() {
    }

    @Bean
    @ConditionalOnMissingBean(
        name = {"redisTemplate"}
    )
}

从这里可以观察到：

1. RedisAutoConfiguration是一个基于JavaConfig形式的配置类。
2. 除了基本的@Configuration注解，还有一个@ConditionalOnClass注解（条件控制机制），主要负责判断classpath下是否存在RedisOperations这个类，如果是，那么把当前配置类注册到IOC容器中。 说白了，就是看你项目中有没有用到这个配置类。
3. @EnableConfigurationProperties是属性的配置，即我们可以在application.properties配置文件中配置Redis的相关参数，而这些配置会加载到RedisProperties类中。

自动装配原理总结

SpringBoot自动装配的流程如下：

1. 启动类添加了@SpringBootApplication注解，该注解下有一个叫@EnableAutoConfiguration的注解。
2. @EnableAutoConfiguration包含注解@AutoConfigurationPackage，负责项目中类的扫描和注册。
3. @EnableAutoConfiguration通过@Import导入AutoConfigurationImportSelector类，将扫描到的类进行自动装配。
4. AutoConfigurationImportSelector实现了ImportSelector接口，重写了方法selectImports()，用于实现配置类的批量导入。
5. 方法selectImports()通过SpringFactoriesLoader类加载机制，扫描classpath下的META-INF/spring.factories文件，读取需要实现自动装配的配置类。
6. 通过条件筛选，把不符合条件的 配置类剔除，最终返回实现自动装配。