springboot启动原理

最新推荐文章于 2024-08-29 19:26:14 发布
最新推荐文章于 2024-08-29 19:26:14 发布
阅读量62 收藏
点赞数
文章标签： spring boot java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chunbing_dkw/article/details/129865785
版权
本文详细分析了SpringBoot应用的启动过程，从@SpringBootApplication注解的处理，到SpringApplication.run()方法的执行，包括构造方法和run方法内部的关键步骤。着重讨论了spring.factories中EnableAutoConfiguration的读取、配置类转换为BeanDefinition以及何时创建Bean到单例池的过程。
摘要由CSDN通过智能技术生成

不属于源码阅读，属于debug源码，看启动流程

1 @SpringBootApplication

  • 表明是一个注解类
  • 指定扫描路径
  • 导入两个类
    • AutoConfigurationPackages.Registrar.class
      • registry.registerBeanDefinition(BEAN, new BasePackagesBeanDefinition(packageNames));
    • AutoConfigurationImportSelector.class
      • return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());

先简单说明导入的两个类，一个是创建 BasePackagesBeanDefinition（默认传入启动类的包名，可以在使用@SpringBootApplication的时候指定），并放到beanDefinitionMap（ioc存储beandefinition的）

// 还差个东西

2 org.springframework.boot.SpringApplication#run(java.lang.Class<?>, java.lang.String…)

run方法下去之后到这(分成两个文明东西，一个是构造方法，一个是run方法)：

public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
	return new SpringApplication(primarySources).run(args);
}

2.1 org.springframework.boot.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));
	
	// 根据导入的包判断是哪一种中间键（REACTIVE，SERVLET或NONE）
	this.webApplicationType = WebApplicationType.deduceFromClasspath();
	
	// 解析spring.factories，取出BootstrapRegistryInitializer，ApplicationContextInitializer和ApplicationListener的实现类，并创建对象
	this.bootstrapRegistryInitializers = new ArrayList<>(
			getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
	setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
	setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
	
	// 保存启动类（含有方法 main）
	this.mainApplicationClass = deduceMainApplicationClass();
}

2.2 org.springframework.boot.SpringApplication#run(java.lang.String…)

public ConfigurableApplicationContext run(String... args) {
	long startTime = System.nanoTime();
	DefaultBootstrapContext bootstrapContext = createBootstrapContext();
	ConfigurableApplicationContext context = null;
	/*
	 外接设备配置
System.setProperty(
	SYSTEM_PROPERTY_JAVA_AWT_HEADLESS,							 
	System.getProperty(
		SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, 	
		Boolean.toString(this.headless)));
		getProperty传两个参数，如果没有就用后面的默认值
	 */
	configureHeadlessProperty();

	// 获取listeners
	SpringApplicationRunListeners listeners = getRunListeners(args);
	
	// 执行所有listener的start方法
	listeners.starting(bootstrapContext, this.mainApplicationClass);
	try {
		// 组装args
		ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);

		// 所有系统参数，配置文件参数，命令行参数等都在这里
		ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);

		// 设置 System.setProperty(CachedIntrospectionResults.IGNORE_BEANINFO_PROPERTY_NAME, ignore.toString())
		configureIgnoreBeanInfo(environment);
		Banner printedBanner = printBanner(environment);

		// 创建spring容器:AnnotationConfigServletWebServerApplicationContext
		context = createApplicationContext();
		// 感觉就是打日志的		
