SpringBoot入门（四）——自动配置

SpringBoot 2.x入门书籍下载： https://t00y.com/dir/22083442-36337099-378043

SpringBoot之所以能够快速构建项目，得益于它的2个新特性，一个是起步依赖前面已经介绍过，另外一个则是自动配置。起步依赖用于降低项目依赖的复杂度，自动配置负责减少人工配置的工作量。

 

@EnableAutoConfiguration

 

前一篇留了一个注解没介绍，@EnableAutoConfiguration注解是开启自动配置的入口。其定义如下：

 

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {

    ...
}

 

看到@Import注解，参数是AutoConfigurationImportSelector类。

 

先来补充下@Import的知识，最早是为了方便引入java配置类，后来进行了扩展，目前有一下功能：

 

• 参数为@Configuration注解的bean，那么就引入这个配置类。相当于用xml配置时的
• 参数为ImportBeanDefinitionRegistrar接口或者ImportSelector接口的实现类，那么就通过接口方法来实现自定义注入
• 参数为普通类，直接将该类创建到Spring的IoC容器

 

这里的AutoConfigurationImportSelector类属于第二种情况，实现了ImportSelector接口。ImportSelector接口只声明了一个方法，要求返回一个包含类全限定名的String数组，这些类将会被Spring添加到IoC容器。

 

看下AutoConfigurationImportSelector的方法实现：

 

@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
    if (!isEnabled(annotationMetadata)) {
        return NO_IMPORTS;
    }
    try {
        AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
            .loadMetadata(this.beanClassLoader);
        AnnotationAttributes attributes = getAttributes(annotationMetadata);
        // 获取候选配置的类路径
        List<String> configurations = getCandidateConfigurations(annotationMetadata,
                                                                 attributes);
        configurations = removeDuplicates(configurations);
        configurations = sort(configurations, autoConfigurationMetadata);
        Set<String> exclusions = getExclusions(annotationMetadata, attributes);
        checkExcludedClasses(configurations, exclusions);
        configurations.removeAll(exclusions);
        configurations = filter(configurations, autoConfigurationMetadata);
        fireAutoConfigurationImportEvents(configurations, exclusions);
        return StringUtils.toStringArray(configurations);
    }
    catch (IOException ex) {
        throw new IllegalStateException(ex);
    }
}

 

通过某种方法获取配置类的路径，然后去重排序一系列处理之后返回出去交给Spring去处理。

接下来看下某种方法是个什么操作：

 

    protected List<String> getCandidateConfigurations(AnnotationMetadata metadata,
            AnnotationAttributes attributes) {
        // 从SpringFactoriesLoader取候选配置的类路径
        // 第一个参数getSpringFactoriesLoaderFactoryClass()得到的是EnableAutoConfiguration.class
        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;
    }

 

调用了SpringFactoriesLoader.loadFactoryNames()：

 

public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
        // "org.springframework.boot.autoconfigure.EnableAutoConfiguration"
        String factoryClassName = factoryClass.getName();
        // 先调了下面的loadSpringFactories方法，得到一个Map
        // 从Map中用EnableAutoConfiguration类的全限定名取一个String列表(其实也是一些类的全限定名列表)
        return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
    }

    // 上面方法先从这里取了个Map
    private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
        // 这里有个缓存，记一下，后面会提到
        MultiValueMap<String, String> result = cache.get(classLoader);
        if (result != null)
            return result;
        try {
            // FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories"
            // 加载所有META-INF包下的spring.factories文件
            Enumeration<URL> urls = (classLoader != null ?
                    classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
                    ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
            result = new LinkedMultiValueMap<>();
            while (urls.hasMoreElements()) {
                URL url = urls.nextElement();
                UrlResource resource = new UrlResource(url);
                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                for (Map.Entry<?, ?> entry : properties.entrySet()) {
                    // 逗号分隔的String转为List
                    List<String> factoryClassNames = Arrays.asList(
                            StringUtils.commaDelimitedListToStringArray((String) entry.getValue()));
                    result.addAll((String) entry.getKey(), factoryClassNames);
                }
            }
            cache.put(classLoader, result);
            return result;
        }
        catch (IOException ex) {
            throw new IllegalArgumentException("Unable to load factories from location [" +
                    FACTORIES_RESOURCE_LOCATION + "]", ex);
        }
    }

 

