Spring Boot 2.x 源码系列2-spring boot 自动配置

一、前沿

在 Spring Boot 启动流程 文章中我们了解了 Spring Boot 的启动流程，其中在刷新上下文过程中加载了所有的自动化配置类

而 Spring Boot 的自动化配置加载分为了两个步骤：

1）、首先在 Spring Boot 初始化阶段通过 SpringFactoriesLoader 将所有 MATA-INF/spring.factories 文件中的所有配置内容以一对多的类名集合存入到缓存中

spring-boot-autoconfigure 模块中的  MATA-INF/spring.factories 文件 EnableAutoConfiguration 对应的类集合如下：

加载到缓存中的类集合如下所示：

2）、然后在刷新上下文过程中，通过 SpringFactoriesLoader 的 loadFactoryNames 方法获取自动配置类的集合，最后通过反射获取这些类的类对象、构造方法进而生成类实例

创建自动化配置类过程如下：

二、自动化配置流程图

为了更好地理解自动化配置，通过一张图来说明，如下图所示：

mybatis-spring-boot-starter 等组件的 META-INF 目录下均含有 spring.factories 文件，而 SpringFactoriesLoader 会扫描所有 spring.factories 文件中的类全名并返回一个类全名的数组，返回的类全名通过反射被实例化，就形成了具体的工厂实例，工厂实例来生成组件具体需要的bean

三、自动化配置源码

开启 Spring Boot 自动化配置功能的是 @EnableAutoConfiguration 注解，下面我们就从 @EnableAutoConfiguration 注解开始讲起

3.1 EnableAutoConfiguration

@EnableAutoConfiguration 功能是开启 SpringBoot 自动配置，源码如下：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
// 自动配置包下的bean注册
@AutoConfigurationPackage
// AutoConfigurationImportSelector 自动配置导入组件，这个类是 Spring Boot 实现自动配置的核心
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {

	String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

	// 自动配置排除特定的类
	Class[] exclude() default {};

	// 自动配置排除特定的类名
	String[] excludeName() default {};

}

从 @EnableAutoConfiguration 注解源码可知 AutoConfigurationImportSelector 类是实现自动配置的核心所在

3.2  AutoConfigurationImportSelector

AutoConfigurationImportSelector 类结构如下：

AutoConfigurationImportSelector 中的核心方法 getAutoConfigurationEntry 源码如下：

	// 1、AutoConfigurationImportSelector 的 getAutoConfigurationEntry 方法
	protected AutoConfigurationEntry getAutoConfigurationEntry(
			AutoConfigurationMetadata autoConfigurationMetadata,
			AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {
			// 没有开始自动配置，则返回空
			return EMPTY_ENTRY;
		}
		// 获取元数据属性，只有 exclude 和 excludeName
		AnnotationAttributes attributes = getAttributes(annotationMetadata);
		// 根据元数据获取所有配置类集合
		List configurations = getCandidateConfigurations(annotationMetadata,
				attributes);
		configurations = removeDuplicates(configurations);
		// 获取需要排除的配置类集合
		Set exclusions = getExclusions(annotationMetadata, attributes);
		checkExcludedClasses(configurations, exclusions);
		// 移除需要排除的配置类集合
		configurations.removeAll(exclusions);
		// 根据配置的 AutoConfigurationImportFilter 过滤器进一步过滤掉不需要的配置类集合
		configurations = filter(configurations, autoConfigurationMetadata);
		// 发布自动配置导入事件
		fireAutoConfigurationImportEvents(configurations, exclusions);
		// 构建 AutoConfigurationEntry 对象返回
		return new AutoConfigurationEntry(configurations, exclusions);
	}


	// 2、AutoConfigurationImportSelector 的 getCandidateConfigurations 方法
	protected List getCandidateConfigurations(AnnotationMetadata metadata,
			AnnotationAttributes attributes) {
		// 获取 spring.factories 文件中 EnableAutoConfiguration 对应的配置类集合
		List 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;
	}

看完 AutoConfigurationImportSelector 实现的核心方法之后，就是弄清楚哪里调用的 AutoConfigurationImportSelector 的方法呢？

答案肯定是在刷新上下文时调用的，具体过程看自动配置类创建过程

3.3  自动配置类创建过程

自动配置类创建经过以下两个过程：

1）、首先通过 AbstractApplicationContext  的 invokeBeanFactoryPostProcessors 方法将配置的自动配置类转换为 BeanDefinition 并注册到 BeanFactory 中，如果自动配置类需要生成代理类，则会使用CGLIB动态代理直接生成对应的代理类

2）、然后通过 AbstractApplicationContext  的 finishBeanFactoryInitialization 方法将 BeanDefinition 实例化成对应的 Bean

3.3.1  转为 BeanDefinition

具体的入口在 AbstractApplicationContext 的 invokeBeanFactoryPostProcessors 方法，debug过程如下图所示：

debug具体栈信息：

