spring boot @SpringBootApplication @EnableAutoConfiguration 的工作原理

在spring boot中@SpringBootApplication、@EnableAutoConfiguration是最常见Annotation，且最为重要，所以本文将展开对此的解读。@SpringBootApplication在spring框架中的处理尤为复杂，然后能将它的来龙去脉（加载机制）讲清楚的文章非常少。说实话你要完全理解及解读它，需要对spring 3.x的源码有一定程度了解，主要是它在原有的基础上拓展了一些新概念，如若不按本文的思路，稍有不慎就会陷入代码的海洋里不能自拔。

目录

1. SpringApplication

1.1 SpringFactoriesLoader

1.2 ApplicationListener

1.3 ApplicationContextInitializer

1.4 SpringApplication.run

1.5 SpringApplicationRunListeners和SpringApplicationRunListener

2. AbstractApplicationContext.refresh

2.1 BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor和BeanPostProcessor

2.2 ConfigurationClassPostProcessor

2.4 AnnotationConfigServletWebServerApplicationContext

2.5 ConfigurationClassParser

3. EnableAutoConfiguration

3.1 ImportSelector

---

@SpringBootApplication(scanBasePackages = {"com.example"})
public class WebApp {
    public static void main(String[] args) {
        SpringApplication.run(WebApp.class, args);
    }
}

首问：@SpringBootApplication是如何被解析并加载到spring ioc中的？

1. SpringApplication

在之前的文章“容器启动原理揭秘”中提到过，最终通过 JarLauncher.launch 运行的目标是 WebApp.main 方法，之后就没有再深入的讲。首先进入视野的拦路虎就是SpringApplication，可以理解为它相当于spring的外观模式，集各功能于一身，它也给用户提供了链式语法支持-Builder模式（SpringApplicationBuilder().sources(Parent.class).child(Application.class)..run(args)）。

public class SpringApplication {
    //入口
    public static ConfigurableApplicationContext run(Class primarySource, String... args) {
        return run(new Class[]{primarySource}, args);
    }
    public static ConfigurableApplicationContext run(Class[] primarySources, String[] args) {
        return (new SpringApplication(primarySources)).run(args);
    }
    public SpringApplication(Class... primarySources) {
        this((ResourceLoader)null, primarySources);
    }
    public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
        this.sources = new LinkedHashSet();
        this.bannerMode = Mode.CONSOLE;
        this.logStartupInfo = true;
        this.addCommandLineProperties = true;
        this.headless = true;
        this.registerShutdownHook = true;
        this.additionalProfiles = new HashSet();
        this.isCustomEnvironment = false;
        this.resourceLoader = resourceLoader;
        Assert.notNull(primarySources, "PrimarySources must not be null");
        this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
        // 判断web类型为reactive、none、servlet（只要可以加载Servlet或ConfigurableWebApplicationContext），当前为servlet
        this.webApplicationType = this.deduceWebApplicationType();
        //从SpringFactoriesLoader中加载ApplicationContextInitializer类，并实例化
        this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
        //从SpringFactoriesLoader中加载ApplicationListener类，并实例化
        this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
        //这个是很重要的属性：WebApp 
        this.mainApplicationClass = this.deduceMainApplicationClass();
    }
}

你可能会问：SpringFactoriesLoader是什么鬼？ApplicationContextInitializer和ApplicationListener又是什么东西?

1.1 SpringFactoriesLoader

SpringFactoriesLoader 在spring boot中非常重要，它是spring对SPI的实现版本，主要是从jar中META-INF/spring.factories读取拓展配置信息。在spring boot框架中有两个核心的 jar，它内置的 spring.factories 非常重要（使用者一般很少关注），而一般功能进行拓展也基于此：

spring-boot-2.0.5.RELEASE.jar/META-INF/spring.factories

# PropertySource Loaders
org.springframework.boot.env.PropertySourceLoader=\
org.springframework.boot.env.PropertiesPropertySourceLoader,\
org.springframework.boot.env.YamlPropertySourceLoader

# Run Listeners
org.springframework.boot.SpringApplicationRunListener=\
org.springframework.boot.context.event.EventPublishingRunListener

# Error Reporters
org.springframework.boot.SpringBootExceptionReporter=\
org.springframework.boot.diagnostics.FailureAnalyzers