整个流程其实就是读取项目中的META-INF/spring.factories文件，然后挑一挑交给Spring去加到上下文中。

那么META-INF/spring.factories到底是个什么gui呢。以之前创建的Hello World Web为例，工程中一共有2个META-INF/spring.factories文件，一个在spring-boot包中，一个在spring-boot-autoconfigure包中。

 

看下spring-boot-autoconfigure包中的内容（片段）：

 

# Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener

# Application Listeners
org.springframework.context.ApplicationListener=\
org.springframework.boot.autoconfigure.BackgroundPreinitializer

# Auto Configuration Import Listeners
org.springframework.boot.autoconfigure.AutoConfigurationImportListener=\
org.springframework.boot.autoconfigure.condition.ConditionEvaluationReportAutoConfigurationImportListener

# Auto Configuration Import Filters
org.springframework.boot.autoconfigure.AutoConfigurationImportFilter=\
org.springframework.boot.autoconfigure.condition.OnClassCondition

# 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,\
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
org.springframework.boot.autoconfigure.cloud.CloudAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\

...

 

看到一堆的xxxConfiguration，没错，这些都注解了@Configuration。spring-boot-autoconfigure为我们引入了一大堆的java配置类作为组件的默认配置。

 

包括常见组件的默认配置，有rabbit相关的，有redis相关的，有Security相关的等等。

 

那么问题来了，难道所有的配置类都会被加载吗，答案是显而易见的。那么来看看是如何实现的，以Redis的配置类RedisAutoConfiguration为例，看下类源码：

@Configuration
// 当存在RedisOperations时，才会加载该配置类
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {

    @Bean
    // 当不存在名为"redisTemplate"的bean时，才会创建该bean
    @ConditionalOnMissingBean(name = "redisTemplate")
    public RedisTemplate<Object, Object> redisTemplate(
            RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    @Bean
    // 当Spring上下文中不存在StringRedisTemplate类实例的时候，才会创建该bean
    @ConditionalOnMissingBean(StringRedisTemplate.class)
    public StringRedisTemplate stringRedisTemplate(
            RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

 

这里利用了Spring条件注解的特性，通过设定一定的条件来实现不同场景下加载不同的配置。

 

自动配置类生效的条件通常是我们引入了相关的组件，如果没有引入组件，那么就算包含在spring.factories文件中也不会被加载。

 

而是否要注入Bean则要看当前上下文中是否已经存在相应的Bean。如果不存在，那么由默认配置来补充。如果已经存在了，自动配置会不满足注解条件，就不会被创建。

 

有了这两点，可以做到当我们不做任何配置的时候可以用默认配置来运用新组件，而当我们需要对配置进行调整的时候用自定义的配置来覆盖即可。

Tips

 

上面源码中标记了一个缓存。在读取META-INF/spring.factories文件后相关数据是会保存到SpringFactoriesLoader类的缓存中的。而这里第一次读取META-INF/spring.factories的时机并不是在自动配置这里，早在上一篇的SpringApplication构造方法中就已经缓存了：

 

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
    this.resourceLoader = resourceLoader;
    Assert.notNull(primarySources, "PrimarySources must not be null");
    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
    this.webApplicationType = deduceWebApplicationType();
    // 设置初始化器，这里就已经读取了META-INF/spring.factories
    setInitializers((Collection) getSpringFactoriesInstances(
        ApplicationContextInitializer.class));
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    this.mainApplicationClass = deduceMainApplicationClass();
}

 

小结

 

这一节通过@EnableAutoConfiguration注解分析了SpringBoot自动配置的实现。通过@Import注解添加自动配置选择器(AutoConfigurationImportSelector)，选择器中首先读取META-INF路径下的spring.factories文件。在spring.factories文件中，SpringBoot官方提供了许多常见组件的默认配置，以java配置类形式存在。在这些java配置类中又利用了Spring的条件注解，让我们可以在默认配置和自定义配置之间灵活切换。

 

可以这么认为：SpringBoot在Spring原有的基础上，通过拼凑组合又实现了一个强大的特性——自动配置。

 

自动配置让我们可以在不做任何配置的情况下直接使用一个新的类库（前提是足够普遍），也能满足我们自定义配置的需求。除此之外，我们还可以利用这个思路，实现具有团队特色的自动配置，让团队开发也更加高效。