2. Springboot 源码解读：run方法

最新推荐文章于 2024-11-04 23:01:38 发布

原创最新推荐文章于 2024-11-04 23:01:38 发布 · 414 阅读

0 ·

CC 4.0 BY-SA版权

springboot 专栏收录该内容

2 篇文章

订阅专栏

SpringApplication的run方法

确切的说，是SpringApplication实例的run方法执行过程，代码如下

public ConfigurableApplicationContext run(String... args) {
       // 1、创建并启动计时监控类
		StopWatch stopWatch = new StopWatch();
		stopWatch.start();
		// 2、初始化应用上下文和异常报告集合
		ConfigurableApplicationContext context = null;
		Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
		// 3、设置系统属性 `java.awt.headless` 的值，默认值为：true
		configureHeadlessProperty();
		// 4、创建所有 Spring 运行监听器并发布应用启动事件
		SpringApplicationRunListeners listeners = getRunListeners(args);
		listeners.starting();
		try {
		// 5、初始化默认应用参数类
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(
					args);
		   // 6、根据运行监听器和应用参数来准备 Spring 环境
			ConfigurableEnvironment environment = prepareEnvironment(listeners,
					applicationArguments);
			configureIgnoreBeanInfo(environment);
			// 7、创建 Banner 打印类
			Banner printedBanner = printBanner(environment);
			// 8、创建应用上下文
			context = createApplicationContext();
			// 9、准备异常报告器
			exceptionReporters = getSpringFactoriesInstances(
					SpringBootExceptionReporter.class,
					new Class[] { ConfigurableApplicationContext.class }, context);
			// 10、准备应用上下文
			prepareContext(context, environment, listeners, applicationArguments,
					printedBanner);
			// 11、刷新应用上下文
			refreshContext(context);
			// 12、应用上下文刷新后置处理
			afterRefresh(context, applicationArguments);
			// 13、停止计时监控类
			stopWatch.stop();
			// 14、输出日志记录执行主类名、时间信息
			if (this.logStartupInfo) {
				new StartupInfoLogger(this.mainApplicationClass)
						.logStarted(getApplicationLog(), stopWatch);
			}
			 // 15、发布应用上下文启动完成事件
			listeners.started(context);
			// 16、执行所有 Runner 运行器
			callRunners(context, applicationArguments);
		}
		catch (Throwable ex) {
		
			handleRunFailure(context, ex, exceptionReporters, listeners);
			throw new IllegalStateException(ex);
		}

		try {
		 // 17、发布应用上下文就绪事件
			listeners.running(context);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, exceptionReporters, null);
			throw new IllegalStateException(ex);
		}
		// 18、返回应用上下文
		return context;
	}

从代码中可以看出，此方法的目的就是根据传入的参数，进行ConfigurableApplicationContext 的初始化，同时完成上下文的启动

创建并启动计时监控类
记录了当前任务的名称，默认为空字符串，然后记录当前 Spring Boot 应用启动的开始时间
SpringApplicationRunListeners 创建与启动

	// 4、创建所有 Spring 运行监听器并发布应用启动事件
		SpringApplicationRunListeners listeners = getRunListeners(args);
		listeners.starting();

跟ApplicationListener和上下文Initializers一样，也是从 spring.factories文件中获取，并加载到SpringApplicationRunListeners集合中；
然后进行启动。

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

- 创建并配置环境

	private ConfigurableEnvironment prepareEnvironment(
			SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments) {
		// Create and configure the environment 创建并配置环境
		ConfigurableEnvironment environment = getOrCreateEnvironment();
		configureEnvironment(environment, applicationArguments.getSourceArgs());
		listeners.environmentPrepared(environment);
		bindToSpringApplication(environment);
		if (!this.isCustomEnvironment) {
			environment = new EnvironmentConverter(getClassLoader())
					.convertEnvironmentIfNecessary(environment, deduceEnvironmentClass());
		}
		ConfigurationPropertySources.attach(environment);
		return environment;
	}

创建环境：根据webApplicationType创建不同的环境

```
	private ConfigurableEnvironment getOrCreateEnvironment() {
		if (this.environment != null) {
			return this.environment;
		}
		switch (this.webApplicationType) {
		case SERVLET:
			return new StandardServletEnvironment();
		case REACTIVE:
			return new StandardReactiveWebEnvironment();
		default:
			return new StandardEnvironment();
		}
	}
```
配置环境：
1. 添加转换服务
2. 配置property sources
3. 配置profiles :spring.profiles.active 属性中的profile

	protected void configureEnvironment(ConfigurableEnvironment environment,
			String[] args) {
		if (this.addConversionService) {
			ConversionService conversionService = ApplicationConversionService
					.getSharedInstance();
			environment.setConversionService(
					(ConfigurableConversionService) conversionService);
		}
		configurePropertySources(environment, args);
		configureProfiles(environment, args);
	}

创建应用上下文
根据webapplicationType进行不同类型的应用上下文的创建

protected ConfigurableApplicationContext createApplicationContext() {
		Class<?> contextClass = this.applicationContextClass;
		if (contextClass == null) {
			try {
				switch (this.webApplicationType) {
				case SERVLET:
					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);
				}
			}
			catch (ClassNotFoundException ex) {
				throw new IllegalStateException(
						"Unable create a default ApplicationContext, "
								+ "please specify an ApplicationContextClass",
						ex);
			}
		}
		return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
	}

- 准备应用上下文

private void prepareContext(ConfigurableApplicationContext context,
			ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments, Banner printedBanner) {
	    //绑定环境到上下文中
		context.setEnvironment(environment);
		//配置上下文的 bean 生成器beanNameGenerator及资源加载器resourceLoader以及数据转换服务ConversionService
		postProcessApplicationContext(context);
		// 所有初始化器的初始化
		applyInitializers(context);
		//触发所有 SpringApplicationRunListener 监听器的 contextPrepared 事件方法
		listeners.contextPrepared(context);
		//记录启动日志
		if (this.logStartupInfo) {
			logStartupInfo(context.getParent() == null);
			logStartupProfileInfo(context);
		}
		// Add boot specific singleton beans
		//注册两个特殊的单例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);
		}
		// Load the sources 加载所有资源; primarySources ==应用程序类
		Set<Object> sources = getAllSources();
		Assert.notEmpty(sources, "Sources must not be empty");
		load(context, sources.toArray(new Object[0]));
		//触发所有 SpringApplicationRunListener 监听器的 contextLoaded 事件方法
		listeners.contextLoaded(context);
	}

- 刷新应用上下文
其实最终调用的是ApplicationContext类的refresh方法。

	private void refreshContext(ConfigurableApplicationContext context) {
		refresh(context);
		if (this.registerShutdownHook) {
			try {
				context.registerShutdownHook();
			}
			catch (AccessControlException ex) {
				// Not allowed in some environments.
			}
		}
	}
	protected void refresh(ApplicationContext applicationContext) {
			Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
			((AbstractApplicationContext) applicationContext).refresh();
		}

这个刷新方法做的事情非常多，详见代码

@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			//准备刷新上下文：设置启动时间和激活flag
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			//子类进行内部bean工厂的刷新
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
			//准备上下文中的bean工厂
			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				//实例化并注册所有的BeanFactoryPostProcessor beans
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
				//初始化消息资源
				initMessageSource();

				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				//初始化其他的bean
				onRefresh();

				// Check for listener beans and register them.
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}