SpringBoot源码-自动配置

时间:2021-7-3 作者:qvyue

自动配置:根据我们添加的jar包依赖,会自动将一些配置类的bean注册进ioc容器,我们可以需要的地
方使用@autowired或者@resource等注解来使用它。

Spring Boot应用的启动入口是@SpringBootApplication注解标注类中的main()方法,
@SpringBootApplication : SpringBoot 应用标注在某个类上说明这个类是 SpringBoot 的主配置
类, SpringBoot 就应该运行这个类的 main() 方法启动 SpringBoot 应用。

@SpringBootApplication

看@SpringBootApplication内部源码进行分析 ,核心代码具体如下

@Target({ElementType.TYPE}) //注解的适用范围,Type表示注解可以描述在类、接口、注解或枚举中 
@Retention(RetentionPolicy.RUNTIME) //表示注解的生命周期,Runtime运行时 
@Documented //表示注解可以记录在javadoc中 
@Inherited //表示可以被子类继承该注解 

@SpringBootConfiguration // 标明该类为配置类 
@EnableAutoConfiguration // 启动自动配置功能 
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = 
TypeExcludeFilter.class), 
@Filter(type = FilterType.CUSTOM, classes = 
AutoConfigurationExcludeFilter.class) }) 
public @interface SpringBootApplication { 
// 根据class来排除特定的类,使其不能加入spring容器,传入参数value类型是class类型。 
@AliasFor(annotation = EnableAutoConfiguration.class) 
Class>[] exclude() default {}; 
// 根据classname 来排除特定的类,使其不能加入spring容器,传入参数value类型是class的全 
类名字符串数组。 
@AliasFor(annotation = EnableAutoConfiguration.class) 
String[] excludeName() default {}; 
// 指定扫描包,参数是包名的字符串数组。 
@AliasFor(annotation = ComponentScan.class, attribute = "basePackages") 
String[] scanBasePackages() default {}; 
// 扫描特定的包,参数类似是Class类型数组。 
@AliasFor(annotation = ComponentScan.class, attribute = 
"basePackageClasses") 
Class>[] scanBasePackageClasses() default {}; 
}

从上述源码可以看出,@SpringBootApplication注解是一个组合注解,前面 4 个是注解的元数据信
息, 我们主要看后面 3 个注解:@SpringBootConfiguration、@EnableAutoConfiguration、
@ComponentScan三个核心注解,关于这三个核心注解的相关说明具体如下

@SpringBootConfiguration

@SpringBootConfiguration : SpringBoot 的配置类,标注在某个类上,表示这是一个 SpringBoot
的配置类。
查看@SpringBootConfiguration注解源码,核心代码具体如下。

@Target({ElementType.TYPE}) 
@Retention(RetentionPolicy.RUNTIME) 
@Documented 
@Configuration // 配置类的作用等同于配置文件,配置类也是容器中的一个对象 
public @interface SpringBootConfiguration { 
}

从上述源码可以看出,@SpringBootConfiguration注解内部有一个核心注解@Configuration,该注解
是Spring框架提供的,表示当前类为一个配置类(XML配置文件的注解表现形式),并可以被组件扫描
器扫描。由此可见,@SpringBootConfiguration注解的作用与@Configuration注解相同,都是标识一
个可以被组件扫描器扫描的配置类,只不过@SpringBootConfiguration是被Spring Boot进行了重新封
装命名而已

@EnableAutoConfiguration

package org.springframework.boot.autoconfigure; 
// 自动配置包 
@AutoConfigurationPackage 
// Spring的底层注解@Import,给容器中导入一个组件; 
// 导入的组件是AutoConfigurationPackages.Registrar.class 
@Import(AutoConfigurationImportSelector.class) 
// 告诉SpringBoot开启自动配置功能,这样自动配置才能生效。 
public @interface EnableAutoConfiguration { 
String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration"; 
// 返回不会被导入到 Spring 容器中的类 
Class>[] exclude() default {}; 
// 返回不会被导入到 Spring 容器中的类名 
String[] excludeName() default {}; 
}

