深入理解SpringApplication

最新推荐文章于 2022-10-03 12:48:46 发布
最新推荐文章于 2022-10-03 12:48:46 发布
阅读量240 收藏 2
点赞数
分类专栏： springboot源码 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Donqueer/article/details/107042687
版权

用过 SpringBoot 的同学都知道，其程序的启动类是在一个main方法中调用SpringApplication.run方法执行的，如：

@SpringBootApplication
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class, args);
    }
}

SpringApplication初始化

先看看SpringApplication的构造

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) { 
	this.resourceLoader = resourceLoader;                                             
	Assert.notNull(primarySources, "PrimarySources must not be null");
  《1》
	this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));  
  《2》
	this.webApplicationType = WebApplicationType.deduceFromClasspath();   
  《3》
	setInitializers((Collection) getSpringFactoriesInstances(                         
			ApplicationContextInitializer.class)); 
  《4》
	setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
  《5》
	this.mainApplicationClass = deduceMainApplicationClass();                         
}

主要的逻辑：

  1. 初始化Spring容器的配置类primarySources
  2. 推断应用程序的类型，进而根据应用程序的类型创建恰当的ApplicationContext
  3. 初始化指定的ApplicationContextInitializer列表
  4. 初始化指定的ApplicationListener列表
  5. 推断main class的类名称

决策WebApplicationType

具体第二步决策创建什么样的ApplicationContext

    private static final String[] WEB_ENVIRONMENT_CLASSES = { "javax.servlet.Servlet",
            "org.springframework.web.context.ConfigurableWebApplicationContext" };

    private static final String REACTIVE_WEB_ENVIRONMENT_CLASS = "org.springframework."
            + "web.reactive.DispatcherHandler";

    private static final String MVC_WEB_ENVIRONMENT_CLASS = "org.springframework."
            + "web.servlet.DispatcherServlet";

    private WebApplicationType deduceWebApplicationType() {
        if (ClassUtils.isPresent(REACTIVE_WEB_ENVIRONMENT_CLASS, null)
                && !ClassUtils.isPresent(MVC_WEB_ENVIRONMENT_CLASS, null)) {
            return WebApplicationType.REACTIVE;
        }
        for (String className : WEB_ENVIRONMENT_CLASSES) {
            if (!ClassUtils.isPresent(className, null)) {
                return WebApplicationType.NONE;
            }
        }
        return WebApplicationType.SERVLET;
    }

根据 classpath 下是否存在某个特征类来决定是否应该创建一个为 Web 应用使用的ApplicationContext类型。具体判断为：

  1. 如果仅存在 Reactive 的包，则为WebApplicationType.REACTIVE类型；
  2. 如果 Servlet 和 Reactive的包都不存在，则为WebApplicationType.NONE类型；
  3. 其他情况都为WebApplicationType.SERVLET类型。

获取ApplicationContextInitializer和ApplicationListener

代码如下：

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type,         
		Class<?>[] parameterTypes, Object... args) {                         
	ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
	// Use names and ensure unique to protect against duplicates             
	Set<String> names = new LinkedHashSet<>(                                 
			SpringFactoriesLoader.loadFactoryNames(type, classLoader));      
	List<T> instances = createSpringFactoriesInstances(type, parameterTypes, 
			classLoader, args, names);                                       
	AnnotationAwareOrderComparator.sort(instances);                          
	return instances;                                                        
}

步骤：

  1. 通过SpringFactoriesLoader.loadFactoryNames(type, classLoader)方法，在 META-INF/spring.factories 文件下查找ApplicationContextInitializer类型对应的资源名称。
  2. 实例化上面的资源信息（初始化器）。
  3. 对初始化器根据Ordered接口或者@Order注解进行排序。

SpringFactoriesLoader会读取META-INF/spring.factories文件中的配置。一个工程项目中可以同时有多个META-INF/spring.factories文件(每个jar中都能有一个)。
例如在spring-boot-autoconfigure和spring-boot两个jar的META-INF/spring.factories文件中，均有针对ApplicationContextInitializer的配置：

# spring-boot-autoconfigure jar中的META-INF/spring.factories
# Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener

# spring-boot jar中的META-INF/spring.factories
# Application Context Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer,\
org.springframework.boot.context.ContextIdApplicationContextInitializer,\
org.springframework.boot.context.config.DelegatingApplicationContextInitializer,\
org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer

拿到配置文件之后，就进行第二步的实例化

获取ApplicationListener的过程和这个是一样的，就不多哔哔了

