springboot完整启动流程源码（一）

已于 2022-11-06 17:02:23 修改
阅读量367 收藏
点赞数
分类专栏： Spring源码 文章标签： spring boot spring java
于 2022-11-05 19:35:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38965431/article/details/127674995
版权

spring启动流程首先从SpringApplication.run(StartWorkApplication.class, args);这一行代码进入。run方法进入首先会创建SpringApplication的对象，调用构造方法。如下：

	public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
		this.resourceLoader = resourceLoader;
		Assert.notNull(primarySources, "PrimarySources must not be null");
		this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
		this.webApplicationType = WebApplicationType.deduceFromClasspath();
		this.bootstrapRegistryInitializers = getBootstrapRegistryInitializersFromSpringFactories();
		//创建类型为ApplicationContextInitializer的对象
		setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
		//创建类型为ApplicationListener的对象
		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
		this.mainApplicationClass = deduceMainApplicationClass();
	}

上面的getSpringFactoriesInstances方法最终会调用loadSpringFactories。
这个方法会读取每一个jar下面的META-INF/spring.factories文件，得到所有的配置类，并返回一个map。接下来获取指定类型的bean创建对象加载到内存。

	private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
		Map<String, List<String>> result = cache.get(classLoader);
		if (result != null) {
			return result;
		}

		result = new HashMap<>();
		try {
		//从META-INF/spring.factories读取配置类
			Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
			while (urls.hasMoreElements()) {
				URL url = urls.nextElement();
				UrlResource resource = new UrlResource(url);
				Properties properties = PropertiesLoaderUtils.loadProperties(resource);
				for (Map.Entry<?, ?> entry : properties.entrySet()) {
					String factoryTypeName = ((String) entry.getKey()).trim();
					String[] factoryImplementationNames =
							StringUtils.commaDelimitedListToStringArray((String) entry.getValue());
					for (String factoryImplementationName : factoryImplementationNames) {
						result.computeIfAbsent(factoryTypeName, key -> new ArrayList<>())
								.add(factoryImplementationName.trim());
					}
				}
			}

			// Replace all lists with unmodifiable lists containing unique elements
			result.replaceAll((factoryType, implementations) -> implementations.stream().distinct()
					.collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList)));
			cache.put(classLoader, result);
		}
		catch (IOException ex) {
			throw new IllegalArgumentException("Unable to load factories from location [" +
					FACTORIES_RESOURCE_LOCATION + "]", ex);
		}
		return result;
	}

创建完SpringApplication对象后就会调用他的run方法。其中主要的方法是prepareContext和refreshContext。如下：

	public ConfigurableApplicationContext run(String... args) {
		StopWatch stopWatch = new StopWatch();
		stopWatch.start();
		DefaultBootstrapContext bootstrapContext = createBootstrapContext();
		ConfigurableApplicationContext context = null;
		configureHeadlessProperty();
		SpringApplicationRunListeners listeners = getRunListeners(args);
		listeners.starting(bootstrapContext, this.mainApplicationClass);
		try {
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
			ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
			configureIgnoreBeanInfo(environment);
			Banner printedBanner = printBanner(environment);
			context = createApplicationContext();
			context.setApplicationStartup(this.applicationStartup);
			prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
			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, listeners);
			throw new IllegalStateException(ex);
		}

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

（一）prepareContext方法
prepareContext方法主要做一些预处理的工作，环境信息配置以及预处理一些后置处理器和springApplication启动类。调用链如下:
prepareContext*>>BeanDefinitionLoader#load>>AnnotatedBeanDefinitionReader#register>>GenericApplicationContext#registerBeanDefinition>>*DefaultListableBeanFactory#registerBeanDefinition。可以看到最终调用DefaultListableBeanFactory的registerBeanDefinition方法。这个方法会将项目启动类springApplication的beanDefinition缓存到beanDefinitionMap。
在这里插入图片描述
（二）refreshContext方法
refreshContext调用AbstractApplicationContext#refresh方法。里面的主要逻辑如下：

				// Allows post-processing of the bean factory in context subclasses.		
				//beanFactory扩展点
				postProcessBeanFactory(beanFactory);

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

				// Register bean processors that intercept bean creation.
				//2)注册BeanPostProcessors
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
				//初始化消息  。。。暂时忽略
				initMessageSource();

				// Initialize event multicaster for this context.
				//3)初始化multicaster
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				onRefresh();

				// Check for listener beans and register them.
				//4)注册listener 
				registerListeners();
				
				// Instantiate all remaining (non-lazy-init) singletons.
				//5)预先创建非懒加载的单例bean
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				//6)执行LifecycleProcessor的onRefresh方法以及发布ContextRefreshedEvent事件
				finishRefresh();

