@Import标签,从源码详细分析使用和原理

最新推荐文章于 2025-06-08 19:58:55 发布
原创 最新推荐文章于 2025-06-08 19:58:55 发布 · 942 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#@Import标签 #源码分析使用和原理

本文详细分析了Spring框架中@Import标签的使用，包括导入ImportSelector实现类、ImportBeanDefinitionRegistrar实现类和普通类的三种情况。通过实例展示了不同返回类型对Spring容器的影响，并给出了核心源码解析。结论指出，ImportSelector和ImportBeanDefinitionRegistrar实现类自身不会放入容器，而特定条件下的普通类会被解析并放入容器。

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

首先@Import标签可以引入三种类,分别说明其作用

一.@Import(ImportSelector实现类.class)

实现接口ImportSelector,重写抽象方法selectImports,返回类全限定名字符串数组
下面针对返回类全限定名三种不同场景分析:

1.selectImports方法返回的类全限定名是普通类(即没有实现ImportSelector和ImportBeanDefinitionRegistrar接口)

①编写实现ImportSelector接口的子类MyImportSelector,重写抽象方法selectImports,返回普通类全限定名字符串

import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;

public class MyImportSelector implements ImportSelector {

	@Override
	public String[] selectImports(AnnotationMetadata importingClassMetadata) {
		//返回的User就是普通类
		return new String[]{"cn.zhutan.test.import_anno.User"};
	}

}

②在测试类中,用@Import标签引入MyImportSelector

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Import;

@Import(value = {MyImportSelector.class})
public class DemoTest {
	@SuppressWarnings("resource")
	public static void main(String[] args) {
		ApplicationContext ac = new AnnotationConfigApplicationContext(DemoTest.class);
		User user = ac.getBean(User.class);
		System.out.println(user);
	}
}

运行结果如下,表明可以从spring已经创建User对象,并且可以从容器中获取到User对象
在这里插入图片描述
结论:
当你返回的类是普通类时,spring后续就会根据你返回的类全限定名字符串解析和创建bean定义,创建bean对象等等一系列操作,然后放到spring容器中

2.返回的类是ImportSelector子类

①编写ImportSelector的子类OtherImportSelector,重写抽象方法selectImports,返回MyImportSelector全限定名字符串

import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;

public class OtherImportSelector implements ImportSelector {

	@Override
	public String[] selectImports(AnnotationMetadata importingClassMetadata) {
		//返回的MyImportSelector是实现了ImportSelector接口的类
		//而MyImportSelector的selectImports方法又返回了User类
		return new String[]{"cn.zhutan.test.import_anno.MyImportSelector"};
	}

}

②在测试类中,用@Import标签引入OtherImportSelector

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Import;

@Import(value = {OtherImportSelector.class})
public class DemoTest {
	@SuppressWarnings("resource")
	public static void main(String[] args) {
		ApplicationContext ac = new AnnotationConfigApplicationContext(DemoTest.class);
		User user = ac.getBean(User.class);
		System.out.println(user);
		MyImportSelector mis = ac.getBean(MyImportSelector.class);
		System.out.println(mis);
		//OtherImportSelector ois = ac.getBean(OtherImportSelector.class);
		//System.out.println(ois);
	}
}

运行结果如下,User对象可以从spring容器中拿到,但是MyImportSelector不能从spring中拿到,同理OtherImportSelector也不能拿到
在这里插入图片描述
结论:
当返回的类是ImportSelector子类时,创建该类对象后(只是创建了临时变量),调用完selectImports方法后,对象就销毁了,其实就是局部变量而已,不会放到spring容器中

3.返回的类是ImportBeanDefinitionRegistrar子类

①编写ImportBeanDefinitionRegistrar的实现类MyImportBeanDefinitionRegistrar,重写抽象方法registerBeanDefinitions,注册了User对象

import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

	@Override
	public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(User.class);
		AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();
		/**
		 * 注册了User对象
		 */
		registry.registerBeanDefinition("user", beanDefinition);
	}

}

②编写ImportSelector的子类AnOtherImportSelector,重写抽象方法selectImports,返回MyImportBeanDefinitionRegistrar全限定名字符串

import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;

public class AnOtherImportSelector implements ImportSelector{