context.setApplicationStartup(this.applicationStartup);
		// 设置环境，ConversionService，ApplicationContextInitializer#initialize
		// SpringApplicationRunListener#contextPrepared
		// org.springframework.boot.DefaultBootstrapContext#close 回调close
		// 日志打印激活的环境
		// beanFactory.registerSingleton("springApplicationArguments", applicationArguments);// 启动参数的包装
		// beanFactory.registerSingleton("springBootBanner", printedBanner);启动项目打印的spring
		// 阻止循环引用 ((AbstractAutowireCapableBeanFactory) beanFactory).setAllowCircularReferences(this.allowCircularReferences)
		// 是否允许同名beandefinitiong覆盖
		// context.addBeanFactoryPostProcessor(new PropertySourceOrderingBeanFactoryPostProcessor(context));
		// 配置类/启动类装配成beandefintion 放到容器中
		// SpringApplicationRunListener#contextLoaded
		prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
		// ioc容器启动
		refreshContext(context);
		// 空实现
		afterRefresh(context, applicationArguments);
		Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
		if (this.logStartupInfo) {
			new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
		}
		// ConfigurableApplicationContext, java.time.Duration)
		listeners.started(context, timeTakenToStartup);
		// ApplicationRunner和CommandLineRunner的run()
		callRunners(context, applicationArguments);
	}
	catch (Throwable ex) {
		handleRunFailure(context, ex, listeners);
		throw new IllegalStateException(ex);
	}
	try {
		Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
		// SpringApplicationRunListener#ready
		listeners.ready(context, timeTakenToReady);
	}
	catch (Throwable ex) {
		handleRunFailure(context, ex, null);
		throw new IllegalStateException(ex);
	}
	return context;
}

3 相关重点说明

一句话叫做抛开世事不谈，你就没有错吗，
我这抛开所有扩展功能（监听等）和spring，基础功能（import注解的解析等），只关注：

  1. spring.factories中的org.springframework.boot.autoconfigure.EnableAutoConfiguration什么时候读
  2. 什么时候创建这个beandefinition
  3. 什么时候创建这个bean到单例池

3.1 读取spring.factories中的org.springframework.boot.autoconfigure.EnableAutoConfiguration什么时候读

refresh:564, AbstractApplicationContext (org.springframework.context.support)
invokeBeanFactoryPostProcessors:748, AbstractApplicationContext (org.springframework.context.support)
invokeBeanFactoryPostProcessors:112, PostProcessorRegistrationDelegate (org.springframework.context.support)
invokeBeanDefinitionRegistryPostProcessors:311, PostProcessorRegistrationDelegate (org.springframework.context.support)
postProcessBeanDefinitionRegistry:247, ConfigurationClassPostProcessor (org.springframework.context.annotation)

/******************* 以上是ioc容器执行  BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry  ConfigurationClassPostProcessor是我们实现需要功能的实现类  *******************/

// 然后是找到 我们在启动类上import的 AutoConfigurationImportSelector.class，执行 process
processConfigBeanDefinitions:331, ConfigurationClassPostProcessor (org.springframework.context.annotation)
parse:192, ConfigurationClassParser (org.springframework.context.annotation)
process:780, ConfigurationClassParser$DeferredImportSelectorHandler (org.springframework.context.annotation)
processGroupImports:809, ConfigurationClassParser$DeferredImportSelectorGroupingHandler (org.springframework.context.annotation)
getImports:879, ConfigurationClassParser$DeferredImportSelectorGrouping (org.springframework.context.annotation)
process:441, AutoConfigurationImportSelector$AutoConfigurationGroup (org.springframework.boot.autoconfigure)
getAutoConfigurationEntry:125, AutoConfigurationImportSelector (org.springframework.boot.autoconfigure)

3.1.1 重要代码块

// 那多配置文件中的所有 EnableAutoConfiguration 配置
// org.springframework.boot.autoconfigure.AutoConfigurationImportSelector#getCandidateConfigurations
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
	List<String> configurations = new ArrayList<>(
			SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader()));
	ImportCandidates.load(AutoConfiguration.class, getBeanClassLoader()).forEach(configurations::add);
	Assert.notEmpty(configurations,
			"No auto configuration classes found in META-INF/spring.factories nor in META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports. If you "
					+ "are using a custom packaging, make sure that file is correct.");
	return configurations;
}

// 上面的方法是这个方法的 List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
// 拿到返回值，下面还有操作
protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
	if (!isEnabled(annotationMetadata)) {
		return EMPTY_ENTRY;
	}
	AnnotationAttributes attributes = getAttributes(annotationMetadata);
	List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
	configurations = removeDuplicates(configurations);
	Set<String> exclusions = getExclusions(annotationMetadata, attributes);
	checkExcludedClasses(configurations, exclusions);
	configurations.removeAll(exclusions);
	/*
	根据@Conditiong注解等，筛选
	*/
	configurations = getConfigurationClassFilter().filter(configurations);
	// 找到对应的listen，执行
	fireAutoConfigurationImportEvents(configurations, exclusions);

	// 组装成 new AutoConfigurationEntry(configurations, exclusions)，并保存到 autoConfigurationEntries中
	return new AutoConfigurationEntry(configurations, exclusions);
}

