深入理解SpringBoot之系统初始化器

已于 2022-05-05 11:49:47 修改
阅读量1.1k 收藏
点赞数 2
文章标签： spring boot java
于 2022-05-04 16:45:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SenGe6/article/details/124570801
版权

深入理解SpringBoot之系统初始化器


1. 什么是系统初始化器

系统初始化器是一种回调机制，可以让我们扩展自定义的属性。

2. 如何自定义系统初始化器

SpringBoot提供了三种自定义系统初始化器的方案，接下来我们一一进行实现。

ApplicationContextInitializer<ConfigurableApplicationContext>

要实现自定义系统的初始化器必须实现ApplicationContextInitializer接口，并且可以使用@Order注解进行排序，下面我来创建三个初始化器。

@Order(1)
public class FirstInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        ConfigurableEnvironment environment = applicationContext.getEnvironment();
        Map<String,Object> map = new HashMap<>();
        map.put("key1","value1");
        MapPropertySource propertySource = new MapPropertySource("firstInitializer", map);
        environment.getPropertySources().addFirst(propertySource);
        System.out.println("run firstInitializer");
    }
}

@Order(2)
public class SecondInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        ConfigurableEnvironment environment = applicationContext.getEnvironment();
        Map<String,Object> map = new HashMap<>();
        map.put("key2","value2");
        MapPropertySource propertySource = new MapPropertySource("secondInitializer", map);
        environment.getPropertySources().addFirst(propertySource);
        System.out.println("run secondInitializer");
    }
}

@Order(3)
public class ThirdInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        ConfigurableEnvironment environment = applicationContext.getEnvironment();
        Map<String,Object> map = new HashMap<>();
        map.put("key3","value3");
        MapPropertySource propertySource = new MapPropertySource("thirdInitializer", map);
        environment.getPropertySources().addFirst(propertySource);
        System.out.println("run thirdInitializer");
    }
}

启动类实现：

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

第一种实现方式：在 classpath 下创建 META-INF 文件，并在下面创建 spring.factories 文件
在这里插入图片描述
配置文件内容如下

org.springframework.context.ApplicationContextInitializer=com.wys.initializer.FirstInitializer

这样我们就配置好了第一个系统初始化器，接下来运行，可以看到第一个系统初始化器已经生效。
在这里插入图片描述
配置第二个系统初始化器，修改启动类并运行

public static void main(String[] args) {
        //SpringApplication.run(Application.class,args);
        SpringApplication application = new SpringApplication(Application.class);
        application.addInitializers(new SecondInitializer());
        application.run(args);
    }

在这里插入图片描述
可以看到第二个系统初始化器也成功的运行了，接下来配置第三个初始化器，在 application.properties 中添加如下配置并运行

# 系统初始化器配置
context.initializer.classes=com.wys.initializer.ThirdInitializer

在这里插入图片描述
可以看到三个系统初始化器都已经成功加载了，但是可以看到 ThirdInitializer 这个初始化器的 order 是最小的，在这里是第一个进行初始化的，后面我们讲原理时会给出解释。

接下来我们可以调用系统初始化器中初始化的变量

@Service
public class DemoService implements ApplicationContextAware {

    private ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    public String test(){
        return this.applicationContext.getEnvironment().getProperty("key1");
    }
}

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class DemoTest {

    @Autowired
    private DemoService demoService;

    @Test
    public void test1(){
        System.out.println(this.demoService.test());
    }
}

运行上面测试程序可以看到输出结果为 value1 ，就是我们之前系统初始化器中设置的变量。

注：如果使用 junit 进行单元测试，使用 SpringApplication 的 addInitializer 方法添加的系统初始化器时不生效的。

3. SpringBoot系统初始化器实现原理

3.1 对类初始化器进行初始化并放入到 cache 中

在 SpringApplication 的构造器中会去初始化系统初始化器，通过 SpringFactoriesLoader.loadFactoryNames 来进行初始化

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
		ClassLoader classLoader = getClassLoader();
		// 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;
	}

