springBoot 源码五：springboot启动源码补充和配置优先级

已于 2023-02-26 19:23:02 修改
阅读量1.1k 收藏 1
点赞数 1
分类专栏： 基础源码学习 文章标签： spring boot spring java
于 2022-09-07 18:58:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/admin522043032/article/details/126745085
版权

springboot启动源码补充和配置优先级

上一篇分析了springboot的启动流程，其中还有一些部分没有分析完全。接下来通过一下方面进行分析

  • @SpringBootApplication注解
  • 启动流程中的第五步，准备环境变量部分 这部分和springboot配置优先级有关
  • callRunners(context, applicationArguments); 方法解释
  • 对启动流程的总结

@SpringBootApplication注解分析

先来看下@SpringBootApplication注解有哪些内容
在这里插入图片描述
在这里插入图片描述
@SpringBootApplication包含了以上几个注解和属性。

先来分析几个常用的属性
exclude()和excludeName()都是用来排除自动配置类的。注意这里排除的是自动配置类，不是我们定义的bean。这部分源码在springboot自动配置源码分析中有分析过
scanBasePackages()和scanBasePackageClasses()配置对应的扫描路径，这部分的内容是spring的配置扫描的内容Bean的生命周期源码解析中分析过扫描流程
nameGenerator() 指定使用BeanNameGenerator类型，BeanNameGenerator类型用来创建bean的名字的，一般都不会配置
proxyBeanMethods() 这个是spring的内容，在spring配置类解析源码解析中提到过

在来看看SpringBootApplication的注解
@SpringBootConfiguration
实际上就是 @Configuration spring的内容 标注它的类被spring当成配置类来解析
在这里插入图片描述
@EnableAutoConfiguration 开启自动配置的注解
在这里插入图片描述
其中@Import(AutoConfigurationImportSelector.class)在自动配置底层源码分析中分析了
@AutoConfigurationPackage 的两个属性的值 就是@SpringBootApplication对应的属性配置的值
在这里插入图片描述
在这里插入图片描述
然后来看下@Import(AutoConfigurationPackages.Registrar.class)做了什么？

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {

		@Override
		public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
			register(registry, new PackageImports(metadata).getPackageNames().toArray(new String[0]));
		}

		@Override
		public Set<Object> determineImports(AnnotationMetadata metadata) {
			return Collections.singleton(new PackageImports(metadata));
		}

	}

其中new PackageImports(metadata).getPackageNames().toArray(new String[0])

PackageImports(AnnotationMetadata metadata) {
			//把AutoConfigurationPackage的属性值封装成AnnotationAttributes 对象
			AnnotationAttributes attributes = AnnotationAttributes
					.fromMap(metadata.getAnnotationAttributes(AutoConfigurationPackage.class.getName(), false));
			//从AnnotationAttributes 获取属性名为basePackages的值 也就是获取配置的扫描路径
			List<String> packageNames = new ArrayList<>(Arrays.asList(attributes.getStringArray("basePackages")));
			//遍历配置的扫描类 把对应包路径添加到packageNames中
			for (Class<?> basePackageClass : attributes.getClassArray("basePackageClasses")) {
				packageNames.add(basePackageClass.getPackage().getName());
			}
			// 添加主启动类的包路径 也就是MyApplicatoin类所在的包
			if (packageNames.isEmpty()) {
				packageNames.add(ClassUtils.getPackageName(metadata.getClassName()));
			}
			this.packageNames = Collections.unmodifiableList(packageNames);
		}

获取主启动类的包路径和配置了basePackages和basePackageClasses的包路径。
register(registry, new PackageImports(metadata).getPackageNames().toArray(new String[0]));

public static void register(BeanDefinitionRegistry registry, String... packageNames) {
		if (registry.containsBeanDefinition(BEAN)) {
			//BeanDefinition注册器中如果有AutoConfigurationPackages这个BeanDefinition
			//从BeanDefinition注册器中获取AutoConfigurationPackages的BeanDefinition
			BasePackagesBeanDefinition beanDefinition = (BasePackagesBeanDefinition) registry.getBeanDefinition(BEAN);
			//把扫描路径添加到AutoConfigurationPackages的BeanDefinition中
			beanDefinition.addBasePackages(packageNames);
		}
		else {
			//创建一个BeanDefinition 名字为autoConfigurationPackages
			registry.registerBeanDefinition(BEAN, new BasePackagesBeanDefinition(packageNames));
		}
	}

