Spring Boot2 源码 run prepareEnvironment方法 （三）

最新推荐文章于 2024-05-31 00:49:42 发布
原创 最新推荐文章于 2024-05-31 00:49:42 发布 · 227 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring boot #run  #源码 #prepareEnvironment

本文详细解析了Spring Boot启动过程中的关键步骤，包括环境准备、Banner打印、上下文创建及异常报告器准备。深入探讨了如何通过监听器和应用参数初始化Spring环境，以及创建应用上下文的具体流程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

6、根据运行监听器和应用参数来准备 Spring 环境 

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

 getOrCreateEnvironment初始化运行环境 this.webApplicationType=SERVLET 在前面讲过会在SpringApplication初始化赋值，所以运行环境是StandardServletEnvironment

private ConfigurableEnvironment getOrCreateEnvironment() {
		if (this.environment != null) {
			return this.environment;
		}
		switch (this.webApplicationType) {
		case SERVLET:
			return new StandardServletEnvironment();
		case REACTIVE:
			return new StandardReactiveWebEnvironment();
		default:
			return new StandardEnvironment();
		}
	}

listeners.environmentPrepared(environment);发布org.springframework.boot.context.event.ApplicationEnvironmentPreparedEvent事件 见（ApplicationStartingEvent）事件 不在赘述

ConfigFileApplicationListener该类赋值读取文件

private void onApplicationEnvironmentPreparedEvent(
			ApplicationEnvironmentPreparedEvent event) {
		List<EnvironmentPostProcessor> postProcessors = loadPostProcessors();
		postProcessors.add(this);
		AnnotationAwareOrderComparator.sort(postProcessors);
		for (EnvironmentPostProcessor postProcessor : postProcessors) {
			postProcessor.postProcessEnvironment(event.getEnvironment(),
					event.getSpringApplication());
		}
	}

postProcessors.add(this);将自己也加入list中，循环调用postProcessEnvironment方法，先只看ConfigFileApplicationListener类的

Loader内部类将this.propertySourceLoaders 赋值

org.springframework.boot.env.PropertySourceLoader=\
org.springframework.boot.env.PropertiesPropertySourceLoader,\
org.springframework.boot.env.YamlPropertySourceLoader

循环加载器获取文件，注意在加载EnvironmentPostProcessor实现类是有顺序的，也就是说后面的属性会覆盖前面文件的属性，还记得postProcessors.add(this)么，也就是说最后才会加载ConfigFileApplicationListener，将本项目中的配置文件替换前面配置文件的属性，然后在看下本项目的加载依次的顺序如下： 

1.PropertiesPropertySourceLoader "properties", "xml"   2.YamlPropertySourceLoader "yml", "yaml" 

private void load(String location, String name, Profile profile,
				DocumentFilterFactory filterFactory, DocumentConsumer consumer) {
			if (!StringUtils.hasText(name)) {
				for (PropertySourceLoader loader : this.propertySourceLoaders) {
					if (canLoadFileExtension(loader, location)) {
						load(loader, location, profile,
								filterFactory.getDocumentFilter(profile), consumer);
						return;
					}
				}
			}
			Set<String> processed = new HashSet<>();
			for (PropertySourceLoader loader : this.propertySourceLoaders) {
				for (String fileExtension : loader.getFileExtensions()) {
					if (processed.add(fileExtension)) {
						loadForFileExtension(loader, location + name, "." + fileExtension,
								profile, filterFactory, consumer);
					}
				}
			}
		}

获取文件内容load方法 并赋值addActiveProfiles、addIncludedProfiles 

		private void load(PropertySourceLoader loader, String location, Profile profile,
				DocumentFilter filter, DocumentConsumer consumer) {
			try {
				Resource resource = this.resourceLoader.getResource(location);
				if (resource == null || !resource.exists()) {
					if (this.logger.isTraceEnabled()) {
						StringBuilder description = getDescription(
								"Skipped missing config ", location, resource, profile);
						this.logger.trace(description);
					}
					return;
				}
				if (!StringUtils.hasText(
						StringUtils.getFilenameExtension(resource.getFilename()))) {
					if (this.logger.isTraceEnabled()) {
						StringBuilder description = getDescription(
								"Skipped empty config extension ", location, resource,
								profile);
						this.logger.trace(description);
					}
					return;
				}
				String name = "applicationConfig: [" + location + "]";
				List<Document> documents = loadDocuments(loader, name, resource);
				if (CollectionUtils.isEmpty(documents)) {
					if (this.logger.isTraceEnabled()) {
						StringBuilder description = getDescription(
								"Skipped unloaded config ", location, resource, profile);
						this.logger.trace(description);
					}
					return;
				}
				List<Document> loaded = new ArrayList<>();
				for (Document document : documents) {
					if (filter.match(document)) {
						addActiveProfiles(document.getActiveProfiles());
						addIncludedProfiles(document.getIncludeProfiles());
						loaded.add(document);
					}
				}
				Collections.reverse(loaded);
				if (!loaded.isEmpty()) {
					loaded.forEach((document) -> consumer.accept(profile, document));
					if (this.logger.isDebugEnabled()) {
						StringBuilder description = getDescription("Loaded config file ",
								location, resource, profile);
						this.logger.debug(description);
					}
				}
			}
			catch (Exception ex) {
				throw new IllegalStateException("Failed to load property "
						+ "source from location '" + location + "'", ex);
			}
		}

 loadDocuments(loader, name, resource);会将文件的属性加载项目中来