推断主类

private Class<?> deduceMainApplicationClass() {                                 
	try {                                                                       
		StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
		for (StackTraceElement stackTraceElement : stackTrace) {                
			if ("main".equals(stackTraceElement.getMethodName())) {             
				return Class.forName(stackTraceElement.getClassName());         
			}                                                                   
		}                                                                       
	}                                                                           
	catch (ClassNotFoundException ex) {                                         
		// Swallow and continue                                                 
	}                                                                           
	return null;                                                                
}

通过拿到堆栈信息，遍历方法名，如果是main，则是启动类(长见识)

SpringApplication启动(run)

把启动过程分成三部分来说，第一部分是打印banner及之前，第二部分为容器启动相关的代码，第三部分为容器启动之后的代码

public ConfigurableApplicationContext run(String... args) { 
  《1》
	StopWatch stopWatch = new StopWatch();                                          
	stopWatch.start();                                                              
	ConfigurableApplicationContext context = null;                                  
	Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>(); 
	configureHeadlessProperty();                                                    
	SpringApplicationRunListeners listeners = getRunListeners(args);                
	listeners.starting();                                                           
	try {                                                                           
		ApplicationArguments applicationArguments = new DefaultApplicationArguments(
				args);                                                              
		ConfigurableEnvironment environment = prepareEnvironment(listeners,         
				applicationArguments);                                              
		configureIgnoreBeanInfo(environment);                                       
		Banner printedBanner = printBanner(environment); 
    《2》
		context = createApplicationContext();                                       
		exceptionReporters = getSpringFactoriesInstances(                           
				SpringBootExceptionReporter.class,                                  
				new Class[] { ConfigurableApplicationContext.class }, context);     
		prepareContext(context, environment, listeners, applicationArguments,       
				printedBanner);                                                     
		refreshContext(context);                                                    
		afterRefresh(context, applicationArguments);                                
		stopWatch.stop();  
    《3》
		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;                                                                 
}

应用启动准备阶段

  1. 方法执行伊始，会先创建一个StopWatch对象，该对象用于统计应用的启动时间。下图中的启动时间日志就是根据StopWatch对象统计的数据打印的
  2. 拿到SpringApplication初始化阶段生成的SpringApplicationRunListener
  3. 通知监听事件，应用开始启动了listeners.starting()
prepareEnvironment

加载属性配置。执行完成后，所有的environment的属性都会加载进来，包括 application.properties 和外部的属性配置。

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;                                                               
}

configureEnvironment

protected void configureEnvironment(ConfigurableEnvironment environment,
		String[] args) {                                                
	configurePropertySources(environment, args);                        
	configureProfiles(environment, args);                               
}

应用启动

第二部分的逻辑

createApplicationContext

根据webApplicationType创建响应的ApplicationContext

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);
}

我们以 SERVLET 类型为例，它会创建AnnotationConfigServletWebServerApplicationContext应用上下文实例。

获取 Spring 异常报告器

getSpringFactoriesInstances(SpringBootExceptionReporter.class,new Class[] { ConfigurableApplicationContext.class }, context)方法，获取 META-INF/spring.factories 文件下类型为SpringBootExceptionReporter的资源实例：

# Error Reporters
org.springframework.boot.SpringBootExceptionReporter=\
org.springframework.boot.diagnostics.FailureAnalyzers
prepareContext

Spring 应用上下文启动前的准备工作：

private void prepareContext(ConfigurableApplicationContext context,
            ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
            ApplicationArguments applicationArguments, Banner printedBanner) {
        //设置 context 的 environment 属性
        context.setEnvironment(environment);
        // Spring 应用上下文的后置处理
        postProcessApplicationContext(context);
        // 运用 Spring 应用上下文初始化器
        applyInitializers(context);
        listeners.contextPrepared(context);
        if (this.logStartupInfo) {
            logStartupInfo(context.getParent() == null);
            logStartupProfileInfo(context);
        }

        // Add boot specific singleton beans
        context.getBeanFactory().registerSingleton("springApplicationArguments",
                applicationArguments);
        if (printedBanner != null) {
            context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
        }

        // Load the sources
        Set<Object> sources = getAllSources();
        Assert.notEmpty(sources, "Sources must not be empty");
        // 加载 BeanDefinition
        load(context, sources.toArray(new Object[0]));
        listeners.contextLoaded(context);
    }