把获取到的扫描路径生成BeanDefinition保存起来，一方面给后续执行扫描逻辑时使用，一方面给第三方框架获取扫描路径使用
总结起来就是@EnableAutoConfiguration注解，一方面开启自动配置功能，一方面获取主启动类所在的包作为扫描路径

@ComponentScan
spring的扫描注解，在springboot中

@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })

主要是配置了两个过滤器AutoConfigurationExcludeFilter和TypeExcludeFilter
以AutoConfigurationExcludeFilter为例
在这里插入图片描述
这个过滤器会通过match方法判断当前加载bean是否有@Configuration注解，并且是否是META-INF/spring.factories下的自动配置类当中的。如果是返回true，表示springboot不处理这个类，相当于过滤掉，如果不是返回false，springboot回去解析这个类。
总结下来就是：AutoConfigurationExcludeFilter的作用是扫描到的配置类名字如果在自动配置类名集合中，就不解析
TypeExcludeFilter
同理

@Override
	public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
			throws IOException {
		if (this.beanFactory instanceof ListableBeanFactory && getClass() == TypeExcludeFilter.class) {

			// 从Spring容器中获取TypeExcludeFilter，然后进行匹配，匹配的则不解析
			for (TypeExcludeFilter delegate : getDelegates()) {
				if (delegate.match(metadataReader, metadataReaderFactory)) {
					return true;
				}
			}
		}
		return false;
	}

到此整个@SpringBootApplication就分析完毕

callRunners(context, applicationArguments); 方法解释

这是在springboot启动路程中的第十步，过程大概是，获取Spring容器中的ApplicationRunner类型和CommandLineRunner类型的Bean，执行它们的run()。

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

那么ApplicationRunner和CommandLineRunner这两个接口是用来干嘛的呢，实际上就是对命令行参数的处理。举个例子

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

	}

	@Bean
	public ApplicationRunner applicationRunner(){
		return new ApplicationRunner() {
			@Override
			public void run(ApplicationArguments args) throws Exception {
				//输出带有--的参数 key 和value
				System.out.println(args.getNonOptionArgs());
				//输出不带--的key
				System.out.println(args.getOptionNames());
				//输出不带--的key对应的value
				System.out.println(args.getOptionValues("aa"));
			}
		};
	}

}

springboot启动类中定义了一个bean ，之前说过args的值就是命令行参数。所以在idea中模拟命令行参数
在这里插入图片描述
启动springboot
在这里插入图片描述

启动流程中的第五步，准备环境变量部分和SpringBoot配置优先级

先来看下这部分源码

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
			DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
		// Create and configure the environment
		// 创建ApplicationServletEnvironment，里面添加了四个PropertySource
		// 1. StubPropertySource {name='servletConfigInitParams'}
		// 2. StubPropertySource {name='servletContextInitParams'}
		// 3. PropertiesPropertySource {name='systemProperties'}
		// 4. SystemEnvironmentPropertySource {name='systemEnvironment'}
		ConfigurableEnvironment environment = getOrCreateEnvironment();

		// 添加SimpleCommandLinePropertySource {name='commandLineArgs'}，放在首位
		configureEnvironment(environment, applicationArguments.getSourceArgs());

		// 把所有的PropertySources封装为一个ConfigurationPropertySourcesPropertySource
		// 然后添加到environment中，放在首位
		ConfigurationPropertySources.attach(environment);

		// 发布ApplicationEnvironmentPreparedEvent事件，表示环境已经准备好了
		// 默认EnvironmentPostProcessorApplicationListener会处理这个事件，会从spring.factories中拿出EnvironmentPostProcessor进一步处理Environment
		listeners.environmentPrepared(bootstrapContext, environment);

		// 最后，把defaultProperties移到最后
		DefaultPropertiesPropertySource.moveToEnd(environment);
		Assert.state(!environment.containsProperty("spring.main.environment-prefix"),
				"Environment prefix cannot be set via properties.");
		bindToSpringApplication(environment);
		if (!this.isCustomEnvironment) {
			environment = convertEnvironment(environment);
		}
		ConfigurationPropertySources.attach(environment);
		return environment;
	}