7、创建 Banner 打印类

默认打印SpringBootBanner类 看下这个图片是不是很熟悉呢

class SpringBootBanner implements Banner {

	private static final String[] BANNER = { "",
			"  .   ____          _            __ _ _",
			" /\\\\ / ___'_ __ _ _(_)_ __  __ _ \\ \\ \\ \\",
			"( ( )\\___ | '_ | '_| | '_ \\/ _` | \\ \\ \\ \\",
			" \\\\/  ___)| |_)| | | | | || (_| |  ) ) ) )",
			"  '  |____| .__|_| |_|_| |_\\__, | / / / /",
			" =========|_|==============|___/=/_/_/_/" };

 

8、创建应用上下文

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

容器实际上就是AnnotationConfigServletWebServerApplicationContext类，后面的操作都会基于此类

AnnotationConfigServletWebServerApplicationContext在实例化时还会加载许多类，构造方法

public AnnotationConfigServletWebServerApplicationContext() {
		this.reader = new AnnotatedBeanDefinitionReader(this);
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}

进行跟进AnnotatedBeanDefinitionReader构造方法，加载

internalConfigurationAnnotationProcessor，internalConfigurationBeanNameGenerator、internalAutowiredAnnotationProcessor等类，这也是为什么类名与实际类名称不同，前面多个internal的原因

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
			BeanDefinitionRegistry registry, @Nullable Object source) {

		DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
		if (beanFactory != null) {
			if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
				beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
			}
			if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
				beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
			}
		}

		Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);

		if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
		if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
		if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition();
			try {
				def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
						AnnotationConfigUtils.class.getClassLoader()));
			}
			catch (ClassNotFoundException ex) {
				throw new IllegalStateException(
						"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
			}
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
		}

		if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
		}

		return beanDefs;
	}

 

9、准备异常报告器

exceptionReporters  还是一样读取spring.factory文件赋值实例化

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

 

