SpringBoot自动配置原理

1、SpringBoot项目启动的时候通过加载 @SpringBootApplication 注解的主配置类，开启自动配置功能

@SpringBootApplication
public class AutoConfigApplication {

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

2、@EnableAutoConfiguration 的作用

@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

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

    String[] excludeName() default {};
}

利用 @AutoConfigurationImportSelector 给容器导入组件

import org.springframework.core.type.AnnotationMetadata;
public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
   
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        if (!this.isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        } else {
            AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
            AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata);
            return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
        }
    }

protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata, 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.filter(configurations, autoConfigurationMetadata);
            this.fireAutoConfigurationImportEvents(configurations, exclusions);
            return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
        }
    }

通过查看 selectImports() 中的 this.getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata); 可追溯到导入了哪些组件，其中 List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes); 用来获取候选配置

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

public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
        String factoryClassName = factoryClass.getName();
        return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
    }

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 factoryClassName = ((String)entry.getKey()).trim();
                        String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        int var10 = var9.length;

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

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

default V getOrDefault(Object key, V defaultValue) {
        V v;
        return (((v = get(key)) != null) || containsKey(key))
            ? v
            : defaultValue;
    }

一直追踪 SpringFactoriesLoader.loadFactoryNames() 方法源头发现，loadSpringFactories() 方法是通过扫描所有jar包类路径下文件 META-INF/spring.factories 得到 urls 并对其进行逐个遍历，得到的文件封装成 properties 对象，然后从 properties 中获取到一些值，把这些获取到的值加入到我们最终要返回的结果 result 中；getOrDefault 方法以 factoryClassName (即getSpringFactoriesLoaderFactoryClass 中 EnableAutoConfiguration.class 的类名）作为筛选依据，得到的结果 List<String> 就是我们要交给 Spring 容器的所有组件。
（简单概括即是将类路径下 META-INF/spring.factories 里面配置的所有 EnableAutoConfiguration 的值加入到容器中）

# 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.cloud.CloudServiceConnectorsAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\

如上图，每一个 xxxAutoConfiguration 类都是容器中的一个组件，都加入到容器中，用作自动配置

3、以自动配置类 HttpEncodingAutoConfiguration 为例来解释SpringBoot的自动配置原理

@Configuration // 表示一个配置类
@EnableConfigurationProperties({HttpProperties.class}) // 启动指定类ConfigurationProperties功能，相当于把配置文件中对应值和HttpProperties.class绑定起来，并把HttpProperties加入到ioc容器中
@ConditionalOnWebApplication(
    type = Type.SERVLET
)// 判断当前应用是不是web应用，@Conditional是spring底层注解，根据不同的条件进行判断，如果满足指定的条件，那么整个配置类里边的配置才会生效
@ConditionalOnClass({CharacterEncodingFilter.class})// 判断当前项目里有没有CharacterEncodingFilter这个类，类中是否存在这个过滤器，SpringMVC中解决乱码的过滤器
@ConditionalOnProperty(
    prefix = "spring.http.encoding",
    value = {"enabled"},
    matchIfMissing = true
)// 判断配置文件中是否存在某个配置（spring.http.encoding.enabled）, matchIfMissing = true 如果不存在也是成立的
// 即配置文件中不配置spring.http.encoding.enabled=true这个属性，也默认生效
public class HttpEncodingAutoConfiguration {

	// 已经与SpringBoot中HttpProperties配置文件做了映射
	private final Encoding properties;

	// 只有唯一一个有参构造器的情况下，参数中的值就会从容器中取 （即 @EnableConfigurationProperties({HttpProperties.class})）
    public HttpEncodingAutoConfiguration(HttpProperties properties) {
        this.properties = properties.getEncoding();
    }
    
	@Bean// 给容器添加一个组件
    @ConditionalOnMissingBean
    public CharacterEncodingFilter characterEncodingFilter() {
        CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
        filter.setEncoding(this.properties.getCharset().name());// 组件的某些值需要从 properties 中获取
        filter.setForceRequestEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.REQUEST));
        filter.setForceResponseEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.RESPONSE));
        return filter;
    }
}