在这里可以看到使用 classLoader.getResource 来获取资源，FACTORIES_RESOURCE_LOCATION 值为 META-INF/spring.factories。
会将所有jar包下面的这个配置转换为 properties 并放入 cache 中，第二次获取就直接读 cache 中的数据。

public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
		String factoryClassName = factoryClass.getName();
		return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
	}

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

		try {
			Enumeration<URL> urls = (classLoader != null ?
					classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
					ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
			result = new LinkedMultiValueMap<>();
			while (urls.hasMoreElements()) {
				URL url = urls.nextElement();
				UrlResource resource = new UrlResource(url);
				Properties properties = PropertiesLoaderUtils.loadProperties(resource);
				for (Map.Entry<?, ?> entry : properties.entrySet()) {
					String factoryClassName = ((String) entry.getKey()).trim();
					for (String factoryName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
						result.add(factoryClassName, factoryName.trim());
					}
				}
			}
			cache.put(classLoader, result);
			return result;
		}
		catch (IOException ex) {
			throw new IllegalArgumentException("Unable to load factories from location [" +
					FACTORIES_RESOURCE_LOCATION + "]", ex);
		}
	}

3.2 执行系统初始化器

在 run 方法中该代码中 prepareContext 方法中会调用 applyInitializers 方法来执行类的初始化器，applyInitializer会便利系统初始化器并执行 initializer 方法。

prepareContext(context, environment, listeners, applicationArguments, printedBanner);

applyInitializers(context);

protected void applyInitializers(ConfigurableApplicationContext context) {
		for (ApplicationContextInitializer initializer : getInitializers()) {
			Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(initializer.getClass(),
					ApplicationContextInitializer.class);
			Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
			initializer.initialize(context);
		}
	}

3.3 为什么 ThirdInitializer 的 @Order注解会失效？

SpringBoot 会对初始化器进行排序，可以看到在我们自定义的初始化器前面存在两个初始化器，他们的 Order 都为 0，具备更高的优先级。
在这里插入图片描述
在 DelegatingApplicationContextInitializer 这个类中的 initializer 方法会寻找配置文件中 context.initializer.classes 配置的初始化器并执行，我把代码贴过来大家一看便知。

