Spring Boot启动流程源码分析

悠悠 2022-02-26 10:33 380阅读 0赞

# 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<SpringBootExceptionReporter> 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 <T> Collection<T> getSpringFactoriesInstances(Class<T> type,
    			Class<?>[] parameterTypes, Object... args) {
    		// 1. 获取类加载器
    		ClassLoader classLoader = getClassLoader();
    		// 2. 获取指定类型的工厂实现类的完全限定类名集合
    		Set<String> names = new LinkedHashSet<>(
    				SpringFactoriesLoader.loadFactoryNames(type, classLoader));
    		// 3. 根据传入的完全限定类名集合创建对应工厂实例
    		List<T> 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事件机制][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<Object> sources = getAllSources();
    		Assert.notEmpty(sources, "Sources must not be empty");
    		load(context, sources.toArray(new Object[0]));
    		// 8. 发布应用准备事件
    		listeners.contextLoaded(context);
    	}

应用上下文对象准备好了，接下来就进行刷新上下文操作。

**12. 刷新底层的ApplicationContext：**

refreshContext方法实现：

private void refreshContext(ConfigurableApplicationContext context) {
    		refresh(context);
    		if (this.registerShutdownHook) {
    			try {
    			    // 向JVM运行时注册一个关机钩子，在JVM关闭时同时关闭这个上下文。
    				context.registerShutdownHook();
    			}
    			......
    		}
    	}

进入到ServletWebServerApplicationContext类的refresh(context)方法实现：

@Override
    	public final void refresh() throws BeansException, IllegalStateException {
    		try {
    			super.refresh();
    		}
    		......
    	}

发现是直接调用的父类AbstractApplicationContext的refresh方法实现：

@Override
    	public void refresh() throws BeansException, IllegalStateException {
    		synchronized (this.startupShutdownMonitor) {
    			// 1. 准备好刷新上下文
    			prepareRefresh();
    
    			// 2. 告诉子类刷新内部bean工厂
    			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
    			// 3. 准备bean工厂以用于此上下文中
    			prepareBeanFactory(beanFactory);
    
    			try {
    				// 4. 允许在特定的ApplicationContext实现中注册特殊的bean后置处理器
    				postProcessBeanFactory(beanFactory);
    
    				// 5. 实例化并调用所有已注册的BeanFactoryPostProcessor bean
    				invokeBeanFactoryPostProcessors(beanFactory);
    
    				// 6. 实例化并调用所有已注册的BeanPostProcessor bean
    				registerBeanPostProcessors(beanFactory);
    
    				// 7. 初始化MessageSource用于当前上下文，提供参数化和i18n的支持
    				initMessageSource();
    
    				// 8. 初始化事件多路广播用于当前上下文，默认使用SimpleApplicationEventMulticaster单例bean
    				initApplicationEventMulticaster();
    
    				// 9. 在特定上下文子类中初始化其他特殊bean。
    				onRefresh();
    
    				// 10. 检查监听器bean并注册它们
    				registerListeners();
    
    				// 11. 实例化剩余所有非懒加载的单例bean
    				finishBeanFactoryInitialization(beanFactory);
    
    				// 12. 最后一步: 发布相应的事件
    				finishRefresh();
    			}
    			catch (BeansException ex) {
    				......
    	            // 销毁所有创建的单例来避免悬空资源
    				destroyBeans();
    				// 重置 'active' 标识.
    				cancelRefresh(ex);
    				// 抛出异常给调用者
    				throw ex;
    			}
    			finally {
    				// 重置Spring的公共反射元数据缓存
    				resetCommonCaches();
    			}
    		}
    	}

第一点主要做了以下操作：

*  清除本地元数据缓存(如果有的话)，删除所有缓存的类元数据。
 *  设置其启动日期和活动标志以及执行任何属性源的初始化。

第二点主要做了以下操作：

*  将成员变量 refreshed 设为 true。
 *  为 DefaultListableBeanFactory 指定一个用于序列化的id。

第三点主要做了以下操作：