# Application Context Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer,\
org.springframework.boot.context.ContextIdApplicationContextInitializer,\
org.springframework.boot.context.config.DelegatingApplicationContextInitializer,\
org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer

# Application Listeners
org.springframework.context.ApplicationListener=\
org.springframework.boot.ClearCachesApplicationListener,\
org.springframework.boot.builder.ParentContextCloserApplicationListener,\
org.springframework.boot.context.FileEncodingApplicationListener,\
org.springframework.boot.context.config.AnsiOutputApplicationListener,\

spring-boot-autoconfigure-2.0.5.RELEASE.jar/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.OnClassCondition

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\

SpringFactoriesLoader 源码其实也不复杂，这里不再赘述。

public abstract class SpringFactoriesLoader {
    public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
    private static final Map> cache = new ConcurrentReferenceHashMap();
    public static  List loadFactories(Class factoryClass, @Nullable ClassLoader classLoader) {
        Assert.notNull(factoryClass, "'factoryClass' must not be null");
        ClassLoader classLoaderToUse = classLoader;
        if (classLoader == null) {
            classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
        }

        List factoryNames = loadFactoryNames(factoryClass, classLoaderToUse);
        if (logger.isTraceEnabled()) {
            logger.trace("Loaded [" + factoryClass.getName() + "] names: " + factoryNames);
        }

        List result = new ArrayList(factoryNames.size());
        Iterator var5 = factoryNames.iterator();

        while(var5.hasNext()) {
            String factoryName = (String)var5.next();
            result.add(instantiateFactory(factoryName, factoryClass, classLoaderToUse));
        }

        AnnotationAwareOrderComparator.sort(result);
        return result;
    }
}

1.2 ApplicationListener

ApplicationListener 就是Spring的事件监听器，最重要的方法就是 onApplicationEvent，而事件源就是spring的广播组件（SimpleApplicationEventMulticaster），所有监听器通过 SpringFactoriesLoader 获取。

//事件监听器
@FunctionalInterface
public interface ApplicationListener extends EventListener {
    void onApplicationEvent(E var1);
}
//广播事件
public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {
    public void multicastEvent(ApplicationEvent event) {
        this.multicastEvent(event, this.resolveDefaultEventType(event));
    }
    //添加监听器
    public void addApplicationListener(ApplicationListener listener) {
        Object var2 = this.retrievalMutex;
        synchronized(this.retrievalMutex) {
            Object singletonTarget = AopProxyUtils.getSingletonTarget(listener);
            if (singletonTarget instanceof ApplicationListener) {
                this.defaultRetriever.applicationListeners.remove(singletonTarget);
            }

            this.defaultRetriever.applicationListeners.add(listener);
            this.retrieverCache.clear();
        }
    }
}
//较重要的监听器实现类
public class BackgroundPreinitializer implements ApplicationListener {
    public void onApplicationEvent(SpringApplicationEvent event) {
        //如果是首次触发ApplicationStartingEvent时执行
        if (event instanceof ApplicationStartingEvent && preinitializationStarted.compareAndSet(false, true)) {
            this.performPreinitialization();
        }

        if ((event instanceof ApplicationReadyEvent || event instanceof ApplicationFailedEvent) && preinitializationStarted.get()) {
            try {
                preinitializationComplete.await();
            } catch (InterruptedException var3) {
                Thread.currentThread().interrupt();
            }
        }
    }
    private void performPreinitialization() {
        try {
            Thread thread = new Thread(new Runnable() {
                public void run() {
                    this.runSafely(new BackgroundPreinitializer.ConversionServiceInitializer());
                    this.runSafely(new BackgroundPreinitializer.ValidationInitializer());
                    this.runSafely(new BackgroundPreinitializer.MessageConverterInitializer());
                    this.runSafely(new BackgroundPreinitializer.MBeanFactoryInitializer());
                    this.runSafely(new BackgroundPreinitializer.JacksonInitializer());
                    this.runSafely(new BackgroundPreinitializer.CharsetInitializer());
                    BackgroundPreinitializer.preinitializationComplete.countDown();
                }
                public void runSafely(Runnable runnable) {
                    try {
                        runnable.run();
                    } catch (Throwable var3) {
                        ;
                    }

                }
            }, "background-preinit");
            thread.start();
        } catch (Exception var2) {
            preinitializationComplete.countDown();
        }
    }
}