Spring 中有很多以 Enable 开头的注解,其作用就是借助 @Import 来收集并注册特定场景相关的
Bean ,并加载到 IOC 容器。
@EnableAutoConfiguration就是借助@Import来收集所有符合自动配置条件的bean定义,并加载到
IoC容器。

@AutoConfigurationPackage

package org.springframework.boot.autoconfigure; 
@Import(AutoConfigurationPackages.Registrar.class) // 导入Registrar中注册的组件 
public @interface AutoConfigurationPackage { 
}

@AutoConfigurationPackage :自动配置包,它也是一个组合注解,其中最重要的注解是
@Import(AutoConfigurationPackages.Registrar.class) ,它是 Spring 框架的底层注解,它的作
用就是给容器中导入某个组件类,例如
@Import(AutoConfigurationPackages.Registrar.class) ,它就是将 Registrar 这个组件类导入
到容器中,可查看 Registrar 类中 registerBeanDefinitions 方法:

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
    Registrar() {
    }

    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        AutoConfigurationPackages.register(registry, (String[])(new AutoConfigurationPackages.PackageImports(metadata)).getPackageNames().toArray(new String[0]));
    }

    public Set determineImports(AnnotationMetadata metadata) {
        return Collections.singleton(new AutoConfigurationPackages.PackageImports(metadata));
    }
}

再看register方法

public static void register(BeanDefinitionRegistry registry, String... 
packageNames) { 
// 这里参数 packageNames 缺省情况下就是一个字符串,是使用了注解 
// @SpringBootApplication 的 Spring Boot 应用程序入口类所在的包 
if (registry.containsBeanDefinition(BEAN)) { 
// 如果该bean已经注册,则将要注册包名称添加进去 
BeanDefinition beanDefinition = registry.getBeanDefinition(BEAN); 
ConstructorArgumentValues constructorArguments = beanDefinition 
.getConstructorArgumentValues(); 
constructorArguments.addIndexedArgumentValue(0, 
addBasePackages(constructorArguments, packageNames)); 
}
else {
//如果该bean尚未注册,则注册该bean,参数中提供的包名称会被设置到bean定义中去 
GenericBeanDefinition beanDefinition = new GenericBeanDefinition(); 
beanDefinition.setBeanClass(BasePackages.class); 
beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(0,
packageNames); 
beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE); 
registry.registerBeanDefinition(BEAN, beanDefinition); 
} 
} 

AutoConfigurationPackages.Registrar这个类就干一个事,注册一个 Bean ,这个 Bean 就是
org.springframework.boot.autoconfigure.AutoConfigurationPackages.BasePackages ,它有
一个参数,这个参数是使用了 @AutoConfigurationPackage 这个注解的类所在的包路径,保存自动配置
类以供之后的使用,比如给 JPA entity 扫描器用来扫描开发人员通过注解 @Entity 定义的 entity
类。

@Import(AutoConfigurationImportSelector.class)

@Import({AutoConfigurationImportSelector.class}) :将
AutoConfigurationImportSelector 这个类导入到 Spring 容器中,
AutoConfigurationImportSelector 可以帮助 Springboot 应用将所有符合条件的 @Configuration
配置都加载到当前 SpringBoot 创建并使用的 IOC 容器( ApplicationContext )中。

SpringBoot源码-自动配置
image.png

AutoConfigurationImportSelector 重点是实现了 DeferredImportSelector 接口和各种
Aware 接口,然后 DeferredImportSelector 接口又继承了 ImportSelector 接口。
其不光实现了 ImportSelector 接口,还实现了很多其它的 Aware 接口,分别表示在某个时机会被回
调。

确定自动配置实现逻辑的入口方法:

跟自动配置逻辑相关的入口方法在 DeferredImportSelectorGrouping 类的 getImports 方法处,
因此我们就从 DeferredImportSelectorGrouping 类的 getImports 方法来开始分析SpringBoot的自
动配置源码好了。

