【SpringBoot】自动配置原理

Spring Boot 自动配置原理是 Spring Boot 提供简化 Spring 应用程序开发的核心特性之一。

它使得开发者无需编写大量的配置代码就能让应用程序具有很多常见的功能。

以下是 Spring Boot 自动配置的基本原理和工作流程：

1. 通过 @SpringBootConfiguration 引入了 @EnableAutoConfiguration（负责启动自动配置功能）

2. @EnableAutoConfiguration 引入了 @lmport

3. Spring 容器启动时：加载 loc 容器时会解析 @Import 注解

4. @Import 导入了一个 deferredlmportSelector，它会使 SpringBoot 的自动配置类的顺序在最后，这样方便我们扩展和覆盖

5. 然后读取所有的 /META-INF/spring.factories 文件（伪 SPI）

6. 过滤出所有 AutoConfigurtionClass 类型的类

7. 最后通过 @Condition 排除无效的自动配置类

 

下面我们在通过源码走一遍上述的流程：

1、找到项目的启动类

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

}

2、进入 @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 {
	......
}

3、进入 @EnableAutoConfiguration

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

    Class<?>[] exclude() default {};

    String[] excludeName() default {};
}

4、进入 AutoConfigurationImportSelector.class  

public class AutoConfigurationImportSelector 
    implements  DeferredImportSelector, 
                BeanClassLoaderAware, 
                ResourceLoaderAware, 
                BeanFactoryAware, 
                EnvironmentAware, 
                Ordered {......}

5、找到 selectImports(AnnotationMetadata annotationMetadata) 方法  

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

6、进入 this.getAutoConfigurationEntry(annotationMetadata)

protected 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);
        
        // 获得注解中被 exclude 和 excludeName 排除的类的集合
        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 AutoConfigurationEntry(configurations, exclusions);
    }
}

7、进入 this.getCandidateConfigurations(annotationMetadata, attributes)

依据 getSpringFactoriesLoaderFactoryClass() 返回的 key 在 spring.factories 中找到该 key 对应的 value（到这里就可以得到候选配置类）

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;
}

protected Class<?> getSpringFactoriesLoaderFactoryClass() {
    return EnableAutoConfiguration.class;
}

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
......

8、获取到候选配置类后，会经过去重、排除、过滤等操作，最终会通过 selectImports() 方法返回一个自动配置类的全限定名数组

9、得到了一个动态配置类的全限定名数组后，这些配置类需要在满足 @Condition 后才能真正的被注册到 Spring 容器之中

注解	说明
@ConditionOnBean	在容器中有指定 Bean 的条件下
@ConditionalOnMissingBean	在容器中没有指定 Bean 的条件下
@ConditionOnClass	在 classpath 类路径下有指定类的条件下
@ConditionalOnMissingClass	在 classpath 类路径下没有指定类的条件下
@ConditionalOnResource	类路径是否有指定的值
@ConditionalOnWebApplication	在项目是一个 Web 项目的条件下
@ConditionOnProperty	在指定的属性有指定的值条件下
@ConditionalOnExpression	当表达式为 true 的时候，才会实例化这个 Bean
@AutoConfigureAfter	在某个 Bean 完成自动配置后实例化这个 Bean
@AutoConfigureBefore	在某个 Bean 完成自动配置前实例化这个 Bean

 

getCandidateConfigurations() 方法如何获取 spring.factories 的路径？

getCandidateConfigurations() 方法中调用了 SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());

其中的 loadSpringFactories() 方法，该方法中会加载类路径下的 META-INF/spring.factories 文件

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
    ClassLoader classLoaderToUse = classLoader;
    if (classLoaderToUse == null) {
        classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
    }

    String factoryTypeName = factoryType.getName();
    return (List)loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
}



private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
    Map<String, List<String>> result = (Map)cache.get(classLoader);
    if (result != null) {
        return result;
    } else {
        Map<String, List<String>> result = new HashMap();

        try {
            Enumeration<URL> urls = classLoader.getResources("META-INF/spring.factories");

            ......
        }
    }   
}

 

自动配置类还会绑定到 application.properties 或 application.yml 中的属性。

Spring Boot 通过 @ConfigurationProperties 注解将配置文件中的属性绑定到 Java Bean 上。

可以通过在配置文件中设置特定的属性来调整自动配置的行为，或者通过提供自己的实现来覆盖默认的自动配置。

Spring Boot 的自动配置机制是为了减少开发者的配置负担，使开发者能够更专注于业务逻辑的实现。

它通过条件注解来智能地决定哪些配置应该启用，并且可以很容易地被覆盖和扩展。

 

一  叶  知  秋，奥  妙  玄  心