SpringBoot入门到精通-SpringBoot自动配置原理(五)

SpringBoot源码解析

• SpringBoot入门到精通-Spring的注解编程(一)
• SpringBoot入门到精通-SpringBoot入门(二)
• SpringBoot入门到精通-Spring的基本使用(三)
• SpringBoot入门到精通-SpringBoot集成SSM(四)
• SpringBoot入门到精通-SpringBoot自动配置原理(五)
• SpringBoot入门到精通-SpringBoot自定义starter(六)

---

1.SpringBoot的自动配置

在之前的学习中，我们深刻的感受到SpringBoot的便捷之处，使用它来开发项目确实是快了很多，SpringBoot为何能做到如此？我们知道SpringBoot是基于Spring进行封装，屏蔽了Spring的配置细节让我们配置Spring显得尤为简单，这需要归功于SpringBoot的“自动配置”能力。

这里我先抛出一个问题：集成SpringMVC后为什么不需要配置DispatcherServlet？带着这个问题我们来一步一步分析SpringBoot自动配置原理。

1.1.@SpringBootApplication注解

使用SpringBoot就需要在启动类贴上：@SpringBootApplication注解，该注解是一个组合注解，结构如下

//配置注解，该注解上又贴了一个 @Configuration
@SpringBootConfiguration
//开启自动配置
@EnableAutoConfiguration
//Spring IOC自动扫描
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {...}

【重要】@SpringBootApplication 包含了三个注解

• @SpringBootConfiguration ：该注解的本质其实就是一个 @Configuration 配置注解，标记某个类成为配置类
• @EnableAutoConfiguration ：开启SpringBoot自动配置的注解，比如我们集成SpringMVC并没有配置DispatcherServlet前端控制器，但是这个东西一定是存在的，就是SpringBoot帮我们自动配置好了。
• @ComponentScan ：这个在讲Spring的Java Config就有介绍，它是Spring IOC的自动扫描的注解，默认扫描当前包及其子包中的打了 @Component;@Repository;@Service；@Controller 注解的类。也就是说我们的HelloController其实已经被启动类默认扫描到了。

1.2.@EnableAutoConfiguration自动配置

其中有@EnableAutoConfiguration注解就是开启SpringBoot自动配置的注解，它的结构如下

/**
  启用 Spring Application Context 的自动配置，尝试猜测和配置您可能需要的 bean。 
  自动配置类通常根据您的类路径和您定义的 bean 应用
 * Enable auto-configuration of the Spring Application Context, attempting to guess and
 * configure beans that you are likely to need. Auto-configuration classes are usually
 * applied based on your classpath and what beans you have defined. For example, 8
 
 **/
@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 {};
}

该注解使用了 @Import({AutoConfigurationImportSelector.class}) 导入了一个选择器 该类实现了ImportSelector，在JavaConfig部分有学习过，ImportSelector提供了selectImports方法所返回的类名会自动被注册到Spring容器中，AutoConfigurationImportSelector结构如下

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,
		ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
            
     @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());
	}
            
	protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
			AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {
			return EMPTY_ENTRY;
		}
		AnnotationAttributes attributes = getAttributes(annotationMetadata);
		List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
		...省略...
		return new AutoConfigurationEntry(configurations, exclusions);
	}
            
     /**
     	返回自动配置的类的名称
	 * Return the auto-configuration class names that should be considered. By default
	 * this method will load candidates using {@link SpringFactoriesLoader} with
	 * {@link #getSpringFactoriesLoaderFactoryClass()}.
	 * @param metadata the source metadata
	 * @param attributes the {@link #getAttributes(AnnotationMetadata) annotation
	 * attributes}
	 * @return a list of candidate configurations
	 */
     protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
		//使用SpringFactoriesLoader（SPI）加载配置类名
         List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
				getBeanClassLoader());
         //从下面日志可以看出来，是在  MET-INF/spring.factories 中加载配置类
		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#selectImports最终会调用getCandidateConfigurations方法，该方法的作用是加载需要自动配置的类的名字(权限定名)。也就是说getCandidateConfigurations方法负责加载配置类的类名返回给selectImports方法，而selectImports方法拿到类名再返回，那么这些配置就就会自动注册到Spring容器中了。

从上面代码可以看出，getCandidateConfigurations方法中使用了 SpringFactoriesLoader.loadFactoryNames(SPI)去加载 META-INF/spring.factories 中的配置类。

我们可以使用IDEA搜索一下这个文件 spring.factories