// ConfigurationClassParser.java 
public Iterable getImports() { 
// 遍历DeferredImportSelectorHolder对象集合deferredImports,deferredImports集合 
装了各种ImportSelector,当然这里装的是AutoConfigurationImportSelector 
for (DeferredImportSelectorHolder deferredImport : this.deferredImports) { 
// 【1】,利用AutoConfigurationGroup的process方法来处理自动配置的相关逻辑,决定 
导入哪些配置类(这个是我们分析的重点,自动配置的逻辑全在这了) 
this.group.process(deferredImport.getConfigurationClass().getMetadata(), 
deferredImport.getImportSelector()); 
}
// 【2】,经过上面的处理后,然后再进行选择导入哪些配置类 
return this.group.selectImports(); 
}

标 【1】 处的的代码是我们分析的重中之重,自动配置的相关的绝大部分逻辑全在这里了。那么
this.group.process(deferredImport.getConfigurationClass().getMetadata(), deferredImport.getImportSelector()) ;主要做的事情就是在 this.group 即 AutoConfigurationGroup 对象的 process 方法中,传入的 AutoConfigurationImportSelector
对象来选择一些符合条件的自动配置类,过滤掉一些不符合条件的自动配置类

注:
AutoConfigurationGroup:是AutoConfigurationImportSelector的内部类,主要用来处理自动配 
置相关的逻辑,拥有process和selectImports方法,然后拥有entries和 
autoConfigurationEntries集合属性,这两个集合分别存储被处理后的符合条件的自动配置类,我们知道 
这些就足够了; 
AutoConfigurationImportSelector:承担自动配置的绝大部分逻辑,负责选择一些符合条件的自动配 
置类; 
metadata:标注在SpringBoot启动类上的@SpringBootApplication注解元数据 
标【2】的this.group.selectImports的方法主要是针对前面的process方法处理后的自动配置类再进一 
步有选择的选择导入

SpringBoot源码-自动配置
image.png

图中我们可以看到,跟自动配置逻辑相关的入口方法在process方法中

自动配置的主要逻辑

// AutoConfigurationImportSelector$AutoConfigurationGroup.java 
// 这里用来处理自动配置类,比如过滤掉不符合匹配条件的自动配置类 
public void process(AnnotationMetadata annotationMetadata, 
DeferredImportSelector deferredImportSelector) { 
Assert.state( 
deferredImportSelector instanceof AutoConfigurationImportSelector, 
() -> String.format("Only %s implementations are supported, got %s", 
AutoConfigurationImportSelector.class.getSimpleName(), 
deferredImportSelector.getClass().getName())); 
// 【1】,调用getAutoConfigurationEntry方法得到自动配置类放入 autoConfigurationEntry对象中 
AutoConfigurationEntry autoConfigurationEntry = 
((AutoConfigurationImportSelector) deferredImportSelector) 
.getAutoConfigurationEntry(getAutoConfigurationMetadata(), 
annotationMetadata);
//上面代码中我们再来看标 【1】 的方法 getAutoConfigurationEntry ,这个方法主要是用来获取自动 配置类有关,承担了自动配置的主要逻辑。直接上代码: 
//深入 getCandidateConfigurations 方法 
// 【2】,又将封装了自动配置类的autoConfigurationEntry对象装进 
//autoConfigurationEntries集合 
this.autoConfigurationEntries.add(autoConfigurationEntry); 
// 【3】,遍历刚获取的自动配置类 
for (String importClassName : autoConfigurationEntry.getConfigurations()) { 
// 这里符合条件的自动配置类作为key,annotationMetadata作为值放进entries集合 
this.entries.putIfAbsent(importClassName, annotationMetadata); 
} 
}

上面代码中我们再来看标 【1】 的方法 getAutoConfigurationEntry ,这个方法主要是用来获取自动
配置类有关,承担了自动配置的主要逻辑。

