关于SpringBoot的自动配置原理

一. 加载自动配置类

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

在springboot给我们生成的启动类中我们可以看到这样一个注解**@SpringBootApplication**，这个注解定义的内容为

//@SpringBootApplication注解的内容 @Target(ElementType.TYPE) //元注解 //@Target(ElementType.TYPE) //接口、类、枚举 //@Target(ElementType.FIELD) //字段、枚举的常量 //@Target(ElementType.METHOD) //方法 //@Target(ElementType.PARAMETER) //方法参数 //@Target(ElementType.CONSTRUCTOR) //构造函数 //@Target(ElementType.LOCAL_VARIABLE)//局部变量 //@Target(ElementType.ANNOTATION_TYPE)//注解 //@Target(ElementType.PACKAGE) ///包 @Retention(RetentionPolicy.RUNTIME) //元注解 //1、RetentionPolicy.SOURCE：注解只保留在源文件，当Java文件编译成class文件的时候，注解被遗弃； //2、RetentionPolicy.CLASS：注解被保留到class文件，但jvm加载class文件时候被遗弃，这是默认的生命周期； //3、RetentionPolicy.RUNTIME：注解不仅被保存到class文件中，jvm加载class文件之后，仍然存在； @Documented //元注解 //在自定义注解的时候可以使用@Documented来进行标注，如果使用@Documented标注了，在生成javadoc的时候就会把@Documented注解给显示出来。 @Inherited //元注解 //类继承关系中@Inherited的作用 //类继承关系中，子类会继承父类使用的注解中被@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 // 添加该注解的类所在的package 作为 自动配置package 进行管理。 @Import(AutoConfigurationImportSelector.class) //将这个类导入到容器中 public @interface EnableAutoConfiguration {

这里把AutoConfigurationImportSelector.class这个类加入到了容器中，我们再去看看这个方法里卖弄做了什么 重点看AutoConfigurationImportSelector的selectImports方法

@Override public String[] selectImports(AnnotationMetadata annotationMetadata) { if (!isEnabled(annotationMetadata)) { return NO_IMPORTS; } AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader .loadMetadata(this.beanClassLoader); AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata); return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations()); }

可以看到在这个方法里面获得了一个AutoConfigurationEntry类的对象，并且通过该对象的方法getConfigurations()返回了一个string数组 StringUtils.toStringArray方法如下：

public static String[] toStringArray(@Nullable Collection<String> collection) { return (!CollectionUtils.isEmpty(collection) ? collection.toArray(EMPTY_STRING_ARRAY) : EMPTY_STRING_ARRAY); }

这里我们就要去注意AutoConfigurationEntry这个类是什么类，以及它里面封装了什么 接下来我们可以看到AutoConfigurationEntry是AutoConfigurationImportSelector的一个内部类，以下是它的源码：

protected static class AutoConfigurationEntry { private final List<String> configurations; private final Set<String> exclusions; private AutoConfigurationEntry() { this.configurations = Collections.emptyList(); this.exclusions = Collections.emptySet(); }

这里封装了两个集合类型的成员变量，从名字上可以看出，这两个集合类型应该是封装着配置信息和不需要配置的信息 看完了内部类AutoConfigurationEntry，我们再来看autoConfiguraationEntry这个内部类的对象调用的getConfigurations()方法是干嘛的，源码附上：

public List<String> getConfigurations() { return this.configurations; }

在这里可以看到该方法返回了一个List集合，但是这里并不能看出什么，就是返回它的类属性，所以我们回到selectImports方法中，看看autoConfiguraationEntry这个内部类的这些信息是哪里来的

selectImports()方法中有这样一句，我们点进去看看

AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata);

以下是getAutoConfigurationEntry（）方法的源码

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

在这里我们可以看到这样两行

List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes); Set<String> exclusions = getExclusions(annotationMetadata, attributes);

接下来我们就分析这两个方法是怎么样拿到这些配置信息并封装到autoConfiguraationEntry这个类中的 先分析getCandidateConfigurations这个方法，先贴源码

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) { List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), 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; }

我们可以看到这样一句

List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());

我们点进去看看 这是loadFactoryNames的源码 注意，现在已经是在SpringFactoriedLoader类下了

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

我们来看看它返回的这个list集合是从哪里得到的，于是我们点进loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList())这里里面去看看，可以看到loadSpringFactories()的源码

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) { MultiValueMap<String, String> result = cache.get(classLoader); if (result != null) { return result; } try { Enumeration<URL> urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) : ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION)); result = new LinkedMultiValueMap<>(); while (urls.hasMoreElements()) { URL url = urls.nextElement(); UrlResource resource = new UrlResource(url); Properties properties = PropertiesLoaderUtils.loadProperties(resource); for (Map.Entry<?, ?> entry : properties.entrySet()) { String factoryTypeName = ((String) entry.getKey()).trim(); for (String factoryImplementationName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) { result.add(factoryTypeName, factoryImplementationName.trim()); } } } cache.put(classLoader, result); return result; } catch (IOException ex) { throw new IllegalArgumentException("Unable to load factories from location [" + FACTORIES_RESOURCE_LOCATION + "]", ex); } }

在这里我们终于找到了一点线索，这里面有加载资源并封装的操作，我们接着看 第一句：

Enumeration<URL> urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) : ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));

