SpringBoot源码分析之run方法

SpringBoot的启动很简单，代码如下：

从代码上可以看出，调用了SpringApplication的静态方法run。这个run方法会构造一个SpringApplication的实例，然后再调用这里实例的run方法就表示启动SpringBoot。

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

因此，想要分析SpringBoot的启动过程，我们需要熟悉SpringApplication的构造过程以及SpringApplication的run方法执行过程即可。

我们以上述这段代码为例，分析SpringBoot的启动过程。

SpringApplication的构造过程

SpringApplication构造的时候内部会调用一个private方法initialize：

public SpringApplication(Object... sources) {
    initialize(sources); // sources目前是一个MyApplication的class对象
}
private void initialize(Object[] sources) {
    if (sources != null && sources.length > 0) {
        this.sources.addAll(Arrays.asList(sources)); // 把sources设置到SpringApplication的sources属性中，目前只是一个MyApplication类对象
    }
    this.webEnvironment = deduceWebEnvironment(); // 判断是否是web程序(javax.servlet.Servlet和org.springframework.web.context.ConfigurableWebApplicationContext都必须在类加载器中存在)，并设置到webEnvironment属性中
    // 从spring.factories文件中找出key为ApplicationContextInitializer的类并实例化后设置到SpringApplication的initializers属性中。这个过程也就是找出所有的应用程序初始化器
    setInitializers((Collection) getSpringFactoriesInstances(
    ApplicationContextInitializer.class));
    // 从spring.factories文件中找出key为ApplicationListener的类并实例化后设置到SpringApplication的listeners属性中。这个过程就是找出所有的应用程序事件监听器
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    // 找出main类，这里是MyApplication类
    this.mainApplicationClass = deduceMainApplicationClass();
}

ApplicationContextInitializer，应用程序初始化器，做一些初始化的工作：

public interface ApplicationContextInitializer<C extends ConfigurableApplicationContext> {
    void initialize(C applicationContext);
}

ApplicationListener，应用程序事件(ApplicationEvent)监听器：

public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
void onApplicationEvent(E event);
}

监听器和初始化器详细见https://blog.csdn.net/Bob_666/article/details/79715156

SpringApplication的run方法代码如下：

public ConfigurableApplicationContext run(String... args) {
    StopWatch stopWatch = new StopWatch(); // 构造一个任务执行观察器
    stopWatch.start(); // 开始执行，记录开始时间
    ConfigurableApplicationContext context = null;
    configureHeadlessProperty();
    // 获取SpringApplicationRunListeners，内部只有一个EventPublishingRunListener
    SpringApplicationRunListeners listeners = getRunListeners(args);
    // 上面分析过，会封装成SpringApplicationEvent事件然后广播出去给SpringApplication中的listeners所监听
    // 这里接受ApplicationStartedEvent事件的listener会执行相应的操作
    listeners.starting();
	try {
			// 构造一个应用程序参数持有类
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(
					args);
			// 创建配置应用程序的环境信息。
			ConfigurableEnvironment environment = prepareEnvironment(listeners,
					applicationArguments);
			Banner printedBanner = printBanner(environment);
			// 创建Spring容器
			context = createApplicationContext();
			analyzers = new FailureAnalyzers(context);
			//准备Spring容器，设置Spring容器的环境信息，SpringApplication的的初始化器开始工作
			//将MyApplication类作为BeanDefinition注册进BeanFactory，为后续的refresh做准备
			prepareContext(context, environment, listeners, applicationArguments,
					printedBanner);
			refreshContext(context);//Spring容器的刷新,重点，详细看后面的文章
			// 容器创建完成之后执行额外一些操作
			afterRefresh(context, applicationArguments);
			// 广播出ApplicationReadyEvent事件给相应的监听器执行
			listeners.finished(context, null);
			// 执行结束，记录执行时间
			stopWatch.stop();
			if (this.logStartupInfo) {
				new StartupInfoLogger(this.mainApplicationClass)
						.logStarted(getApplicationLog(), stopWatch);
			}
			return context;
		}
		catch (Throwable ex) {
			// 这个过程报错的话会执行一些异常操作、然后广播出ApplicationFailedEvent事件给相应的监听器执行
			handleRunFailure(context, listeners, analyzers, ex);
			throw new IllegalStateException(ex);
		}
}

prepareEnvironment方法：

