SpringBoot深入理解 -- @AliasFor注解的作用
SpringBoot源碼解析 -- SpringBoot啟動過程
SpringBoot源碼解析 -- AutoConfigure的實(shí)現(xiàn)原理
SpringBoot源碼解析 -- @ComponentScan的實(shí)現(xiàn)原理
SpringBoot源碼解析 -- @Value,@Autowired實(shí)現(xiàn)原理
SpringBoot源碼解析 -- Tomcat，SpringMVC啟動
SpringBoot源碼解析 -- Logging，Environment啟動

源碼分析基于spring boot 2.1

SpringBoot中使用@EnableAutoConfiguration注解啟動AutoConfigure功能

@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
    ...
}

這里起作用的實(shí)際上是@Import和AutoConfigurationImportSelector。
@Import注解非常重要，它是SpringBoot中AutoConfiguration功能的基礎(chǔ)。

前面解析SpringBoot啟動過程的文章說過，SpringBoot啟動時(shí)會注入ConfigurationClassPostProcessor，該P(yáng)ostProcessor正是處理@Import的類。

ConfigurationClassPostProcessor#postProcessBeanFactory -> ConfigurationClassPostProcessor#processConfigBeanDefinitions

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
    List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
    String[] candidateNames = registry.getBeanDefinitionNames();

    for (String beanName : candidateNames) {
        BeanDefinition beanDef = registry.getBeanDefinition(beanName);
        if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
                ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
            if (logger.isDebugEnabled()) {
                logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
            }
        }
        else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {   // #1
            configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
        }
    }
    if (configCandidates.isEmpty()) {
        return;
    }

    ...
    
    ConfigurationClassParser parser = new ConfigurationClassParser(
            this.metadataReaderFactory, this.problemReporter, this.environment,
            this.resourceLoader, this.componentScanBeanNameGenerator, registry);    //#2

    Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
    Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
    do {
        parser.parse(candidates);   //#3
        parser.validate();

        Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());  // #4
        configClasses.removeAll(alreadyParsed);

        if (this.reader == null) {
            this.reader = new ConfigurationClassBeanDefinitionReader(
                    registry, this.sourceExtractor, this.resourceLoader, this.environment,
                    this.importBeanNameGenerator, parser.getImportRegistry());
        }
        this.reader.loadBeanDefinitions(configClasses); // #5
        alreadyParsed.addAll(configClasses);

        candidates.clear();
        if (registry.getBeanDefinitionCount() > candidateNames.length) {
            String[] newCandidateNames = registry.getBeanDefinitionNames(); // #6
            Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
            Set<String> alreadyParsedClasses = new HashSet<>();
            for (ConfigurationClass configurationClass : alreadyParsed) {
                alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
            }
            for (String candidateName : newCandidateNames) {
                if (!oldCandidateNames.contains(candidateName)) {
                    BeanDefinition bd = registry.getBeanDefinition(candidateName);  
                    if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
                            !alreadyParsedClasses.contains(bd.getBeanClassName())) {
                        candidates.add(new BeanDefinitionHolder(bd, candidateName));    // #7
                    }
                }
            }
            candidateNames = newCandidateNames;
        }
    }
    while (!candidates.isEmpty());  // #8

    ...
}

#1 檢查bean是否為ConfigurationClass，這里主要是檢查class注解信息（spring中將@Configuration標(biāo)注的類歸類為ConfigurationClass）
#2 構(gòu)建ConfigurationClassParser
#3 解析ConfigurationClass
#4 獲取結(jié)果，注意ConfigurationClassParser#getConfigurationClasses方法獲取ConfigurationClassParser的處理結(jié)果
#5 獲取ConfigurationClass引入的Class，將其轉(zhuǎn)化為BeanDefinition，并注冊到Spring上下文
最后構(gòu)造bean，是在AbstractApplicationContext#refresh方法中，調(diào)用finishBeanFactoryInitialization，構(gòu)建熱加載的單例bean時(shí)完成。
#6 獲取新的BeanDefinition列表
#7 如果前面的ConfigurationClass有引入了新的ConfigurationClass，添加到待處理集合
#8 循環(huán)處理，直到待處理集合為空

ConfigurationClassParser#parse -> ConfigurationClassParser#processConfigurationClass

    protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
        if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {    // #1
            return;
        }

        ...

        SourceClass sourceClass = asSourceClass(configClass);   // #2
        do {
            sourceClass = doProcessConfigurationClass(configClass, sourceClass);    // #3
        }
        while (sourceClass != null);    // #4

        this.configurationClasses.put(configClass, configClass);    // #5
    }