// AutoConfigurationImportSelector.java 
// 获取符合条件的自动配置类,避免加载不必要的自动配置类从而造成内存浪费 
protected AutoConfigurationEntry getAutoConfigurationEntry( 
AutoConfigurationMetadata autoConfigurationMetadata, 
AnnotationMetadata annotationMetadata) { 
// 获取是否有配置spring.boot.enableautoconfiguration属性,默认返回true 
if (!isEnabled(annotationMetadata)) { 
return EMPTY_ENTRY; 
}
// 获得@Congiguration标注的Configuration类即被审视introspectedClass的注解数据, 
// 比如:@SpringBootApplication(exclude = FreeMarkerAutoConfiguration.class) 
// 将会获取到exclude = FreeMarkerAutoConfiguration.class和excludeName=""的注解 数据 
AnnotationAttributes attributes = getAttributes(annotationMetadata); 
// 【1】得到spring.factories文件配置的所有自动配置类 
List configurations = getCandidateConfigurations(annotationMetadata, 
attributes); 
// 利用LinkedHashSet移除重复的配置类 
configurations = removeDuplicates(configurations); 
// 得到要排除的自动配置类,比如注解属性exclude的配置类 
// 比如:@SpringBootApplication(exclude = FreeMarkerAutoConfiguration.class) 
// 将会获取到exclude = FreeMarkerAutoConfiguration.class的注解数据 
Set exclusions = getExclusions(annotationMetadata, attributes); 
// 检查要被排除的配置类,因为有些不是自动配置类,故要抛出异常 
checkExcludedClasses(configurations, exclusions); 
// 【2】将要排除的配置类移除 
configurations.removeAll(exclusions); 
// 【3】因为从spring.factories文件获取的自动配置类太多,如果有些不必要的自动配置类都加载 
//进内存,会造成内存浪费,因此这里需要进行过滤 
// 注意这里会调用AutoConfigurationImportFilter的match方法来判断是否符合 
//@ConditionalOnBean,@ConditionalOnClass或@ConditionalOnWebApplication,后面会重点分 
//析一下
configurations = filter(configurations, autoConfigurationMetadata); 
// 【4】获取了符合条件的自动配置类后,此时触发AutoConfigurationImportEvent事件, 
// 目的是告诉ConditionEvaluationReport条件评估报告器对象来记录符合条件的自动配置类 
// 该事件什么时候会被触发?--> 在刷新容器时调用invokeBeanFactoryPostProcessors后置处 
//理器时触发 
fireAutoConfigurationImportEvents(configurations, exclusions); 
// 【5】将符合条件和要排除的自动配置类封装进AutoConfigurationEntry对象,并返回 
return new AutoConfigurationEntry(configurations, exclusions); 
}

此流程遍历整个ClassLoader中所有jar包下的spring.factories文件,并进行过滤。
spring.factories里面保存着springboot的默认提供的自动配置类。

META-INF/spring.factories

SpringBoot源码-自动配置
image.png

主要逻辑

AutoConfigurationEntry 方法主要做的事情就是获取符合条件的自动配置类,避免加载不必要的自
动配置类从而造成内存浪费。我们下面总结下 AutoConfigurationEntry 方法主要做的事情:
【1】从 spring.factories 配置文件中加载 EnableAutoConfiguration 自动配置类),获取的自动配
置类如图所示。
【2】若 @EnableAutoConfiguration 等注解标有要 exclude 的自动配置类,那么再将这个自动配置类
排除掉;
【3】排除掉要 exclude 的自动配置类后,然后再调用 filter 方法进行进一步的过滤,再次排除一些
不符合条件的自动配置类;
【4】经过重重过滤后,此时再触发 AutoConfigurationImportEvent 事件,告诉
ConditionEvaluationReport 条件评估报告器对象来记录符合条件的自动配置类;
【5】 最后再将符合条件的自动配置类返回。

过滤方法