根据当前不同的条件判断，决定这个配置类是否生效（参照代码注释）
一旦配置类生效，便会给容器添加各种组件，这些组件的属性是从对应的 Properties 类中获取的，而类中的每一个属性又是和配置文件绑定的

@ConfigurationProperties(
    prefix = "spring.http"
)// 从配置文件中获取指定的值和bean的属性进行绑定
public class HttpProperties {
    private final HttpProperties.Encoding encoding = new HttpProperties.Encoding();

	public static class Encoding {
        public static final Charset DEFAULT_CHARSET;
        private Charset charset;
        private Boolean force;
        private Boolean forceRequest;
        private Boolean forceResponse;
        private Map<Locale, Charset> mapping;

        public Encoding() {
            this.charset = DEFAULT_CHARSET;
        }
        
        static {
            DEFAULT_CHARSET = StandardCharsets.UTF_8;
        }
    }
}

所有配置文件中能配置的属性都在 xxxProperties 类中封装，所以我们能够配置的属性，都是来源于某个功能的 Properties 类

spring.http.encoding.enabled=true
spring.http.encoding.charset=utf-8
spring.http.encoding.force=true

如在 application.properties 配置文件下配置以上属性

4、如何用好SpringBoot只要把握以下几点（精髓）

• SpringBoot 启动会加载大量的自动配置类
• 查看所需功能是否有 SpringBoot 默认写好的自动配置类
• 查看自动配置类中到底配置了哪些组件，只要有所需要的组件，就不需要再来配置；如果没有所需要的组件，那么就需要自己来写一个配置类来把相应的组件配置起来
• 给容器中自动配置类添加组件的时候，会从 Properties 类中获取某些属性，而这些属性就可以在配置文件指定属性的值

5、如何判断配置类是否生效

通过启用 debug=true 属性（默认false），在控制台输出自动配置报告

============================
CONDITIONS EVALUATION REPORT
============================


Positive matches:
-----------------

   CodecsAutoConfiguration matched:
      - @ConditionalOnClass found required class 'org.springframework.http.codec.CodecConfigurer' (OnClassCondition)

   CodecsAutoConfiguration.JacksonCodecConfiguration matched:
      - @ConditionalOnClass found required class 'com.fasterxml.jackson.databind.ObjectMapper' (OnClassCondition)

   CodecsAutoConfiguration.JacksonCodecConfiguration#jacksonCodecCustomizer matched:
      - @ConditionalOnBean (types: com.fasterxml.jackson.databind.ObjectMapper; SearchStrategy: all) found bean 'jacksonObjectMapper' (OnBeanCondition)

   DataSourceAutoConfiguration matched:
      - @ConditionalOnClass found required classes 'javax.sql.DataSource', 'org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType' (OnClassCondition)

   DataSourceAutoConfiguration.PooledDataSourceConfiguration matched:
      - AnyNestedCondition 1 matched 1 did not; NestedCondition on DataSourceAutoConfiguration.PooledDataSourceCondition.PooledDataSourceAvailable PooledDataSource found supported DataSource; NestedCondition on DataSourceAutoConfiguration.PooledDataSourceCondition.ExplicitType @ConditionalOnProperty (spring.datasource.type) did not find property 'type' (DataSourceAutoConfiguration.PooledDataSourceCondition)
      - @ConditionalOnMissingBean (types: javax.sql.DataSource,javax.sql.XADataSource; SearchStrategy: all) did not find any beans (OnBeanCondition)

Negative matches:
-----------------

   ActiveMQAutoConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required class 'javax.jms.ConnectionFactory' (OnClassCondition)

   AopAutoConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required class 'org.aspectj.lang.annotation.Aspect' (OnClassCondition)

   ArtemisAutoConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required class 'javax.jms.ConnectionFactory' (OnClassCondition)

   BatchAutoConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required class 'org.springframework.batch.core.launch.JobLauncher' (OnClassCondition)

如上图，Positive matches 指匹配成功的自动配置类（即已启用的自动配置类），Negative matches 指没有匹配成功的自动配置类（即没启用的自动配置类）