题外话，BackgroundPreinitializer 把耗时的操作采用这种模式(事件+多线程)来实现，足以可见spring的设计功底。

1.3 ApplicationContextInitializer

ApplicationContextInitializer 是 ConfigurableApplicationContext（继承自ApplicationContext） 实例后的上下文初始化组件，它主要可以向 applicationContext 注入一些新的bean、修改 applicationContext 基本信息等，核心方法是 initialize，所有实现类通过 SpringFactoriesLoader 获取。

public interface ApplicationContextInitializer {
    void initialize(C var1);
}

spring提供的实现非常多，比如：ContextIdApplicationContextInitializer，它实现applicationContext.setId(contextId.getId())。

1.4 SpringApplication.run

其实 SpringApplication.run 整体还不算特别复杂，关键的方法有 prepareContext ，refreshContext会比较绕。当然这里面有一个出现的频率非常高的对象 SpringApplicationRunListeners （读源码就是这样，要解决痛点），那它是干什么的？继续向下看吧！

public class SpringApplication {
    //真正的入口
    public ConfigurableApplicationContext run(String... args) {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        ConfigurableApplicationContext context = null;
        Collection exceptionReporters = new ArrayList();
        this.configureHeadlessProperty();
        //下面专门解释
        SpringApplicationRunListeners listeners = this.getRunListeners(args);
        //触发ApplicationStartingEvent
        listeners.starting();

        Collection exceptionReporters;
        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            //获取配置对象
            ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
            //向environment添加新配置
            this.configureIgnoreBeanInfo(environment);
            //打印spring boot的Banner
            Banner printedBanner = this.printBanner(environment);
            //根据webApplicationType类型获取applicationContext，当前为AnnotationConfigServletWebServerApplicationContext
            context = this.createApplicationContext();
            //异常汇总报告
            exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);
            //向applicationContext中填充信息（environment、调用ApplicationContextInitializer、注入新bean）
            this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
            //刷新application
            this.refreshContext(context);
            //无任何实现
            this.afterRefresh(context, applicationArguments);
            stopWatch.stop();
            if (this.logStartupInfo) {
                //打印日志
                (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
            }
            //触发ApplicationStartedEvent
            listeners.started(context);
            //调用ioc中所有ApplicationRunner.run和CommandLineRunner.run
            this.callRunners(context, applicationArguments);
        } catch (Throwable var10) {
            this.handleRunFailure(context, var10, exceptionReporters, listeners);
            throw new IllegalStateException(var10);
        }
        try {
            //触发ApplicationReadyEvent
            listeners.running(context);
            return context;
        } catch (Throwable var9) {
            this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null);
            throw new IllegalStateException(var9);
        }
    }
    private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments) {
        ConfigurableEnvironment environment = this.getOrCreateEnvironment();  
        this.configureEnvironment((ConfigurableEnvironment)environment, applicationArguments.getSourceArgs());
        //触发ApplicationEnvironmentPreparedEvent
        listeners.environmentPrepared((ConfigurableEnvironment)environment);
        this.bindToSpringApplication((ConfigurableEnvironment)environment);
        if (!this.isCustomEnvironment) {
            //根据webApplicationType类型获取配置对象（环境信息、profile），当前为StandardServletEnvironment
            environment = (new EnvironmentConverter(this.getClassLoader())).convertEnvironmentIfNecessary((ConfigurableEnvironment)environment, this.deduceEnvironmentClass());
        }

        ConfigurationPropertySources.attach((Environment)environment);
        return (ConfigurableEnvironment)environment;
    }
    private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
        context.setEnvironment(environment);
        //注入beanNameGenerator、设置ResourceLoader
        this.postProcessApplicationContext(context);
        //调用所有的初始化组件（ApplicationContextInitializer）
        this.applyInitializers(context);
        //无任何实现
        listeners.contextPrepared(context);
        if (this.logStartupInfo) {
            //打印getApplicationLog()信息
            this.logStartupInfo(context.getParent() == null);
            // 打印Profile信息
            this.logStartupProfileInfo(context);
        }
        //ioc容器保存应用程序启动参数（String[] args）信息
        context.getBeanFactory().registerSingleton("springApplicationArguments", applicationArguments);
        if (printedBanner != null) {
            //ioc容器保存Banner信息
            context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
        }
        
        Set