public class DelegatingApplicationContextInitializer
		implements ApplicationContextInitializer<ConfigurableApplicationContext>, Ordered {

	// NOTE: Similar to org.springframework.web.context.ContextLoader

	private static final String PROPERTY_NAME = "context.initializer.classes";

	private int order = 0;

	@Override
	public void initialize(ConfigurableApplicationContext context) {
		ConfigurableEnvironment environment = context.getEnvironment();
		List<Class<?>> initializerClasses = getInitializerClasses(environment);
		if (!initializerClasses.isEmpty()) {
			applyInitializerClasses(context, initializerClasses);
		}
	}

	private List<Class<?>> getInitializerClasses(ConfigurableEnvironment env) {
		String classNames = env.getProperty(PROPERTY_NAME);
		List<Class<?>> classes = new ArrayList<>();
		if (StringUtils.hasLength(classNames)) {
			for (String className : StringUtils.tokenizeToStringArray(classNames, ",")) {
				classes.add(getInitializerClass(className));
			}
		}
		return classes;
	}

	private Class<?> getInitializerClass(String className) throws LinkageError {
		try {
			Class<?> initializerClass = ClassUtils.forName(className, ClassUtils.getDefaultClassLoader());
			Assert.isAssignable(ApplicationContextInitializer.class, initializerClass);
			return initializerClass;
		}
		catch (ClassNotFoundException ex) {
			throw new ApplicationContextException("Failed to load context initializer class [" + className + "]", ex);
		}
	}

	private void applyInitializerClasses(ConfigurableApplicationContext context, List<Class<?>> initializerClasses) {
		Class<?> contextClass = context.getClass();
		List<ApplicationContextInitializer<?>> initializers = new ArrayList<>();
		for (Class<?> initializerClass : initializerClasses) {
			initializers.add(instantiateInitializer(contextClass, initializerClass));
		}
		applyInitializers(context, initializers);
	}

	private ApplicationContextInitializer<?> instantiateInitializer(Class<?> contextClass, Class<?> initializerClass) {
		Class<?> requireContextClass = GenericTypeResolver.resolveTypeArgument(initializerClass,
				ApplicationContextInitializer.class);
		Assert.isAssignable(requireContextClass, contextClass,
				String.format(
						"Could not add context initializer [%s]" + " as its generic parameter [%s] is not assignable "
								+ "from the type of application context used by this " + "context loader [%s]: ",
						initializerClass.getName(), requireContextClass.getName(), contextClass.getName()));
		return (ApplicationContextInitializer<?>) BeanUtils.instantiateClass(initializerClass);
	}

	@SuppressWarnings({ "unchecked", "rawtypes" })
	private void applyInitializers(ConfigurableApplicationContext context,
			List<ApplicationContextInitializer<?>> initializers) {
		initializers.sort(new AnnotationAwareOrderComparator());
		for (ApplicationContextInitializer initializer : initializers) {
			initializer.initialize(context);
		}
	}

	public void setOrder(int order) {
		this.order = order;
	}

	@Override
	public int getOrder() {
		return this.order;
	}

以上就是类初始化器的使用和原理，大家有什么问题欢迎在评论区进行讨论。

程序员逍遥
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Springboot Initializer
09-01
内网中连接不上https://start.spring.io，搭建\https://start.spring.io一样的服务器。 initializr-service-0.7.0.BUILD-SNAPSHOT.jar
学习篇-springboot-系统初始化器
东东爱编码博客
04-07 1589
文章目录一、springboot-系统初始化器1. 实现方式一2. 实现方式二3. 实现方式三 一、springboot-系统初始化器 系统初始化器重点关注的类：ApplicationContextInitializer Spring容器刷新之前执行的一个回调函数 向SpringBoot容器中注册属性 继承接口自定义实现 1. 实现方式一 存放自定属性 实现ApplicationContex...
spring-boot-initializer
04-09
Spring 是一个扩展性很强的容器框架，为开发者提供了丰富的扩展入口，其中一个扩展点便是 ApplicationContextInitializer （应用上下文初始化器 ）。
SpringBoot的系统初始化器分析
lhf2112的博客
12-31 502
三种方式定义初始化器，来为容器中增加自定义的对象
SpringBoot启动流程中的Initializer和Listeners
weixin_46666822的博客
05-07 2317
SpringBoot启动大致需要分为两个阶段，第一个阶段就是实例化一个SpringApplication对象，第二个阶段就是调用这个对象的run()方法。在SpringApplication的构造方法中，分别设置了Listeners和Initializers。 1.Initializers 1.定义 private List<ApplicationContextInitializer<?>> initializers; 在SpringApplication中定义了一个泛型为Appl
SpringBoot深入理解之内置web容器及配置的总结
08-26
SpringBoot深入理解之内置web容器及配置的总结 SpringBoot作为当前最流行的Java框架之一，具有很多优点，如快速开发、简洁配置、自动依赖注入等。今天，我们将深入探讨SpringBoot中的内置web容器及配置，了解其...
springboot订餐系统.zip
04-18
《SpringBoot在线订餐系统详解》 在现代的互联网应用中，SpringBoot因其简洁的配置、快速的开发特性，已经成为企业级...通过对各个层面的深入理解，开发者能够更好地设计和优化此类系统，为用户提供更优质的订餐体验。
springboot排课系统.zip
最新发布
03-23
SpringBoot排课系统是一个基于Java技术栈的教育管理软件，旨在帮助学生深入理解软件开发的整个流程，从需求分析到系统设计，再到编码实现和测试部署，涵盖了软件工程的核心环节。本文将详细探讨SpringBoot在构建排课...
基于springboot的oa自动化办公系统
11-06
【标题】：“基于SpringBoot的OA自动...通过深入研究和实践这个基于SpringBoot的OA自动化办公系统，不仅可以提升对SpringBoot框架的理解，还能掌握OA系统的开发流程，对于个人技能的提升和职业发展具有积极的推动作用。
基于springboot商城系统
04-02
本篇文章将深入探讨如何利用Java技术栈，特别是SpringBoot框架来构建一个功能完备的商城系统。本文将涵盖SpringBoot的基本概念、商城系统的关键组件以及实现细节。 SpringBoot是由Pivotal团队开发的，旨在简化...
SpringBoot之系统初始化器（一）
mo_long00的博客
06-27 580
ApplicationContextInitializer作为SpringBoot的系统初始化器，我们先来知其所以然，而后知其然。ApplicationContextInitialializer是在Spring Context刷新之前初始化Spring ConfigurableApplicationContext的回调接口。通常用于需要通过编程初始化应用上下文的web应用中。例如，针对上下文环境注入属性或者激活配置。此外，所有实现了ApplicationContextInitializer接口的类还可以通过
【SpringBoot深入理解源码】之自定义系统初始化器
铭记：
05-17 599
有人辞官归故里 有人星夜赶科考 前途似海来日方长。 文章目录实现实现方式测试为什么ThirdInitializer第一个执行？注意如何被系统容器所识别并注册进去SpringFactoriesLoader源码SpringFactoriesLoader加载流程及作用 实现 实现方式 方式一(推荐) 实现ApplicationContextInitializer接口 @Order(1) public class FirstInitializer implements ApplicationContext.
Spring Boot Environment的初始化和预处理
weixin_34026276的博客
04-08 837
Spring Boot Environment的初始化和预处理实在启动时完成的， 即SpringApplication的run方法中。 ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments); Environment负责读...
springboot-Initializer例子及分析
PacosonSWJTU的博客
11-14 687
【README】 1，本文主要编写了 初始化器例子并分析了其调用路径； 2，初始化器的执行顺序 先于 后置处理器； 后置处理器，refer2 springboot：BeanPostProcessor示例及分析_PacosonSWJTU的博客-CSDN博客【README】1，本文主要分析 BeanPostProcessor 的作用， 开发方式；2，BeanPostProcessor 是bean后置处理器， 简而言之就是bean被创建好了，之后如果需要对其属性进行修改，则 需要使用 BeanPostPr..
仅需5分钟，使用Initializr快速开发Spring Boot应用
u013643074的博客
01-15 2138
讲解如何使用Spring Initializr在本地环境中创建和运行基本的Spring Boot应用程序。
Spring Boot-使用Spring Initializer快速创建Spring Boot项目
Kevinnsm的博客
12-13 300
File->project->Spring Initializer 点击next 点击下一步即可，如果是第一次可能需要下载jar包，如下图
springboot源码解析-管中窥豹系列之Initializer（四）
程序员丰极
01-12 194
一、前言 Springboot源码解析是一件大工程，逐行逐句的去研究代码，会很枯燥，也不容易坚持下去。 我们不追求大而全，而是试着每次去研究一个小知识点，最终聚沙成塔，这就是我们的springboot源码管中窥豹系列。 二、Initializer 上一节我们介绍了Runner,它是在项目加载完成之后执行的 有后就有前，有没有在项目加载之前执行的呢？ 我们今天介绍的ApplicationContextInitializer就是在spring的bean加载之前执行的 public interface
3.使用Spring Initializer快速创建Spring Boot项目
Mao_yafeng的博客
09-28 769
3.使用Spring Initializer快速创建Spring Boot项目 1.使用IDEA快速创建项目 1）创建项目 打开IDEA-> file->new->Project 打开创建项目的页面如下 ​ 左侧是创建项目的组件以及需要依赖的组件，选中Spring boot 需要的Spring Initializr,右侧选择JDK版本，点击next按钮，如下图 ​ 这一步跟我们创建maven项目一样，项目名字（Artifact）不能出现大写字母,Type 要选择 Mav
使用spring Initializer快速创建spring Boot项目
wangxulei123的博客
12-03 1807
2.使用spring Initializer快速创建spring Boot项目 2.1 利用idea创建springBoot项目时，可以选择多个模块。模块就是你需要用到的功能模块，比如sql、nosql…** 默认生成的spring Boot项目： 主程序已经生成好了，只需要编写业务逻辑 resources文件夹中目录结构 static：保存所有的静态资源：js css images; tem...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值