《SpringBoot启动源码分析》

最新推荐文章于 2024-03-07 17:03:43 发布
最新推荐文章于 2024-03-07 17:03:43 发布
阅读量196 收藏 1
点赞数
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zousufow/article/details/111415119
版权

一、整体过程说明

1.1 启动入口方法
SpringApplication.run(LoySpringBootApplication.class,args);
1.2 总体过程说明
  • 1.获取并启动监听器
  • 2.构建容器环境
  • 3.创建容器
  • 4.实例化SpringBootExceptionReporter,用于支持报告异常的错误
  • 5.准备容器
  • 6.刷新容器
  • 7.刷新容器后的扩展接口
1.3 整体过程源码
	/**
	 *  运行一个spring应用，创建并刷新一个ApplicationContext
	 */
	public ConfigurableApplicationContext run(String... args) {
		// 时间监控
		StopWatch stopWatch = new StopWatch();
		stopWatch.start();
		ConfigurableApplicationContext context = null;
		Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
		configureHeadlessProperty();
		// 获取Spring.factories中的监听器变量，args为指定的参数数组，默认为SpringApplication

		// 1.获取并启动监听器
		SpringApplicationRunListeners listeners = getRunListeners(args);
		listeners.starting();
		try {
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(
					args);
			
			// 2.构建容器环境
			ConfigurableEnvironment environment = prepareEnvironment(listeners,
					applicationArguments);
			
			// 设置需要忽略的bean
			configureIgnoreBeanInfo(environment);
			// banner的打印控制
			Banner printedBanner = printBanner(environment);

			// 3.创建容器
			context = createApplicationContext();
			
			// 4.实例化SpringBootExceptionReporter,用于支持报告异常的错误
			exceptionReporters = getSpringFactoriesInstances(
					SpringBootExceptionReporter.class,
					new Class[] { ConfigurableApplicationContext.class }, context);
		
			// 5.准备容器
			prepareContext(context, environment, listeners, applicationArguments,
					printedBanner);
			
			// 6. 刷新容器
			refreshContext(context);
			
			// 7.刷新容器后的扩展接口
			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;
	}

二、源码分析

2.1.1 getRunListeners(args)获取并启动监听器
private SpringApplicationRunListeners getRunListeners(String[] args) {
		Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };
		return new SpringApplicationRunListeners(logger, getSpringFactoriesInstances(
				SpringApplicationRunListener.class, types, this, args));
	}

在获取监听器的方法中，getSpringFactoriesInstances(SpringApplictionRunListener.class, types, this,args)将当前对象作为参数，该方法用来获取spring.factories对应的监听器

org.springframework.boot.SpringApplicationRunListener=
\org.springframework.boot.context.event.EventPublishingRunListener

2.1.2 listeners.starting()启动监听器
// 启动监听器
listeners.starting();

// 实现方法 SpringApplicationRunListeners
public void starting() {
		for (SpringApplicationRunListener listener : this.listeners) {
			listener.starting();
		}
	}

// 最终调用方法 EventPublishingRunListener
@Override
public void starting() {
	// 这里是创建application启动事件“ApplicationStartingEvent”
	this.initialMulticaster.multicastEvent(
		new ApplicationStartingEvent(this.application, this.args));
	}

EventPublishingRunListener 这个是SpringBoot框架中最早执行的监听器，在该监听器执行started()方法时，会继续发布事件，也就是事件传递，这种实现主要还是基于Spring的事件机制。

2.2.1 prepareEnvironment(listeners,applicationArguments) 构建容器环境
private ConfigurableEnvironment prepareEnvironment(
			SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments) {

		// 获取对应的ConfigurableEnvironment
		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;
	}

Environment接口提供了4种实现方式，StandardEnvironment、StandardServletEnvironment和MockEnvironment、StandardReactiveWebEnvironment，分别代表普通程序、Web程序、测试程序的环境、响应式web环境

2.3.1 createApplicationContext() 创建容器
	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) {
			... 
		}
		return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
	}

这里创建容器的类型 还是根据webApplicationType进行判断的。

2.4.1 实例化SpringBootExceptionReporter,用于支持报告异常的错误
exceptionReporters = getSpringFactoriesInstances(
					SpringBootExceptionReporter.class,
					new Class[] { ConfigurableApplicationContext.class }, context);

这里还是以同样的方式获取 spring.factories文件中的指定类。

org.springframework.boot.SpringBootExceptionReporter=
\org.springframework.boot.diagnostics.FailureAnalyzers

该类主要是在项目启动失败之后，打印log：