	@Override
	public String[] selectImports(AnnotationMetadata importingClassMetadata) {
		//返回实现了接口ImportBeanDefinitionRegistrar的子类MyImportBeanDefinitionRegistrar
		return new String[]{"cn.zhutan.test.import_anno.MyImportBeanDefinitionRegistrar"};
	}

}

③在测试类中,用@Import标签引入AnOtherImportSelector

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Import;

@Import(value = {AnOtherImportSelector.class})
public class DemoTest {
	@SuppressWarnings("resource")
	public static void main(String[] args) {
		ApplicationContext ac = new AnnotationConfigApplicationContext(DemoTest.class);
		User user = ac.getBean(User.class);
		System.out.println(user);
		MyImportBeanDefinitionRegistrar mibdr = ac.getBean(MyImportBeanDefinitionRegistrar.class);
		System.out.println(mibdr);
	}
}

运行结果如下,可以从spring容器中获取User对象,但是不能获取MyImportBeanDefinitionRegistrar对象
在这里插入图片描述
结论:
当返回的类是ImportBeanDefinitionRegistrar子类时,创建该类对象后(只是创建了临时变量)并put到了importBeanDefinitionRegistrars这个map中,后续执行registerBeanDefinitions方法创建了User对象放到了spring容器中,但是MyImportBeanDefinitionRegistrar本身不会放到spring容器中

二.@Import(ImportBeanDefinitionRegistrar实现类.class)

①编写ImportBeanDefinitionRegistrar的实现类MyImportBeanDefinitionRegistrar,重写抽象方法registerBeanDefinitions,注册User对象

import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

	@Override
	public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(User.class);
		AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();
		/**
		 * 注册了User对象
		 */
		registry.registerBeanDefinition("user", beanDefinition);
	}

}

②在测试类中,用@Import标签引入MyImportBeanDefinitionRegistrar

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Import;

@Import(value = {MyImportBeanDefinitionRegistrar.class})
public class DemoTest {
	@SuppressWarnings("resource")
	public static void main(String[] args) {
		ApplicationContext ac = new AnnotationConfigApplicationContext(DemoTest.class);
		User user = ac.getBean(User.class);
		System.out.println(user);
		MyImportBeanDefinitionRegistrar mibdr = ac.getBean(MyImportBeanDefinitionRegistrar.class);
		System.out.println(mibdr);
	}
}

运行结果如下,可以从spring容器中获取User对象,但是不能获取MyImportBeanDefinitionRegistrar对象
在这里插入图片描述
结论:
实现接口ImportBeanDefinitionRegistrar,重写抽象方法registerBeanDefinitions,参数中提供了注册器,可以向容器中注册相关bean,但是从下面源码可以知道,实现ImportBeanDefinitionRegistrar的子类首先会put到importBeanDefinitionRegistrars这个map中,后续会取出importBeanDefinitionRegistrars调用registerBeanDefinitions方法,进行注册bean,MyImportBeanDefinitionRegistrar本身不会放到spring容器中

三.@Import(普通类.class)

①创建User对象

public class User {
	
}

②在测试类中,用@Import标签引入User

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Import;

@Import(value = {User.class})
public class DemoTest {
	@SuppressWarnings("resource")
	public static void main(String[] args) {
		ApplicationContext ac = new AnnotationConfigApplicationContext(DemoTest.class);
		User user = ac.getBean(User.class);
		System.out.println(user);
	}
}

运行结果如下,User对象可以从spring容器拿出来
在这里插入图片描述
结论:
普通对象会解析创建然后放到spring容器中

核心源码如下:

ConfigurationClassParser解析@Import标签,下面贴出核心方法