3.2 将配置的类组装成beandefinition

// 没看懂，周末看吧
refresh:564, AbstractApplicationContext (org.springframework.context.support)
invokeBeanFactoryPostProcessors:748, AbstractApplicationContext (org.springframework.context.support)
invokeBeanFactoryPostProcessors:112, PostProcessorRegistrationDelegate (org.springframework.context.support)
invokeBeanDefinitionRegistryPostProcessors:311, PostProcessorRegistrationDelegate (org.springframework.context.support)
postProcessBeanDefinitionRegistry:247, ConfigurationClassPostProcessor (org.springframework.context.annotation)
processConfigBeanDefinitions:343, ConfigurationClassPostProcessor (org.springframework.context.annotation)

/******** 之前的功能是在读取spring.factories 中的内容，并解析 @Bean会接写成 beanMethod *****/
// 举例
/*
// 配置在 spring.factories 中的
@Configuration
@EnableConfigurationProperties({CsiiProperty.class})
public class CsiiConfig {

    @Bean
    @ConditionalOnMissingBean({CsiiService.class})
    public CsiiService csiiService() {
        return new CsiiService();
    }
}



*/
loadBeanDefinitions:129, ConfigurationClassBeanDefinitionReader (org.springframework.context.annotation)
loadBeanDefinitionsForConfigurationClass:153, ConfigurationClassBeanDefinitionReader (org.springframework.context.annotation)
loadBeanDefinitionsForBeanMethod:238, ConfigurationClassBeanDefinitionReader (org.springframework.context.annotation)

3.3 什么时候创建这个bean到单例池

/*

UserController中依赖UserService
UserService 是在 配置文件 UserConfig 中通过@Bean注解 惊醒控制反转的
UserConfig是配置在spring.factories中的，代码结构


/******需要自己写的代码开始****************/
@Controller
public UserController {
    @Resource
    private UserService userService;
}
/******需要自己写的代码结束***************/



/******引入starter包开始***************/
public class UserService {}

@Configuration
public class UserConfig {
    @Bean
    public UserService userService(){
        return new UserService();
    }
}

// spring.factories文件
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
包名.UserConfig

/******引入starter包结束***************/


*/

简单描述：
1.创建Usercontroller的时候，由于依赖注入要创建UserService
2.UserService是由@Bean交给spring的，在解析这个注解的时候，
3.就会将配置类的name放到UserService的beandefinition中的 factoryBeanName 字段中，现在取出这个字段，到spring容器中取这个配置bean（创建）



1.创建Usercontroller的时候，由于依赖注入要创建UserService
refresh:583, AbstractApplicationContext (org.springframework.context.support)
finishBeanFactoryInitialization:920, AbstractApplicationContext (org.springframework.context.support)
preInstantiateSingletons:955, DefaultListableBeanFactory (org.springframework.beans.factory.support)
getBean:208, AbstractBeanFactory (org.springframework.beans.factory.support)
doGetBean:333, AbstractBeanFactory (org.springframework.beans.factory.support)
getSingleton:234, DefaultSingletonBeanRegistry (org.springframework.beans.factory.support)
getObject:-1, 1677568775 (org.springframework.beans.factory.support.AbstractBeanFactory$$Lambda$209)
lambda$doGetBean$0:335, AbstractBeanFactory (org.springframework.beans.factory.support)
createBean:542, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
doCreateBean:619, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
populateBean:1431, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)

