本专栏将从基础开始，循序渐进，以实战为线索，逐步深入SpringBoot相关知识相关知识，打造完整的云原生学习步骤，提升工程化编码能力和思维能力，写出高质量代码。希望大家都能够从中有所收获，也请大家多多支持。
专栏地址:SpringBoot专栏
本文涉及的代码都已放在gitee上：gitee地址
如果文章知识点有错误的地方，请指正！大家一起学习，一起进步。
Spring Boot最大的功劳就在于自动配置，它的自动配置功能能根据类加载路径下的JAR依赖自动配置基础设施。例如，当Spring Boot检测到类加载路径下包含了MySQL依赖，且容器中没有配置其他任何DataSource时，Spring Boot就会自动启动HSQLDB数据库。
Spring Boot 的自动配置大多会根据特定依赖库自动触发，启用自动配置需要使用@EnableAutoConfiguration注解。注意，整个应用只需要添加一个该注解，因此，通常只要将该注解添加到主配置类（SpringApplication所运行的配置类）即可。
@SpringBootApplication注解是@Configuration、@EnableAutoConfiguration和@ComponentScan 这三个注解的组合体，因此，在实际项目中只要用@SpringBootApplication 注解修饰主配置类，也就自然为主配置类增加了@EnableAutoConfiguration注解，从而开启了自动配置。
1 自动配置的替换原则
Spring Boot自动配置通常有一个原则：只有当容器中不存在特定类型的Bean或特定Bean时，Spring Boot自动配置才会配置该类型的Bean或特定Bean。
例如，在项目的类加载路径下添加spring-boot-starter-jdbc依赖，Spring Boot将会尝试在容器中自动配置一个DataSource Bean；但如果显式在Spring容器中配置了一个DataSource Bean，那么Spring Boot就不再尝试去自动配置DataSource。
看上去似乎很智能，对不对？其实原理很简单，Spring Boot提供了一个@ConditionalOnMissingBean注解，该注解通常与@Bean注解同时使用，这意味着只有当某个Bean不存在时，才会创建@Bean注解配置的Bean。
比如如下配置片段：
上面配置指定只有当容器中不存在类型为DataSource的Bean时，@Bean注解所配置的Bean才会生效。
再比如如下配置片段：
上面配置指定只要容器中不存在ID为dataSource的Bean，@Bean注解所配置的Bean就会生效。
由于Spring Boot的自动配置具有一定的透明性（有时候无法准确地知道Spring Boot自动配置了哪些Bean），因此Spring Boot为应用程序提供了“–debug”开关。
如果通过“–debug”开关启动Spring Boot应用，则将为核心组件开启DEBUG级别的日志，并将自动配置的相关日志输出到控制台。
2 禁用特定的自动配置
在某些情况下，如果希望应用禁用特定的自动配置类，则可通过@EnableAutoConfiguration注解的如下属性来指定。
➢ exclude：该属性的值可以是一个Class数组，用于禁用一个或多个自动配置类。
➢ excludeName：与前一个属性的作用基本相同，只不过它指定一个或者多个自动配置类的完整类名的字符串形式。
而在实际项目中通常使用@SpringBootApplication注解，该注解已包含了@EnableAutoConfiguration注解，@SpringBootApplication注解的exclude和excludeName属性就是@EnableAutoConfiguration注解的这两个属性的别名。
例如，如下主类上的@SpringBootApplication注解可禁用DataSourceAutoConfiguration自动配置类。
上面代码使用 exclude 属性指定了要禁用的自动配置类。
此外，Spring Boot也允许在application.properties文件中通过spring.autoconfigure.exclude属性来指定要禁用的自动配置类。例如如下配置：
上面的配置片段表示禁用了DataSourceAutoConfiguration、RedisAutoConfiguration两个自动配置类。
3 创建自己的自动配置
Spring Boot的核心功能就是自动配置，只有真正掌握Spring Boot自动配置的原理，才算熟练掌握了 Spring Boot，如果仅仅会基于自动配置来开发应用，那么其实只能算“依葫芦画瓢”搞了几个“Hello World”例子。
在进行实际项目开发时，仅依靠Spring Boot的自动配置是远远不够的。举例来说，比如Spring Boot应用要访问多个数据源，自动配置就完全无能为力了。
自动配置确实非常方便，但它只能提供最通用的基础组件，而实际应用往往需要进行不同程度的扩展，完全依赖自动配置是绝对不够的。因此，开发者不仅需要熟练地使用自动配置，而且更需要掌握自动配置底层的原理，这样才能从容面对实际项目的各种扩展需求：当自动配置实现不了时，替换自动配置，改为项目自己的定制配置。
3.1 自动配置的本质
自动配置其实很简单，其本质就是在容器中预配置要整合的框架所需的基础Bean。
以整合常见的MyBatis为例，直接用Spring整合MyBatis无非就是完成如下事情：
➢ 配置SqlSessionFactory Bean，当然，该Bean需要注入一个DataSource。
➢ 配置SqlSessionTemplate Bean，将上面配置的SqlSessionFactory注入该Bean即可。
➢ 注册Mapper组件的自动扫描，就是相当于添加﹤mybatis：scan…/﹥元素。
所谓的自动配置，无非就是由框架提供一个@Configuration修饰的配置类（相当于传统的 XML 配置文件），在该配置类中用@Bean 预先配置默认的 SqlSessionFactory`SqlSessionTemplate，并注册Mapper组件的自动扫描即可。
打开MyBatis为整合Spring Boot提供的自动配置类：MybatisAutoConfiguration的源文件，可以看到如下源代码：
package org.mybatis.spring.boot.autoconfigure;
import java.beans.FeatureDescriptor;
...
@Configuration
//当SqlSessionFactory、SqlSessionFactoryBean类存在时配置生效
@ConditionalOnClass({
SqlSessionFactory.class, SqlSessionFactoryBean.class})
//当单例的DataSource Bean存在时配置生效
@ConditionalOnSingleCandidate(DataSource.class)
//启动MybatisProperties属性处理类
@EnableConfigurationProperties({
MybatisProperties.class})
@AutoConfigureAfter({
DataSourceAutoConfiguration.class, MybatisLanguageDriverAutoConfiguration.class})
//InitializingBean接口中的afterPropertiesSet()生命周期方法将会在该Bean初始化完成后被自动调用
public class MybatisAutoConfiguration implements InitializingBean {
private static final Logger logger = LoggerFactory.getLogger(MybatisAutoConfiguration.class);
//MybatisProperties类负责加载配置属性
private final MybatisProperties properties;
//下面的成员变量用于保存MyBatis的拦截器、类型处理器等
private final Interceptor[] interceptors;
private final TypeHandler[] typeHandlers;
private final LanguageDriver[] languageDrivers;
private final ResourceLoader resourceLoader;
private final DatabaseIdProvider databaseIdProvider;
private final List<ConfigurationCustomizer> configurationCustomizers;
public MybatisAutoConfiguration(MybatisProperties properties, ObjectProvider<Interceptor[]> interceptorsProvider, ObjectProvider<TypeHandler[]> typeHandlersProvider, ObjectProvider<LanguageDriver[]> languageDriversProvider, ResourceLoader resourceLoader, ObjectProvider<DatabaseIdProvider> databaseIdProvider, ObjectProvider<List<ConfigurationCustomizer>> configurationCustomizersProvider) {
this.properties = properties;
this.interceptors = (Interceptor[])interceptorsProvider.getIfAvailable();
this.typeHandlers = (TypeHandler[])typeHandlersProvider.getIfAvailable();
this.languageDrivers = (LanguageDriver[])languageDriversProvider.getIfAvailable();
this.resourceLoader = resourceLoader;
this.databaseIdProvider = (DatabaseIdProvider)databaseIdProvider.getIfAvailable();
this.configurationCustomizers = (List)configurationCustomizersProvider.getIfAvailable();
}
//重写InitializingBean接口中的afterPropertiesSet()方法
public void afterPropertiesSet() {
this.checkConfigFileExists();
}
// 检查配置文件是否存在
private void checkConfigFileExists() {
if (this.properties.isCheckConfigLocation() && StringUtils.hasText(this.properties.getConfigLocation())) {
//根据MybatisProperties读取configLocation加载MyBatis配置文件
Resource resource = this.resourceLoader.getResource(this.properties.getConfigLocation());
//如果resource.exists()为false，则文件加载失败，抛出异常
Assert.state(resource.exists(), "Cannot find config location: " + resource + " (please add config file or check your Mybatis configuration)");
}
}
//配置SqlSessionFactory Bean
@Bean
//当SqlSessionFactory Bean不存在时配置生效
@ConditionalOnMissingBean
public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
//创建SqlSessionFactoryBean工厂Bean
SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
//注入DataSource Bean
factory.setDataSource(dataSource);
factory.setVfs(SpringBootVFS.class);
//如果存在MyBatis配置文件，则应用该配置文件
if (StringUtils.hasText(this.properties.getConfigLocation())) {
factory.setConfigLocation(this.resourceLoader.getResource(this.properties.getConfigLocation()));
}
this.applyConfiguration(factory);
//应用MyBatisProperties读取到的配置属性
if (this.properties.getConfigurationProperties() != null) {
factory.setConfigurationProperties(this.properties.getConfigurationProperties());
}
//应用所有的拦截器
if (!ObjectUtils.isEmpty(this.interceptors)) {
factory.setPlugins(this.interceptors);
}
//应用所有的DatabaseIdProvider
if (this.databaseIdProvider != null) {
factory.setDatabaseIdProvider(this.databaseIdProvider);
}
//根据包名应用TypeAlias
if (StringUtils.hasLength(this.properties.getTypeAliasesPackage())) {
factory.setTypeAliasesPackage(this.properties.getTypeAliasesPackage());
}
//根据父类型应用TypeAlias
if (this.properties.getTypeAliasesSuperType() != null) {
factory.setTypeAliasesSuperType(this.properties.getTypeAliasesSuperType());
}
//根据包名应用TypeHandler
if (StringUtils.hasLength(this.properties.getTypeHandlersPackage())) {
factory.setTypeHandlersPackage(this.properties.getTypeHandlersPackage());
}
//应用所有TypeHandler
if (!ObjectUtils.isEmpty(this.typeHandlers)) {
factory.setTypeHandlers(this.typeHandlers);
}
//设置Mapper的加载位置
if (!ObjectUtils.isEmpty(this.properties.resolveMapperLocations())) {
factory.setMapperLocations(this.properties.resolveMapperLocations());
}
Set<String> factoryPropertyNames = (Set)Stream.of((new BeanWrapperImpl(SqlSessionFactoryBean.class)).getPropertyDescriptors()).map(FeatureDescriptor::getName).collect(Collectors.toSet());
Class<? extends LanguageDriver> defaultLanguageDriver = this.properties.getDefaultScriptingLanguageDriver();
if (factoryPropertyNames.contains("scriptingLanguageDrivers") && !ObjectUtils.isEmpty(this.languageDrivers)) {
factory.setScriptingLanguageDrivers(this.languageDrivers);
if (defaultLanguageDriver == null && this.languageDrivers.length == 1) {
defaultLanguageDriver = this.languageDrivers[0].getClass();
}
}
if (factoryPropertyNames.contains("defaultScriptingLanguageDriver")) {
factory.setDefaultScriptingLanguageDriver(defaultLanguageDriver);
}
//返回SqlSessionFactory Bean
return factory.getObject();
}
private void applyConfiguration(SqlSessionFactoryBean factory) {
org.apache.ibatis.session.Configuration configuration = this.properties.getConfiguration();
if (configuration == null && !StringUtils.hasText(this.properties.getConfigLocation())) {
configuration = new org.apache.ibatis.session.Configuration();
}
if (configuration != null && !CollectionUtils.isEmpty(this.configurationCustomizers)) {
Iterator var3 = this.configurationCustomizers.iterator();
while(var3.hasNext()) {
ConfigurationCustomizer customizer = (ConfigurationCustomizer)var3.next();
customizer.customize(configuration);
}
}
factory.setConfiguration(configuration);
}
//配置SqlSessionTemplate Bean
@Bean
//但SqlSessionTemplate Bean不存在时配置生效
@ConditionalOnMissingBean
public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
ExecutorType executorType = this.properties.getExecutorType();
//如果executorType属性存在，则使用该属性创建SqlSessionTemplate
return executorType != null ? new SqlSessionTemplate(sqlSessionFactory, executorType) : new SqlSessionTemplate(sqlSessionFactory);
}
@Configuration
//导入AutoConfiguredMapperScannerRegistrar注册类
@Import({
MybatisAutoConfiguration.AutoConfiguredMapperScannerRegistrar.class})
//当MapperFactoryBean、MapperScannerConfigurer Bean不存在时配置生效
@ConditionalOnMissingBean({
MapperFactoryBean.class, MapperScannerConfigurer.class})
public static class MapperScannerRegistrarNotFoundConfiguration
//实现InitializingBean接口，该接口中的afterPropertiesSet()生命周期方法将会在该Bean初始化完成后被自动调用
implements InitializingBean {
public MapperScannerRegistrarNotFoundConfiguration() {
}
//重写InitializingBean接口中的afterPropertiesSet()方法
public void afterPropertiesSet() {
MybatisAutoConfiguration.logger.debug("Not found configuration for registering mapper bean using @MapperScan, MapperFactoryBean and MapperScannerConfigurer.");
}
}
//定义自动扫描Mapper组件的注册器类
public static class AutoConfiguredMapperScannerRegistrar
//实现BeanFactoryAware接口可访问Spring容器
//实现ImportBeanDeficitionReggistrar接口可配置额外的Bean
implements BeanFactoryAware, ImportBeanDefinitionRegistrar {
//用于保存获取到的Spring容器
private BeanFactory beanFactory;
public AutoConfiguredMapperScannerRegistrar() {
}
//重写ImportBeanDefinitionRegistrar接口中的方法
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
if (!AutoConfigurationPackages.has(this.beanFactory)) {
MybatisAutoConfiguration.logger.debug("Could not determine auto-configuration package, automatic mapper scanning disabled.");
} else {
MybatisAutoConfiguration.logger.debug("Searching for mappers annotated with @Mapper");
//获取自动配置要处理的包
List<String> packages = AutoConfigurationPackages.get(this.beanFactory);
if (MybatisAutoConfiguration.logger.isDebugEnabled()) {
packages.forEach((pkg) -> {
MybatisAutoConfiguration.logger.debug("Using auto-configuration base package '{}'", pkg);
});
}
//创建BeanDefinitionBuilder对象
//它帮助开发者以反射方式创建任意类的实例
//此处就是帮助创建MapperScannerConfigurer实例
BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);
//为要创建的对象设置属性
builder.addPropertyValue("processPropertyPlaceHolders", true);
builder.addPropertyValue("annotationClass", Mapper.class);
builder.addPropertyValue("basePackage", StringUtils.collectionToCommaDelimitedString(packages));
BeanWrapper beanWrapper = new BeanWrapperImpl(MapperScannerConfigurer.class);
Stream.of(beanWrapper.getPropertyDescriptors()).filter((x) -> {
return x.getName().equals("lazyInitialization");
}).findAny().ifPresent((x) -> {
builder.addPropertyValue("lazyInitialization", "${mybatis.lazy-initialization:false}");
});
//在容器中注册BeanDefinitionBuilder创建的对象
registry.registerBeanDefinition(MapperScannerConfigurer.class.getName(), builder.getBeanDefinition());
}
}
//重写该方法用于获取Spring容器
public void setBeanFactory(BeanFactory beanFactory) {
this.beanFactory = beanFactory;
}
}
}
上面的MybatisAutoConfiguration是一个典型的自动配置类，该类使用了如下注解修饰。
➢@Configuration：被修饰的类变成配置类。
➢@ConditionalOnClass：条件注解之一，接下来会详细介绍。
➢@ConditionalOnSingleCandidate：条件注解之一，接下来会详细介绍。
➢@EnableConfigurationProperties：用于启动属性处理类。
➢@AutoConfigureAfter：指定该自动配置类必须在Xxx自动配置类生效之后。此处指定该自动配置类必须在DataSourceAutoConfiguration、MybatisLanguageDriverAutoConfiguration两个类生效之后，其中DataSourceAutoConfiguration是Spring Boot本身提供的自动配置类，它负责在容器中配置一个DataSource Bean；而MybatisLanguageDriverAutoConfiguration则负责在容器中配置脚本语言驱动的Bean。
该自动配置类实现了InitializingBean生命周期接口，该接口中的afterPropertiesSet()生命周期方法将会在该 Bean 初始化完成后被自动调用，这也是Spring 框架的基本内容之一。该类实现了afterPropertiesSet()方法，该方法调用checkConfigFileExists()方法。
上面对MyBatis提供的自动配置类的源代码进行了非常详细的讲解。事实上，Spring Boot框架的所有自动配置类基本都是这个套路，这些配置类都会大量使用@Configuration、@Bean、@Import及@Conditional条件注解等注解，也会大量使用Spring框架及被整合框架的核心API。如果刚开始阅读这些源代码时存在一定的不适应，那是正常的；但如果静下心来认真看这些源代码还看不明白，那不是Spring Boot知识有缺陷，而是对Spring框架的API还不熟，建议先认真学习Spring框架本身。
当开发完自动配置类之后，还需要使用META-INF/spring.factories文件来定义自动配置类，应该在该文件中以“org.springframework.boot.autoconfigure.EnableAutoConfiguration”为key列出所有自动配置类。
还是以MyBatis整合Spring Boot的自动配置为例，打开其JAR包中的META-INF/spring.factories文件，可以看到如下代码：
上面列出了MybatisLanguageDriverAutoConfiguration类和MybatisAutoConfiguration类，它们就是MyBatis为整合Spring Boot所提供的自动配置类。前面详细讲解了MybatisAutoConfiguration类，而MybatisLanguageDriverAutoConfiguration自动配置类则用于在容器中配置各种脚本语言驱动的Bean，该自动配置类的源代码更简单，就是通过大量@Configuration和@Bean注解在容器中配置Bean。
自动配置类只能通过META-INF/spring.factories进行加载，并确保它们处于一个特殊的包空间内，尤其是不能让它们变成普通@ComponentScan 的目标。此外，自动配置类也不应该用@ComponentScan来扫描其他组件，如果确实需要加载其他配置文件，则应使用@Import显式指定要加载的配置类。
如果要为自动配置类指定它们的加载顺序，Spring Boot则提供了如下两个注解。
➢@AutoConfigureAfter：指定被修饰的类必须在一个或多个自动配置类加载之后加载。
➢@AutoConfigureBefore：指定被修饰的类必须在一个或多个自动配置类加载之前加载。
如果自动配置包中包含多个自动配置类，且要求以特定的顺序来加载这些自动配置类，则可用@AutoConfigureOrder注解来修饰它们。@AutoConfigureOrder注解完全类似于Spring框架原有的@Order注解，只不过它专门用于修饰自动配置类。
由此可见，创建自动配置的关键就是开发自动配置类，而开发自动配置类除了要熟练掌握Spring及被整合框架的API，还要熟练使用Spring Boot提供的条件注解。下面就来详细介绍Spring Boot的条件注解。
