spring之ImportSelector和DeferredImportSelector注解分析

最新推荐文章于 2024-07-23 18:16:22 发布
最新推荐文章于 2024-07-23 18:16:22 发布
阅读量517 收藏
点赞数
分类专栏： spring 文章标签： spring spring boot java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wang0907/article/details/117068749
版权

写在前面

本文基于springboot来进行测试，对springboot不了解或者是想要直接获取测试代码的朋友，可以参考这篇文章。

1：源码分析

1.1：入口分析

当我们执行main方法，然后调用run函数，最终会执行到代码org.springframework.context.annotation.ConfigurationClassParser#parse(java.util.Set<org.springframework.beans.factory.config.BeanDefinitionHolder>)，该方法是用来解析java config类的，即标记有@Configuration注解的类,的我们来通过调用栈看下：
在这里插入图片描述
其中4执行BeanFactoryPostProcessor的时候会调用到该方法，关于该过程详细可以参考这篇文章。parse方法也正是我们要分析的入口了。

1.2：parse

源码位置：org.springframework.context.annotation.ConfigurationClassParser#parse(java.util.Set<org.springframework.beans.factory.config.BeanDefinitionHolder>)，源码如下：

org.springframework.context.annotation.ConfigurationClassParser#parse(java.util.Set<org.springframework.beans.factory.config.BeanDefinitionHolder>)
public void parse(Set<BeanDefinitionHolder> configCandidates) {
	for (BeanDefinitionHolder holder : configCandidates) {
		// 获取bean定义
		BeanDefinition bd = holder.getBeanDefinition();
		try {
			// <202105201137>
			if (bd instanceof AnnotatedBeanDefinition) {
				// <202105231114>
				parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
			}
			....snip...
	}
	// <202105201138>
	this.deferredImportSelectorHandler.process();
}

<202105201137>处如果是AnnotatedBeanDefinition类型，这是BeanDefinition的子接口，对外暴露了注解源信息，源码如下：

org.springframework.beans.factory.annotation.AnnotatedBeanDefinition
// 扩展BeanDefinition接口，在不需要加载class类的前提下，暴漏关于bean对应class的AnnotationMetadata
public interface AnnotatedBeanDefinition extends BeanDefinition {

	// 返回bean定义对应的注解元信息对象
	AnnotationMetadata getMetadata();

	// 如果是有工厂方法的话，返回工厂方法的注解元信息对象
	@Nullable
	MethodMetadata getFactoryMethodMetadata();

}

<202105231114>处源码如下：

org.springframework.context.annotation.ConfigurationClassParser#parse(org.springframework.core.type.AnnotationMetadata, java.lang.String)
protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
	// <202105231117>
	processConfigurationClass(new ConfigurationClass(metadata, beanName));
}

<202105231117>处源码如下：

org.springframework.context.annotation.ConfigurationClassParser#processConfigurationClass
protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
	...snip...
	// 这里通过do..while循环来依次处理每个bean的相关注解
	do {
		// <202105231122>
		sourceClass = doProcessConfigurationClass(configClass, sourceClass);
	} while (sourceClass != null);
	...snip...
}

<202105231122>(重点！！！)处源码如下：

