SpringBoot2启动流程分析

首先上一张图，图片来自 SpringBoot启动流程解析

本文基于spring-boot-2.0.4.RELEASE.jar包分析。

程序启动入口

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

run是一个静态方法，最后会调用创建SpringApplication实例并run

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);
}

我们先看new SpringApplication(xx)构建的实例。

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.resourceLoader = resourceLoader;
	Assert.notNull(primarySources, "PrimarySources must not be null");
	//配置source
	this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
	//判断是否web应用
	this.webApplicationType = this.deduceWebApplicationType();
	//创建初始化构造器
	this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
	//创建应用监听器
	this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
	//推断出main方法类
	this.mainApplicationClass = this.deduceMainApplicationClass();
}

SpringApplication的构造函数主要设置了一些基本参数并配置source、判断了是否web应用、创建初始化构造器、创建应用监听器、找出main方法所在的类。
getSpringFactoriesInstances为获取spring工厂中的实例，具体代码块为

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {
	return this.getSpringFactoriesInstances(type, new Class[0]);
}

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
    //获取类加载器
	ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
	//通过类加载器、获取指定的spring.factories文件，并获取文件中工厂类的全路径名
	Set<String> names = new LinkedHashSet(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
    //通过类路径反射得到工厂class对象、构造方法
	List<T> instances = this.createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
	AnnotationAwareOrderComparator.sort(instances);
	return instances;
}

new SpringApplication(xx)构建完实例后，会进行run方法。

public ConfigurableApplicationContext run(String... args) {
		StopWatch stopWatch = new StopWatch();
        //应用启动计时器开始计时
		stopWatch.start();
		ConfigurableApplicationContext context = null;
		Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
        //Headless模式配置
		configureHeadlessProperty();
        //获取启动监听器
		SpringApplicationRunListeners listeners = getRunListeners(args);
        //应用启动监听器开始计时
		listeners.starting();
		try {
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(
					args);
             //配置环境模块（祥见下面prepareEnvironment方法）
			ConfigurableEnvironment environment = prepareEnvironment(listeners,
					applicationArguments);
             //配置需要忽略的bean
			configureIgnoreBeanInfo(environment);
            //Banner配置
			Banner printedBanner = printBanner(environment);
            //创建应用上下文对象
			context = createApplicationContext();
			exceptionReporters = getSpringFactoriesInstances(
					SpringBootExceptionReporter.class,
					new Class[] { ConfigurableApplicationContext.class }, context);
            //上下文基本属性配置（祥见下面prepareContext方法）
			prepareContext(context, environment, listeners, applicationArguments,
					printedBanner);
            //更新应用上下文（祥见下面refresh方法）
			refreshContext(context);
			afterRefresh(context, applicationArguments);
			stopWatch.stop();
			if (this.logStartupInfo) {
				new StartupInfoLogger(this.mainApplicationClass)
						.logStarted(getApplicationLog(), stopWatch);
			}
			listeners.started(context);
			callRunners(context, applicationArguments);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, exceptionReporters, listeners);
			throw new IllegalStateException(ex);
		}

		try {
			listeners.running(context);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, exceptionReporters, null);
			throw new IllegalStateException(ex);
		}
		return context;
	}

private ConfigurableEnvironment prepareEnvironment(
			SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments) {
		// 创建配置环境
		ConfigurableEnvironment environment = getOrCreateEnvironment();
        //加载属性文件
		configureEnvironment(environment, applicationArguments.getSourceArgs());
        //监听器监听配置
		listeners.environmentPrepared(environment);
		bindToSpringApplication(environment);
		if (this.webApplicationType == WebApplicationType.NONE) {
			environment = new EnvironmentConverter(getClassLoader())
					.convertToStandardEnvironmentIfNecessary(environment);
		}
		ConfigurationPropertySources.attach(environment);
		return environment;
	}

private void prepareContext(ConfigurableApplicationContext context,
			ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments, Banner printedBanner) {
        //加载配置环境
		context.setEnvironment(environment);
        //ResourceLoader资源加载器
		postProcessApplicationContext(context);
        //初始化环境
		applyInitializers(context);
        //配置监听
		listeners.contextPrepared(context);
		if (this.logStartupInfo) {
			logStartupInfo(context.getParent() == null);
			logStartupProfileInfo(context);
		}

		// Add boot specific singleton beans
		context.getBeanFactory().registerSingleton("springApplicationArguments",
				applicationArguments);
		if (printedBanner != null) {
			context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
		}

		// Load the sources
		Set<Object> sources = getAllSources();
		Assert.notEmpty(sources, "Sources must not be empty");
        //加载启动参数
		load(context, sources.toArray(new Object[0]));
        //监听加载应用上下文
		listeners.contextLoaded(context);
	}

 public void refresh() throws BeansException, IllegalStateException {
        Object var1 = this.startupShutdownMonitor;
        synchronized(this.startupShutdownMonitor) {
            //准备更新上下文时的预备工作：1.初始化PropertySource; 2.验证Enrivonment中必要的属性
            this.prepareRefresh();
            //获取上下文中的BeanFactory
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            //对BeanFactory做些预备工作
            this.prepareBeanFactory(beanFactory);

            try {
                //对BeanFactory进行预处理
                this.postProcessBeanFactory(beanFactory);
                //执行容器中的BeanFactoryPostProcessor
                this.invokeBeanFactoryPostProcessors(beanFactory);
                //注册BeanPostProcessor
                this.registerBeanPostProcessors(beanFactory);
                //初始化MessageSource(国际化相关)
                this.initMessageSource();
                //初始化容器事件广播器(用来发布事件)
                this.initApplicationEventMulticaster();
                //初始化一些特殊的Bean,主要做了: 1.初始化ThemeSource(跟国际化相关的接口) 2.创建WebServer
                this.onRefresh();
                //将所有监听器注册到前两步创建的事件广播器中
                this.registerListeners();
                //结束BeanFactory的初始化工作(这一步主要用来将所有的单例BeanDefinition实例化)
                this.finishBeanFactoryInitialization(beanFactory);
                //上下文刷新完毕
                this.finishRefresh();
            } catch (BeansException var9) {
                if (this.logger.isWarnEnabled()) {
                    this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
                }

                this.destroyBeans();
                this.cancelRefresh(var9);
                throw var9;
            } finally {
                this.resetCommonCaches();
            }

        }
    }