2.UserService是由@Bean交给spring的，在解析这个注解的时候，
postProcessProperties:329, CommonAnnotationBeanPostProcessor (org.springframework.context.annotation)
inject:119, InjectionMetadata (org.springframework.beans.factory.annotation)
inject:228, InjectionMetadata$InjectedElement (org.springframework.beans.factory.annotation)
getResourceToInject:673, CommonAnnotationBeanPostProcessor$ResourceElement (org.springframework.context.annotation)
getResource:520, CommonAnnotationBeanPostProcessor (org.springframework.context.annotation)
autowireResource:550, CommonAnnotationBeanPostProcessor (org.springframework.context.annotation)
resolveBeanByName:479, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
getBean:213, AbstractBeanFactory (org.springframework.beans.factory.support)
doGetBean:333, AbstractBeanFactory (org.springframework.beans.factory.support)
getSingleton:234, DefaultSingletonBeanRegistry (org.springframework.beans.factory.support)
getObject:-1, 1677568775 (org.springframework.beans.factory.support.AbstractBeanFactory$$Lambda$209)
lambda$doGetBean$0:335, AbstractBeanFactory (org.springframework.beans.factory.support)
createBean:542, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
doCreateBean:582, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
createBeanInstance:1195, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
instantiateUsingFactoryMethod:1352, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)