*  配置工厂的标准上下文特征，例如上下文的类加载器和后置处理程序。
 *  所有bean定义都已加载，但还没有实例化bean。

第四点主要做了以下操作：

*  注册特定应用上下文的后置处理器bean
 *  扫描basePackage指定的包路径
 *  注册被注解的类，例如@Configuration

第五点主要做了以下操作：

*  实例化并调用所有已注册的BeanFactoryPostProcessor bean，如果给定显式顺序，则遵循显式顺序
 *  分别调用实现了BeanFactoryPostProcessor接口的bean。

第六点主要做了以下操作：

*  实例化并调用所有已注册的BeanPostProcessor bean，如果给定显式顺序，则遵循显式顺序
 *  分别调用实现了BeanPostProcessor接口的bean。

第九点主要做了以下操作：

*  默认创建TomcatWebServer
 *  初始化WebApplicationContext和SerlvetContext参数

第十一点完成BeanFactory的初始化并实例化剩余的单例bean：

finishBeanFactoryInitialization方法实现：

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    		// 初始化用于此上下文的转换服务
    		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
    				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
    			beanFactory.setConversionService(
    					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
    		}
    
    		// 如果没有内嵌value解析器Bean则注册一个(例如 PropertyPlaceholderConfigurer bean)，主要用于解析${}占位符.
    		if (!beanFactory.hasEmbeddedValueResolver()) {
    			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
    		}
    		
    		// 尽早地初始化LoadTimeWeaverAware bean以允许尽早地注册其变换器
    		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    		for (String weaverAwareName : weaverAwareNames) {
    			getBean(weaverAwareName);
    		}
    
    		// 停止正用于类型匹配的临时类加载器
    		beanFactory.setTempClassLoader(null);
    
    		// 缓存所有bean定义的元数据，不接受后面的改变
    		beanFactory.freezeConfiguration();
    
    		// 实例化所有剩余的（非懒加载）单例bean
    		beanFactory.preInstantiateSingletons();
    	}

其中重点看最后一步preInstantiateSingletons方法的实现：

@Override
    	public void preInstantiateSingletons() throws BeansException {
            ......
            
    		// 迭代一个beanDefinitionNames的副本以允许init方法，这些方法又轮流注册新的bean定义。
    		// 虽然这可能不是常规工厂引导程序的一部分，但它确实可以正常工作。
    		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
    
    		// 触发所有非懒加载单例bean的初始化...
    		for (String beanName : beanNames) {
    			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
    			// 如果不是抽象的bean并且是非懒加载的单例bean，则进行
    			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
    			    // 判断是否是FactoryBean，如果是则进一步判断是否需要尽早的初始化bean，否则直接初始化bean
    				if (isFactoryBean(beanName)) {
    					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
    					if (bean instanceof FactoryBean) {
    						final FactoryBean<?> factory = (FactoryBean<?>) bean;
    						boolean isEagerInit;
    						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
    							isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
    											((SmartFactoryBean<?>) factory)::isEagerInit,
    									getAccessControlContext());
    						}
    						else {
    							isEagerInit = (factory instanceof SmartFactoryBean &&
    									((SmartFactoryBean<?>) factory).isEagerInit());
    						}
    						if (isEagerInit) {
    							getBean(beanName);
    						}
    					}
    				}
    				else {
    					getBean(beanName);
    				}
    			}
    		}
    
    		// 触发所有可用单例bean的afterSingletonsInstantiated方法回调...
    		for (String beanName : beanNames) {
    			Object singletonInstance = getSingleton(beanName);
    			if (singletonInstance instanceof SmartInitializingSingleton) {
    				final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
    				if (System.getSecurityManager() != null) {
    					AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
    						smartSingleton.afterSingletonsInstantiated();
    						return null;
    					}, getAccessControlContext());
    				}
    				else {
    					smartSingleton.afterSingletonsInstantiated();
    				}
    			}
    		}
    	}