#1 檢查ConfigurationClass是否存在@Conditional注解，如果存在，取注解中Condition條件判斷類進(jìn)行判斷
#2 將ConfigurationClass轉(zhuǎn)化為SourceClass
SourceClass對Class元數(shù)據(jù)進(jìn)行封裝，可以兼容處理JVM加載的Class和ASM讀取的元數(shù)據(jù)，獲取元數(shù)據(jù)中注解，方法等信息
#3 doProcessConfigurationClass方法很關(guān)鍵，處理@Component，@PropertySources，@ComponentScans，@Import，@ImportResource，帶@Bean的方法，接口及父類。
#4 如果ConfigurationClass存在父類，doProcessConfigurationClass返回父類，這里遞歸處理父類數(shù)據(jù)
#5 將該ConfigurationClass加入configurationClasses，以便ConfigurationClassPostProcessor#processConfigBeanDefinitions方法#5步驟使用
該方法是處理ConfigurationClass的入口，doProcessConfigurationClass中引入了新的ConfigurationClass，也會調(diào)用該方法處理。

ConfigurationClassParser#doProcessConfigurationClass

protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
        throws IOException {
    if (configClass.getMetadata().isAnnotated(Component.class.getName())) { 
        processMemberClasses(configClass, sourceClass); // #1
    }

    ...

    processImports(configClass, sourceClass, getImports(sourceClass), true);    // #2

    AnnotationAttributes importResource =
            AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);   // #3
    if (importResource != null) {
        String[] resources = importResource.getStringArray("locations");
        Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
        for (String resource : resources) {
            String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
            configClass.addImportedResource(resolvedResource, readerClass);
        }
    }

    Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);  // #4
    for (MethodMetadata methodMetadata : beanMethods) {
        configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
    }

    processInterfaces(configClass, sourceClass);    // #5

    if (sourceClass.getMetadata().hasSuperClass()) {    // #6
        String superclass = sourceClass.getMetadata().getSuperClassName();
        if (superclass != null && !superclass.startsWith("java") &&
                !this.knownSuperclasses.containsKey(superclass)) {
            this.knownSuperclasses.put(superclass, configClass);
            return sourceClass.getSuperClass();
        }
    }

    return null;
}

這里只關(guān)注該方法AutoConfigure功能相關(guān)的代碼
#1 如果Class存在@Component注解，會查詢Class的內(nèi)部類，如果內(nèi)部類也是ConfigurationClass，會調(diào)用processConfigurationClass方法處理內(nèi)部類（注意，@Configuration注解上標(biāo)識了@Component注解）
#2 處理@Import注解
#3 處理@ImportResource，添加引入資源信息到ConfigurationClass#importedResources，ConfigurationClassPostProcessor#processConfigBeanDefinitions方法#5步驟會處理
#4 選擇Class中存在@Bean標(biāo)注的方法，加入到ConfigurationClass#beanMethods中
#5 選擇接口中存在@Bean標(biāo)注的方法，同樣加入到ConfigurationClass#beanMethods中
#6 如果存在父類，返回父類到ConfigurationClassParser#processConfigurationClass中，遞歸處理父類。

ConfigurationClassParser#processImports

private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
        Collection<SourceClass> importCandidates, boolean checkForCircularImports) {

    if (importCandidates.isEmpty()) {
        return;
    }

    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)) { // #1
                    Class<?> candidateClass = candidate.loadClass();
                    ImportSelector selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class);
                    ParserStrategyUtils.invokeAwareMethods(
                            selector, this.environment, this.resourceLoader, this.registry);    
                    if (selector instanceof DeferredImportSelector) {   // #2
                        this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
                    }
                    else {
                        String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());   // #3
                        Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);    // #4
                        processImports(configClass, currentSourceClass, importSourceClasses, false);    //#5
                    }
                }
                else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) { // #6
                    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());  //#7
                }
                else {  
                    this.importStack.registerImport(
                            currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
                    processConfigurationClass(candidate.asConfigClass(configClass));    //#8
                }
            }
        }
        catch (BeanDefinitionStoreException ex) {
            throw ex;
        }
        catch (Throwable ex) {
            throw new BeanDefinitionStoreException(
                    "Failed to process import candidates for configuration class [" +
                    configClass.getMetadata().getClassName() + "]", ex);
        }
        finally {
            this.importStack.pop();
        }
    }
}

