SpringBoot系列二Starter自动配置原理

观察@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 {

其中最为关键的注解为@EnableAutoConfiguration，它是spring的全局开关，如果把这个注解去掉，则一切Starter都会失效，这是约定大于配置的潜规则

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

AutoConfigurationImportSelector作为Starter的自动化导入的关键

protected boolean isEnabled(AnnotationMetadata metadata) {
    return this.getClass() == AutoConfigurationImportSelector.class ? (Boolean)this.getEnvironment().getProperty("spring.boot.enableautoconfiguration", Boolean.class, true) : true;
}

spring通过AutoConfigurationImportSelector类中的isEnabled方法来识别并让@EnableAutoConfiguration注解起作用。

一、spring.factories的加载

查看AutoConfigurationImportSelector类selectImports方法

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

protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
    if (!this.isEnabled(annotationMetadata)) {
        return EMPTY_ENTRY;
    } else {
        AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
        List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
        configurations = this.removeDuplicates(configurations);
        Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
        this.checkExcludedClasses(configurations, exclusions);
        configurations.removeAll(exclusions);
        configurations = this.getConfigurationClassFilter().filter(configurations);
        this.fireAutoConfigurationImportEvents(configurations, exclusions);
        return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
    }
}

1、CandidateConfigurations

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    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;
}

函数中看到了META-INF/spring.factories，按照约定大于配置的原则下，Starter如果要生效必须要在META-INF文件下建立spring.factories文件，并把相关的配置类声明在里面。

继续进入loadSpringFactories方法

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
    MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
    if (result != null) {
        return result;
    } else {
        try {
            Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
            LinkedMultiValueMap result = new LinkedMultiValueMap();

            while(urls.hasMoreElements()) {
                URL url = (URL)urls.nextElement();
                UrlResource resource = new UrlResource(url);
                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                Iterator var6 = properties.entrySet().iterator();

                while(var6.hasNext()) {
                    Entry<?, ?> entry = (Entry)var6.next();
                    String factoryTypeName = ((String)entry.getKey()).trim();
                    String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                    int var10 = var9.length;

                    for(int var11 = 0; var11 < var10; ++var11) {
                        String factoryImplementationName = var9[var11];
                        result.add(factoryTypeName, factoryImplementationName.trim());
                    }
                }
            }

            cache.put(classLoader, result);
            return result;
        } catch (IOException var13) {
            throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
        }
    }
}

loadSpringFactories方法中表明了Starter生效必须要依赖META-INF/spring.factories，因为在启动过程中有一段硬编码逻辑会扫描各个包中的对应的配置文件，并把配置取出来。

二、factories调用时序图（AutoConfigurationImportSelector与spring整合）

从图中看到是EmbeddedWebApplicationContext到AutoConfigurationImportSelector的调用链路。

spring boot使用BeanDefinitionRegistryPostProcessor扩展点实现了ConfigurationClassPostProcessor类，从而实现了一系列逻辑扩展

 三、配置类的解析

根据factories调用时序图中调用链路，为了搞明白，selectImports后的流程，就需要进入调用selectImports的类中查看。进入ConfigurationClassParser，查看processImports方法。

注意：ConfigurationClassParser中的processDeferredImportSelectors方法是老版本，最新版使用processImports方法。

//spring启动的时候会扫描所有jar包中的spring.factories定义的类。
String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
Collection<ConfigurationClassParser.SourceClass> importSourceClasses = this.asSourceClasses(importClassNames, exclusionFilter);
//对配置文件的处理的逻辑
this.processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);

processImports时序图

 逻辑分析

1、ConfigurationClassPostProcessor作为spring扩展点是spring boot一系列功能的基础入口

2、ConfigurationClassParser作为解析职责的基本处理类，涵盖了各种解析处理的逻辑。

（1）@Import

（2）@Bean

（3）@ImportResource

（4）@PropertySource

（5）@ComponentScan

该类对外开放的的函数入口是parse方法，对应时序图中的步骤3

3、在parse中的处理逻辑最复杂

（1）首先会处理自己本身可以扫描到的bean注册逻辑

（2）扫描到了注册的bean之后，才会处理spring.factories定义的配置，处理spring.factories定义的配置，首先要加载配置类，此时调用AutoConfigurationImportSelector类selectImports方法。

返回的配置需要进一步解析，因为这些配置类可能对应不同的类型（@Import，@Bean，@ImportResource，@PropertySource，@ComponentScan），而这些类又有不同的处理逻辑。

4、步骤3结束后，所有的解析结果通过3.2.2放在parse的configurationClasses属性中

private final Map<ConfigurationClass, ConfigurationClass> configurationClasses = new LinkedHashMap();

 这个时候对configurationClasses属性统一的spring bean硬编码注册，注册逻辑统一委托给ConfigurationClassBeanDefinitionReader，对外的方法是loadBeanDefinitions

四、ComponentScan的切入点

进入ConfigurationClassParser的doProcessConfigurationClass方法，该方法是很多注解逻辑的实现

Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
if (!componentScans.isEmpty() && !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
    Iterator var14 = componentScans.iterator();

    while(var14.hasNext()) {
        AnnotationAttributes componentScan = (AnnotationAttributes)var14.next();
        Set<BeanDefinitionHolder> scannedBeanDefinitions = this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
        Iterator var8 = scannedBeanDefinitions.iterator();

        while(var8.hasNext()) {
            BeanDefinitionHolder holder = (BeanDefinitionHolder)var8.next();
            BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
            if (bdCand == null) {
                bdCand = holder.getBeanDefinition();
            }
            //对扫描数来的类进行过滤
            if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
                //将所有扫描出来的类委托给parse方法递归处理
                this.parse(bdCand.getBeanClassName(), holder.getBeanName());
            }
        }
    }
}

方法中（ConfigurationClass configClass）是spring.factories终定义的配置类

1、获取ComponentScan注解配置信息

Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);

获取注解配置信息，@ComponentScan({"path"})

2、扫描路径

Set<BeanDefinitionHolder> scannedBeanDefinitions = this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());

注解中配置的路径path会委托给ComponentScanAnnotationParser的parse进一步扫描

ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry, componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);

scanner.doScan(StringUtils.toStringArray(basePackages));

ComponentScanAnnotationParser的扫描逻辑会委托给ClassPathBeanDefinitionScanner。

ClassPathBeanDefinitionScanner是spring原生的解析类，通过字节码扫描的方式，效率比反射机制高很多。mybatis的动态扫描就是封装了类似的类。

Spring 是解析配置类过程详解 - it610.com