@EnableAutoConfiguration自动配置原理分析

@enableautoconfiguration 原理分析

@springbootapplication中包含了@enableautoconfiguration注解，@enableautoconfiguration的作用是启用spring的自动加载配置。

springboot一个最核心的观点就是，约定大于配置，这种看似降低了灵活度的方法，却大大简化了springboot的开发过程。这种约定在实现角度看就是springboot提供了大量的默认配置参数，那么问题来了，springboot在哪里存放这些默认的配置参数，并如何自动配置这些默认的参数呢？

实际上，springboot的很多starter都有@enable开头的注解，实现原理也很是类似，这里先来看这个注解的实现原理。

@target(elementtype.type)
@retention(retentionpolicy.runtime)
@documented
@inherited
@autoconfigurationpackage
@import(autoconfigurationimportselector.class)
public @interface enableautoconfiguration {

这里我们可以看到@enableautoconfiguration使用@import添加了一个autoconfigurationimportselector类，spring自动注入配置的核心功能就依赖于这个对象。

在这个类中，提供了一个getcandidateconfigurations()方法用来加载配置文件。借助spring提供的工具类springfactories的loadfactorynames()方法加载配置文件。扫描的默认路径位于meta-inf/spring.factories中。

# 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.onbeancondition,\
org.springframework.boot.autoconfigure.condition.onclasscondition,\
org.springframework.boot.autoconfigure.condition.onwebapplicationcondition

# 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,\
...

上边只是一部分的配置信息。等号左边的是对应配置的接口，而右边是配置类。我们来看具体是如何加载这些类的。

private static map<string, list<string>> loadspringfactories(@nullable classloader classloader) {
    multivaluemap<string, string> result = cache.get(classloader);
    if (result != null) {
        return result;
    }

    try {
        // 从meta-inf/spring.factories中加载urls。
        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 factoryclassname = ((string) entry.getkey()).trim();
                for (string factoryname : stringutils.commadelimitedlisttostringarray((string) entry.getvalue())) {
                    result.add(factoryclassname, factoryname.trim());
                }
            }
        }
        // 添加到缓存中防止重新加载
        cache.put(classloader, result);
        return result;
    }
    catch (ioexception ex) {
        throw new illegalargumentexception("unable to load factories from location [" +
                                           factories_resource_location + "]", ex);
    }
}

最后返回的result实际上就是meta-inf/spring.factories对应的map数据结构。在这个map中实际上保存了整个spring中的各个配置类的全类名，包括一些listener、filter等等。加载一个类的第一步，就是要获取到对应类的全类名，而之后具体的加载过程实际上是由springapplication具体完成的，这里不做先仔细介绍，我们回到我们的重点上，如何自动加载配置。在刚刚的spring.factories中，我们来看下边的内容：

# 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,\
...

在这里我们可以看到非常多熟悉的名称，aop，rabbit等等非常多，看来自动加载的配置远远不止我们使用到的简单配置，springboot会加载全部可能用到的配置类。这里我们先来打开一个熟悉的rabbitautoconfiguration看一看。

@configuration
@conditionalonclass({ rabbittemplate.class, channel.class })
@enableconfigurationproperties(rabbitproperties.class)
@import(rabbitannotationdrivenconfiguration.class)
public class rabbitautoconfiguration {

这个类上边添加了很多注解，我们一个个来看。

1. @configuration: 这个注解我们非常熟悉，标明这就是一个配置类；
2. @conditionalonclass()：这个注解是可以输入几个class，相当于给这个配置类添加了一个开关，当检测存在输入的类时候，该配置类生效，否则将不被实例化。也就是说，如果你的项目存在对应的依赖，将自动开启配置类，这个是非常实用的一个注解。
3. @enableconfigurationproperties(): 启用一个@configurationproperties注解
4. @import(rabbitannotationdrivenconfiguration.class): 导入了一个基于注解的配置类

在上边的注解中你可能很疑惑@configurationproperties的作用，这里我们看看与之对应的rabbitproperties的具体实现。

@configurationproperties(prefix = "spring.rabbitmq")
public class rabbitproperties {

    /**
     * rabbitmq host.
     */
    private string host = "localhost";

    /**
     * rabbitmq port.
     */
    private int port = 5672;

    /**
     * login user to authenticate to the broker.
     */
    private string username = "guest";
    ...

整体上看，rabbitproperies整体上大概就是一个pojo的类，其中包含了rabbitmq的各项参数，其中有一些已经设置了初始值，但是直接在类中配置初始值的方式很难让我们自定义修改这些配置参数，所以在这个类上使用了@configurationproperties()注解。

@configurationproperties(perfix = "spring.rabbitmq")作用是从spring的配置中加载指定前缀的配置，并自动设置到对应的成员变量上。也正是通过这种方式，真正实现了配置的自动注入。

小结

到这里，我们实际上已经从@enableautoconfiguration这个注解入手，分析了整个自动配置的流程。简单再复述下上边的流程：

@enableautoconfiguration->autoconfigurationimportselector->spring.factories->enableautoconfiguration->rabbitautoconfiguration(具体的配置类)->@enableconfigurationproperties->rabbitproperties(具体的配置类)->@configurationproperties(prefix = "spring.rabbitmq")

通过上边的层层加载，我们很容易就可以实现配置的自动注入。这个过程也并不复杂，下一篇将尝试按照上面的流程，自己实现一个starter类。