private void reportFailure(Collection<SpringBootExceptionReporter> exceptionReporters,
			Throwable failure) {
		try {
			for (SpringBootExceptionReporter reporter : exceptionReporters) {
				if (reporter.reportException(failure)) {
					//上报错误log
					registerLoggedException(failure);
					return;
				}
			}
		}
		catch (Throwable ex) {
			// Continue with normal handling of the original failure
		}
		if (logger.isErrorEnabled()) {
			logger.error("Application run failed", failure);
			registerLoggedException(failure);
		}
	}
2.5.1 prepareContext() 准备容器
prepareContext(context, environment, listeners, applicationArguments,
					printedBanner);

private void prepareContext(ConfigurableApplicationContext context,
			ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments, Banner printedBanner) {
		//设置容器环境，包括各种变量
		context.setEnvironment(environment);
		
		//执行容器后置处理(分析在2.5.2)
		postProcessApplicationContext(context);
		
		//执行容器中的ApplicationContextInitializer（包括 spring.factories和自定义的实例）
		applyInitializers(context);
		
		//发送容器已经准备好的事件，通知各监听器
		listeners.contextPrepared(context);
		
		//打印log
		if (this.logStartupInfo) {
			logStartupInfo(context.getParent() == null);
			logStartupProfileInfo(context);
		}

		//注册启动参数bean，这里将容器指定的参数封装成bean，注入容器
		context.getBeanFactory().registerSingleton("springApplicationArguments",
				applicationArguments);
		//设置banner
		if (printedBanner != null) {
			context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
		}


		//获取我们的启动类指定的参数，可以是多个
		Set<Object> sources = getAllSources();
		Assert.notEmpty(sources, "Sources must not be empty");
		
		//加载我们的启动类，将启动类注入容器(分析在2.5.3)
		load(context, sources.toArray(new Object[0]));
		//发布容器已加载事件。
		listeners.contextLoaded(context);
	}
2.5.2 容器的后置处理
protected void postProcessApplicationContext(ConfigurableApplicationContext context) {
		if (this.beanNameGenerator != null) {
			context.getBeanFactory().registerSingleton(
					AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR,
					this.beanNameGenerator);
		}
		if (this.resourceLoader != null) {
			if (context instanceof GenericApplicationContext) {
				((GenericApplicationContext) context)
						.setResourceLoader(this.resourceLoader);
			}
			if (context instanceof DefaultResourceLoader) {
				((DefaultResourceLoader) context)
						.setClassLoader(this.resourceLoader.getClassLoader());
			}
		}
	}

这里默认不执行任何逻辑，因为beanNameGenerator和resourceLoader默认为空。之所以这样做，是springBoot留给我们的扩展处理方式，类似于这样的扩展，spring中也有很多

2.5.3 加载启动指定类
protected void load(ApplicationContext context, Object[] sources) {
		if (logger.isDebugEnabled()) {
			logger.debug(
					"Loading source " + StringUtils.arrayToCommaDelimitedString(sources));
		}
		BeanDefinitionLoader loader = createBeanDefinitionLoader(
				getBeanDefinitionRegistry(context), sources);
		if (this.beanNameGenerator != null) {
			loader.setBeanNameGenerator(this.beanNameGenerator);
		}
		if (this.resourceLoader != null) {
			loader.setResourceLoader(this.resourceLoader);
		}
		if (this.environment != null) {
			loader.setEnvironment(this.environment);
		}
		loader.load();
	}

// 实际调用	
private int load(Class<?> source) {
		if (isGroovyPresent()
				&& 	GroovyBeanDefinitionSource.class.isAssignableFrom(source)) {
			// Any GroovyLoaders added in beans{} DSL can contribute beans here
			GroovyBeanDefinitionSource loader = BeanUtils.instantiateClass(source,
					GroovyBeanDefinitionSource.class);
			load(loader);
		}
		if (isComponent(source)) {
			//以注解的方式，将启动类bean信息存入beanDefinitionMap
			this.annotatedReader.register(source);
			return 1;
		}
		return 0;
	}

这里参数即为我们项目启动时传递的参数：SpringApplication.run(SpringBootApplication.class, args);
由于我们指定了启动类，所以上面也就是加载启动类到容器。

