一.何为自动装配
自动装配是 SpringBoot 的核心功能，主要是让开发者尽可能少的关注一些基础化的 Bean 的配置，实际上完成的工作是如何自动将 Bean 装载到 Ioc 容器中。
在 SpringBoot 中如果想要引入一个新的模块，例如项目中想使用 Redis 缓存，只需要做以下几步即可。
1、在 pom.xml 文件中引入 spring-boot-starter-data-redis 相关的 jar 包
代码语言：javascript复制<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
2、在 application.properties 文件中加入 Redis 相关的配置
代码语言：javascript复制spring.redis.host=127.0.0.1
spring.redis.port=6379
3、在代码中引用 Redis 缓存的操作类
代码语言：javascript复制@Autowired
private RedisTemplate<String,String>redisTemplate;
为什么 RedisTemplate 可以被直接注入，它是什么时候加入到 Ioc 容器中的，这都是自动装配的功劳，我们一起来看一下。
二.自动装配过程
1、@EnableAutoConfiguration分析
SpringBoot 项目启动类上有 @SpringBootApplication 这样一个注解，它继承了 @EnableAutoConfiguration，主要作用是帮助 Springboot 应用把所有符合条件的配置类都加载到当前 SpringBoot 创建并使用的 Ioc 容器中。
这个注解主要由两部分组成
- @AutoConfigurationPackage，指定 SpringBoot 扫描的包范围，这个范围下使用 @Service 、 @Component 等注解的 Bean 加入 Ioc 容器，默认值是启动类所在的包路径，默认指定启动类路径下的类加载到 Ioc 容器。
- **@Import(AutoConfigurationImportSelector.class)**，将导入第三方提供的 Bean 配置类加载加载到 Ioc 容器。
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
...
}
1.1 @AutoConfigurationPackage
@AutoConfigurationPackage 指定 SpringBoot 扫描的包范围,主要逻辑在 AutoConfigurationPackages#register 方法中。
该方法有两个参数 registry 和 packageNames，在断点中发现 registry 实际上就是 DefaultListableBeanFactory 实例，packageNames 的值默认是启动类包所在的路径，在这里将 @AutoConfigurationPackage 指定的包路径添加到 DefaultListableBeanFactory，在后续Ioc容器扫描时将其加载进去。
1.2 AutoConfigurationImportSelector.class
AutoConfigurationImportSelector 主要是实现 importSelector 方法来实现基于动态 Bean 的加载功能，我们定位到 importSelector 方法看一下里面的逻辑。
代码语言：javascript复制@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
if (!isEnabled(annotationMetadata)) {
return NO_IMPORTS;
}
//1、从配置文件spring-autoconfigure-metadata.properties中加载自动装配候选规则
AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
.loadMetadata(this.beanClassLoader);
//2、获取@SpringBootApplication上配置的属性值
AnnotationAttributes attributes = getAttributes(annotationMetadata);
//3、使用SpringFactoriesLoader 加载classpath路径下META-INFspring.factories中
//通过key=org.springframework.boot.autoconfigure.EnableAutoConfiguration获取候选类
List<String> configurations = getCandidateConfigurations(annotationMetadata,attributes);
//4、去除重复值
configurations = removeDuplicates(configurations);
//5、获取exclude属性值，将exclude中的值排除掉
Set<String> exclusions = getExclusions(annotationMetadata, attributes);
checkExcludedClasses(configurations, exclusions);
configurations.removeAll(exclusions);
//6、检查候选配置类上的注解@ConditionalOnClass，如果要求的类不存在，则这个候选类会被过滤不被加载
configurations = filter(configurations, autoConfigurationMetadata);
fireAutoConfigurationImportEvents(configurations, exclusions);
return StringUtils.toStringArray(configurations);
}
第一步和第三步逻辑中涉及到两个非常重要的文件 spring-autoconfigure-metadata.properties、spring.factories
- spring.factories 主要记录了待自动装配的候选类，从下图断点中可以看到有 109 个。
- spring-autoconfigure-metadata.properties 中配置了系列 ConditionalOnClass 类和配置类之间的依赖，通过这个文件中配置的规则，来判断 spring.factories 哪些类真的需要加载。为什么会这样做，是因为很多的 @Configuration 其实是依托于其他的框架来加载的，如果当前的 classpath 环境下没有相关联的依赖，则意味着这些类没必要进行加载，断点的最后发现真正需要加载的只有 31 个。
- 加载 spring.factories 文件，借助了 Spring 框架提供的一个工具类 SpringFactoriesLoader，它的实现和 java 中的 SPI 机制原理是一样的，它相对于 SPI 的改进点在于不会一次性加载所有的类，而是根据 key 进行加载。
SPI ，全称为 Service Provider Interface，是一种服务发现机制。它通过在 ClassPath 路径下的 META-INF/services 文件夹查找文件，自动加载文件里所定义的类。这一机制为很多框架扩展提供了可能，比如在 Dubbo、JDBC 中都使用到了 SPI 机制。
2、@Import分析
在 @EnableAutoConfiguration 分析中，两种加载 Bean 到 Ioc 容器的方式，他们都是通过 @import 引入，这里我们来分析一下 @import 是在哪里进行加载的。
2.1 @import3种使用方式
- 引入普通类,直接在 @Import 中引入即可。
@Import(PersonConfig.class)
@Configuration
public class PersonConfiguration {
}
- 引入 ImportSelector 实现类（AutoConfigurationImportSelector 就是实现了这个接口），这个接口需要实现的方法是 selectImports()，它返回的是一个字符串数组，代表的是类名集合，这些类将会被加载到Ioc容器中。
@Import(TestImportSelector.class)
@Configuration
public class ImportTestConfig {
}
public class TestImportSelector implements ImportSelector {
@Override
public String[] selectImports(AnnotationMetadata importingClassMetadata) {
return new String[]{"com.example.service.TestService"};
}
}
- 引用 ImportBeanDefinitionRegistrar 实现类(AutoConfigurationPackages.Registrar 就是实现类这个接口)，这个接口需要实现的方法是 registerBeanDefinitions()，它有两个入参，第一个参数 AnnotationMetadata代表当前类的注解信息；第二个参数 registry 代表的是 DefaultListableBeanFactory 实例，因为参数 DefaultListableBeanFactory 代表的是 Ioc 容器，如果想注入 Bean，可以直接对该类进行操作。
@Import(TestImportBeanDefinitorSelector.class)
@Configuration
public class ImportBeanDefinitionTestConfig {
}
public class TestImportBeanDefinitorSelector implements ImportBeanDefinitionRegistrar {
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
BeanDefinitionRegistry registry) {
AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder
.rootBeanDefinition(Person.class)
.getBeanDefinition();
registry.registerBeanDefinition("person", beanDefinition);
}
}
2.2 @Import实现原理
- @Import 主要由 ConfigurationClassPostProcessor 后置处理器加载实现，ConfigurationClassPostProcessor 则实现了 BeanDefinitionRegistryPostProcessor 接口，在 invokeBeanFactoryPostProcessors() 方法中进行处理，该方法实例化并调用所有的 BeanFactory 后置处理器。
@Override
public void refresh() throws BeansException, IllegalStateException {
//....省略n行代码
//1.beanFactory后置处理逻辑，在这个方法里加载ConfigurationClassPostProcessor
invokeBeanFactoryPostProcessors(beanFactory);
//2.注册bean后置处理逻辑
registerBeanPostProcessors(beanFactory);
//...省略n行代码
//3.实例化非懒加载的bean，并加入到Ioc容器中
finishBeanFactoryInitialization(beanFactory);
//....省略n行代码
}
- ConfigurationClassPostProcessor 实现了方法 postProcessBeanDefinitionRegistry()，在这个方法中跟踪代码到 ConfigurationClassParser.parse()，所有配置类的解析逻辑都在 parse() 方法中进行处理。
- 在 ConfigurationClassParser.parseparse() 继续往下跟踪会到 doProcessConfigurationClass() 方法，在该方法中会有一些常用配置注解的解析，例如 @Component、@ComponentScan、@Bean、@Configuration、@Import 等。
@Nullable
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
throws IOException {
//...省略n行代码
//加载@Import注解，递归解析，获取导入的配置类
processImports(configClass, sourceClass, getImports(sourceClass), true);
//...省略n行代码
}
- processImports() 中主要实现类了 @Import 接口的 3 种不同的加载方式
private void processImports(ConfigurationClass configClass,
SourceClass currentSourceClass,
Collection<SourceClass> importCandidates,
boolean checkForCircularImports) {
//...省略n行代码
if (candidate.isAssignable(ImportSelector.class)) {
//1.实现了ImportSelector接口的类在@Import中引用逻辑
Class<?> candidateClass = candidate.loadClass();
ImportSelector selector = BeanUtils.instantiateClass(
candidateClass,ImportSelector.class);
ParserStrategyUtils.invokeAwareMethods(
selector, this.environment, this.resourceLoader, this.registry);
if (this.deferredImportSelectors != null &&
selector instanceof DeferredImportSelector) {
this.deferredImportSelectors.add(
new DeferredImportSelectorHolder(configClass, (DeferredImportSelector) selector));
} else {
String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);
processImports(configClass, currentSourceClass, importSourceClasses, false);
}
} else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
//2.实现了ImportBeanDefinitionRegistrar接口的类在@Import中引用逻辑
Class<?> candidateClass = candidate.loadClass();
ImportBeanDefinitionRegistrar registrar =BeanUtils.instantiateClass(
candidateClass, ImportBeanDefinitionRegistrar.class);
ParserStrategyUtils.invokeAwareMethods(
registrar, this.environment, this.resourceLoader, this.registry);
configClass.addImportBeanDefinitionRegistrar(
registrar, currentSourceClass.getMetadata());
} else {
//3.普通类直接在@Import中引用逻辑
this.importStack.registerImport(
currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
processConfigurationClass(candidate.asConfigClass(configClass));
}
//...省略n行代码
}
总结一下就是如下的方法链调用
代码语言：javascript复制refresh()=>invokeBeanFactoryPostProcessors()=>postProcessBeanDefinitionRegistry()=>parse()=>
doProcessConfigurationClass()=>processImports()
3、启动类何时加入到 Ioc 容器
前面我们分析了自动装配的主要逻辑，那么 SpringBoot 启动类又是如何加入到Ioc容器中的呢？
3.1 prepareContext() 中的 load() 方法
- 从 SpringBoot 启动类的 run() 方法开始，跟踪代码到 SpringApplication.run() 方法，这里是 SpringBoot 启动的核心逻辑。
- 在 SpringApplication.run() 方法中有一个 prepareContext() 方法，进入这个方法里面，会发现有一个 load() 方法，这里就是加载启动类的地方，它会将启动类注入到 Ioc 容器中。
private void prepareContext(ConfigurableApplicationContext context,
ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
ApplicationArguments applicationArguments, Banner printedBanner) {
//...省略n行代码
//加载启动类，将启动类注入到Ioc容器中
load(context, sources.toArray(new Object[0]));
//...省略n行代码
}
- 在断点中可以看到，SpringBoot 启动类注入到了 annotatedReader 中（AnnotatedBeanDefinitionReader 基于注解的 beanDefinition 解析器），在这里将启动类加入到了 Ioc 容器。
总结一下就是如下的方法链调用
代码语言：javascript复制run()=>prepareContext()()=>load()=>parse()=>register()
4、自动装配整体流程
基于以上3块的分析我们可以得到如下一个关于自动装配的流程图
三.总结
学习源码的过程中如果不了解源码的整体思路，直接看代码会迷失在源码的海洋中。要了解代码的整体脉络，以总-分-总的方式去学习，学会舍弃部分无关的代码，才能高效的阅读和学习源码，从中汲取到代码的精华所在，提升自己的编程能力。
参考资料：
- 知乎：@Import使用及原理详解