Springboot 源码分析 —— prepareEnvironment() 解析
一步一步往上爬
05-11 3753
spring 配置属性加载流程分析。
SpringBoot源码-spring boot启动入口run方法主线分析（一）
最新发布
qq_37200262的博客
11-27 1436
SpringBoot的启动核心run方法，从主流程讲解每个方法做了哪些事情。包括监听器、yaml配置文件加载、banner打印、Spring Boot自动装配、内嵌tomcat启动等讲解
SpringBoot 源码 | prepareEnvironment 方法解析
AS011x的博客
09-12 647
执行完成准备环境的 prepareEnvironment 方法之后，会继续执行容器上下文启动前的其他准备工作，后续我会继续更新，欢迎共同讨论，一同进步。
springboot源码分析之prepareEnvironment
qq_21277357的博客
09-05 261
/然后environment的propertySources的propertySourceList集合就有新的数据了,我们可以看下效果。//我们可以看下document.getActiveProfiles()的数据，这就是我们指定的环境。//profile =null就是我们的默认文件,profile=dev就是我们的dev文件。//从 上面的方法可以看到,默认的配置文件和dev的配置文件,已经读取到,因为我们设置了。//我们可以看到系统的属性,和环境都已经放入了。
【死磕-springboot第三篇】prepareEnvironment
daguniang123的博客
10-10 1276
【死磕-第三篇】prepareEnvironment 导读 上一篇讲述了，获取运行监听器，然后调用starting方法，干了些什么 这一篇主要讲springApplication.run这个流程中准备环境的这个过程 1. 源码详解 /** * Run the Spring application, creating and refreshing a new * {@link ApplicationContext}. * 翻译：运行一个spring程序，创建并且刷新一个新的Applica
SpringBoot源码（六）： 启动流程：prepareEnvironment
xby7437的博客
03-11 994
介绍 前面介绍了spring对于键值的抽象PropertySource,以及对外提供数据的统一处理接口PropertyResolver。还有对ConfigurableEnvironment的源码解析。接下来继续看springBoot启动流程的源码prepareEnvironment。 prepareEnvironment private ConfigurableEnvironment prepareEnvironment( SpringApplicationRunListeners l.
Spring Boot源码（spring-boot-2.6.2.zip）
01-07
Spring Boot是Java开发中的一个关键框架，它简化了基于Spring的应用程序开发流程。Spring Boot 2.6.2是该框架的一个稳定版本，提供了一系列...对于Java开发者来说，研究Spring Boot源码是一项非常有价值的学习过程。
spring boot源码-自定义初始化器的三种方式
12-21
下面将详细介绍三种在Spring Boot中创建自定义初始化器的方法。 ### 第一种：通过`spring.factories`文件 1. **创建配置文件**：在`src/main/resources/META-INF/spring.factories`文件中，添加以下内容： ``` ...
java maven工程 spring boot 学习源码
08-22
本学习资源包“java maven工程 spring boot 学习源码”提供了一个可以直接运行的示例工程，有助于深入理解Spring Boot和Maven的结合使用。 首先，我们需要了解Spring Boot的核心特性。Spring Boot通过内嵌的Servlet...
SpringBoot 五、Spring Boot 启动全过程run方法源码分析
大鹏小站的博客
03-21 634
1、今天分析springboot启动的run方法 先看下源码 /** 运行Spring应用程序，创建并刷新一个新的 * Run the Spring application, creating and refreshing a new * {@link ApplicationContext}. * @param args the application arguments (usually passed from a Java main method) * @return a runn
[springboot源码分析]-启动-02-prepareEnvironment
dark
03-13 137
springboot 启动
SpringBoot属性加载-run方法（prepareEnvironment）
BushRo
04-05 1726
我们在项目中有时候会发现设置的变量没有生效，可能是被其它优先级高的变量给覆盖了。所以我们需要搞清楚SpringBoot的加载顺序。Spring Boot属性加载顺序（优先级由高到底）
SpringBoot源码分析(3)--Environment简介/prepareEnvironment准备环境（万字图文源码debug分析）
weixin_49114503的博客
07-07 1834
一、前言 二、Environment 2.1、什么是 Environment？ 2.2、Environment组成 2.2.1、profile数据结构 2.2.2、properties数据结构 三、prepareEnvironment 3.1、获取或者创建环境getOrCreateEnvironment 3.1.1、AbstractEnvironment 3.1.2、StandardEnvironment 3.1.3、StandardServletEnvironment 3.2、配置环境configureE
SpringBoot源码分析之-启动流程分析四(prepareEnvironment 环境准备)
xc的博客
06-14 566
3.ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments); private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments) { // Create and config
SpringBoot源码解析（十）prepareEnvironment收尾
m0_37298252的博客
01-28 914
最近很多篇都是围绕prepareEnvironment方法在分析，上篇补充了ApplicationEnvironmentPreparedEvent事件的处理，相当于下面的listeners.environmentPrepared方法就结束掉了，本文就把这个方法中剩下的几行代码收下尾 private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, ApplicationArgumen
Spring Boot 项目启动时在 environmentPrepared 阶段到底干了啥？
若千年后
05-31 1455
在《Spring Boot 启动流程详解》一文中详细给大家介绍了 Spring Boot 的启动流程，但是由于Spring Boot 启动时做了很多事件，有些地方没有详细给大家介绍，只是大概介绍了下做了什么，这让大家对具体的实现仍不甚了解，这其中就包括 environmentPrepared 阶段触发的事件。下面就详细给大家介绍下 environmentPrepared 阶段 Spring Boot 具体做了什么。
SpringBoot启动系列之prepareEnvironment浅析
雪落南城的博客
10-25 1164
环境准备 prepareEnvironment方法 private ConfigurableEnvironment prepareEnvironment( SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments) { // Create and configure ...
spring-boot-2.0.3启动源码篇三 - run方法(二)之prepareEnvironment
weixin_30410999的博客
09-17 241
前言 　　此系列是针对springboot的启动，旨在于和大家一起来看看springboot启动的过程中到底做了一些什么事。如果大家对springboot的源码有所研究，可以挑些自己感兴趣或者对自己有帮助的看；但是如果大家没有研究过springboot的源码，不知道springboot在启动过程中做了些什么，那么我建议大家从头开始一篇一篇按顺序读该系列，不至于从中途插入，看的有些懵懂。当然，文中...
SpringBoot外化配置源码解析：命令参数获取文件加载
m0_63437643的博客
02-23 518
命令参数的获取 命令行参数就是在启动 Spring Boot 项目时通过命令行传递的参数。比如，用如下命令来启动一个 Spring Boot 的项目。 java -jar app.jar --name=SpringBoot 那么，参数--name=SpringBoot 是如何一 步步传递到 Spring 内部的呢?这就是本节要分析的代码内容。 默认情况下，SpringApplication 会将以 上类似 name 的命令行参数(以“”开通)解析封装成一-个 PropertySource 对象 (
Spring Boot项目源码教程与实践详解
从给定的文件信息中，我们可以看出，文件包标题是“spring boot实践三四源码 ch01_2.zip”，这表明了文件内容与Spring Boot相关，并且包含第三章和第四章的源码。文件描述提到了两篇博客内容，涉及使用Spring ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值