private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
			Collection<SourceClass> importCandidates, boolean checkForCircularImports) {

		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)) {
						// Candidate class is an ImportSelector -> delegate to it to determine imports
						Class<?> candidateClass = candidate.loadClass();
						ImportSelector selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class);
						ParserStrategyUtils.invokeAwareMethods(
								selector, this.environment, this.resourceLoader, this.registry);
						if (this.deferredImportSelectors != null && selector instanceof DeferredImportSelector) {
							/**
							 * 如果是这个接口的实现类DeferredImportSelector,那么就添加到集合中,延迟执行
							 */
							this.deferredImportSelectors.add(
									new DeferredImportSelectorHolder(configClass, (DeferredImportSelector) selector));
						}
						else {
							/**
							 * 这里调用了ImportSelector.selectImports方法
							 */
							String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
							Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);
							processImports(configClass, currentSourceClass, importSourceClasses, false);
						}
					}
					/**
					 * 处理ImportBeanDefinitionRegistrar
					 */
					else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
						// Candidate class is an ImportBeanDefinitionRegistrar ->
						Class<?> candidateClass = candidate.loadClass();
						// delegate to it to register additional bean definitions
						ImportBeanDefinitionRegistrar registrar =
								BeanUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class);
						ParserStrategyUtils.invokeAwareMethods(
								registrar, this.environment, this.resourceLoader, this.registry);
						/**
						 * 添加了ImportBeanDefinitionRegistrar到集合中,还未执行,后面会执行
						 */
						configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
					}
					/**
					 * 处理普通的Import
					 * 
					 * 注意:只有不实现ImportSelector和不实现ImportBeanDefinitionRegistrar的普通类才会注册解析并且注册到spring容器中
					 * (意思就是只要实现了ImportSelector和ImportBeanDefinitionRegistrar其中一个接口,即使贴上了@Configuration注解,也不解析该配置)
					 */
					else {
						// Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
						// process it as an @Configuration class
						/**
						 * 
						 */
						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();
			}
		}
	}

总结:

不会放到spring容器中的情况:
1.使用@Import标签引入的ImportSelector或ImportBeanDefinitionRegistrar的实现类本身不会放到spring容器中
2.使用@Import标签引入的ImportSelector实现类,对应的实现方法selectImports返回的类,如果还是ImportSelector或者ImportBeanDefinitionRegistrar实现类,也不会放到容器中

放到spring容器中的情况:
1.直接通过@Import引入没有实现ImportSelector和ImportBeanDefinitionRegistrar接口的普通类
2.使用@Import引入一个ImportSelector实现类,selectImports方法返回没有实现ImportSelector和ImportBeanDefinitionRegistrar接口的普通类全限定名字符串
3.使用@Import引入ImportBeanDefinitionRegistrar的实现类,直接用方法registerBeanDefinitions中参数registry注册器,注册bean到spring容器中