我们看到，在很多的jar包中都有这个文件，就拿 mybatis来说，为了整合SpringBoot在程序启动的时候就需要一些初始配置.那么在 mybatis-spring-boot-autoconfigure 这个包中就提供了 spring.factories 文件其中包含了mybatis的配置类，在SpringBoot启动时就会通过自动配置流程把这些配置类加载到Spring容器，配置类中的配置项也就生效了。

我们这里重点看 spring-boot-autoconfigure 这个包中的spring.factories文件，它是SpringBoot自己的自动配置包

在 External Libraries 中找到这个包，展开就可以看到 spring.factories文件，其中有一个 EnableAutoConfiguration的配置项，后面跟了很多很多的以AutoConfiguration 结尾的自动配置类。其中就有 org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration

@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
//配置类
@Configuration(proxyBeanMethods = false)
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnClass(DispatcherServlet.class)
@AutoConfigureAfter(ServletWebServerFactoryAutoConfiguration.class)
public class DispatcherServletAutoConfiguration {
    
    /*
     dispatcherServlet的默认的名字
	 * The bean name for a DispatcherServlet that will be mapped to the root URL "/"
	 */
	public static final String DEFAULT_DISPATCHER_SERVLET_BEAN_NAME = "dispatcherServlet";

	/*
	 * The bean name for a ServletRegistrationBean for the DispatcherServlet "/"
	 */
	public static final String DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME = "dispatcherServletRegistration";

	@Configuration(proxyBeanMethods = false)
	@Conditional(DefaultDispatcherServletCondition.class)
	@ConditionalOnClass(ServletRegistration.class)
	@EnableConfigurationProperties({ HttpProperties.class, WebMvcProperties.class })
	protected static class DispatcherServletConfiguration {

        //注册一个DispatcherServlet
		@Bean(name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
		public DispatcherServlet dispatcherServlet(HttpProperties httpProperties, WebMvcProperties webMvcProperties) {
			DispatcherServlet dispatcherServlet = new DispatcherServlet();
			dispatcherServlet.setDispatchOptionsRequest(webMvcProperties.isDispatchOptionsRequest());
			dispatcherServlet.setDispatchTraceRequest(webMvcProperties.isDispatchTraceRequest());
			dispatcherServlet.setThrowExceptionIfNoHandlerFound(webMvcProperties.isThrowExceptionIfNoHandlerFound());
			dispatcherServlet.setPublishEvents(webMvcProperties.isPublishRequestHandledEvents());
			dispatcherServlet.setEnableLoggingRequestDetails(httpProperties.isLogRequestDetails());
			return dispatcherServlet;
		}

    ...省略...
}

该类标记了@Configuration注解可以被识别为一个配置类，在配置类中通过@Bean+方法的方式注册了一个DispatcherServlet的Bean。最开始提的那个问题似乎可以解答了。

1.3.自动配置总结

1. @SpringBootApplication 注解中包含了@EnableAutoConfiguration 注解，它的作用是开启SpringBoot自动配置.

2. 该注解上标记了一个@Import({AutoConfigurationImportSelector.class}) 导入选择器，在该导入选择器的selectImports中通过 SpringFactoriesLoader(SPI)去扫描classpath中的jar包中的 META-INF/spring.factories 文件.

3. 该文件中有大量的自动配置类的权限定名(标记了@Configuration注解)。 然后会被这些自动配置类注册到Spirng容器中(ImportSelector拥有这样的能力)，达到Spring启动就动态加载配置的目的。

比如：在spring.factories 有一个 DispatcherServletAutoConfiguration ，它就是一个标记了@Configuration 的配置类，它通过@Bean+方法 的方式定义了 DispatcherServlet的Bean。

2.DataSource的自动配置

2.1.DataSource的配置

对于DataSource而言，我们在导入了相关依赖之后，就只需要值yml中配置如下信息

spring:
  datasource:
    username: root
    password: admin
    url: jdbc:mysql:///test?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
    driver-class-name: com.mysql.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource #指定使用druid的连接池

2.2.DataSource自动配置

然后SpringBoot就可以自动为我们创建DataSource的Bean,那么SpringBoot是如何做到的呢？在 spring-boot-autoconfigure这个jar的 MATE-INF/spring.factories 文件中有一个配置类 DataSourceAutoConfiguration ，它的作用就是自动配置DataSource，结构如下

//是一个配置类
@Configuration(proxyBeanMethods = false)
//满足条件，存在DataSource.class,配置生效
@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
//开启Properties ,DataSourceProperties
@EnableConfigurationProperties(DataSourceProperties.class)
@Import({ DataSourcePoolMetadataProvidersConfiguration.class, DataSourceInitializationConfiguration.class })
public class DataSourceAutoConfiguration {