private ConfigurableEnvironment prepareEnvironment(
			SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments) {
		// Create and configure the environment
		// 创建应用程序的环境信息。如果是web程序，创建StandardServletEnvironment；否则，创建StandardEnvironment
		// StandardServletEnvironment继承自StandardEnvironment，StandardEnvironment继承AbstractEnvironment
		// AbstractEnvironment内部有个MutablePropertySources类型的propertySources属性，用于存储多个属性源PropertySource
		// AbstractEnvironment构造函数有一个模板方法customizePropertySources(this.propertySources)
		// StandardServletEnvironment调用customizePropertySources先生成两个StubPropertySource,servletConfigInitParams和servletContextInitParams
		// StandardEnvironment会默认加上2个PropertySource。分别是MapPropertySource(调用System.getProperties()配置)和SystemEnvironmentPropertySource(调用System.getenv()配置)
		ConfigurableEnvironment environment = getOrCreateEnvironment();
		// 如果设置了一些启动参数args，添加基于args的SimpleCommandLinePropertySource
		// 还会配置profile信息，比如设置了spring.profiles.active启动参数，设置到环境信息中
		configureEnvironment(environment, applicationArguments.getSourceArgs());
		// 广播出ApplicationEnvironmentPreparedEvent事件给相应的监听器执行
		// ConfigFileApplicationListener会加载application.properties进环境，详细见环境和配置文件的加载那篇文章
		listeners.environmentPrepared(environment);
		if (!this.webEnvironment) {
			environment = new EnvironmentConverter(getClassLoader())
					.convertToStandardEnvironmentIfNecessary(environment);
		}
		return environment;
}

createApplicationContext()方法： 详细见 http://blog.csdn.net/liaokailin/article/details/48186331

protected ConfigurableApplicationContext createApplicationContext() {
    Class<?> contextClass = this.applicationContextClass;
    if (contextClass == null) {
    try {
        // 如果是web程序，那么构造org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext容器
        // 否则构造org.springframework.context.annotation.AnnotationConfigApplicationContext容器
        contextClass = Class.forName(this.webEnvironment? DEFAULT_WEB_CONTEXT_CLASS : DEFAULT_CONTEXT_CLASS);
        }
        catch (ClassNotFoundException ex) {
            throw new IllegalStateException("Unable create a default ApplicationContext, "+ "please specify an ApplicationContextClass",ex);
        }
    }
    return (ConfigurableApplicationContext) BeanUtils.instantiate(contextClass);
}

在实例化AnnotationConfigEmbeddedWebApplicationContext时会创建属性reader:AnnotatedBeanDefinitionReader实例，reader在实例化的构造函数中会调用 AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);

给BeanFactory设置依赖比较器AnnotationAwareOrderComparator和自动装入处理器ContextAnnotationAutowireCandidateResolver.

并注册各种BeanFactoryPostProcessor和BeanPostProcessor:

        ConfigurationClassPostProcessor.class， 实现了BeanDefinitionRegistryPostProcessor接口即BeanFactoryPostProcessor

AutowiredAnnotationBeanPostProcessor.class，实现MergedBeanDefinitionPostProcessor（BeanPostProcessor）

       RequiredAnnotationBeanPostProcessor.class， 实现 MergedBeanDefinitionPostProcessor（BeanPostProcessor）

      CommonAnnotationBeanPostProcessor.class，实现InstantiationAwareBeanPostProcessor（BeanPostProcessor）

 EventListenerMethodProcessor.class，DefaultEventListenerFactory.class等

prepareContext方法：设置环境，初始化器运行，注册@SpringBootApplication的类

private void prepareContext(ConfigurableApplicationContext context,
			ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments, Banner printedBanner) {
		// 将前面准备好的环境设置给contex
		context.setEnvironment(environment);
		// 回调方法，Spring容器创建之后做一些额外的事
		postProcessApplicationContext(context);
		applyInitializers(context);// SpringApplication的的初始化器开始工作
		listeners.contextPrepared(context);// 遍历调用SpringApplicationRunListener的contextPrepared方法(目前空方法)。
		if (this.logStartupInfo) {
			logStartupInfo(context.getParent() == null);
			logStartupProfileInfo(context);
		}

		// Add boot specific singleton beans
		// 把应用程序参数持有类注册到Spring容器中，并且是一个单例
		context.getBeanFactory().registerSingleton("springApplicationArguments",
				applicationArguments);
		if (printedBanner != null) {
			context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
		}

		// Load the sources
		Set<Object> sources = getSources();
		Assert.notEmpty(sources, "Sources must not be empty");
		// 将MyApplication类（@SpringBootApplication）作为BeanDefinition注册到Context的beanFactory中，为后续context的refresh()初始化做准备
		load(context, sources.toArray(new Object[sources.size()])); //详细见本博客内https://blog.csdn.net/Bob_666/article/details/79716954 也可看这篇文章 https://blog.csdn.net/liaokailin/article/details/49048557
		// 广播出ApplicationPreparedEvent事件给相应的监听器执行
		listeners.contextLoaded(context);
}