org.springframework.context.annotation.ConfigurationClassParser#doProcessConfigurationClass
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
			throws IOException {
	// 如果是标注了@Component注解
	if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
		processMemberClasses(configClass, sourceClass);
	}

	// 处理@PropertySource注解
	// 关于PropertySource可以参考：https://blog.csdn.net/wang0907/article/details/117037183
	for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
			sourceClass.getMetadata(), PropertySources.class,
			org.springframework.context.annotation.PropertySource.class)) {
		if (this.environment instanceof ConfigurableEnvironment) {
			processPropertySource(propertySource);
		}
		else {
			logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
					"]. Reason: Environment must implement ConfigurableEnvironment");
		}
	}

	// 处理@ComponentScan注解
	Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
			sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
	if (!componentScans.isEmpty() &&
			!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
		for (AnnotationAttributes componentScan : componentScans) {
			// 通过当前的componentscan的信息，扫描对应的类生成bean定义
			// 最终成为spring bean
			Set<BeanDefinitionHolder> scannedBeanDefinitions =
					this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
			// 递归处理有@Configuration注解的bean定义
			for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
				BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
				if (bdCand == null) {
					bdCand = holder.getBeanDefinition();
				}
				if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
					parse(bdCand.getBeanClassName(), holder.getBeanName());
				}
			}
		}
	}
	// <202105251519>
	// 处理@Import注解
	// 关于@Import注解可以参考：https://blog.csdn.net/wang0907/article/details/113131549#t7
	processImports(configClass, sourceClass, getImports(sourceClass), true);

	// 处理@ImportResource注解
	// 关于@ImportResource注解，可以参考：https://blog.csdn.net/wang0907/article/details/117037183
	// 一般在启动类上我们不会使用@ImportResource注解，所以这里一般为null
	AnnotationAttributes importResource =
			AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
	if (importResource != null) {
		String[] resources = importResource.getStringArray("locations");
		Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
		for (String resource : resources) {
			String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
			configClass.addImportedResource(resolvedResource, readerClass);
		}
	}

	// <202105251442>
	// 处理类中方法的@Bean注解
	Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
	for (MethodMetadata methodMetadata : beanMethods) {
		configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
	}

	processInterfaces(configClass, sourceClass);

	// 递归处理@Configuration注解所在类的父类，返回值会在外层的do...while循环中被处理
	if (sourceClass.getMetadata().hasSuperClass()) {
		String superclass = sourceClass.getMetadata().getSuperClassName();
		if (superclass != null && !superclass.startsWith("java") &&
				!this.knownSuperclasses.containsKey(superclass)) {
			this.knownSuperclasses.put(superclass, configClass);
			return sourceClass.getSuperClass();
		}
	}

	// 如果是执行到这里，则外层的do...while循环也就结束了
	return null;
}

<202105251442>处是处理标记有@Bean注解的方法，比如在启动类配置如下：

@SpringBootApplication
public class HelloWorldMainApplication {

    public static void main(String[] args) throws URISyntaxException, IOException {
        ConfigurableApplicationContext run = SpringApplication.run(HelloWorldMainApplication.class, args);
        MyPropertySourceBean bean = run.getBean(MyPropertySourceBean.class);
        System.out.println(bean);
    }

    @Bean
    public Object obj1() {
        return new Object();
    }

    @Bean
    public Object obj2() {
        return new Object();
    }
}

则此处运行结果就如下图，获取的是obj1和obj2这两个方法的信息：
在这里插入图片描述
<202105251519>处会处理ImportSelector，具体参考1.3：processImports。<202105201138>处用于处理DeferredImportSelector，具体参考1.4：deferredImportSelectorHandler_process。

1.3：processImports

源码：

org.springframework.context.annotation.ConfigurationClassParser#processImports
private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
			Collection<SourceClass> importCandidates, boolean checkForCircularImports) {
	// <202105251535>
	if (importCandidates.isEmpty()) {
		return;
	}
	// 循环引入等异常情况检测
	if (checkForCircularImports && isChainedImportOnStack(configClass)) {
		this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
	}
	else {
		this.importStack.push(configClass);
		try {
			// 循环处理每个候选者
			for (SourceClass candidate : importCandidates) {
				// 如果是ImportSelector
				if (candidate.isAssignable(ImportSelector.class)) {
					Class<?> candidateClass = candidate.loadClass();
					// 创建ImportSelector类实例
					ImportSelector selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class);
					// 回调相关aware
					ParserStrategyUtils.invokeAwareMethods(
							selector, this.environment, this.resourceLoader, this.registry);
					// 如果是也实现了DeferredImportSelector，注意这里就不执行else了，即不执行ImportSelector的selectImports方法
					if (selector instanceof DeferredImportSelector) {
						// <202105251610>
						// 处理DeferedImportSelector逻辑
						this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
					}
					else {
						// 通过执行ImportSelector接口的selectImports方法，获取要import的类名称数组，重要！！！
						String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
						Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);
						processImports(configClass, currentSourceClass, importSourceClasses, false);
					}
				}
				// 如果是ImportBeanDefinitionRegistrar，用于注册bean定义
				else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
					Class<?> candidateClass = candidate.loadClass();
					ImportBeanDefinitionRegistrar registrar =
							BeanUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class);
					ParserStrategyUtils.invokeAwareMethods(
							registrar, this.environment, this.resourceLoader, this.registry);
					configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
				}
				else {
					this.importStack.registerImport(
							currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
					processConfigurationClass(candidate.asConfigClass(configClass));
				}
			}
		}
		catch (BeanDefinitionStoreException ex) {
			throw ex;
		}
		catch (Throwable ex) {
			throw new BeanDefinitionStoreException(
					"Failed to process import candidates for configuration class [" +
					configClass.getMetadata().getClassName() + "]", ex);
		}
		finally {
			this.importStack.pop();
		}
	}
}