大致流程为：

  1. 给context的属性做赋值，如设置环境变量，调用初始化器来初始化context。
  2. 获取所有配置源信息，包括 Configuration Class、类名、包名及Spring XML 配置资源路径信息。
  3. 加载 Spring 应用上下文配置源。将BeanDefinition加载到context中。
  4. 发布上下文已准备事件ApplicationPreparedEvent。

Spring Boot 中的BeanDefinitionLoader是BeanDefinition读取的综合实现。当其load()方法调用时，各个BeanDefinitionReader类型的属性各司其职，为 Spring 应用上下文从不同的配置源装载 Spring Bean 定义(BeanDefinition)。

ApplicationContext 启动阶段

这个后续专门写一篇吧，这里知道spring容器启动了就行

ApplicationContext 启动后阶段

这是一个空方法

应用启动完成

最主要有个callRunners方法，来调用实现了CommandLineRunner或者ApplicationRunner接口的类的 run 方法，得以满足需要在 Spring 应用上下文完全准备完毕后，执行一些操作的场景。

private void callRunners(ApplicationContext context, ApplicationArguments args) {
	List<Object> runners = new ArrayList<>();                                    
	runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());    
	runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());    
	AnnotationAwareOrderComparator.sort(runners);                                
	for (Object runner : new LinkedHashSet<>(runners)) {                         
		if (runner instanceof ApplicationRunner) {                               
			callRunner((ApplicationRunner) runner, args);                        
		}                                                                        
		if (runner instanceof CommandLineRunner) {                               
			callRunner((CommandLineRunner) runner, args);                        
		}                                                                        
	}                                                                            
}

总结

SpringApplication类将一个SpringBoot应用的启动流程模板化，并在启动过程中提供了一些扩展点让我们可以根据具体需求进行扩展(通过SpringApplicationRunListener机制)。

来源

https://segmentfault.com/a/1190000019560001

https://www.jianshu.com/p/c2789f1548ab

http://svip.iocoder.cn/Spring-Boot/SpringApplication/