#1 @Import引入的類是ImportSelector實(shí)現(xiàn)類
#2 DeferredImportSelector接口需要延遲處理，加入到deferredImportSelectorHandler中
ConfigurationClassParser#parse方法最后會調(diào)用deferredImportSelectorHandler#process方法處理DeferredImportSelector接口
#3 調(diào)用ImportSelector#selectImports方法
#4 使用ImportSelector#selectImports返回Class Name數(shù)組，加載對應(yīng)的SourceClass
#5 使用processImports方法繼續(xù)處理這些SourceClass
#6 @Import引入的類是ImportBeanDefinitionRegistrar實(shí)現(xiàn)類
#7 將該類加入到ConfigurationClass#importBeanDefinitionRegistrars中，ConfigurationClassPostProcessor#processConfigBeanDefinitions方法#5步驟會處理
#8 @Import引入的類是其他類，轉(zhuǎn)發(fā)為ConfigurationClass，使用processConfigurationClass方法處理

這里對應(yīng)了@Import注解的三種用法，引入ImportSelector，ImportBeanDefinitionRegistrar或者具體的ConfigurationClass。

@Import最后都要processConfigurationClass處理它引入的ConfigurationClass

回到ConfigurationClassPostProcessor#processConfigBeanDefinitions方法#5步驟，
ConfigurationClassBeanDefinitionReader#loadBeanDefinitions -> loadBeanDefinitionsForConfigurationClass

private void loadBeanDefinitionsForConfigurationClass(
        ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {

    ...

    if (configClass.isImported()) {
        registerBeanDefinitionForImportedConfigurationClass(configClass);   // #1
    }
    for (BeanMethod beanMethod : configClass.getBeanMethods()) {
        loadBeanDefinitionsForBeanMethod(beanMethod);   // #2
    }

    loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());   // #3
    loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars()); // #4
}

#1 注冊ConfigurationClass自身的BeanDefinition
#2 注冊@Bean注解標(biāo)識方法引入的bean
#3 從@ImportResource引入的資源中讀取BeanDefinition
#4 處理@Import引入的ImportBeanDefinitionRegistrar，調(diào)用ImportBeanDefinitionRegistrar#registerBeanDefinitions方法

@EnableAutoConfiguration注解引入的AutoConfigurationImportSelector，實(shí)現(xiàn)的是DeferredImportSelector接口
AutoConfigurationImportSelector#selectImports -> getAutoConfigurationEntry

protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
        AnnotationMetadata annotationMetadata) {
    if (!isEnabled(annotationMetadata)) {
        return EMPTY_ENTRY;
    }
    AnnotationAttributes attributes = getAttributes(annotationMetadata);
    List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);   // #1
    configurations = removeDuplicates(configurations);  // #2
    Set<String> exclusions = getExclusions(annotationMetadata, attributes); 
    checkExcludedClasses(configurations, exclusions);
    configurations.removeAll(exclusions);   // #3
    configurations = filter(configurations, autoConfigurationMetadata); // #4
    fireAutoConfigurationImportEvents(configurations, exclusions);  // #5
    return new AutoConfigurationEntry(configurations, exclusions);
}

#1 從spring.factories文件中獲取@EnableAutoConfiguration對應(yīng)的ConfigurationClass
#3 排除spring.autoconfigure.exclude配置的ConfigurationClass
#4 使用spring.factories中配置的AutoConfigurationImportFilter的實(shí)現(xiàn)類（OnBeanCondition，OnClassCondition，OnWebApplicationCondition）過濾部分ConfigurationClass，這里處理@ConditionalOnBean，@ConditionalOnClass，@ConditionalOnMissingClass等注解。
OnClassCondition可以判斷當(dāng)前Java應(yīng)用中存在或者不存在某一個(gè)class，SpringBoot AutoConfigure功能可以實(shí)現(xiàn)當(dāng)我們引入某個(gè)框架jar后，自動配置完成該框架的配置，正是通過該條件判斷類實(shí)現(xiàn)。

來看一個(gè)例子，RedisAutoConfiguration

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

    @Bean
    @ConditionalOnMissingBean(name = "redisTemplate")
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
            throws UnknownHostException {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
    ...
}

RedisAutoConfiguration是一個(gè)ConfigurationClass，他使用@Bean標(biāo)識方法引入其他bean
（RedisAutoConfiguration在spring-boot-autoconfigure這個(gè)jar下的spring.factories文件中已經(jīng)被配置為@EnableAutoConfiguration的ConfigurationClass）

@ConditionalOnClass表明classpath只有存在RedisOperations這個(gè)類，RedisAutoConfiguration的配置才生效
（引入spring-data-redis的jar后有這個(gè)類了，RedisAutoConfiguration也就生效了）
@Import引入的 LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class用于與redis建立連接，并生成RedisConnectionFactory。
同樣，引入 Lettuce相關(guān)jar后，LettuceConnectionConfiguration生效，引入Jedis相關(guān)jar后，JedisConnectionConfiguration生效。

如果您覺得本文不錯，歡迎關(guān)注我的微信公眾號，您的關(guān)注是我堅(jiān)持的動力！