接下来看getBean(beanName)方法的底层实现，是直接调用doGetBean方法，返回指定bean的实例，该实例可以是共享的或独立的：

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
    			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
            // 1. 返回bean名称，必要时删除工厂前缀，并将别名解析为规范名称。
    		final String beanName = transformedBeanName(name);
    		Object bean;
    
    		// 2. 急切地检查单例缓存以手动地注册单例
    		Object sharedInstance = getSingleton(beanName);
    		// 共享的单例bean实例不为空并且args为空
    		if (sharedInstance != null && args == null) {
    			if (logger.isTraceEnabled()) {
    			    // 3. 判断该当前bean是否在创建中
    				if (isSingletonCurrentlyInCreation(beanName)) {
    					logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
    							"' that is not fully initialized yet - a consequence of a circular reference");
    				}
    				else {
    					logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
    				}
    			}
    			//  4. 获取给定bean实例的对象，如果是FactoryBean，则为bean实例本身或其创建的对象。
    			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    		}
    
    		else {
    		    // 其它情况暂不做深入研究，感兴趣的读者可以自行阅读AbstractBeanFactory#doGetBean方法源码
    		    ......
            }
    		return (T) bean;
    	}

查看第二点getSingleton方法的实现：

@Nullable
    	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    		Object singletonObject = this.singletonObjects.get(beanName);
    		// 如果从singletonObjects单例bean缓存中获取key为beanName的单例bean为空并且该单例bean
    		// 当前在创建中（在整个工厂内）则从早期已实例化的单例bean缓存earlySingletonObjects中
    		// 检查beanName的单例对象，如果为空则进一步从singletonFactories单例工厂缓存中获取beanName为key
    		// 的BeanFactory，如果BeanFactory不为空则获取到其管理的单例bean实例并将其缓存
    		// 到earlySingletonObjects对象上，最后从singletonFactories缓存中移除管理该beanName
    		// 实例的BeanFactory对象（解决循环引用）
    		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
    			synchronized (this.singletonObjects) {
    				singletonObject = this.earlySingletonObjects.get(beanName);
    				if (singletonObject == null && allowEarlyReference) {
    					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
    					if (singletonFactory != null) {
    						singletonObject = singletonFactory.getObject();
    						this.earlySingletonObjects.put(beanName, singletonObject);
    						this.singletonFactories.remove(beanName);
    					}
    				}
    			}
    		}
    		return singletonObject;
    	}

几个重要对象说明：

*  singletonObjects：单例bean对象的缓存，ConcurrentHashMap->\{beanName:beanInstance\}
 *  earlySingletonObjects: 早期的单例bean对象的缓存，HashMap->\{beanName:beanInstance\}
 *  singletonFactories：单例BeanFactory的缓存，HashMap->\{beanName:beanFactory\}, beanFactory->beanInstance

回到refresh方法的第十二点，最后完成上下文的刷新操作，调用LifecycleProcessor的onRefresh方法并且发布最终的ContextRefreshedEvent事件：

protected void finishRefresh() {
    		// 清除此资源加载器中的所有资源缓存。
    		clearResourceCaches();
    
    		// 初始化此上下文的生命周期处理器DefaultLifecycleProcessor。
    		initLifecycleProcessor();
    
    		// 调用DefaultLifecycleProcessor的onRefresh方法
    		getLifecycleProcessor().onRefresh();
    
    		// 发布最终的ContextRefreshedEvent事件
    		publishEvent(new ContextRefreshedEvent(this));
    
    		// 如果激活则参与到LiveBeansView MBean中
    		LiveBeansView.registerApplicationContext(this);
    	}

子类finishRefresh方法最后启动相应的WebServer并发布事件。

@Override
    	protected void finishRefresh() {
    		super.finishRefresh();
    		WebServer webServer = startWebServer();
    		if (webServer != null) {
    			publishEvent(new ServletWebServerInitializedEvent(webServer, this));
    		}
    	}

以上就是**Spring Boot启动流程源码分析**的完整内容，如果有问题欢迎提出！

[Spring]: https://www.jianshu.com/p/dcbe8f0afbdb