spring源码：@Import注解
小小少年的博客
06-18 352
目的 前面的文章@Bean源码解析有说到，将一个bean，转换成BeanDefinition，并存入BeanDefinitionMap有三种方式；本文，我们要说的是@Import注解这种方式； @Import是用来引入bean的；和本文相关的，我们需要关注ImportSelector和ImportBeanDefinitionRegistrar 接口说明 ImportBeanDefinitionRegistrar该接口，定义了一个public void registerBeanDefinitions( Ann
【Spring】Spring原理源码解析（三）-- Spring在解析配置类时，怎么识别并处理@Import类的
ArvinZsh的博客
08-19 307
本篇主要介绍了spring如何通过内置的bean工厂后置处理器，解析配置类上的@Import注解的
Spring @Import注解源码解析
javaxuexilu的博客
08-29 383
简介Spring 3.0之前，创建Bean可以通过xml配置文件与扫描特定包下面的类来将类注入到Spring IOC容器内。而在Spring 3.0之后提供了JavaCo...
@Import原理与实战
最新发布
西岭千秋雪的博客
06-08 689
摘要： Spring框架的@Import注解提供了三种导入方式：1)直接导入普通类并注册为bean；2)通过ImportSelector实现类动态选择要导入的类；3)通过ImportBeanDefinitionRegistrar实现类自定义注册逻辑。解析过程由ConfigurationClassPostProcessor处理，在refresh阶段的invokeBeanFactoryPostProcessors中完成，分别针对不同类型采用递归解析策略。其中ImportSelector的处理可能延迟进行，而Im
@Import标签
qq_41835813的博客
11-27 324
当你用@Bean时，可以直接使用@import让它生成Bean public class Mapper { @Bean public StudentMapper getsStudentMappe() { return ApplicationContextConfig.getApplicationContext().getBean(StudentMapper.class); } }...
深入分析@Import源码
及时当勉励，岁月不待人
03-12 976
深入分析@Import源码
Spring中@Import注解源码分析
白鸽
08-08 430
基础知识 我们知道@Import注解是向容器中导入bean的。 @Import的注解主要作用于类上，往往搭配@Configuration，ImportSelector接口，还有ImportBeanDefinitionRegistrar往IOC容器中放入bean @Import导入bean的三种方式 1、class数组的方式 2、ImportSelector接口的方式，即批量导入（源码解析） 3、ImportBeanDefinitionRegistrar接口方式，即手工注册bean到容器中 class数组方
相亲相爱的@Import和@EnableXXX
天堂的博客
09-20 674
扫描下方二维码或者微信搜索公众号菜鸟飞呀飞，即可关注微信公众号，阅读更多Spring源码分析文章 文章目录1. @Import注解1.1 直接注册1.2 通过ImportSelector接口1.3 通过ImportBeanDefinitionRegistrar接口2. @Import的原理3. @Enable系列注解4. 为什么要用？5. 总结6. 推荐 1. @Import注解 通过Im...
Spring源码解密之自定义标签与解析
08-28
本篇文章将深入探讨Spring自定义标签的定义、解析以及相关源码分析。 首先，自定义标签的定义通常涉及到两个主要步骤： 1. **定义XSD文件**： XSD（XML Schema Definition）文件用于描述XML文档的结构和数据类型...
xelection__draw__import.zip_源码
09-20
源码是程序员理解软件工作原理和进行修改的基础，它揭示了程序的内部逻辑和结构。 【描述】中的"文件切割器32bit原码,File cutter 32bit original code"表明这是一个针对32位操作系统编写的程序。在计算机领域，32...
spring 个人小结 源码分析机制原理
06-19
Spring框架是Java开发中不可或缺的一部分，它以Inversion of Control（IoC）和Dependency Injection（DI）为核心，简化...通过源码分析，我们可以更深入地了解Spring的工作原理，从而更好地应用和扩展这一强大的框架。
@Import源码分析
duzhuang2399的博客
09-11 191
`@Import` 是 Spring 框架的核心注解，用于导入配置类或组件到当前的 Spring 上下文中。它可以用于导入常规的 `@Configuration` 类、常规组件类，或实现了 `ImportSelector` 和 `ImportBeanDefinitionRegistrar` 接口的类。`ImportSelector` 允许根据条件动态地选择要导入的组件，而 `ImportBeanDefinitionRegistrar` 提供了一种以编程方式注册bean的方法。
CSS（1）——@import标签
ZXY_Hobby的博客
10-15 966
1、link语法结构 此标签是引入CSS文件link标签，只要设置好路径即可。2、@import语法结构 @import + 空格+ url(CSS文件路径地址); 在html中： @import url(CSS文件路径地址); 在CSS中： ? 1 @import url(CSS文件路径地址); 在css和html中均可以使用@import二，link与@import区别
Spring @Import源码解析
demon7552003的小本本
02-07 283
在Spring boot中常用到@Import，允许通过它引入 @Configuration 注解的类 (java config)， 引入ImportSelector接口(这个比较重要， 因为要通过它去判定要引入哪些@Configuration) 和 ImportBeanDefinitionRegistrar 接口的实现， 也包括 @Component注解的普通类。 @Target(Eleme...
@import注解_Spring源码解析之@Import注解源码解析
weixin_39946029的博客
12-30 244
Spring 3.0之前，创建Bean可以通过xml配置文件与扫描特定包下面的类来将类注入到Spring IOC容器内。而在Spring 3.0之后提供了JavaConfig的方式，也就是将IOC容器里Bean的元信息以java代码的方式进行描述。我们可以通过@Configuration与@Bean这两个注解配合使用来将原来配置在xml文件里的bean通过java代码的方式进行描述@Import注...
@Import的使用和源码分析
热门推荐
qq_40223554的博客
06-25 2万+
@Import可以让我们实现根据用启动类上的注解来动态加载某些功能和特性例如Mybatis，本文章可以然你透彻理解并开心使用@import注解
@Import注解详解
怪咖@的博客
10-22 1万+
@Import这个注解非常重要，而且在springboot项目当中随处可见，就拿springboot启动类来说，我们经常会遇到一些@Enable相关的注解，例如开启异步@EnableAsync、开启缓存支持@EnableCaching、开启定时任务@EnableScheduling等等...
@Import注解原理源码分析
yuchangyuan5237的博客
01-13 790
@Import注解是Spring体系中重要的注解之一，本文详细分析了@Import注解的原理
二维码源码分析与使用教程
- 从文件名“CQRcode”可以推测，文件中可能包含的源码与二维码的生成有关，且有可能是使用C语言或C++语言编写。 - 使用这些源码时需要注意，未经授权使用受版权保护的源码可能会侵犯原作者的版权。在参考、学习和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值