donqueer
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Boot核心特性（一）——SpringApplication
欢迎来到代码生的博客空间
01-27 1202
Spring Boot核心特性之SpringApplication
SpringApplication
joeyin
04-01 281
SpringApplication 定义：Spring应用引导类，提供便利的自定义行为方法场景：嵌入式Web应用和非Web应用 准备阶段 配置：Spring Bean来源 Java配置Class：Spring注解驱动中Java配置类，大多是情况下是Spring 模式注解锁标注的类，如被@configuration标注的类 XML上下文配置文件：用于Spring 传统配置驱动中的xml文件 BeanDefinitionLoader(BeanDefinitionRegistry registr
SpringBoot深度探究（七）源码探究启动流程之一
Smallc0de的博客
12-04 405
前面已经罗嗦了三篇博客用来介绍观察者模式的理论以及实现，都是为了本节讲解SpringBoot启动流程的源码做准备的，因为在阅读SpringBoot源码启动流程的时候发现spring公司的大神们在设计SpringBoot的时候，把观察者模式用到了极限。如果不把观察者模式讲清楚，那么读起来SpringBoot的源码会非常的痛苦。那么既然观察者模式已经搞清楚了，下面就开始正式进入SpringBoot的源码探究的过程。
Spring Boot 2.2.6 源码之旅三SpringApplication启动流程三
王伟王胖胖的博客
04-10 1058
Spring Boot 2.2.6 源码之旅三SpringApplication启动流程三SpringApplication的setListeners设置监听器deduceMainApplicationClass对端主启动类rungetRunListeners获取SpringApplicationRunListener监听器EventPublishingRunListener的构造方法Simple...
SpringApplication运行阶段
通往神秘的道路的专栏
05-29 2057
SpringApplication运行阶段围绕run(String …)方法展开，该过程结合初始化阶段完成的状态进一步完善了运行时所需要准备的资源，随后启动Spring应用上下文，在此期间伴随Spring Boot和Spring事件的触发，形成完整的SpringApplication生命周期： SpringApplication准备阶段 SpringApplication启动阶段 SpringApplication启动后阶段 1、SpringApplication准备阶段 本阶段涉及的范围从run(St
深入理解SpringApplication原理
10-18
SpringApplication是springboot驱动spring应用上下文的引导类，他的run()方法启动Spring应用，实质上是为Spring应用创建并初始化Spring上下文。
SpringApplication详解源码
05-09
本文将深入解析`SpringApplication`的源码，帮助开发者理解其工作原理，从而更好地利用这一强大工具。 首先，`SpringApplication`是启动Spring Boot应用的入口，它的主要职责是初始化ApplicationContext，加载配置...
SpringBoot 源码解析 —— SpringApplication 源码分析.docx
11-12
Spring Boot@SpringBootApplication 源码分析 本文对 Spring Boot 中的@...通过分析@SpringBootApplication 注解和 SpringApplication 类的 run 方法，我们可以更好地理解 Spring Boot 应用程序的启动过程和基本原理。
spring boot 深入浅出源码
01-29
在深入理解Spring Boot的源码时，我们首先要明白其核心设计理念——“约定优于配置”。Spring Boot通过预设默认配置，使得开发者能够快速启动并运行应用，同时提供了丰富的启动器（Starters）来简化依赖管理。 ...
Spring Boot 核心知识，深入剖析！.docx
最新发布
11-20
让我们逐一深入理解。 首先，自动配置是Spring Boot的核心特点之一。它通过在`@SpringBootApplication`注解的类下查找特定的`@Configuration`类来实现。这些配置类根据项目中的依赖项进行自动配置。例如，如果你在...
spring boot源码解析（一）spring boot启动类SpringApplication
默默草
03-14 1104
题外话 因工作原因，陆续开始接触spring boot，且对其源码和机制越来越发的需要深入了解。所以想系统的分析下spring boot源码，希望可以检查下去。 spring boot启动 @SpringBootApplication public class SimpleApplication { public static void main(String[] args) { Spri...
Spring boot启动源码之SpringApplication构造器
yuanchangliang的博客
04-18 630
Spring启动源码之SpringApplication构造器 Spring boot项目的启动类中的main方法如下： public static void main(String[] args) { SpringApplication.run(SspWebApplication.class, args); } ctrl + 鼠标左键点击查看run方法： public static ConfigurableApplicationContext run(Class<?&g.
Spring Boot的SpringApplication类详解
热门推荐
成长的足迹
08-13 2万+
相信使用过Spring Boot的开发人员，都对Spring Boot的核心模块中提供的SpringApplication类不陌生。SpringApplication类的run()方法往往在Spring应用的入口类中被调用，以启动Spring应用。 1.Spring应用的入口类与SpringApplication类 1) Spring应用的入口类 Spring应用的入口类是Spring应
SpringBoot学习SpringApplication
墨笙弘一
06-17 394
SpringApplication类提供了一种方便的方法来引导从main（）方法启动Spring应用程序。在许多情况下，您可以委托给静态SpringApplication.run()方法，如下例所示: @SpringBootApplication public class Application { public static void main(String[] args) { ...
SpringBoot源码系列（一）——启动过程分析
scorpio的博客
11-08 425
SpringBoot源码系列（一）——启动过程分析
深入SpringBoot源码（七）SpringApplication与Environment绑定的前置工作（上）
现阶段围绕Java展开
04-19 2453
ConfigurationPropertySources的attach方法将ConfigurationPropertySource支持附加到指定的Environment。使环境管理的每个PropertySource适应ConfigurationPropertySource并允许经典的PropertySourcesPropertyResolver调用使用configuration property names进行解析。 附加的解析器将动态跟踪来自基础Environment属性源的任何添加或删除。 publ.
Spring Boot源码解析（一）SpringApplication初始化
DevCampsite的博客
08-18 591
Spring Boot 源码解读之SpringApplication初始化
不懂SpringApplication生命周期事件？那就等于不会Spring Boot嘛
weixin_47067712的博客
07-15 378
前言 各位小伙伴大家好。本文属总结性文章，对纵览Spring Boot生命周期很是重要，建议点在看、转发“造福”更多小伙伴。 我最近不是在写Spring Cloud深度剖析的相关专栏么，最近有收到小伙伴发过来一些问题，通过这段时间收集到的反馈，总结了一下有一个问题非常集中：那便是对Spring Boot应用SpringApplication的生命周期、事件的理解。有句话我不是经常挂嘴边说的麽，你对Spring Framework有多了解决定了你对Spring Boot有多了解，你对Spring Boot的了
spring-boot源码解析之SpringApplication
weixin_45594127的博客
10-03 1138
SpringApplication源码阅读
深入理解Spring Boot的自动配置原理
通过深入理解自动配置原理，开发人员可以更加灵活地使用Spring Boot，并更好地应对工作中的各种情况。 在开发中，Spring Boot已成为我们必知必会的技能项。几乎所有行业都在迅速采用这个已经不再新颖的Spring启动...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值