spring boot的自动配置原理解析

Spring boot的自动配置

   Springboo应用启动的时候，首先会先走主配置类，如下代码所示：

@SpringBootApplication//这是Springboot的核心注解，也是一个混合注解。
public class DemoApplication {

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

}


==========

//@SpringBootApplication点进去看如下所示：
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration//这是springboot配置类的一个注解
@EnableAutoConfiguration//这是自动配置注解，也是我们关注的重点
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {...

==========

//@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 {};
}


==========

//点进去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);
    }
}

protected List<String> getCandidateConfigurations(dAnnotationMetadata 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 fi/le is correct.");
    //下面这个判空以及后面的消息，也验证我们的思路来到这里是正确的
    return configurations;
}
//接下来我们点进去SpringFactoriesLoader.loadFactoryNames这个方法来看一眼


===========

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

    String factoryTypeName = factoryType.getName();
    return (List)loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());//调用了loadSpringFactories这个方法
}

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

        try {
            Enumeration urls = classLoader.getResources("META-INF/spring.factories");//这里自动配置类加载的路径

            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[] factoryImplementationNames = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                    String[] var10 = factoryImplementationNames;
                    int var11 = factoryImplementationNames.length;

                    for(int var12 = 0; var12 < var11; ++var12) {
                        String factoryImplementationName = var10[var12];
                        ((List)result.computeIfAbsent(factoryTypeName, (key) -> {
                            return new ArrayList();
                        })).add(factoryImplementationName.trim());
                    }
                }
            }

            result.replaceAll((factoryType, implementations) -> {
                return (List)implementations.stream().distinct().collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
            });
            cache.put(classLoader, result);
            return result;
        } catch (IOException var14) {
            throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var14);
        }
    }
}

  看完了上面整个代码的调用过程，接下来来小结一下：

1. 首先@SpringBootApplication这个注解包含了一个@EnableAutoConfiguration注解
2. @EnableAutoConfiguration中包含了@Import({AutoConfigurationImportSelector.class})，导入一个AutoConfigurationImportSelector类，这个类中主要的就是的selectImports这个方法
3. selectImports经过一系列的调用，最终会去扫描所有jar包类路径下的META-INF/spring.factories路径，把扫描到的内容包装成一个properties对象。
4. 从properties中获取EnableAutoConfiguration.class类型的类名，去加载并把它们添加到容器之中。

接下来来看下META-INF/spring.factories这个文件

这上面的每一个XXXAutoConfiguration都会被扫描到并加入到容器之中，并进行各个类的自动配置工作，接下来列举其中的一个比较简单列子：
org.springframework.boot.autoconfigure.web.servlet.HttpEncodingAutoConfiguration

@Configuration(//说明是一个配置类
    proxyBeanMethods = false
)
@EnableConfigurationProperties({ServerProperties.class})//将配置文件中的值和ServerProperties.class绑定起来，ServerProperties.class的代码贴在下面
@ConditionalOnWebApplication(//判断是否是web环境
    type = Type.SERVLET
)
@ConditionalOnClass({CharacterEncodingFilter.class})//判断项目中是否存在这个类，有才生效
@ConditionalOnProperty(//判断是否存在这个属性
    prefix = "server.servlet.encoding",
    value = {"enabled"},
    matchIfMissing = true
)
public class HttpEncodingAutoConfiguration {
    private final Encoding properties;

    public HttpEncodingAutoConfiguration(ServerProperties properties) {
        this.properties = properties.getServlet().getEncoding();//ServerProperties拿到我们配置的属性
    }

    @Bean
    @ConditionalOnMissingBean
    public CharacterEncodingFilter characterEncodingFilter() {
        CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
        filter.setEncoding(this.properties.getCharset().name());
        filter.setForceRequestEncoding(this.properties.shouldForce(org.springframework.boot.web.servlet.server.Encoding.Type.REQUEST));
        filter.setForceResponseEncoding(this.properties.shouldForce(org.springframework.boot.web.servlet.server.Encoding.Type.RESPONSE));
        return filter;
    }

    @Bean
    public HttpEncodingAutoConfiguration.LocaleCharsetMappingsCustomizer localeCharsetMappingsCustomizer() {
        return new HttpEncodingAutoConfiguration.LocaleCharsetMappingsCustomizer(this.properties);
    }
    static class LocaleCharsetMappingsCustomizer implements WebServerFactoryCustomizer<ConfigurableServletWebServerFactory>, Ordered {
        private final Encoding properties;
        LocaleCharsetMappingsCustomizer(Encoding properties) {
            this.properties = properties;
        }
        public void customize(ConfigurableServletWebServerFactory factory) {
            if (this.properties.getMapping() != null) {
                factory.setLocaleCharsetMappings(this.properties.getMapping());
            }

        }
        public int getOrder() {
            return 0;
        }
    }
}

==========
@ConfigurationProperties(
    prefix = "server",//将我们配置文件中的前缀为server的配置和ServerProperties中的属性相映射。
    ignoreUnknownFields = true
)
public class ServerProperties {
    private Integer port;
    private InetAddress address;
    @NestedConfigurationProperty
    private final ErrorProperties error = new ErrorProperties();
    private ServerProperties.ForwardHeadersStrategy forwardHeadersStrategy;
    private String serverHeader;
    private DataSize maxHttpHeaderSize = DataSize.ofKilobytes(8L);
    private Shutdown shutdown;
    @NestedConfigurationProperty
    private Ssl ssl;
    @NestedConfigurationProperty
    ...

接下来总结一下：
结论1：

• 通过org.springframework.boot.autoconfigure.web.servlet.HttpEncodingAutoConfiguration例子，我们可以按照上述的方式去寻找自己能在配置文件中去配置哪些属性值

结论2：

• springboot在启动的时候会去加载很多自动配置类，正是这些类帮我们完成了繁琐的配置工作，降低了我们的开发难度
• 平常开发中，可以自己去寻找springboot是否已经帮我们加载了相关的配置类，如果加载了，这样我们只需要在配置文件中去加上相关的属性配置即可。

以上是个人的一些总结，如有错误，望大佬不吝指教