// AutoConfigurationImportSelector.java 
private List filter(List configurations, 
AutoConfigurationMetadata autoConfigurationMetadata) { 
long startTime = System.nanoTime(); 
// 将从spring.factories中获取的自动配置类转出字符串数组 
String[] candidates = StringUtils.toStringArray(configurations); 
// 定义skip数组,是否需要跳过。注意skip数组与candidates数组顺序一一对应 
boolean[] skip = new boolean[candidates.length]; 
boolean skipped = false; 
// getAutoConfigurationImportFilters方法:拿到OnBeanCondition, 
OnClassCondition和OnWebApplicationCondition 
// 然后遍历这三个条件类去过滤从spring.factories加载的大量配置类 
for (AutoConfigurationImportFilter filter : 
getAutoConfigurationImportFilters()) { 
// 调用各种aware方法,将beanClassLoader,beanFactory等注入到filter对象中, 
// 这里的filter对象即OnBeanCondition,OnClassCondition或 
OnWebApplicationCondition 
invokeAwareMethods(filter); 
// 判断各种filter来判断每个candidate(这里实质要通过candidate(自动配置类)拿到其标 
注的 
// @ConditionalOnClass,@ConditionalOnBean和@ConditionalOnWebApplication里 
面的注解值)是否匹配, 
// 注意candidates数组与match数组一一对应 
/**********************【主线,重点关注】********************************/ 
boolean[] match = filter.match(candidates, autoConfigurationMetadata); 
// 遍历match数组,注意match顺序跟candidates的自动配置类一一对应 
for (int i = 0; i  result = new ArrayList(candidates.length); 
for (int i = 0; i (result); 
}

AutoConfigurationImportSelector 的 filter 方法主要做的事情就是调用
AutoConfigurationImportFilter 接口的 match 方法来判断每一个自动配置类上的条件注解(若有
的话) @ConditionalOnClass , @ConditionalOnBean 或 @ConditionalOnWebApplication 是否满足
条件,若满足,则返回true,说明匹配,若不满足,则返回false说明不匹配。
我们现在知道 AutoConfigurationImportSelector 的 filter 方法主要做了什么事情就行了

关于条件注解的讲解

@Conditional是Spring4新提供的注解,它的作用是按照一定的条件进行判断,满足条件给容器注册
bean。
@ConditionalOnBean:仅仅在当前上下文中存在某个对象时,才会实例化一个Bean。
@ConditionalOnClass:某个class位于类路径上,才会实例化一个Bean。
@ConditionalOnExpression:当表达式为true的时候,才会实例化一个Bean。基于SpEL表达式
的条件判断。
@ConditionalOnMissingBean:仅仅在当前上下文中不存在某个对象时,才会实例化一个Bean。
@ConditionalOnMissingClass:某个class类路径上不存在的时候,才会实例化一个Bean。
@ConditionalOnNotWebApplication:不是web应用,才会实例化一个Bean。
@ConditionalOnWebApplication:当项目是一个Web项目时进行实例化。
@ConditionalOnNotWebApplication:当项目不是一个Web项目时进行实例化。
@ConditionalOnProperty:当指定的属性有指定的值时进行实例化。
@ConditionalOnJava:当JVM版本为指定的版本范围时触发实例化。
@ConditionalOnResource:当类路径下有指定的资源时触发实例化。
@ConditionalOnJndi:在JNDI存在的条件下触发实例化。
@ConditionalOnSingleCandidate:当指定的Bean在容器中只有一个,或者有多个但是指定了首
选的Bean时触发实例化。

有选择的导入自动配置类

this.group.selectImports 方法是如何进一步有选择的导入自动配置类的。

// AutoConfigurationImportSelector$AutoConfigurationGroup.java 
public Iterable selectImports() { 
if (this.autoConfigurationEntries.isEmpty()) { 
return Collections.emptyList(); 
}
// 这里得到所有要排除的自动配置类的set集合 
Set allExclusions = this.autoConfigurationEntries.stream() 
.map(AutoConfigurationEntry::getExclusions)
.flatMap(Collection::stream).collect(Collectors.toSet()); 
// 这里得到经过滤后所有符合条件的自动配置类的set集合 
Set processedConfigurations = this.autoConfigurationEntries.stream() 
.map(AutoConfigurationEntry::getConfigurations) 
.flatMap(Collection::stream) 
.collect(Collectors.toCollection(LinkedHashSet::new)); 
// 移除掉要排除的自动配置类 
processedConfigurations.removeAll(allExclusions); 
// 对标注有@Order注解的自动配置类进行排序, 
return sortAutoConfigurations(processedConfigurations, 
getAutoConfigurationMetadata()) 
.stream() 
.map((importClassName) -> new Entry( 
this.entries.get(importClassName), importClassName)) 
.collect(Collectors.toList()); 
}

可以看到, selectImports 方法主要是针对经过排除掉 exclude 的和被
AutoConfigurationImportFilter 接口过滤后的满足条件的自动配置类再进一步排除 exclude 的自
动配置类,然后再排序
最后,我们再总结下SpringBoot自动配置的原理,主要做了以下事情:

  1. 从spring.factories配置文件中加载自动配置类;
  2. 加载的自动配置类中排除掉 @EnableAutoConfiguration 注解的 exclude 属性指定的自动配置
    类;
  3. 然后再用 AutoConfigurationImportFilter 接口去过滤自动配置类是否符合其标注注解(若有
    标注的话) @ConditionalOnClass , @ConditionalOnBean 和 @ConditionalOnWebApplication 的条件,若都符合的话则返回匹配结果;
  4. 然后触发 AutoConfigurationImportEvent 事件,告诉 ConditionEvaluationReport 条件评
    估报告器对象来分别记录符合条件和 exclude 的自动配置类。
  5. 最后spring再将最后筛选后的自动配置类导入IOC容器中
SpringBoot源码-自动配置
image.png

总解

  1. SpringBoot 启动会加载大量的自动配置类
  2. 我们看我们需要实现的功能有没有 SpringBoot 默认写好的自动配置类
  3. 我们再来看这个自动配置类中到底配置了哪些组件;(只要我们有我们要用的组件,我们就不需要
    再来配置了)
  4. 给容器中自动配置类添加组件的时候,会从 properties 类中获取某些属性,我们就可以在配置文
    件中指定这些属性的值。
    xxxAutoConfiguration :自动配置类,用于给容器中添加组件从而代替之前我们手动完成大量繁
    琐的配置。
    xxxProperties : 封装了对应自动配置类的默认属性值,如果我们需要自定义属性值,只需要根据
    xxxProperties 寻找相关属性在配置文件设值即可。

例子HttpEncodingAutoConfiguration ( Http 编码自动配置)

// 表示这是一个配置类,和以前编写的配置文件一样,也可以给容器中添加组件 
@Configuration 
// 启动指定类的ConfigurationProperties功能;将配置文件中对应的值和 
//HttpEncodingProperties绑定起来; 
@EnableConfigurationProperties({HttpEncodingProperties.class}) 
// Spring底层@Conditional注解,根据不同的条件,如果满足指定的条件,整个配置类里面的配置就会生效。 
// 判断当前应用是否是web应用,如果是,当前配置类生效。并把HttpEncodingProperties加入到 ioc 容器中 
@ConditionalOnWebApplication 
// 判断当前项目有没有这个CharacterEncodingFilter : SpringMVC中进行乱码解决的过滤器 
@ConditionalOnClass({CharacterEncodingFilter.class}) 
// 判断配置文件中是否存在某个配置 spring.http.encoding.enabled 如果不存在,判断也是成立的 
// matchIfMissing = true 表示即使我们配置文件中不配置 
spring.http.encoding.enabled=true,也是默认生效的 

@ComponentScan注解

@ComponentScan使用
主要是从定义的扫描路径中,找出标识了需要装配的类自动装配到spring 的bean容器中。
常用属性如下:
basePackages、value:指定扫描路径,如果为空则以@ComponentScan注解的类所在的包为基
本的扫描路径
basePackageClasses:指定具体扫描的类
includeFilters:指定满足Filter条件的类
excludeFilters:指定排除Filter条件的类
includeFilters和excludeFilters 的FilterType可选:ANNOTATION=注解类型 默认、
ASSIGNABLE_TYPE(指定固定类)、ASPECTJ(ASPECTJ类型)、REGEX(正则表达式)、CUSTOM(自定义类
型),自定义的Filter需要实现TypeFilter接口
@ComponentScan的配置如下:

@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = 
TypeExcludeFilter.class), 
@Filter(type = FilterType.CUSTOM, classes = 
AutoConfigurationExcludeFilter.class) }) 

借助excludeFilters将TypeExcludeFillter及FilterType这两个类进行排除
当前@ComponentScan注解没有标注basePackages及value,所以扫描路径默认为@ComponentScan
注解的类所在的包为基本的扫描路径(也就是标注了@SpringBootApplication注解的项目启动类所在
的路径)

声明:本文内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎发送邮件至:qvyue@qq.com 进行举报,并提供相关证据,工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。