一.何為自動裝配
自動裝配是 SpringBoot 的核心功能，主要是讓開發者盡可能少的關注一些基礎化的 Bean 的配置，實際上完成的工作是如何自動將 Bean 裝載到 Ioc 容器中。
在 SpringBoot 中如果想要引入一個新的模塊，例如項目中想使用 redis 緩存，只需要做以下幾步即可。
1、在 pom.xml 文件中引入 spring-boot-starter-data-redis 相關的 jar 包
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
2、在 Application.properties 文件中加入 Redis 相關的配置
spring.redis.host=127.0.0.1
spring.redis.port=6379
3、在代碼中引用 Redis 緩存的操作類
@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 方法看一下里面的邏輯。
@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行代碼
}
總結一下就是如下的方法鏈調用
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 容器。
圖片
總結一下就是如下的方法鏈調用
run()=>prepareContext()()=>load()=>parse()=>register()
4、自動裝配整體流程
基于以上3塊的分析我們可以得到如下一個關于自動裝配的流程圖
圖片
三.總結
學習源碼的過程中如果不了解源碼的整體思路，直接看代碼會迷失在源碼的海洋中。要了解代碼的整體脈絡，以總-分-總的方式去學習，學會舍棄部分無關的代碼，才能高效的閱讀和學習源碼，從中汲取到代碼的精華所在，提升自己的編程能力。
參考資料：
- 知乎：@Import使用及原理詳解