getAutoConfigurationEntry:127, AutoConfigurationImportSelector (org.springframework.boot.autoconfigure)
process:420, AutoConfigurationImportSelector$AutoConfigurationGroup (org.springframework.boot.autoconfigure)
getImports:878, ConfigurationClassParser$DeferredImportSelectorGrouping (org.springframework.context.annotation)
processGroupImports:804, ConfigurationClassParser$DeferredImportSelectorGroupingHandler (org.springframework.context.annotation)
process:774, ConfigurationClassParser$DeferredImportSelectorHandler (org.springframework.context.annotation)
parse:185, ConfigurationClassParser (org.springframework.context.annotation)
processConfigBeanDefinitions:315, ConfigurationClassPostProcessor (org.springframework.context.annotation)
postProcessBeanDefinitionRegistry:232, ConfigurationClassPostProcessor (org.springframework.context.annotation)
invokeBeanDefinitionRegistryPostProcessors:275, PostProcessorRegistrationDelegate (org.springframework.context.support)
invokeBeanFactoryPostProcessors:95, PostProcessorRegistrationDelegate (org.springframework.context.support)
invokeBeanFactoryPostProcessors:691, AbstractApplicationContext (org.springframework.context.support)
refresh:528, AbstractApplicationContext (org.springframework.context.support)
refresh:142, ServletWebServerApplicationContext (org.springframework.boot.web.servlet.context)
refresh:775, SpringApplication (org.springframework.boot)
refreshContext:397, SpringApplication (org.springframework.boot)
run:316, SpringApplication (org.springframework.boot)
main:29, MainApplication (com.springboot.demo)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
run:49, RestartLauncher (org.springframework.boot.devtools.restart)

经过 AbstractApplicationContext 的 invokeBeanFactoryPostProcessors 方法之后，将所有 spring.factories 文件中自动配置类解析成了 BeanDefinition，如下图所示：

3.3.2  BeanDefinition 生成 Bean 实例

生成了 BeanDefinition 之后，就是将BeanDefinition 生成对应的 Bean 实例，而对于 Bean 的创建我们已经在 Spring 源码之 Bean 加载 分析过了，这里不在赘述了

四、自动配置类示例分析

我们以 RedisAutoConfiguration 为例，通过源码理解其原理

RedisAutoConfiguration 源码如下：

// 表明是一个配置类，其所有被 @bean 注解的方法都会被 Spring 容器创建成 Bean 实例，
// proxyBeanMethods 属性表示是否是代理，默认为 true，如果需要生成代理类，则会调用 CGLIB 生成代理类实例
@Configuration(proxyBeanMethods = false)
// 依赖于 RedisOperations 类，必须先实例该类
@ConditionalOnClass(RedisOperations.class)
// 启动该类的 ConfigurationProperties 功能；将配置文件中对应的值和 RedisProperties 绑定起来；并把 RedisProperties 加入到 Spring 的 Environment 中去
// 例如配置文件中的 spring.redis.url、spring.redis.host 等属性值会绑定到 RedisProperties 对应的属性上去
@EnableConfigurationProperties(RedisProperties.class)
// 引入需要的配置类
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {

	@Bean
	// 缺少 RedisTemplate Bean 时会创建 RedisTemplate 实例，否则什么也不做
	@ConditionalOnMissingBean(name = "redisTemplate")
	public RedisTemplate redisTemplate(
			RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
		RedisTemplate template = new RedisTemplate<>();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

	// 会生成 StringRedisTemplate 实例
	@Bean
	@ConditionalOnMissingBean
	public StringRedisTemplate stringRedisTemplate(
			RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
		StringRedisTemplate template = new StringRedisTemplate();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

}

所有在配置文件中能配置的属性都是在 xxxProperties 类中定义好的，配置文件能配置哪些属性就可以参照某个功能对应的这个属性类，例如 RedisAutoConfiguration 源码中的 @EnableConfigurationProperties(RedisProperties.class) ，RedisProperties 文件中定义的属性就是我们可以在配置文件中配置的属性

RedisProperties 源码如下：

// 所有属性的前缀
@ConfigurationProperties(prefix = "spring.redis")
public class RedisProperties {

	/**
	 * Database index used by the connection factory.
	 */
	// 数据库，默认是 0
	private int database = 0;

	/**
	 * Connection URL. Overrides host, port, and password. User is ignored. Example:
	 * redis://user:[email protected]:6379
	 */
	// url
	private String url;

	/**
	 * Redis server host.
	 */
	// host 地址，默认是 localhost
	private String host = "localhost";

	/**
	 * Login password of the redis server.
	 */
	// 密码
	private String password;

	/**
	 * Redis server port.
	 */
	// 端口，默认是 6379
	private int port = 6379;

	/**
	 * Whether to enable SSL support.
	 */
	// 是否支持 ssl
	private boolean ssl;

	/**
	 * Connection timeout.
	 */
	// 超时时间
	private Duration timeout;
}

从 RedisProperties 源码可知，配置文件中可以配置 spring.redis.url、spring.redis.host、spring.redis.password 等属性

配置文件中配置 redis 属性，如下图所示：

右边红框中的所有属性全部来自 RedisProperties 属性定义

五、总结

1、Spring Boot 启动后会加载大量的配置类，这些配置类都定义在 spring-boot-autoconfigure 模块的 META-INF/spring.factories 中

2、如果需要使用 spring-boot-autoconfigure 没有定义的自动配置的话，需要在 pom 中单独引用其依赖模块，比如引入 mybatis-spring-boot-starter 依赖使用 mybatis

3、xxxxAutoConfigurartion 自动配置类的作用就是给容器中添加组件

4、xxxxProperties 的作用就是封装配置文件中相关属性，即配置文件中可以配置的属性

5、给容器中自动配置类添加组件的时候，会从 Properties 类中获取某些属性，我们可以在配置文件中指定这些属性的值