这里面比较复杂，具体的步骤源码不再展开，具体说说大致流程。
ConfigurableEnvironment environment = getOrCreateEnvironment();
首先创建一个ConfigurableEnvironment 环境变量的对象。这个过程中往ConfigurableEnvironment 条件四个PropertySource。每个PropertySource相当于properties文件解析后或者理解成一个map。一开始这四个PropertySource分别是

  1. StubPropertySource {name=‘servletConfigInitParams’} servlet的初始化参数的键值对
  2. StubPropertySource {name=‘servletContextInitParams’} web容器的初始化参数
  3. PropertiesPropertySource {name=‘systemProperties’} jvm参数和-D配置的参数
  4. SystemEnvironmentPropertySource {name=‘systemEnvironment’} 操作系统的参数

当我们需要用到配置参数的时候就会从这些PropertySource里面拿，那么是怎么拿的呢？，springboot会从第一个开始，拿到了就直接使用，这就是优先级了。

configureEnvironment(environment, applicationArguments.getSourceArgs());
这个方法中，先判断有没有设置DefaultProperties，例如

@SpringBootApplication
public class Application {
	public static void main(String[] args) {
//		SpringApplication.run(Application.class, args);
		SpringApplication springApplication = new SpringApplication(Application.class);
		Map<String,Object> map = new HashMap<>();
		map.put("server.port",8009);
		springApplication.setDefaultProperties(map);
		springApplication.run(args);
	}

如果设置了，在最后一个PropertySource后面添加一个名字叫defaultProperties的PropertySource。此时就有五个PropertySource

servletConfigInitParams
servletContextInitParams
systemProperties
systemEnvironment
defaultProperties

然后把命令行参数放到名字叫commandLineArgs的PropertySource中，放到最前面。命令行参数也就是java -jar xxx.jar --server.port=8002此时就有6个PropertySource

commandLineArgs ：命令行参数
servletConfigInitParams ：servlet的初始化参数的键值对
servletContextInitParams ：web容器的初始化参数
systemProperties：jvm参数和-D配置的参数
systemEnvironment ：操作系统的参数
defaultProperties： SpringApplication 配置的参数

listeners.environmentPrepared(bootstrapContext, environment);
发布一个环境变量准备好的事件，有一个叫EnvironmentPostProcessorApplicationListener的监听器监听到这个事件后会进行后续处理。具体的处理代码

private void onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent event) {
		ConfigurableEnvironment environment = event.getEnvironment();
		SpringApplication application = event.getSpringApplication();

		// 从spring.factories中拿出EnvironmentPostProcessor进一步处理Environment
		// RandomValuePropertySourceEnvironmentPostProcessor
		// SystemEnvironmentPropertySourceEnvironmentPostProcessor
		// SpringApplicationJsonEnvironmentPostProcessor
		// CloudFoundryVcapEnvironmentPostProcessor
		// ConfigDataEnvironmentPostProcessor
		// IntegrationPropertiesEnvironmentPostProcessor
		// DebugAgentEnvironmentPostProcessor
		for (EnvironmentPostProcessor postProcessor : getEnvironmentPostProcessors(application.getResourceLoader(),
				event.getBootstrapContext())) {
			postProcessor.postProcessEnvironment(environment, application);
		}
	}

这个方法会从spring.factories拿到一系列的EnvironmentPostProcessor。对environment进行处理，例如第一个RandomValuePropertySourceEnvironmentPostProcessor，就会在systemEnvironment 这个PropertySource后面在增加加一个叫random的PropertySource。此时就有7个PropertySource

commandLineArgs ：命令行参数
servletConfigInitParams ：servlet的初始化参数的键值对
servletContextInitParams ：web容器的初始化参数
systemProperties：jvm参数和-D配置的参数
systemEnvironment ：操作系统的参数
random ：存储一些随机数 通过random.int 可以获取到int的随机数 同理还有random.long 等等
defaultProperties： SpringApplication 配置的参数

其他的EnvironmentPostProcessor就不在分析，核心来分析下ConfigDataEnvironmentPostProcessor
ConfigDataEnvironmentPostProcessor
首先会调用ConfigDataEnvironmentPostProcessor.的postProcessEnvironment的方法

void postProcessEnvironment(ConfigurableEnvironment environment, ResourceLoader resourceLoader,
			Collection<String> additionalProfiles) {
		try {
			this.logger.trace("Post-processing environment to add config data");
			resourceLoader = (resourceLoader != null) ? resourceLoader : new DefaultResourceLoader();
			// 先生成ConfigDataEnvironment对象，核心是根据指定location构造类型为Kind.INITIAL_IMPORT的ConfigDataEnvironmentContributor
			// processAndApply()将进行解析
			getConfigDataEnvironment(environment, resourceLoader, additionalProfiles).processAndApply();
		}
		catch (UseLegacyConfigProcessingException ex) {
			this.logger.debug(LogMessage.format("Switching to legacy config file processing [%s]",
					ex.getConfigurationProperty()));
			configureAdditionalProfiles(environment, additionalProfiles);
			postProcessUsingLegacyApplicationListener(environment, resourceLoader);
		}
	}