1）invokeBeanFactoryPostProcessors
invokeBeanFactoryPostProcessors主要是执行BeanFactory的后置处理器。先执行实现了BeanDefinitionRegistryPostProcessor接口的Processor，再执行实现BeanFactoryPostProcessor接口的Processor，实现PriorityOrdered接口的Processor优先于实现Ordered执行。其中ConfigurationClassPostProcessor这个后置处理器实现了BeanDefinitionRegistryPostProcessor和PriorityOrdered接口，会被第一个执行。 ConfigurationClassPostProcessor会处理@ComponentScan，@Import等注解。关于这个类具体的解析逻辑在这篇文章[springboot BeanFactoryPostProcesser之ConfigurationClassPostProcessor]。(https://blog.csdn.net/weixin_38965431/article/details/123595745)

2）registerBeanPostProcessors
registerBeanPostProcessors作用是注册Bean的后置处理器。主要逻辑如下：先注册实现了PriorityOrdered接口的PostProcessor,再注册实现了Ordered接口的BeanPostProcessor,最后再注册剩余的BeanPostProcessor。他的注册逻辑是通过AbstractBeanFactory#doGetBean获取到BeanPostProcessor实例然后缓存到beanPostProcessors集合中。doGetBean创建bean对象的逻辑放到后续篇章。

	public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
			//获取BeanPostProcessor类型的beanName
		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

		//根据优先级不同对这些BeanPostProcessor做不同的划分
		List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
		List<String> orderedPostProcessorNames = new ArrayList<>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		for (String ppName : postProcessorNames) {
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
			   //创建bean实例，注入到IOC容器
				BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
				priorityOrderedPostProcessors.add(pp);
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					internalPostProcessors.add(pp);
				}
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// First, register the BeanPostProcessors that implement PriorityOrdered.
		//排序  按照PriorityOrdered值从小到大的顺序
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		//优先注册实现了PriorityOrdered接口的BeanPostProcessor
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		// Next, register the BeanPostProcessors that implement Ordered.
		//再注册实现了Ordered接口的BeanPostProcessor
		List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
		for (String ppName : orderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			orderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, orderedPostProcessors);
	}

3）initApplicationEventMulticaster
initApplicationEventMulticaster方法主要是注册了一个事件监听广播器SimpleApplicationEventMulticaster。
4）registerListeners
registerListeners的作用是注册事件监听器
5）finishBeanFactoryInitialization
finishBeanFactoryInitialization的作用是提前创建非懒加载的单例Bean。他调用了DefaultListableBeanFactory#preInstantiateSingletons这个方法，内部通过doGetBean创建Bean注入Ioc容器。具体实现如下：

	public void preInstantiateSingletons() throws BeansException {
		if (logger.isTraceEnabled()) {
			logger.trace("Pre-instantiating singletons in " + this);
		}

		// Iterate over a copy to allow for init methods which in turn register new bean definitions.
		// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

		// Trigger initialization of all non-lazy singleton beans...
		//加载所有非懒加载的单例bean
		for (String beanName : beanNames) {
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			//非抽象的非懒加载的单例bean
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				//处理factorybean
				if (isFactoryBean(beanName)) {
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof FactoryBean) {
						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 {
					//处理非factorybean
					getBean(beanName);
				}
			}
		}

		// Trigger post-initialization callback for all applicable beans...
		//如果bean实现了SmartInitializingSingleton，调用afterSingletonsInstantiated进行初始化
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
						.tag("beanName", beanName);
				SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
						smartSingleton.afterSingletonsInstantiated();
						return null;
					}, getAccessControlContext());
				}
				else {
					smartSingleton.afterSingletonsInstantiated();
				}
				smartInitialize.end();
			}
		}
	}

6）finishRefresh
finishRefresh主要作用是执行LifecycleProcessor的onRefresh方法以及发布ContextRefreshedEvent事件。发布事件监听器的逻辑也放在后续篇章。

总结：spring启动流程其实主要是refreshContext方法里面的1,2,5步。第一步主要是执行BeanFactoryPostProcessors其中就包括解析各种注解类然后生成BeanDefination描述性信息缓存到BeanDefinationMap。第二步是优先创建各种BeanPostProcessor后置处理器，注册到spring容器，然后在后续创建bean时候会执行这些后置处理器。第五步主要是创建非懒加载的单例bean，根据BeanDefinationMap里面的信息，通过doGetBean创建。

