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

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对其他组件都是以这样的方式和流程进行自动配置的。

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