<202105251535>处的值来源于@Import注解信息的值，来源如下图：
标记1和2的就是结果
标记1和2的就是结果。
最终结果值如下图：
在这里插入图片描述
<202105251610>处理在实现了ImportSelector接口时，也实现了DeferredImportSelector接口的情况，源码如下：

org.springframework.context.annotation.ConfigurationClassParser.DeferredImportSelectorHandler#handle
public void handle(ConfigurationClass configClass, DeferredImportSelector importSelector) {
	DeferredImportSelectorHolder holder = new DeferredImportSelectorHolder(configClass, importSelector);
	if (this.deferredImportSelectors == null) {
		DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
		handler.register(holder);
		// 执行相关的import的工作
		handler.processGroupImports();
	}
	else {
		// 添加到集合中，统一处理，详细参考“1.4：deferredImportSelectorHandler_process”
		this.deferredImportSelectors.add(holder);
	}
}

1.4：deferredImportSelectorHandler_process

重要！！！,用来引入springboot在META-INF/spring.factories文件中配置的自动配置类。
源码如下：

org.springframework.context.annotation.ConfigurationClassParser.DeferredImportSelectorHandler#process
public void process() {
			// <202105251650>
			List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
	this.deferredImportSelectors = null;
	try {
			if (deferredImports != null) {
			DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
			deferredImports.sort(DEFERRED_IMPORT_COMPARATOR);
			deferredImports.forEach(handler::register);
			// <202105251708>
			handler.processGroupImports();
		}
	}
	finally {
		this.deferredImportSelectors = new ArrayList<>();
	}
}

<202105251650>默认只有一个即AutoConfigurationImportSelector类，如下图：
在这里插入图片描述
<202105251708>处是执行具体的引入，源码如下：

org.springframework.context.annotation.ConfigurationClassParser.DeferredImportSelectorGroupingHandler#processGroupImports
public void processGroupImports() {
	// 循环所有，依次处理
	for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {
		
		// grouping.getImports()处就是获取所有的自动配置类,然后在依次递归处理import信息
		grouping.getImports().forEach(entry -> {
			ConfigurationClass configurationClass = this.configurationClasses.get(entry.getMetadata());
			try {
				processImports(configurationClass, asSourceClass(configurationClass),
						asSourceClasses(entry.getImportClassName()), false);
			}
			catch (BeanDefinitionStoreException ex) {
				throw ex;
			}
			catch (Throwable ex) {
				throw new BeanDefinitionStoreException(
						"Failed to process import candidates for configuration class [" +
								configurationClass.getMetadata().getClassName() + "]", ex);
			}
		});
	}
}

最后

参考文章列表：
ImportSelector与DeferredImportSelector的区别（spring4）。

