SpringBoot 自动配置源码分析
SpringBoot
- 1. SpringBoot 项目快速搭建
- 2. HelloWorld 探究
-
- 2.1 pom.xml
-
- 2.1.1 父项目
- 2.1.2 导入的依赖
- 2.2 主启动类
-
- 2.2.1 @SpringBootApplication
- 3. @EnableAutoConfiguration
-
- 3.1 @AutoConfigurationPackage
-
- 3.1.1 AutoConfigurationImportSelector
-
- 深入研究 loadMetadata 方法
- 深入研究 getAutoConfigurationEntry 方法
-
- 深入 getCandidateConfigurations 方法
- 3.2 自动配置原理
- 3.3 精髓
1. SpringBoot 项目快速搭建
- 创建一个
maven工程（jar） - 导入
SpringBoot相关的依赖
<parent>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-parentartifactId>
<version>2.1.12.RELEASEversion>
parent>
<dependencies>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
dependencies>
- 编写一个主程序，启动
SpringBoot应用
package com.wangzhao;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
* @author wangzhao
* @date 2020/6/29 17:43
*/
// @SpringBootApplication 来标注一个主程序类，说明这是一个Spring Boot应用
@SpringBootApplication
public class HelloWorldMainApplication {
public static void main(String[] args) {
SpringApplication.run(HelloWorldMainApplication.class, args);
}
}
- 编写
Controller层
package com.wangzhao.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* @author wangzhao
* @date 2020/6/29 17:47
*/
@RestController
public class HelloController {
@RequestMapping("/hello")
public String sayHello() {
return "Hello World!";
}
}
- 运行主程序测试
6. 项目整体结构
如上，便成功启动了一个SpringBoot的项目，可以看到，相比于Spring而言，SpringBoot使用非常简单，快速，并且我们几乎没有进行任何配置文件的填写。
2. HelloWorld 探究
2.1 pom.xml
2.1.1 父项目
Hello World其所依赖的父项目为：spring-boot-starter-parent
<parent>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-parentartifactId>
<version>1.5.9.RELEASEversion>
parent>
我们可以看一下spring-boot-starter-parent做了哪些事情
<properties>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
<resource.delimiter>@</resource.delimiter>
<maven.compiler.source>${java.version}</maven.compiler.source>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.target>${java.version}</maven.compiler.target>
</properties>
- 使用
UTF-8格式编码 - 定义了
Java编译版本为1.8。
除此之外，spring-boot-starter-parent其所依赖的父项目为spring-boot-dependencies：
<parent>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-dependenciesartifactId>
<version>2.1.12.RELEASEversion>
<relativePath>../../spring-boot-dependenciesrelativePath>
parent>
<properties>
<activemq.version>5.15.11activemq.version>
<antlr2.version>2.7.7antlr2.version>
<appengine-sdk.version>1.9.77appengine-sdk.version>
<artemis.version>2.6.4artemis.version>
<aspectj.version>1.9.5aspectj.version>
<assertj.version>3.11.1assertj.version>
<atomikos.version>4.0.6atomikos.version>
<bitronix.version>2.1.4bitronix.version>
......
properties>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-bootartifactId>
<version>2.1.12.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-testartifactId>
<version>2.1.12.RELEASEversion>
dependency>
......
dependencies>
dependencyManagement>
其相当于SpringBoot的版本仲裁中心；
他提供了jar包的版本管理，以及Spring框架和其他第三方组件jar包的依赖管理。
2.1.2 导入的依赖
回到我们项目的pom文件中，导入了该依赖。
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
让我们进入到spring-boot-starter-web的pom文件中，可以看到导入的都是web相关的模块，并且还内置了一个tomcat。
<dependencies>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starterartifactId>
<version>2.1.12.RELEASEversion>
<scope>compilescope>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-jsonartifactId>
<version>2.1.12.RELEASEversion>
<scope>compilescope>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-tomcatartifactId>
<version>2.1.12.RELEASEversion>
<scope>compilescope>
dependency>
<dependency>
<groupId>org.hibernate.validatorgroupId>
<artifactId>hibernate-validatorartifactId>
<version>6.0.18.Finalversion>
<scope>compilescope>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-webartifactId>
<version>5.1.13.RELEASEversion>
<scope>compilescope>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-webmvcartifactId>
<version>5.1.13.RELEASEversion>
<scope>compilescope>
dependency>
dependencies>
spring-boot-starter：spring-boot场景启动器，其帮我们导入了相关场景模块正常运行所依赖的组件；
Spring Boot将所有的功能场景都抽取出来，做成一个个的starter（启动器），只需要在项目里面引入这些starter相关场景的所有依赖都会导入进来。要用什么功能，就导入什么场景的启动器。
2.2 主启动类
// @SpringBootApplication 来标注一个主程序类，说明这是一个Spring Boot应用
@SpringBootApplication
public class HelloWorldMainApplication {
public static void main(String[] args) {
SpringApplication.run(HelloWorldMainApplication.class, args);
}
}
@SpringBootApplication：SpringBoot应用标注在某个类上说明这个类是SpringBoot的主配置类，SpringBoot就应该运行这个类的main()方法启动SpringBoot应用。
2.2.1 @SpringBootApplication
进入到@SpringBootApplication内，观察其做了哪些工作：
package org.springframework.boot.autoconfigure;
@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是一个复合注解，包括@SpringBootConfiguration，@EnableAutoConfiguration和@ComponentScan。
@SpringBootConfiguration：SpringBoot的配置类，标注在某个类上，表示这是一个SpringBoot的配置类。
package org.springframework.boot;
// 配置类的作用等同于配置文件，配置类也是容器中的一个对象
@Configuration
public @interface SpringBootConfiguration {
}
@EnableAutoConfiguration：开启自动配置功能，以前由我们需要配置的东西，现在由SpringBoot帮我们自动配置，这个注解就是Springboot能实现自动配置的关键。@ComponentScan：这个注解是组件扫描这个是我们最熟悉的注解，即使没有使用过注解也经常在Spring的配置文件中使用过
3. @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容器。
@EnableAutoConfiguration就是借助@Import来收集所有符合自动配置条件的Bean定义，并加载到IOC容器。
3.1 @AutoConfigurationPackage
@AutoConfigurationPackage：自动配置包，它也是一个组合注解，其中最重要的注解是@Import(AutoConfigurationPackages.Registrar.class)，它是Spring框架的底层注解，它的作用就是给容器中导入某个组件类，例如@Import(AutoConfigurationPackages.Registrar.class)，它就是将Registrar这个组件类导入到容器中，可查看Registrar类中registerBeanDefinitions方法，这个方法就是导入组件类的具体实现。
package org.springframework.boot.autoconfigure;
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {
}
@Override
public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
// 将注解标注的元信息传入，获取到相应的包名
register(registry, new PackageImport(metadata).getPackageName());
}
可以看到AnnotationMetadata（注解标注注的元信息中包含了使用了哪些注解，相应的注解作用在哪个类上）
我们对new PackageImport(metadata).getPackageName()进行检索，看看其结果是什么？
因此可以得知使用@AutoConfigurationPackage注解就是将主程序类所在包及所有子包下的组件到扫描到Spring容器中。
3.1.1 AutoConfigurationImportSelector
@Import({AutoConfigurationImportSelector.class})：将AutoConfigurationImportSelector这个类导入到Spring容器中，AutoConfigurationImportSelector可以帮助Springboot应用将所有符合条件的@Configuration配置都加载到当前SpringBoot创建并使用的IOC容器(ApplicationContext)中。
AutoConfigurationImportSelector 是 ImportSelector 接口的实现类，而 ImportSelector 接口中的selectImports方法将返回的全限定类名对应的类交给 Spring 容器管理。
其不光实现了ImportSelector接口，还实现了很多其它的Aware接口，分别表示在某个时机会被回调。
public interface ImportSelector {
String[] selectImports(AnnotationMetadata importingClassMetadata);
}
我们可以知道，所有的aware都优先于selectImports方法执行，也就是说selectImports方法最后执行，那么在它执行的时候所有需要的资源都已经获取到了（AutoConfigurationImportSelector的四个成员变量）
public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,
ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
private ConfigurableListableBeanFactory beanFactory;
private Environment environment;
private ClassLoader beanClassLoader;
private ResourceLoader resourceLoader;
@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
if (!isEnabled(annotationMetadata)) {
return NO_IMPORTS;
}
// 获得自动配置元信息，需要传入beanClassLoader这个类加载器
AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
.loadMetadata(this.beanClassLoader);
AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(autoConfigurationMetadata,
annotationMetadata);
return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}
深入研究 loadMetadata 方法
// 文件中为需要加载的配置类的类路径
protected static final String PATH = "META-INF/" + "spring-autoconfigure-metadata.properties";
public static AutoConfigurationMetadata loadMetadata(ClassLoader classLoader) {
return loadMetadata(classLoader, PATH);
}
static AutoConfigurationMetadata loadMetadata(ClassLoader classLoader, String path) {
try {
// 读取spring-boot-autoconfigure-2.1.12.RELEASE.jar包中
// spring-autoconfigure-metadata.properties的信息生成urls枚举对象
Enumeration<URL> urls = (classLoader != null) ? classLoader.getResources(path)
: ClassLoader.getSystemResources(path);
Properties properties = new Properties();
//解析urls枚举对象中的信息封装成properties对象并加载
while (urls.hasMoreElements()) {
properties.putAll(PropertiesLoaderUtils
.loadProperties(new UrlResource(urls.nextElement())));
}
//根据封装好的properties对象生成AutoConfigurationMetadata对象返回
return loadMetadata(properties);
}
catch (IOException ex) {
throw new IllegalArgumentException(
"Unable to load @ConditionalOnClass location [" + path + "]", ex);
}
}
深入研究 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);
// 应用 exclusion 属性
Set<String> exclusions = getExclusions(annotationMetadata, attributes);
checkExcludedClasses(configurations, exclusions);
configurations.removeAll(exclusions);
// 应用过滤器 AutoConfigurationImportFilter，
// 对于 spring boot autoconfigure，定义了一个需要被应用的过滤器 ：
// org.springframework.boot.autoconfigure.condition.OnClassCondition，
// 此过滤器检查候选配置类上的注解@ConditionalOnClass，如果要求的类在classpath
// 中不存在，则这个候选配置类会被排除掉
configurations = filter(configurations, autoConfigurationMetadata);
// 现在已经找到所有需要被应用的候选配置类
// 广播事件 AutoConfigurationImportEvent
fireAutoConfigurationImportEvents(configurations, exclusions);
return new AutoConfigurationEntry(configurations, exclusions);
}
深入 getCandidateConfigurations 方法
这个方法中有一个重要方法loadFactoryNames，这个方法是让SpringFactoryLoader去加载一些组件的名字。
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
// 这个方法需要传入两个参数getSpringFactoriesLoaderFactoryClass()和getBeanClassLoader()
// getSpringFactoriesLoaderFactoryClass()这个方法返回的是EnableAutoConfiguration.class
// getBeanClassLoader()这个方法返回的是beanClassLoader（类加载器）
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;
}
继续点开loadFactory方法
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 {
//如果类加载器不为null，则加载类路径下spring.factories文件，将其中设置的配置类的全路径信息封装 为Enumeration类对象
Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
LinkedMultiValueMap result = new LinkedMultiValueMap();
//循环Enumeration类对象，根据相应的节点信息生成Properties对象，通过传入的键获取值，在将值切割为一个个小的字符串转化为Array，方法result集合中
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;
}
}
}
3.2 自动配置原理
SpringBoot启动的时候加载主配置类，开启了自动配置功能 @EnableAutoConfiguration@EnableAutoConfiguration作用：
- 利用
EnableAutoConfigurationImportSelector给容器中导入一些组件 - 可以查看
selectImports()方法的内容：
List<String> configurations = this.getCandidateConfigurations(annotationMetadata,attributes);
- 上面代码的作用是获取候选的配置
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
List<String> configurations = SpringFactoriesLoader.loadFactoryNames();
// 扫描所有 jar 包类路径下 META-INF/spring.factories
// 把扫描到的这些文件的内容包装成 properties 对象
// 从properties中获取到 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,\
......
每一个这样的 xxxAutoConfiguration类都是容器中的一个组件，都加入到容器之中。用它们来做自动配置。
- 每一个自动配置类进行自动配置功能
- 以
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，也是默认生效的
@ConditionalOnProperty(
prefix = "spring.http.encoding",
value = {"enabled"},
matchIfMissing = 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类中获取的，这些类里面的每一个属性又是和配置文件绑定的。
# 我们能配置的属性都是来源于这个功能的properties类
spring.http.encoding.enabled=true
spring.http.encoding.charset=utf-8
spring.http.encoding.force=true
- 所有在配置文件中能配置的属性都是在
xxxProperties类中封装着，配置文件能配置什么就可以参照某个功能对应的这个属性类。
// 从配置文件中获取指定的值和bean的属性进行绑定
@ConfigurationProperties(prefix = "spring.http.encoding")
public class HttpEncodingProperties {
public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
3.3 精髓
-
SpringBoot 启动会加载大量的自动配置类
-
我们看我们需要实现的功能有没有
SpringBoot默认写好的自动配置类 -
我们再来看这个自动配置类中到底配置了哪些组件；（只要我们有我们要用的组件，我们就不需要再来配置了）
-
给容器中自动配置类添加组件的时候，会从
properties类中获取某些属性，我们就可以在配置文件中指定这些属性的值。
xxxAutoConfiguration：自动配置类，用于给容器中添加组件从而代替之前我们手动完成大量繁琐的配置。
xxxProperties : 封装了对应自动配置类的默认属性值，如果我们需要自定义属性值，只需要根据xxxProperties寻找相关属性在配置文件设值即可。