	...省略...

	@Configuration(proxyBeanMethods = false)
	@Conditional(PooledDataSourceCondition.class)
	@ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
     //连接池配置，默认使用 Hikari 。当我们配置了 Type,会使用 DataSourceConfiguration.Generic
	@Import({ DataSourceConfiguration.Hikari.class, DataSourceConfiguration.Tomcat.class,
			DataSourceConfiguration.Dbcp2.class, DataSourceConfiguration.Generic.class,
			DataSourceJmxConfiguration.class })
	protected static class PooledDataSourceConfiguration {

	}

该类也标记了 @Configuration 注解，可被识别为Spring的配置类，类上通过 @EnableConfigurationProperties(DataSourceProperties.class) 引入了DataSourceProperties。 DataSourceProperties是用来绑定yml中DataSource配置的，源码如下

@ConfigurationProperties(prefix = "spring.datasource")
public class DataSourceProperties implements BeanClassLoaderAware, InitializingBean {

	private ClassLoader classLoader;
	private Class<? extends DataSource> type;
	private String driverClassName;
	private String url;
	private String username;
	private String password;

@ConfigurationProperties(prefix = “spring.datasource”)这种用法我们在Spring注解编程的时候已经有学习过，就是把yml中以spring.datasource为前缀的配置绑定到当前对象中。DataSourceAutoConfiguration通过DataSourceProperties得到yml中的配置内容。

我们来看一下 DataSourceConfiguration.Hikari.class ，它是SpringBoot默认的连接池，源码如下org.springframework.boot.autoconfigure.jdbc.DataSourceConfiguration.Hikari

abstract class DataSourceConfiguration {

    //创建DataSource
	@SuppressWarnings("unchecked")
	protected static <T> T createDataSource(DataSourceProperties properties, Class<? extends DataSource> type) {
		return (T) properties.initializeDataSourceBuilder().type(type).build();
	}	
    
	@Configuration(proxyBeanMethods = false)
	@ConditionalOnClass(HikariDataSource.class)
	@ConditionalOnMissingBean(DataSource.class)
	@ConditionalOnProperty(name = "spring.datasource.type", havingValue = "com.zaxxer.hikari.HikariDataSource",
			matchIfMissing = true)
	static class Hikari {

        //读取以
		@Bean
		@ConfigurationProperties(prefix = "spring.datasource.hikari")
        //绑定以spring.datasource.hikari开头的配置
		HikariDataSource dataSource(DataSourceProperties properties) {
            //创建DataSource
			HikariDataSource dataSource = createDataSource(properties, HikariDataSource.class);
			if (StringUtils.hasText(properties.getName())) {
				dataSource.setPoolName(properties.getName());
			}
			return dataSource;
		}

	}

如果我们yml中没有配置spring.datasource.type属性，就会使用 HikariDataSource作为DataSource。也是通过DataSourceProperties来绑定配置到DataSource对象中。

当我们在yml中配置了spring.datasource.type属性，就会走DataSourceConfiguration.Generic

	/**
	 * Generic DataSource configuration.
	 */
	@Configuration(proxyBeanMethods = false)
    //当不存在DataSource，就创建DataSource
	@ConditionalOnMissingBean(DataSource.class)
    //当有spring.datasource.type就创建DataSource
	@ConditionalOnProperty(name = "spring.datasource.type")
	static class Generic {

        //向Spring容器注册DataSource
		@Bean
		DataSource dataSource(DataSourceProperties properties) {
            //使用properties创建DataSource
			return properties.initializeDataSourceBuilder().build();
		}

	}

Generic是个内部类，上面有两个条件，需要满足这两个条件，配置类才会起作用

• @ConditionalOnMissingBean(DataSource.class) ： 当不存在DataSource，就创建DataSource

• @ConditionalOnProperty(name = “spring.datasource.type”) ： 当有spring.datasource.type就创建DataSource

Generic中通过 DataSourceProperties 创建DataSource,其中会拿到spring.datasource.type指向的DataSource的名字，然后使用反射创建实例，然后把参数设置到DataSource中，如下

public T build() {
    //拿到 spring.datasource.type指向的class
    Class<? extends DataSource> type = getType();
    //创建DataSource实例
    DataSource result = BeanUtils.instantiateClass(type);
    maybeGetDriverClassName();
    //绑定四大属性
    bind(result);
    return (T) result;
}

自动配置就分析到这里，SpringBoot对其他组件都是以这样的方式和流程进行自动配置的。

文章结束啦，如果文章对你有所帮助，请一定给个好评哦，请一定给个好评哦，请一定给个好评哦