该方法的核心方法是getConfigDataEnvironment(environment, resourceLoader, additionalProfiles).processAndApply();这个方法可以分成两部分，一部分getConfigDataEnvironment(environment, resourceLoader, additionalProfiles) 使用来创建 ConfigDataEnvironment对象的
另一部分就是通过ConfigDataEnvironment的processAndApply()进行配置解析。
其中ConfigDataEnvironment有一些默认路径来找application.properties 等这些配置文件
在这里插入图片描述
optional:前缀表示允许在该路径下找不到配置文件
也可以通过配置以下参数指定找配置文件的路径

spring.config.location 指定了默认路径就不生效
spring.config.import 在默认路径下新增
spring.config.additional-location 在默认路径下新增

当然这些参数配置在配置文件中是不生效，因为现在就是要去找寻配置文件。
那么这些路径的顺序是怎样的呢，先从那个路劲下开始找呢？
如果通过spring.config.import 或者 spring.config.additional-location配置了新的路径 那么该路径排最前面

新配置的路径
file./
file./config
file./config/*/
classpath:/
classpath:/config/

从上到下的顺序去找配置文件。那么找那些配置文件呢，可以通过spring.config.name进行配置，默认值为application。
所以会从上面几个路径依次去找application.yaml，application.yml，application.properties
按照上述文件顺序找到后，有一个倒序的操作
在这里插入图片描述
所以配置文件的优先级变成properties>yml。如果多个路径下有配置文件，那么先按照路径的优先级，再到文件的优先级。
此时找到的配置文件并没有解析所有配置文件放入到环境变量中，而是解析成PropertySource按顺序放到一个集合当中，判断有没有配置spring.profiles.active。比如说配置了spring.profiles.active=dve，那么就会去找application-dve的配置文件。所以spring.profiles.active=dve的配置需要放在application配置文件下。
找到以后再解析application-dve的配置文件，解析完成后放入到环境变量中，此时application-dve的优先级是高于application的。
此时环境变量的PropertySource 顺序如下

commandLineArgs ：命令行参数
servletConfigInitParams ：servlet的初始化参数的键值对
servletContextInitParams ：web容器的初始化参数
systemProperties：jvm参数和-D配置的参数
systemEnvironment ：操作系统的参数
random ：存储一些随机数 通过random.int 可以获取到int的随机数 同理还有random.long 等等
application-dve.properties
application-dve.yml
application.properties
application.yml
defaultProperties： SpringApplication 配置的参数

优先级自然从上到下。
到此整个环境配置就完成了

SpringBoot配置exclude时需要同时配置@ComponentScan与@SringbootApplication才生效
ceyowa的博客
02-24 2899
SpringBoot配置exclude时需要同时配置@ComponentScan与@SringbootApplication才生效
SpringBoot源码分析(2)--SpringBoot启动源码(万字图文源码debug讲解springboot启动原理)
weixin_49114503的博客
07-04 1204
、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
SpringBoot 过滤器Filter的过滤链 多个过滤器优先级
生产队的驴
02-05 837
指的是有多个过滤器形成的过滤链，一个项目中可以存在多个过滤器。
springboot中TypeExcludeFilter的使用
最新发布
qq_46588615的博客
09-20 476
首先你需要继承 TypeExcludeFilter，并重写 match 方法。match 方法的返回值决定了某个类是否会被排除。@Override// 排除特定类，假设我们不想加载 xxxController 类// 返回 true 表示排除该类// 否则不排除match 方法会检查传入的类是否是 xxxController，如果是，则返回 true，表示排除这个类。在你的自定义TypeExcludeFilter上加上注解@Configuration和@ComponentScan。
spring-boot源码解析之SpringApplication
weixin_45594127的博客
10-03 1307
SpringApplication源码阅读
nacos配置中心spring.config.import配置文件优先级的问题
wangBing_的博客
12-01 1796
Spring Boot 2.4 版本之后对配置文件优先级做了调整，默认去除了bootstrap配置方式。使用bootstrap引入配置的话，nacos中的优先级高，在nacos中可以方便的修改配置。现在用spring.config.import，无法修改本地application-{profile}.yml中的配置，导致无法在nacos远端配置动态修改或覆盖
六十八、SpringBoot的Filter优先级
I want to know a little more.
03-14 6344
最近接入第三方账号登录和跨域问题时遇到个大坑，浪费本人半天时间。 刚开始我是这样接入的： 1、新创建一个CommonFilter类继承Filter，加注解设置order为1作为过滤器解决跨域 2、在SpringBoot的启动类里创建返回值为FilterRegistrationBean的Bean作为登录校验过滤器 前端请求被拦截的接口发现会出现401问题（说明确实检测到未授权），但是resp...
SpringBoot源码初学者（一）：SpringBoot功能扩展接口的使用与源码分析
12-22
阅读SpringBoot源码时，理解这些扩展点的实现和调用顺序至关重要。同时，注意源码分析时应关注类与类之间的关系、方法的参数含义以及方法间的调用流程。不要试图一次性理解所有源码，而是逐步深入，结合实践加深理解...
SpringBoot源码分析：模块代码统计与解析
在深入理解SpringBoot源码之前，了解其各模块的代码量可以帮助我们更好地规划学习路径和优先级。以下是对这些模块及其功能的详细说明： 1. **spring-boot-test**: 这个模块包含了Spring Boot的测试支持，包括测试...
springboot:springboot源码分析
03-28
配置文件的加载顺序和优先级也是分析的重点。 5. **条件注解（Conditional Annotation）** - 如`@ConditionalOnClass`, `@ConditionalOnMissingBean`等，这些注解允许SpringBoot在满足特定条件时才进行配置，增强...
springBoot+jsp源码实例
02-08
同时，"绝对跑的起来"意味着所有配置都是正确的，只要按照正确的方式导入和运行，项目就能正常启动并提供服务。 "初学者适合看看"表明这个项目适合那些刚开始学习Spring Boot和JSP的开发者，因为它提供了一个实际...
springBoot静态资源文件夹以及文件夹之间的优先级
质量不太好的博客
03-11 1800
springBoot静态资源文件夹以及文件夹之间的优先级
SpringBoot项目配置方式及优先级
小何的博客
06-14 2603
SpringBoot项目配置方式及优先级
Spring Boot 实现带顺序的过滤器
一只不知疲倦的学习猿
05-18 307
Spring Boot 实现带顺序的过滤器
Spring关于配置优先级
09-30 1050
Spring Cloud Alibaba Nacos Config 目前提供了三种配置能力从 Nacos 拉取相关的配置。作用是导入配置文件，可以是本地也可以是配置中心的。作用都是读取外部的配置文件。
【SpringBoot】异步执行，设置某些异步任务优先执行
superKusch的博客
06-14 1640
前提： @Async 注解可以实现异步功能，但是如果想让其中一些异步任务先于一些异步任务执行，那么这个注解就实现不了了。参考大神文章：这篇文章，需要大显神通解决思路：为使用 这里的配置基本和使用注解时配置线程池的无异，就是使用了去为在等待队列中的线程设置优先级。 调试和输出结果 String类型任务优先级高，List类型任务优先级低 输出结果：可见List任务在最后执行完成......
Spring Boot 中的 CompletableFuture 类是什么，如何使用？
程序猿徐师兄的博客
07-08 1816
在开发企业级应用程序时，我们经常需要异步执行任务。异步执行任务可以提高应用程序的性能和响应能力。在 Java 8 中，引入了 CompletableFuture 类，它提供了一种简单而强大的方式来执行异步任务。Spring Boot 中的 CompletableFuture 类是基于 Java 8 的 CompletableFuture 类构建的。它提供了一种简单而强大的方式来执行异步任务，并在任务完成时执行回调函数。
Spring：配置优先级（注解覆盖）
dengfengling999的博客
05-29 1565
Customer： package com.baizhiedu.bean; import org.springframework.stereotype.Component; @Component //通过注解创建他的对象 public class Customer { private Integer id; private String name; public Integer getId() { return id; }......
SpringBoot Filter使用
Mr_Roki的博客
06-07 1373
1）使用Servlet3.0的注解进行配置2）启动类里面增加，进行扫描3）新建一个Filter类，，并实现对应的接口4)@WebFilter标记一个类为filter，被spring进行扫描urlPatterns：拦截规则，支持正则5）控制的方法的调用，来实现是否通过放行不放行，web应用进行跳转场景：权限控制、用户登录等。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值