2.6.1 refreshContext(context) 刷新容器
synchronized (this.startupShutdownMonitor) {
			// 刷新上下文环境
			prepareRefresh();
			
			// 初始化BeanFactory，解析XML，相当于之前的XmlBeanFactory的操
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
 
			// 为上下文准备BeanFactory，即对BeanFactory的各种功能进行填充，
			prepareBeanFactory(beanFactory);
 
			try {
				//  提供子类覆盖的额外处理，即子类处理自定义的BeanFactoryPostProcess
				postProcessBeanFactory(beanFactory);
				
			 // 激活各种BeanFactory处理器,包括BeanDefinitionRegistryBeanFactoryPostProcessor和普通的BeanFactoryPostProcessor
			// 执行对应的postProcessBeanDefinitionRegistry方法 和 postProcessBeanFactory方法
				invokeBeanFactoryPostProcessors(beanFactory);
 
				// 注册拦截Bean创建的Bean处理器，即注册BeanPostProcessor，不是BeanFactoryPostProcessor
				registerBeanPostProcessors(beanFactory);
				
				// 初始化上下文中的资源文件，如国际化文件的处理等
				initMessageSource();
 
				// 初始化上下文事件广播器，并放入applicatioEventMulticaster,如ApplicationEventPublisher
				initApplicationEventMulticaster();
 
				 // 给子类扩展初始化其他Bean
			
				onRefresh();
				
				 // 在所有bean中查找listener bean，然后注册到广播器中
				registerListeners();
 

				/**
				 * 设置转换器
				 * 注册一个默认的属性值解析器
				 * 冻结所有的bean定义，说明注册的bean定义将不能被修改或进一步的处理
				 * 初始化剩余的非惰性的bean，即初始化非延迟加载的bean
				 */
				finishBeanFactoryInitialization(beanFactory);
 
	
				 // 完成初始化，通知生命周期处理器lifeCycleProcessor刷新过程，同时发出ContextRefreshEvent通知其他人
				finishRefresh();
			}
 
			catch (BeansException ex) {
				...
			}
 
			finally {
				// 重置缓存
				resetCommonCaches();
			}
		}
2.7.1 afterRefresh 刷新容器后的扩展接口
protected void afterRefresh(ConfigurableApplicationContext context,
			ApplicationArguments args) {
	}

扩展接口，设计模式中的模板方法，默认为空实现。如果有自定义需求，可以重写该方法。比如打印一些启动结束log，或者一些其它后置处理。

