Spring Boot启动流程源码分析

Spring Boot启动流程源码分析

版本：2.1.1.RELEASE

使用main方法启动Spring Boot应用：

    public static void main(String[] args) {
        SpringApplication.run(DingtalkApplication.class, args);
    }

进入SpringApplication类的run方法最终实现位置：

	public ConfigurableApplicationContext run(String... args) {
	    // 1. 启动计时
		StopWatch stopWatch = new StopWatch();
		stopWatch.start();
		ConfigurableApplicationContext context = null;
		// 2. 回调接口SpringBootExceptionReporter用于支持自定义spring应用程序启动错误的报告
		Collection exceptionReporters = new ArrayList<>();
		// 3. 配置启用Java headless模式 
		configureHeadlessProperty();
		// 4. 获取Spring应用run方法的监听器集合并启动所有的监听器
		SpringApplicationRunListeners listeners = getRunListeners(args);
		listeners.starting();
		try {
		    // 5. 提供对用于运行SpringApplication的参数的访问
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(
					args);
			// 6. 创建和配置环境
			ConfigurableEnvironment environment = prepareEnvironment(listeners,
					applicationArguments);
		    // 7. 配置忽略BeanInfo类的加载
			configureIgnoreBeanInfo(environment);
			// 8. 打印Banner
			Banner printedBanner = printBanner(environment);
			// 9. 创建ApplicationContext
			context = createApplicationContext();
			// 10. 获取异常报告实例列表
			exceptionReporters = getSpringFactoriesInstances(
					SpringBootExceptionReporter.class,
					new Class[] { ConfigurableApplicationContext.class }, context);
			// 11. 准备应用上下文
			prepareContext(context, environment, listeners, applicationArguments,
					printedBanner);
			// 12. 刷新底层的ApplicationContext
			refreshContext(context);
			// 13. protected方法，应用上下文刷新后，子类可实现此方法用于后续的操作
			afterRefresh(context, applicationArguments);
			// 14. 打印应用启动信息
			stopWatch.stop();
			if (this.logStartupInfo) {
				new StartupInfoLogger(this.mainApplicationClass)
						.logStarted(getApplicationLog(), stopWatch);
			}
			// 15. 启动实现了CommandLineRunner 和 ApplicationRunner 接口的类的run方法 
			listeners.started(context);
			callRunners(context, applicationArguments);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, exceptionReporters, listeners);
			throw new IllegalStateException(ex);
		}

		try {
		    // 16. 在run 方法结束之前立即调用，发布事件，应用程序已准备好接受服务请求
			listeners.running(context);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, exceptionReporters, null);
			throw new IllegalStateException(ex);
		}
		return context;
	}

run方法源码上注释了大概流程，接下来继续深入重点流程的源码。

流程4，获取Spring应用run方法的监听器集合并启动所有的监听器:

getRunListeners(String[] args) 方法源码：

    private SpringApplicationRunListeners getRunListeners(String[] args) {
		Class[] types = new Class[] { SpringApplication.class, String[].class };
		return new SpringApplicationRunListeners(logger, getSpringFactoriesInstances(
				SpringApplicationRunListener.class, types, this, args));
	}

返回SpringApplicationRunListeners 实例，直接看构造方法的第二个参数的getSpringFactoriesInstances方法实现：

    private  Collection getSpringFactoriesInstances(Class type,
			Class[] parameterTypes, Object... args) {
		// 1. 获取类加载器
		ClassLoader classLoader = getClassLoader();
		// 2. 获取指定类型的工厂实现类的完全限定类名集合
		Set names = new LinkedHashSet<>(
				SpringFactoriesLoader.loadFactoryNames(type, classLoader));
		// 3. 根据传入的完全限定类名集合创建对应工厂实例
		List instances = createSpringFactoriesInstances(type, parameterTypes,
				classLoader, args, names);
	    // 4. 根据工厂实例上的@Order注解指定的顺序排序
		AnnotationAwareOrderComparator.sort(instances);
		return instances;
	}