这里表示使用类加载器去FACTORIES_RESOURCE_LOCATION这个路径下加载文件，要是传入的类加载器为空，那么就去加载FACTORIES_RESOURCE_LOCATION这个路径下的文件，这里我们应该直到，这两个字符串都代表着字符串常量，于是我们去揭开庐山真面目

public final class SpringFactoriesLoader { /** * The location to look for factories. * <p>Can be present in multiple JAR files. */ public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

我们可以看到，loadSpringFactories()方法中去加载META-INF/spring.factories的资源，并封装为一个properties，最后封装为LinkedMultiValueMap<>()对象并返回，到这一步，springBoot自动配置就拿到了需要配置的资源 我们可以去看看这些资源 我们进去其中去看看

# Initializers org.springframework.context.ApplicationContextInitializer=\ org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\ org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener # Application Listeners org.springframework.context.ApplicationListener=\ org.springframework.boot.autoconfigure.BackgroundPreinitializer # Auto Configuration Import Listeners org.springframework.boot.autoconfigure.AutoConfigurationImportListener=\ org.springframework.boot.autoconfigure.condition.ConditionEvaluationReportAutoConfigurationImportListener # Auto Configuration Import Filters org.springframework.boot.autoconfigure.AutoConfigurationImportFilter=\ org.springframework.boot.autoconfigure.condition.OnBeanCondition,\ org.springframework.boot.autoconfigure.condition.OnClassCondition,\ org.springframework.boot.autoconfigure.condition.OnWebApplicationCondition # 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,\ org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\ org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,\ org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\ org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveDataAutoConfiguration,\ org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveRepositoriesAutoConfiguration,\ org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,\ org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\ org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveDataAutoConfiguration,\ org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveRepositoriesAutoConfiguration,\ org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration,\

这里面我们可以看到有很多资源 如： org.springframework.context.ApplicationContextInitializer org.springframework.context.ApplicationListener org.springframework.boot.autoconfigure.AutoConfigurationImportListener org.springframework.boot.autoconfigure.EnableAutoConfiguration等等资源，那是不是这写资源全部都要自动加载入容器中呢？ 肯定不是的 使用内部工具 SpringFactoriesLoader，查找classpath上所有jar包中的 META-INF\spring.factories，找出其中key为 org.springframework.boot.autoconfigure.AutoConfigurationImportFilter的属性定义的过滤器类并实例化。AutoConfigurationImportFilter过滤器可以被注册到 spring.factories用于对自动配置类做一些限制，在这些自动配置类的字节码被读取之前做快速排除处理。 spring boot autoconfigure 缺省注册了一个 AutoConfigurationImportFilter :org.springframework.boot.autoconfigure.condition.OnClassCondition

当这些自动配置类进入到容器的时候，它们就可以执行自动配置的功能了 比如以**HttpEncodingAutoConfiguration（Http编码自动配置）**为例解释自动配置原理；

@Configuration //表示这是一个配置类，以前编写的配置文件一样，也可以给容器中添加组件 @EnableConfigurationProperties(HttpEncodingProperties.class) //启动指定类的ConfigurationProperties功能；将配置文件中对应的值和HttpEncodingProperties绑定起来；并把HttpEncodingProperties加入到ioc容器中 @ConditionalOnWebApplication //Spring底层@Conditional注解（Spring注解版），根据不同的条件，如果满足指定的条件，整个配置类里面的配置就会生效； 判断当前应用是否是web应用，如果是，当前配置类生效 @ConditionalOnClass(CharacterEncodingFilter.class) //判断当前项目有没有这个类CharacterEncodingFilter；SpringMVC中进行乱码解决的过滤器； @ConditionalOnProperty(prefix = "spring.http.encoding", value = "enabled", matchIfMissing = true) //判断配置文件中是否存在某个配置 spring.http.encoding.enabled；如果不存在，判断也是成立的 //即使我们配置文件中不配置pring.http.encoding.enabled=true，也是默认生效的； public class HttpEncodingAutoConfiguration { //他已经和SpringBoot的配置文件映射了 private final HttpEncodingProperties properties; //只有一个有参构造器的情况下，参数的值就会从容器中拿 public HttpEncodingAutoConfiguration(HttpEncodingProperties properties) { this.properties = properties; } @Bean //给容器中添加一个组件，这个组件的某些值需要从properties中获取 @ConditionalOnMissingBean(CharacterEncodingFilter.class) //判断容器没有这个组件？ public CharacterEncodingFilter characterEncodingFilter() { CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter(); filter.setEncoding(this.properties.getCharset().name()); filter.setForceRequestEncoding(this.properties.shouldForce(Type.REQUEST)); filter.setForceResponseEncoding(this.properties.shouldForce(Type.RESPONSE)); return filter; }

根据当前不同的条件判断，决定这个配置类是否生效 一但这个配置类生效；这个配置类就会给容器中添加各种组件；这些组件的属性是从对应的properties类中获取的，这些类里面的每一个属性又是和配置文件绑定的； 所有在配置文件中能配置的属性都是在xxxxProperties类中封装者‘；配置文件能配置什么就可以参照某个功能对应的这个属性类

@ConfigurationProperties(prefix = "spring.http.encoding") //从配置文件中获取指定的值和bean的属性进行绑定 public class HttpEncodingProperties { public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

写的还不完全，也不一定正确，欢迎各位大佬指正