Spring源码解析----SpringBoot启动流程
菜鸟一名
02-11 3607
一个简单的SB程序如下，点击main方法左边的原谅色的三角形就能把程序启动起来，虽然什么功能都没有，但是启动做了很多处理，加载了很多支持多种功能的组件(类似使用new ClassPathXmlApplicationContext()启动一个Spring程序，其中加载了很多东西) @SpringBootApplication public class SpringBootDemoApplicatio...
SpringBoot源码分析(2)--SpringBoot启动源码(万字图文源码debug讲解springboot启动原理)
weixin_49114503的博客
07-04 1205
、SpringApplication实例化及run()方法 2.1、SpringApplication实例化 2.1.1、 web应用判断 2.1.2、设置初始化器 2.1.3、设置监听器 2.1.4、判断主应用入口类 2.2、run()方法 2.2.1、获取监听器集合getRunListeners(args) 2.2.1.1、开启监听器 2.2.2、准备Spring环境 prepareEnvironment() 2.2.3、打印banner图 2.2.4、创建Spring应用上下文createApplic
spring容器启动过程
1
10-27 529
1.什么是BeanFactoryPostProcessor 叫做BeanFactory的后置处理器，和Bean的后置处理器对比理解。 BeanPostProcessor是用来对Bean进行处理的， BeanFactoryPostProcessor是用来对BeanFactory进行处理的。 2.ApplicationContext启动过程详解 下面以AnnotationConfigApplicationContext为例子，来介绍refresh的底层原理。 1. 在调用AnnotationConfig...
spring boot 启动源码分析
pointer_future的专栏
05-31 229
spring boot 启动流程 @SpringBootApplication // (1) 标明是 spring boot 应用, 开启自动配置 public class Example { public static void main(String[] args) { // (2) SpringApplication.run() xxx启动 spring boot 应用 ConfigurableApplicationContext context = Spr
Spring Boot 启动源码分析
convict_EVA的专栏
04-24 865
spring boot 项目都有个启动类，如下： @SpringBootApplication public class DemoApplication{ public static void main(String[] args) { SpringApplication.run(DemoApplication.class, args); } } 写在前面：...
SpringBoot的启动流程源码分析
qq_54421200的博客
01-21 1138
带你走进springboot源码，剖析springboot如何启动容器，三级缓存的作用
可能是全网最全的SpringBoot启动流程源码分析（基于 2.1.5 版本）
01-20
使用 Spring Boot 启动一个微服务十分简单，只需要在启动类上调用 SpringApplication 的run方法即可 点击进入run方法 1 run 静态辅助类，可用于运行使用默认配置（即我们添加的一系列注解）的指定源的 ...
springboot 启动过程源码分析
11-06
SpringBoot 启动过程源码分析 SpringBoot 的启动原理是基于 JavaConfig 形式的配置，使用 @Configuration 注解标注的启动类来配置 IoC 容器。@SpringBootApplication 注解是 SpringBoot 的核心注解，它包括了三个...
涨姿势：SpringBoot2.x启动全过程源码分析
01-27
《SpringBoot 2.x 启动全过程源码详解》 SpringBoot 2.x 的启动流程是其核心功能的重要组成部分，...SpringBoot的启动源码分析是一个挑战，但同时也是一次宝贵的学习机会，能帮助我们提升对Spring生态系统的深度认知。
SpringBoot源码分析
mutf7的博客
08-04 2157
SpringBoot源码分析 1、Spring和springboot是关系是什么？ Springboot是spring就是最核心的产品之一（是spring的分支项目），当然就包含springmvc。springmvc 只是spring 处理web层请求的一个模块。 Springboot是构建在spring基础之上的一个产品，其主要目的就是简化spring框架中繁复的配置问题，用什么方式来解决的呢？ 用注解和类完成的 无论使用spring还是springboot开发，其本质来说，springboot都是在做一
SpringBoot(二）--SpringBoot启动源码分析
m0_52675592的博客
05-17 179
文章目录入口类SpringApplication实例化设置应用类型设置初始化器（Initializer）设置监听器（Listener）调用run方法总体处理流程源码分析获取并启动监听器获取监听器启动监听器环境构建创建容器Spring容器前置处理刷新容器Spring容器后置处理发出结束执行的事件执行Runners 入口类 SpringApplication实例化 进入SpringApplication.run(HelloWorldMainApplication.class, args);方法： Sprin
springboot启动流程源码分析（一）
hongtaolong的博客
03-15 518
前言：springboot相信基本上所有的人都使用过，但是对于一些初学者可能只是知道如何使用，但是对于它实现的原理不太熟悉，今天跟大家一起去分析下它的启动源码。其实也是比较简单，相信通过这篇文章能对一些初学者有一些帮助，在学习这篇文章之前最好有spring的基础知识。 一、引入问题 今天我们是以web应用为例来分析springboot的启动原理，首先我们看如下的代码 @SpringBootAppl...
SpringBoot启动过程分析——启动过程源码分析
crazyjack1的博客
11-07 897
项目启动入口 实际执行的内容是通过SpringApplication类的静态方法创建一个ConfigurableApplicationContext，顾名思义，即可配置的对象容器，也就是Springboot中的上下文 /** * Static helper that can be used to run a {@link SpringApplication} from the * specified source using default settings. * @param primarySou
SpringBoot启动全流程源码解析
反作弊
02-10 628
SpringBoot启动过程流程图 源码解析 首先，我们先来看下SpringBoot项目的启动类 @SpringBootApplication 　　public class SpringDemoApplication { 　　　　public static void main(String[] args) { 　　　　SpringApplication.run(SpringDemoApplication.class, args); 　　　　} 　　} 一个是@SpringBootApplication，参
springboot启动源码解析-纯干货扒源码
最新发布
m0_48159647的博客
03-07 1648
springboot的启动过程是由一行SpringApplication.run开始的, 其所有的内部细节都隐藏在源码中, 今天一一为大家解开, 过程比较长, 耐心观看相信会有收获的。
springboot源码分析——启动流程分析
ZXMSH的博客
07-10 1476
本文剖析SpringBoot启动时候做了哪些事情。 2.1 、prepareRefresh：初始化前的预处理 如果规则匹配，则会进入下面的 findPathMatchingResources 方法 2.5.2、ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry 2.5.2.2、ConfigurationClassParser#parse 2.5.2.2.1、ConfigurationClassParser#proces
Spring源码分析解读
开发猫
11-13 1922
Spring源码分析解读 如何查看源码 Spring源码下载https://github.com/spring-projects/spring-framework/tags?after=v3.1.0.RC1 源代码结构组织 Build-spring-framework是整个Spring源代码的构建目录，里面是项目的构建脚本，如果要自己动手构建Spring，可以进入这个目录使用ANT进...
SpringBoot源码系列（一）——启动过程分析
scorpio的博客
11-08 461
SpringBoot源码系列（一）——启动过程分析
spring 启动过程源码分析
u012655662的博客
03-25 872
本章所有源码解析基于spring-framework-5.3.10版本进行分析 在下面这行代码就完成了spring容器的初始化，后续将基于这行代码进行spring启动源码分析AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class); 1、AnnotationConfigApplicationContext的类定义及类结构图 public cl
2021springboot启动流程源码分析
09-06
1. 加载启动类：Spring Boot应用程序的启动类通常是一个带有`@SpringBootApplication`注解的Java类。在应用程序启动时，会通过`main`方法加载这个启动类。 2. 创建Spring Application对象：Spring Boot会创建一个`...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值