该方法第一个参数这里传入的是SpringApplicationRunListener 接口，会获取该接口所在类加载器下的“META-INF/spring.factories”属性文件
设置的接口实现org.springframework.boot.context.event.EventPublishingRunListener，然后调用该类的构造方法实例化：

    public EventPublishingRunListener(SpringApplication application, String[] args) {
		this.application = application;
		this.args = args;
		this.initialMulticaster = new SimpleApplicationEventMulticaster();
		for (ApplicationListener listener : application.getListeners()) {
			this.initialMulticaster.addApplicationListener(listener);
		}
	}

该类的主要作用是作为应用启动过程的事件发布监听器，可以看到构造方法中实例化了一个简单的应用事件多播器SimpleApplicationEventMulticaster 并遍历添加应用启动事件监听器。

流程4最后调用listeners.starting() 启动监听器，实现源码：

    @Override
	public void starting() {
		this.initialMulticaster.multicastEvent(
				new ApplicationStartingEvent(this.application, this.args));
	}

该方法多播一个ApplicationStartingEvent实例（应用启动事件），事件源是SpringApplication本身。
接下来就是解析事件类型并调用对应的事件监听器了，感兴趣的可以自己深入。深入之前需要对Spring事件机制有所了解，
推荐此文Spring事件机制。

流程6. 创建和配置环境：

prepareEnvironment(listeners, applicationArguments)方法实现：

    private ConfigurableEnvironment prepareEnvironment(
			SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments) {
		// 创建环境
		ConfigurableEnvironment environment = getOrCreateEnvironment();
		// 配置环境
		configureEnvironment(environment, applicationArguments.getSourceArgs());
		// 发布环境准备事件
		listeners.environmentPrepared(environment);
		// 绑定环境到此应用
		bindToSpringApplication(environment);
		// 判断是否需要转换环境
		if (!this.isCustomEnvironment) {
			environment = new EnvironmentConverter(getClassLoader())
					.convertEnvironmentIfNecessary(environment, deduceEnvironmentClass());
		}
		// 附加ConfigurationPropertySource支持到指定环境
		ConfigurationPropertySources.attach(environment);
		return environment;
	}

其中，getOrCreateEnvironment() 方法实现：

    private ConfigurableEnvironment getOrCreateEnvironment() {
		if (this.environment != null) {
			return this.environment;
		}
		// 根据ClassPath存在的类推断应用运行环境，以下都是web环境
		switch (this.webApplicationType) {
		case SERVLET:
			return new StandardServletEnvironment();
		case REACTIVE:
			return new StandardReactiveWebEnvironment();
		default:
			return new StandardEnvironment();
		}
	}

流程9. 创建ApplicationContext：

createApplicationContext方法实现：

    protected ConfigurableApplicationContext createApplicationContext() {
		Class contextClass = this.applicationContextClass;
		if (contextClass == null) {
			try {
				switch (this.webApplicationType) {
				case SERVLET:
				    // 1. 初始化并返回org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext Class对象
					contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);
					break;
				case REACTIVE:
					contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
					break;
				default:
					contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
				}
			}
			// 忽略异常捕获代码
		}
		// 2. 调用AnnotationConfigServletWebServerApplicationContext对象的默认构造方法实例化
		return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
	}

流程11. 准备应用上下文：

prepareContext方法实现：

    private void prepareContext(ConfigurableApplicationContext context,
			ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments, Banner printedBanner) {
		// 1. 设置环境
		context.setEnvironment(environment);
		// 2. 在ApplicationContext中应用任何相关的后置处理,这里为context对象的BeanFactory实例DefaultListableBeanFactory添加转换服务
		postProcessApplicationContext(context);
		// 3. 在context刷新之前应用实现了ApplicationContextInitializer回调接口的实例进行context上下文对象的初始化
		applyInitializers(context);
		// 4. 发布context初始化事件
		listeners.contextPrepared(context);
		// 5. 打印应用版本信息和激活的配置文件信息active profile
		if (this.logStartupInfo) {
			logStartupInfo(context.getParent() == null);
			logStartupProfileInfo(context);
		}
		// 6. 添加名称为springApplicationArguments，springBootBanner的单例bean
		ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
		beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
		if (printedBanner != null) {
			beanFactory.registerSingleton("springBootBanner", printedBanner);
		}
		if (beanFactory instanceof DefaultListableBeanFactory) {
			((DefaultListableBeanFactory) beanFactory)
					.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
		}
		// 7. 加载源（即main方法所在的类对象）不可变的集合对象并注册其bean到应用上下文
		Set