postProcessApplicationContext：

protected void postProcessApplicationContext(ConfigurableApplicationContext context) {
    if (this.webEnvironment) { // 如果是web程序
        if (context instanceof ConfigurableWebApplicationContext) { // 并且也是Spring Web容器
            ConfigurableWebApplicationContext configurableContext = (ConfigurableWebApplicationContext) context;
            if (this.beanNameGenerator != null) { // 如果SpringApplication设置了是实例命名生成器，注册到Spring容器中
                configurableContext.getBeanFactory().registerSingleton(
                AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR,this.beanNameGenerator);
            }
        }
    }
    if (this.resourceLoader != null) { // 如果SpringApplication设置了资源加载器，设置到Spring容器中
        if (context instanceof GenericApplicationContext) {
        ((GenericApplicationContext) context).setResourceLoader(this.resourceLoader);
        }
        if (context instanceof DefaultResourceLoader) {
        ((DefaultResourceLoader) context).setClassLoader(this.resourceLoader.getClassLoader());
        }
    }
}

初始化器做的工作，比如ContextIdApplicationContextInitializer会设置应用程序的id；AutoConfigurationReportLoggingInitializer会给应用程序添加一个条件注解解析器报告等：详细见初始化器文章

protected void afterRefresh(ConfigurableApplicationContext context,
    ApplicationArguments args) {
    afterRefresh(context, args.getSourceArgs()); // 目前是个空实现
    callRunners(context, args); // 调用Spring容器中的ApplicationRunner和CommandLineRunner接口的实现类
}
private void callRunners(ApplicationContext context, ApplicationArguments args) {
    List<Object> runners = new ArrayList<Object>();
    // 找出Spring容器中ApplicationRunner接口的实现类
    runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
    // 找出Spring容器中CommandLineRunner接口的实现类
    runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
    // 对runners进行排序
    AnnotationAwareOrderComparator.sort(runners);
    // 遍历runners依次执行
    for (Object runner : new LinkedHashSet<Object>(runners)) {
        if (runner instanceof ApplicationRunner) { // 如果是ApplicationRunner，进行ApplicationRunner的run方法调用
            callRunner((ApplicationRunner) runner, args);
        }
        if (runner instanceof CommandLineRunner) { // 如果是CommandLineRunner，进行CommandLineRunner的run方法调用
            callRunner((CommandLineRunner) runner, args);
        }
    }
}

总结

SpringBoot启动的时候，不论调用什么方法，都会构造一个SpringApplication的实例，然后调用这个实例的run方法，这样就表示启动SpringBoot。

在run方法调用之前，也就是构造SpringApplication的时候会进行初始化的工作，初始化的时候会做以下几件事：

1. 把参数sources设置到SpringApplication属性中，这个sources可以是任何类型的参数。本文的例子中这个sources就是MyApplication的class对象
2. 判断是否是web程序，并设置到webEnvironment这个boolean属性中
3. 找出所有的初始化器，默认有5个，设置到initializers属性中
4. 找出所有的应用程序监听器，默认有9个，设置到listeners属性中
5. 找出运行的主类(main class)

SpringApplication构造完成之后调用run方法，启动SpringApplication，run方法执行的时候会做以下几件事：

1. 构造一个StopWatch，观察SpringApplication的执行
2. 找出所有的SpringApplicationRunListener并封装到SpringApplicationRunListeners中，用于监听run方法的执行。监听的过程中会封装成事件并广播出去让初始化过程中产生的应用程序监听器进行监听
3. 构造Spring容器(ApplicationContext)，并返回
   3.1 创建Spring容器的判断是否是web环境，是的话构造AnnotationConfigEmbeddedWebApplicationContext，否则构造AnnotationConfigApplicationContext
   3.2 初始化过程中产生的初始化器在这个时候开始工作
   3.3 Spring容器的刷新(完成bean的解析、各种processor接口的执行、条件注解的解析等等)
4. 从Spring容器中找出ApplicationRunner和CommandLineRunner接口的实现类并排序后依次执行

参考 http://fangjian0423.github.io/2017/04/30/springboot-startup-analysis/