3.就会将配置类的name放到UserService的beandefinition中的 factoryBeanName 字段中，现在取出这个字段，到spring容器中取这个配置bean
instantiateUsingFactoryMethod:410, ConstructorResolver (org.springframework.beans.factory.support)
getBean:208, AbstractBeanFactory (org.springframework.beans.factory.support)
dingkw1115
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringBoot 启动原理
Laorens927的博客
05-20 187
spring boot启动原理 一、启动原理 1.主配置类入口 2.进入run方法 3.创建SpringApplication对象 二、运行流程 前言 关于SpringBoot自动装配的概念： 1）SpringBoot启动会加载大量的自动配置类 2）xxxAutoConfiguration：自动配置类 3）自动配置类中会配置相应的组件，这些组件不需要我 们手动配置 4）在给容器自动配置类添加组件的时候，会从配置文件，例如 .yml .yaml .properties中加载属性值 一、启
SpringBoot启动原理
hahazz233的博客
06-13 711
背景1> 大家都知道SpringBoot是通过main函数启动的，这里面跟踪代码到处都没有找到while(true)，为什么启动后可以一直跑？2> SpringBoot默认使用tomcat作为web容器。大家也可以通过在pom文件中exclusion掉tomcat，denpendency jetty 的方法来使用jetty。那SpringBoot是怎么做到在不同web容器之间切换的呢？2> 传统的web容器比如jetty本质上是直接通过java start.jar 来启动，之后来加载spring上下文的，S
SpringBoot启动原理详解
Aran
07-24 630
虽然Java程序员大部分工作都是CRUD，但是工作中常用的中间件必须和Spring集成，如果不知道Spring的原理，很难理解这些中间件和框架的原理。小菜带你领悟深层原理~
【Java面试题】SpringBoot启动原理
一宿君
10-10 8347
SpringBoot启动原理1、什么是SpringBoot2、SpringBoot启动原理3、三个关键注解解析3.1、@SpringBootConfiguration注解解析 1、什么是SpringBoot Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域（Rapid Application
通过代码实例了解SpringBoot启动原理
08-25
了解SpringBoot启动原理 通过代码实例了解SpringBoot启动原理是了解SpringBoot框架的基础知识。SpringBoot框架的启动过程是通过@SpringBootApplication注解来实现的，该注解是@SpringBootConfiguration、@...
Springboot启动原理详细解析
LoVin'i7
04-02 2792
我们开发任何一个Spring Boot项目，都会用到如下的启动类 1 @SpringBootApplication 2 public class Application { 3 public static void main(String[] args) { 4 SpringApplication.run(Application.class, args); 5 } 6 } 从上面代码可以看出，Annotation定义（@SpringBootApplication）和类定义（
Java面试官面试100问之：SpringBoot 启动原理吗？超详细解答
m0_67402341的博客
08-01 520
点击这里领取!!!暗号CSDN先自我介绍一下，小编13年上师交大毕业，曾经在小公司待过，去过华为OPPO等大厂，18年进入阿里，直到现在。深知大多数初中级java工程师，想要升技能，往往是需要自己摸索成长或是报班学习，但对于培训机构动则近万元的学费，着实压力不小。自己不成体系的自学效率很低又漫长，而且容易碰到天花板技术停止不前。因此我收集了一份《java开发全套学习资料》送给大家，初衷也很简单，就是希望帮助到想自学又不知道该从何学起的朋友，同时减轻大家的负担。添加下方名片，即可获取全套学习资料哦。...
springboot启动原理及相关流程概览
02-20
springboot启动类启动的简要过程
Spring Boot DevTools：简化开发，实现热部署
✨ 欢迎来到【Seal ^_^ 的CSDN博客】！这里是我记录技术心得、分享经验的地方。✨
08-25 5382
Spring Boot DevTools是开发者的得力助手，它通过自动化检测和重启应用来加载最新的代码更改，让开发者从繁琐的手动重启中解脱出来。
【技术解析】Spring Boot异步机制：实现高吞吐量的最佳实践
欢迎来到我的技术空间！我是一名经验丰富的Java开发工程师，热衷于分享我在软件开发领域的知识和心得。在这个博客里，您会发现一系列关于Java编程的文章，包括最佳实践、技术趋势、代码优化技巧以及一些有趣的项目案例。无论是初学者还是有经验的开发者，都能在这里找
08-26 911
本文深入探讨了如何在Spring Boot中利用异步机制提升系统吞吐量，从异步处理的基本概念出发，逐步介绍了Spring Boot提供的多种异步解决方案，包括@Async、Callable、WebAsyncTask和DeferredResult的使用方法。通过实例演示和最佳实践分享，帮助读者理解和应用异步处理技术，从而构建更加高效和响应迅速的应用程序。
Spring Boot 多数据源配置
dream_snow2012的专栏
08-22 995
通过以上配置，您可以在 Spring Boot 项目中成功实现多数据源的管理，分离不同的数据库操作。这样可以轻松处理不同数据源之间的事务以及数据交互，确保应用的高效性和可扩展性。
Spring Boot 日志按天写入配置指南
exlink2012的专栏
08-26 602
要将 Spring Boot 的输出信息按天写入日志文件，你可以使用Logback作为日志框架，结合来实现按天滚动日志文件。
初学者指南：Spring Boot入门
apple_64847327的博客
08-26 281
在当今快速发展的软件开发领域，Spring Boot已经成为了构建现代Java应用程序的首选框架之一。它以其简洁、易用和强大的特性，帮助开发者快速搭建起基于Spring的应用程序。如果你是Java开发新手，或者正在寻找一种更高效的开发方式，那么Spring Boot无疑是一个值得学习的技术。Spring Boot是一个开源的Java框架，由Pivotal团队（现为VMware的一部分）开发。它基于Spring框架，旨在简化Spring应用程序的初始搭建和开发过程。
深入理解Spring Boot的开箱即用与自动装配特性
最新发布
weixin_51052174的博客
08-29 850
Spring Boot的自动配置功能通过注解实现。它根据类路径中的依赖，自动配置Spring应用程序所需的Bean，极大地减少了手动配置的工作量。Spring Boot的自动配置机制能够根据类路径中的依赖，自动创建和配置所需的Bean，极大地简化了配置过程。在此过程中，注解的作用是确保Spring能够扫描到项目中的所有组件（如服务、控制器等），从而使得自动装配顺利进行。开发者可以在业务逻辑中直接使用这些自动配置的Bean，而无需关心它们的创建和管理。
基于Spring Boot的文字识别系统
立志成为炼丹师？
08-24 1370
前端使用html+css+js，后端使用Spring Boot，数据库使用mysql，识别算法有两个，一个是使用百度OCR接口，一个是自己写一个python，用flask包装。
Spring Boot与桥接模式：构建灵活的产品分类体系
心猿意码
08-25 766
桥接模式是一种结构型设计模式，旨在将抽象部分与其实现部分分离，从而使两者可以独立变化。它通过创建一个接口来封装一个类的实现，并允许这个接口与另一个接口进行交互，从而达到解耦的目的。
Spring Boot项目中结合MyBatis详细使用
08-26 1089
Spring Boot项目中结合MyBatis使用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值