1. 前言
我們知道，在spring中，一般的實現ImportSelector接口，然后重寫selectImports方法，就可以使用到spring的SPI技術，加載spring.factories中配置的org.springframework.boot.autoconfigure.EnableAutoConfiguration.EnableAutoConfiguration的類。
抱着測試的心態，給@SpringBootApplication的注解上實現的SelectorAutoConfigurationImportSelector#selectImports打上斷點測試，這一測試，不得了，心態崩了，debug沒進去。Demo有問題？換上開發的項目，還是沒有進debug，難道是大家說的有問題？不行，我這暴脾氣忍不了，要一探究竟。
Note: 本文基於SpringBoot：2.3.0.RELEASE。一般解析寫在代碼的注釋上
2. 序列圖
先擺上debug的時序圖，方法返回沒畫（太丑，me嫌棄，有個大概了解一下就行）
3. 代碼分析
代碼太多，跳過了部分簡單代碼，然后挑關鍵點說。
- 從這
SpringApplication#refresh當入口
protected void refresh(ConfigurableApplicationContext applicationContext) {
// 調用父類的refresh方法
applicationContext.refresh();
}
- 進入
org.springframework.context.support.AbstractApplicationContext#refresh方法
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Invoke factory processors registered as beans in the context.
// 調用BeanFactory前置處理器
invokeBeanFactoryPostProcessors(beanFactory);
}
- 進入
org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors，這有關鍵點，就是生成的postProcessorNames
// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
//
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
...
// 調用BeanDefinitionRegistry前置處理器
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
Debug圖片
我們通過Debug可以看出，currentRegistryProcessors中放的是ConfigurationClassPostProcessor的Bean對象，接着就調用了invokeBeanDefinitionRegistryPostProcessors方法並傳入ConfigurationClassPostProcessor。
- 接着進入
org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions方法
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
...
// 從BeanDefinition中找出帶有Configuration.class的，自己Debug可以進入if的兩個方法中查看
for (String beanName : candidateNames) {
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
if (logger.isDebugEnabled()) {
logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
}
}
else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
...
// 傳入候選人
parser.parse(candidates);
...
}
Debug圖片
通過圖片，可以看出，candidates只有一個，那就是啟動類SpringDemoApplication（測試項目的啟動類）.
- 進入
org.springframework.context.annotation.ConfigurationClassParser#parse()方法，開始解析啟動類。
public void parse(Set<BeanDefinitionHolder> configCandidates) {
for (BeanDefinitionHolder holder : configCandidates) {
BeanDefinition bd = holder.getBeanDefinition();
try {
if (bd instanceof AnnotatedBeanDefinition) {
// 進入此方法了。 這我是Debug進去的，沒有探究啟動類在被解析成BeanDefinition的時候，被解析成
// AnnotatedBeanDefinition， 有興趣的同學自己Debug追究一下
parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
}
}
...
// 這個有用，所以我留在這了，關鍵點。
this.deferredImportSelectorHandler.process();
}
- 接下來進入
org.springframework.context.annotation.ConfigurationClassParser#processConfigurationClass方法。
protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
...
// Recursively process the configuration class and its superclass hierarchy.
SourceClass sourceClass = asSourceClass(configClass, filter);
do {
// 我們可以通過注解，看出這個是循環調用,找到configClass 自己的configuration注解或繼承的注解中包含configuration的
// 不用多糾結，我們直接找到
sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
}
while (sourceClass != null);
}
- 進入
org.springframework.context.annotation.ConfigurationClassParser#doProcessConfigurationClass方法，直接分析代碼.
protected final SourceClass doProcessConfigurationClass(
ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
throws IOException {
if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
// Recursively process any member (nested) classes first
// 在這遞歸的，會回到上一步代碼中
processMemberClasses(configClass, sourceClass, filter);
}
// Process any @Import annotations
// 別的代碼不看，就這個名字，我們也知道這個類是干嘛的了吧！
processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
}
getImports(sourceClass)這個方法是遞歸調用，找到注解Import中的值。 放個Debug圖給大家瞅一下。CustomizedImportSelector是我自己測試的，
/**
* <br>自定義importSelector</br>
*
* @author fattyca1
*/
public class CustomizedImportSelector implements ImportSelector {
@Override
public String[] selectImports(AnnotationMetadata importingClassMetadata) {
return new String[]{"com.spring.demo.config.MyConfig"};
}
}
- 進入
org.springframework.context.annotation.ConfigurationClassParser#processImports方法，核心來了，就是問題的關鍵，到底是怎么使用SpringSPI的
private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter,
boolean checkForCircularImports) {
...
if (checkForCircularImports && isChainedImportOnStack(configClass)) {
this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
}
else {
this.importStack.push(configClass);
try {
for (SourceClass candidate : importCandidates) {
if (candidate.isAssignable(ImportSelector.class)) {
// Candidate class is an ImportSelector -> delegate to it to determine imports
Class<?> candidateClass = candidate.loadClass();
ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class,
this.environment, this.resourceLoader, this.registry);
Predicate<String> selectorFilter = selector.getExclusionFilter();
if (selector instanceof DeferredImportSelector) {
// 因為AutoConfigurationImportSelector繼承了DeferredImportSelector，所以會進入這個方法，放到
// 列表里處理，直接放到一個List中。
this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
}
}
}
...
}
}
}
org.springframework.context.annotation.ConfigurationClassParser.DeferredImportSelectorHandler#handle方法
public void handle(ConfigurationClass configClass, DeferredImportSelector importSelector) {
DeferredImportSelectorHolder holder = new DeferredImportSelectorHolder(configClass, importSelector);
if (this.deferredImportSelectors == null) {
DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
handler.register(holder);
handler.processGroupImports();
}
else {
// deferredImportSelectors 是一個ArrayList，在類部類中被初始化，所以走的此方法
this.deferredImportSelectors.add(holder);
}
}
自此，我們分析完AutoConfigurationImportSelector在第一遍解析完后，被放在哪，那接下來就是如何解析了。激動人心的時刻來了。那就是在ConfigurationClassParser#parse()中執行的代碼了this.deferredImportSelectorHandler.process();
org.springframework.context.annotation.ConfigurationClassParser.DeferredImportSelectorHandler#process代碼
public void process() {
List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
this.deferredImportSelectors = null;
try {
if (deferredImports != null) {
DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
deferredImports.sort(DEFERRED_IMPORT_COMPARATOR);
// 把list中的DeferredImportSelectorHolder注冊到DeferredImportSelectorGroupingHandler
// 這個register方法會對DeferredImportSelectorHolder進行封裝
deferredImports.forEach(handler::register);
handler.processGroupImports();
}
}
finally {
this.deferredImportSelectors = new ArrayList<>();
}
}
org.springframework.context.annotation.ConfigurationClassParser.DeferredImportSelectorGroupingHandler#register代碼
public void register(DeferredImportSelectorHolder deferredImport) {
// AutoConfigurationImportSelector返回的是AutoConfigurationGroup.class，代碼中已寫死
Class<? extends Group> group = deferredImport.getImportSelector().getImportGroup();
// 封裝成 DeferredImportSelector.Group 對象，並放到了groupings中，groupings是LinkedHashMap
// Group對象是用AutoConfigurationGroup.class生成
DeferredImportSelectorGrouping grouping = this.groupings.computeIfAbsent(
(group != null ? group : deferredImport),
key -> new DeferredImportSelectorGrouping(createGroup(group)));
grouping.add(deferredImport);
this.configurationClasses.put(deferredImport.getConfigurationClass().getMetadata(),
deferredImport.getConfigurationClass());
}
org.springframework.context.annotation.ConfigurationClassParser.DeferredImportSelectorGroupingHandler#processGroupImports方法，SpringSPI的調用點
public void processGroupImports() {
for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {
Predicate<String> exclusionFilter = grouping.getCandidateFilter();
//遍歷放入到grouping中的group，並執行getImports()方法，此方法就是SPI調用點！！！！
grouping.getImports().forEach(entry -> {
ConfigurationClass configurationClass = this.configurationClasses.get(entry.getMetadata());
try {
processImports(configurationClass, asSourceClass(configurationClass, exclusionFilter),
Collections.singleton(asSourceClass(entry.getImportClassName(), exclusionFilter)),
exclusionFilter, false);
}
catch (BeanDefinitionStoreException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to process import candidates for configuration class [" +
configurationClass.getMetadata().getClassName() + "]", ex);
}
});
}
}
org.springframework.context.annotation.ConfigurationClassParser.DeferredImportSelectorGrouping#getImports
public Iterable<Group.Entry> getImports() {
for (DeferredImportSelectorHolder deferredImport : this.deferredImports) {
// 調用group的process方法, 也就是上面分析，AutoConfigurationGroup.class類的process方法
this.group.process(deferredImport.getConfigurationClass().getMetadata(),
deferredImport.getImportSelector());
}
return this.group.selectImports();
}
org.springframework.boot.autoconfigure.AutoConfigurationImportSelector.AutoConfigurationGroup#process方法
public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
Assert.state(deferredImportSelector instanceof AutoConfigurationImportSelector,
() -> String.format("Only %s implementations are supported, got %s",
AutoConfigurationImportSelector.class.getSimpleName(),
deferredImportSelector.getClass().getName()));
// getAutoConfigurationEntry 熟悉的方法，SPI的具體執行邏輯
AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
.getAutoConfigurationEntry(annotationMetadata);
this.autoConfigurationEntries.add(autoConfigurationEntry);
for (String importClassName : autoConfigurationEntry.getConfigurations()) {
this.entries.putIfAbsent(importClassName, annotationMetadata);
}
}
自此，我們的代碼分析結束，發現AutoConfigurationImportSelector.class在SpringBoot啟動中，並不是調用的selectImports方法，而是直接調用的getAutoConfigurationEntry方法
4. 總結
SpringBoot在啟動中，AutoConfigurationImportSelector在被加載中，調用的不是selectImports方法， 而是直接被調用了getAutoConfigurationEntry方法。 騷年，你可長點心吧！