丁金阳
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot应用启动流程源码解析
08-19
主要介绍了SpringBoot应用启动流程源码解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
springboot 启动过程源码分析
11-06
SpringBoot 启动过程源码分析 SpringBoot 的启动原理是基于 JavaConfig 形式的配置，使用 @Configuration 注解标注的启动类来配置 IoC 容器。@SpringBootApplication 注解是 SpringBoot 的核心注解，它包括了三个...
SpringBoot启动源码介绍
my java博客园
05-27 1743
一: SpringApplication构造方法 1.首先SpringBoot项目启动类来看 @SpringBootApplication public class DemoApplication { public static void main(String[] args) { //从SpringApplication.run方法中获取取到Applicati...
头秃了，二十三张图带你从源码了解SpringBoot启动流程！
最新发布
2401_85376163的博客
07-17 609
的构建都是为了run()方法启动做铺垫，构造方法中总共就有几行代码，最重要的部分就是设置应用类型、设置初始化器、设置监听器。「注意」：初始化器和这里的监听器都要放置在文件中才能在这一步骤加载，否则不会生效，因此此时IOC容器还未创建，即使将其注入到IOC容器中也是不会生效的。这一步其实就是广播了事件来触发监听这个事件的。因此如果自定义了并且监听了（应用程序开始启动）事件，则这个监听器将会被触发。各位读者，由于本篇幅度过长，为了避免影响阅读体验，下面我就大概概括了整理了。
Spring boot 启动源码
u011627218的专栏
05-20 755
pom文件只要依赖spring-boot-start-tomacat会将Tomcat类引入到项目中，满足EmbeddedTomcat条件装配条件，向容器注入TomcatServletWebServerFactory，springboot容器启动getWebServerFactory会获取TomcatServletWebServerFactory创建Tomcat web容器。分析EmbeddedTomcat，条件装配存在Tomcat类装配TomcatServletWebServerFactory。
SpringBoot的启动流程（源码详解）
qq_50790981的博客
08-09 2567
平时开发springboot项目的时候，一个SpringBootApplication注解加一个main方法就可以启动服务器运行起来（默认tomcat），本文根据源码介绍了springboot启动的主要流程
【源码系列】SpringBoot启动过程原理源码
苏雨丶
03-31 1618
文章目录SpringBoot启动过程原理源码1.Spring的SPI2.SpringApplication实例化3.run方法执行流程1. 获取事件发布器2. 创建环境对象3. 创建上下文对象4.上下文刷新前5.上下文刷新自动装配具体实现Tomcat启动6.上下文刷新后7. 应用生命周期函数 SpringBoot启动过程原理源码 1.Spring的SPI 文章中会多次提到SPI这个东西，我们简单的介绍一下，SPI全称为Service Provider Interface 这个东西你可以理解为 它就是一个
可能是全网最全的SpringBoot启动流程源码分析（基于 2.1.5 版本）
01-20
使用 Spring Boot 启动一个微服务十分简单，只需要在启动类上调用 SpringApplication 的run方法即可 点击进入run方法 1 run 静态辅助类，可用于运行使用默认配置（即我们添加的一系列注解）的指定源的 ...
涨姿势：SpringBoot2.x启动全过程源码分析
01-27
《SpringBoot 2.x 启动全过程源码详解》 SpringBoot 2.x 的启动流程是其核心功能的重要组成部分，理解这一过程对于开发者深入掌握框架的运作机制具有重要意义。接下来，我们将逐步剖析SpringApplication对象的run...
03-SpringBoot启动过程源码解析-周瑜.pdf
10-24
"SpringBoot启动过程源码解析" SpringBoot启动过程可以分为多个阶段，包括构造SpringApplication对象、推测Web应用类型、获取BootstrapRegistryInitializer对象、获取ApplicationContextInitializer对象、获取...
SpringBoot启动流程及源码
GiantCrocodile的博客
05-15 359
SpringBoot的启动流程可以分为几大部分： 1.创建SpringApplication，加载监听器 2.启动监听器 3.创建创建环境 4.创建容器 5.将环境放入容器中 6.refresh容器 7.启动所有监听器 第一部分： 创建SpringApplication 构建好SpringApplication执行run（） 这里是启动的伪代码 public ConfigurableApplicationContext run(String... args) { //记录开.
springboot启动类
10-29
package com; import java.util.Properties; import com.github.pagehelper.PageHelper; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.cloud.client.loadbalancer.LoadBalanced; import org.springframework.context.annotation.Bean; import org.springframework.web.client.RestTemplate; @SpringBootApplication public class OfficeServiceApplication { public static void main(String[] args) { SpringApplication.run(OfficeServiceApplication.class, args); } @Bean @LoadBalanced public RestTemplate getRestTemplate(){ return new RestTemplate(); } //配置mybatis的分页插件pageHelper @Bean public PageHelper pageHelper(){ PageHelper pageHelper = new PageHelper(); Properties properties = new Properties(); properties.setProperty("offsetAsPageNum","true"); properties.setProperty("rowBoundsWithCount","true"); properties.setProperty("reasonable","true"); properties.setProperty("dialect","mysql"); //配置mysql数据库的方言 pageHelper.setProperties(properties); return pageHelper; } }
springboot启动流程源码解析（带流程图）
zkr1234562的博客
11-26 4300
springboot启动流程源码解析（带流程图）
SpringBoot启动执行代码
qq_39951620的博客
09-18 145
SpringBoot启动执行代码 废话少说上代码 @Component @Slf4j public class LimsCommandLineRunner implements CommandLineRunner { @Override public void run(String... args) throws Exception { printInfo(); //openBrowser(); } private void openBrow
SpringBoot启动流程源码分析
SpringBoot应用最佳实践
05-29 796
大部分时候，SpringBoot应用主要通过在引导类调用SpringApplication的静态run方法启动，同时将引导类注册为配置源。比如下面是一个SpringMVC的Web应用，引导类是WebMVCBootstrap，和命令行参数args作为SpringApplication静态run方法的参数，用于构建SpringApplication对象和运行SpringBoot应用。 // 引导类添加@SpringBootApplication注解作为配置源，同时开启自动装配、缺省包路径扫描 @Spring
SpringBoot项目启动过程源码终于整体捋了一遍（六）
白白胖胖充满希望
04-02 621
截止上篇，关于SpingBoot的启动流程终于看完了如何初始化SpringApplication，内容还是挺多的足足写了5篇。并且过程中遗留了一个问题，即初始化SpringApplication的时候设置初始化器setInitializers()和设置监听器setListeners()在启动流程中起着什么作用。 带着遗留问题这篇开始看初始化完SpringApplication之后的run方法，先...
Springboot启动过程的源码
浪迹byb的博客
10-15 218
可能理解有误的可以指出来，仅仅只是源码查看分析，谢谢大家。 原理图：原理图是复制了其他人但是具体是哪个博主的忘记了。 1.SpringApplication 允许run之前的初始化三个步骤。 (1).通过org.springframework.web.context.ConfigurableWebApplicationContext既定的特征类判断applicationType是...
spring boot 启动源码分析
pointer_future的专栏
05-31 207
spring boot 启动流程 @SpringBootApplication // (1) 标明是 spring boot 应用, 开启自动配置 public class Example { public static void main(String[] args) { // (2) SpringApplication.run() xxx启动 spring boot 应用 ConfigurableApplicationContext context = Spr
SpringBoot练手博客项目，含完整项目代码
JAVA葵花宝典
09-09 1638
正文Spring Boot开发个人博客项目实战课程视频教程下载。本套课程主要讲解利用Java Spring Boot框架搭建个人博客，含完整项目代码。可进行二次开发，打造一个属于自己的博...
springboot2启动流程源码分析
09-21
SpringBoot2的启动流程是通过@SpringBootApplication注解自动化配置来实现的。该注解包含了多个注解的组合，其中包括@ComponentScan、@EnableAutoConfiguration和@Configuration等。通过这些注解，Spring Boot会自动扫描并加载配置类，并根据自动配置规则来配置应用程序。 具体而言，当应用程序启动时，Spring Boot会创建一个Spring应用程序上下文。在创建上下文的过程中，会先加载主配置类（通常是包含main方法的类），然后根据@ComponentScan注解扫描指定包下的所有组件。 接下来，Spring Boot会根据@EnableAutoConfiguration注解自动配置应用程序。这个注解会根据classpath和条件匹配的规则，加载配置类，并将它们注册到应用程序上下文中。这些配置类使用了@Configuration注解，会声明一些Bean，并根据条件来决定是否生效。 最后，Spring Boot会启动应用程序，并执行相应的事件处理器。这些事件处理器可以通过自定义ApplicationListener来实现。在应用程序运行期间，Spring Boot会触发不同的事件，并调用相应的事件处理器。 参考文献： 引用:SpringBoot2 | @SpringBootApplication注解 自动化配置流程源码分析（三） [2] 引用:SpringBoot2 | SpringBoot监听器源码分析 | 自定义ApplicationListener（六） 引用:该系列主要还是Spring的核心源码，不过目前Springboot大行其道，所以就从Springboot开始分析。最新版本是Springboot2.0.4，Spring5，所以新特性本系列后面也会着重分析。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值