一户董
关注
专栏目录
spring源码解析之DeferredImportSelector执行延迟导入配置类
蛐蛐的博客
10-14 875
1.简介 之前在对象@Configuration注解配置类bean定义的解析中，最后有一步是执行延迟选择器导入 /** * 扫描{@link BeanDefinitionHolder}，填充{@link ConfigurationClass} * @param configCandidates */ public void parse(Set<BeanDefinitionHolder> configCandidates) { /* 解析配置类bean定义 *.
Spring DeferredImportSelector类解析
Mark2527的博客
01-17 1945
Spring DeferredImportSelector类解析 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录Spring DeferredImportSelector类解析前言一、DeferredImportSelector结构二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，
ImportSelector 与 DeferredImportSelector 的区别（spring4）
java_beautiful的博客
06-25 365
在使用 @Import 注解来注册 bean 的时候，Import 注解的值可以是 ImportSelector 或者 DeferredImportSelector 的实现类，spring 容器会实例化这个实现类，并执行其 selectImports 方法，那么问题来了： ImportSelector 和 DeferredImportSelector 的区别在哪里，我们自定义 Imort 逻辑的时候该选择哪个呢？ 本文通过分析相关的 spring 源码来查找答案；...
ImportSelector与DeferredImportSelector的区别（spring4）
yygr的博客
03-23 250
https://blog.csdn.net/boling_cavalry/article/details/82555352 在使用@Import注解来注册bean的时候，Import注解的值可以是ImportSelector或者DeferredImportSelector的实现类，spring容器会实例化这个实现类，并执行其selectImports方法，那么问题来了：ImportSelector和DeferredImportSelector的区别在哪里，我们自定义Imort逻辑的时候该选择哪个呢？本文通
DeferredImportSelector和ImportSelector的区别？
最新发布
科技互联网领域深度探索者，乐于分享与写作。
07-23 277
DeferredImportSelector与ImportSelector的主要区别在于执行时机。ImportSelector在Spring容器解析配置类时即执行，决定要导入的配置类；而DeferredImportSelector则在所有配置类解析完成后执行，允许基于已注册Bean的状态或属性来动态导入配置类，提供了更高的灵活性和配置能力。这种区别使得DeferredImportSelector在处理复杂依赖关系时更为适用。
Spring注解系列八：组件注册-ImportSelector
苍穹尘的博客
05-08 267
1、MainConfig2 @Configuration //ImportSelector:返回需要导入的组件的全类名数组； @Import(MyImportSelector.class) public class MainConfig2 { } 2、自定义需要导入的组件MyImportSelector 。实现ImportSelector 接口 //自定义逻辑返回需要导入的组件 public ...
同胞兄弟，ImportSelector接口与DeferredImportSelector接口的区别
毛毛的专栏
07-28 900
文章目录一、前言二、看官方文档三、分析spring源码中对这两个接口的处理四、小结 一、前言 在使用@Import注解来注册bean的时候，Import注解的值可以是ImportSelector或者DeferredImportSelector的实现类，spring容器会实例化这个实现类，并执行其selectImports方法， 金手指： Import注解的值可以是ImportSelector或者DeferredImportSelector的实现类，spring容器会实例化这个实现类，并执行其selectI
深入理解Spring的ImportSelector接口
weixin_46062001的博客
04-23 240
ImportSelector接口是至spring中导入外部配置的核心接口，在SpringBoot的自动化配置和@EnableXXX(功能性注解)都有它的存在，关于SpringBoot的分析可以参考：深入理解SpringBoot的自动装配。 一、关于ImportSelector接口 packageorg.springframework.context.annotation; import...
Spring进阶（十四）之@Import注解
weixin_56644618的博客
10-12 562
Spring中@Import源码级分析
spring注解@Import、ImportSelector、ImportBeanDefinitionRegistrar向IOC容器中导入组建
qq_36722039的博客
08-11 2123
* 在容器中注册组建 * 1:包扫描：带用注解的组建(@Controller、@Service、@Repotitory...) * 2:bean注解导入组建【导入第三方包里的组建】 * 3:@Import快速向容器中导入组建 * 1.@Import(需要导入的组建)；容器中会自动注册组建，默认id是全类名 * 2.I...
@EnableAutoConfiguration中@Import注解对于ImportSelector与DeferredImportSelector接口实现类的细节与区别
小爽帅到拖网速的博客
12-14 551
@EnableAutoConfiguration中@Import注解对于ImportSelector与DeferredImportSelector接口实现类的细节与区别，包括对AutoConfigurationImportSelector对于@Import注入的自动配置流程分析
Spring高级之注解@Import注解、ImportSelector、ImportBeanDefinitionRegistrar详解（超详细）
qq_40837310的博客
06-06 3502
定义/作用 @Import注解只能作用在类上，一种使用场景是在spring注解驱动开发环境下与配置类配合使用的，其作用是引用其他配置类。使得我们可以和早起的基于XML配置文件开发那样。使用不同的配置类配置不同的内容，比如Mysql数据源配置用一个配置类。Redis数据源配置用一个配置类等。然后使用在注解在一个主配置类中引入这些从配置类，使得配置更加清晰。被引入的类可以不使用@Configuration、@Component注解。 另一种使用 场景是该注解也是一种注册bean的方案。可以在配置类中使用Impo
Spring注解驱动开发第9讲——在@Import注解中使用ImportSelector接口导入bean
李阿昀的博客
11-30 4538
写在前面 在上一讲关于Spring的@Import注解的文章中，我们简单介绍了如何使用@Import注解给容器中快速导入一个组件，而我们知道，@Import注解总共包含三种使用方法，上一讲已经讲解完第一种方式了，今天我们就一起来学习下关于@Import注解非常重要的第二种方式，即ImportSelector接口的方式。 ImportSelector接口概述 ImportSelector接口是Spring中导入外部配置的核心接口，在Spring Boot的自动化配置和@EnableXXX（功能性注解）都有它的
Spring.ImportSelector接口
cristianoxm的博客
02-19 663
一、关于ImportSelector接口 ImportSelector接口是至spring中导入外部配置的核心接口，在SpringBoot的自动化配置和@EnableXXX(功能性注解)都有它的存在 二、ImportSelector接口源码 package org.springframework.context.annotation; import org.springframework.core.type.AnnotationMetadata; /** * Interface to be imple
Spring架构篇--2.5.4 远程通信基础--Select 源码篇--selector.close()&总结
拽着尾巴的鱼儿的博客
02-22 276
Select 源码篇--selector.close()&总结
Spring系列——@Import、ImportSelector接口
明亮的星光
10-15 1034
Spring注解之@Import前言@Import源码 前言 我们已经知道两种方式给Spring注册组件 包扫描+注解的方式(@Controller、@Service、@Reposity、@Comment) 使用@Configuration+@Bean的方式 这两种的使用区别，第一种只能注册我们自己写的组件，而第二种可以注册jar包里面的组件 接下来我来介绍第三种方式使用@Import来给Spring注册组件 @Import源码 @Target(ElementType.TYPE) @Retention(
Spring-ImportSelector接口功能介绍
weixin_37862824的博客
09-20 696
ImportSelector接口是至spring中导入内部类或者外部类的核心接口，只需要其定义的方法内返回需要创建bean的class字符串就好了，比如：当我们引入一个外部share包，我们拿到里面的Class返回出去，就能得到这个bean,是多么神奇的事情，前提是这个类不是接口哦。ImportSelector往往结合@Import注解一起使用，可以参考我的这篇文章。
（转载）深入理解Spring的ImportSelector，DeferredImportSelector
AnY11的专栏
06-24 2085
转载自：https://www.cnblogs.com/niechen/p/9262452.html 阅读目录 一、关于ImportSelector接口 二、自定义@EnableXXX注解 三、ImportSelector源码分析 　　ImportSelector接口是至spring中导入外部配置的核心接口，在SpringBoot的自动化配置和@EnableXXX(功能性注解)都有它的存在...
Spring框架中@Transactional注解详解
"spring的@Transactional注解用法解读" 在企业级应用中，事务管理是确保数据一致性、可靠性和完整性的关键。Spring Framework 提供了一套强大的事务管理机制，包括编程式和声明式事务管理，使得开发者能够以统一的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值