Spring高级之注解@Import注解、ImportSelector、ImportBeanDefinitionRegistrar详解（超详细）

最新推荐文章于 2025-10-17 12:02:55 发布
原创 最新推荐文章于 2025-10-17 12:02:55 发布 · 3.7k 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #spring #spring高级

本文深入探讨Spring框架中@Import注解的使用方法和原理，包括其在配置类之间的引用，以及通过ImportSelector和ImportBeanDefinitionRegistrar进行组件批量注册的技术细节。

定义/作用

@Import注解只能作用在类上，一种使用场景是在spring注解驱动开发环境下与配置类配合使用的，其作用是引用其他配置类。使得我们可以和早起的基于XML配置文件开发那样。使用不同的配置类配置不同的内容，比如Mysql数据源配置用一个配置类。Redis数据源配置用一个配置类等。然后使用在注解在一个主配置类中引入这些从配置类，使得配置更加清晰。被引入的类可以不使用@Configuration、@Component注解。

另一种使用 场景是该注解也是一种注册bean的方案。可以在配置类中使用Import注册组件。可以配合ImportSelector、ImportBeanDefinitionRegistrar按一定规则进行组件的批量注册。

源码：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Import {

	/**
	 * 要引入的配置类，也可以引入ImportSelector、ImportBeanDefinitionRegistrar过滤器和注册器
	 * 按照一定的规则进行组件的引入。
	 */
	Class<?>[] value();

}

使用方式：

不成功的情况：

/**
 * @author YeHaocong
 * @decription 主配置类
 */

@Configuration
public class SpringConfig {

}

/**
 * @author YeHaocong
 * @decription Mysql数据源配置类
 */
@Configuration
public class MysqlConfig {

    @Bean
    public DruidDataSource dataSource() throws IOException {
    	//创建druid数据源
        DruidDataSource dataSource = new DruidDataSource();
        //加载配置文件，作为数据源的初始化属性
        Properties properties = PropertiesLoaderUtils.loadAllProperties("daoconfig/datasource-config.properties");
        dataSource.setConnectProperties(properties);
        //返回dataSource，spring会把他注册到IOC容器中。
        return dataSource;
    }

    //.....
}


//测试类
public class ImportDemoTest {
	//引入主配置类创建容器
    private AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);

    @Test
    public void testImportDemo(){
        DataSource dataSource = (DataSource) context.getBean("dataSource");
        System.out.println(dataSource);
    }
}

配置文件：
在这里插入图片描述
执行结果：
在这里插入图片描述
分析：因为容器是引入主配置类创建，而没有引入mysql数据源配置类，所以不会扫描创建数据源。

使用Import注解解决：

/**
 * @author YeHaocong
 * @decription 主配置文件
 */

@Configuration
//使用import注解，把其他从配置类引入
@Import({MysqlConfig.class})
public class SpringConfig {

}
/**
 * @author YeHaocong
 * @decription Mysql数据源配置文件
 */
//从配置类可以不使用@Configuration和Component等注解。
public class MysqlConfig {

    @Bean
    public DruidDataSource dataSource() throws IOException {
        DruidDataSource dataSource = new DruidDataSource();
        //加载配置文件，作为数据源的初始化属性
        Properties properties = PropertiesLoaderUtils.loadAllProperties("daoconfig/datasource-config.properties");
        dataSource.setConnectProperties(properties);
        //返回dataSource，spring会把他注册到IOC容器中。
        return dataSource;
    }

    //.....
}

执行结果：
在这里插入图片描述
可见数据源配置类被成功引入，数据源成功创建。

被引入的类会被注册到spring的IOC容器中，并且组件id为类的全限定名称，比如上面的：


public class ImportDemoTest {

    private AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);

    @Test
    public void testImportDemo(){
        //获取MysqlConfig配置组件
        MysqlConfig mysqlConfig = context.getBean(MysqlConfig.class);
        System.out.println(mysqlConfig);

        //获取注解中所有的组件名称
        String[] beanNames = context.getBeanDefinitionNames();
        for (String beanName:beanNames)
            System.out.println(beanName);
    }
}

结果：
在这里插入图片描述

ImportSelector和ImportBeanDefinitionRegistrar

我们注册bean的方式有很多种。
比如：

  1. 我们自己写的类，可以使用@Component及其衍生类进行注册。
  2. 到导入第三方库时，可以使用@Bean注解和@Import注解进行注册。
    但是，当要注册的类很多时，每个类上加注解，写Bean方法注册，用Import方法导入大量的Bean时，会显得很繁琐，此时可以使用自定义ImportSelector和ImportBeanDefinitionRegistrar来实现组件的批量注册。spring boot有很多EnableXXX的注解，绝大多数多借助了ImportSelector和ImportBeanDefinitionRegistrar。

共同点：

  • 他们都用于动态注册bean对象到容器中，并且支持大批量的bean导入。

区别：

  • ImportSelector是一个接口，我们在使用时需要提供自己的实现类，实现类中重写的方法返回要注册的bean的全限定名数组。然后ConfigurationClassParser类中的precessImports方法注册bean对象。
  • ImportBeanDefinitionRegistrar也是一个接口，需要我们自己提供实现类，在实现类中手动注册bean到容器中。

注意事项：实现了ImportSelector和ImportBeanDefinitionRegistrar的类不会被解析成一个bean添加到容器中。

ImportSelector

demo：
包结构：
在这里插入图片描述
代码：

/**
 * @author YeHaocong
 * @decription 自定义的ImportSelector，导入选择器。
 * 1. 通过AspectJ表达式进行类型筛选。
 * 2. 当使用该选择器的配置类没有使用@ComponentScan注解指定扫描包时，会扫描该配置类所在包及其子包。
 */

public class CustomImportSelector implements ImportSelector {

    //AspectJ表达式
    private String expression;

    public CustomImportSelector() throws IOException {
        try {
            //载入配置文件，创建一个Properties对象
            Properties props = PropertiesLoaderUtils.loadAllProperties("import/custom-import-selector.properties");
            //获取配置文件配置的键为 expression的值,并赋值给expression变量
            expression = props.getProperty("expression");
            if (expression == null || expression.isEmpty()){
                throw new RuntimeException("配置文件import/custom-import-selector.properties 的expression 不存在");
            }
        }
        catch (RuntimeException e){
            throw e;
        }
    }

    /**
     *
     * @param importingClassMetadata 参数是被Import注解作用的配置类的注解元信息
     * @return 返回的是要注册的组件的类的全限定名数组。
     */
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {

        //定义要扫描的基础包
        String[] basePackages = null;

        //获取ComponentScan注解的全限定名称。
        String ComponentScanName = ComponentScan.class.getName();
        //判断被Import注解作用的类上是否有@ComponentScan注解
        if (importingClassMetadata.hasAnnotation(ComponentScanName)){
            //有@ComponentScan注解，获取该注解上的属性配置，封装成Map对象。
            Map<String,Object> attributes = importingClassMetadata.getAnnotationAttributes(ComponentScanName);
            //获取@ComponentScan注解的value属性或者basePackages属性，因为他们是互为别名，所以获取其中一个即可。
            basePackages = (String[]) attributes.get("basePackages");
        }

        //判断是否有ComponentScan注解或者ComponentScan注解是否有指定扫描包。
        //当basePackages为null时，表示没有ComponentScan注解。
        //当basePackages.length等于0时，表示有basePackages注解，但是没有指定扫描的包。
        if (basePackages == null || basePackages.length == 0){
            //如果@Import注解作用的配置类上没有ComponentScan注解或者有ComponentScan注解但是没有指定扫描包的情况下。
            //我们就扫描该配置类所在包及其子包。

            String basePackage = null;

            //获取被Import注解作用的配置类所在的包。
            try {
                basePackage = Class.forName(importingClassMetadata.getClass().getName()).getPackage().getName();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            //把包名设置到basePackages中。
            basePackages = new String[]{basePackage};
        }

        //创建类路径扫描器,参数的含义是不使用默认的过滤规则，与@ComponentScan注解的 useDefaultFilters属性一样。
        ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(false);
        //创建类型过滤器，此处使用AspectJ类型过滤器。传入参数是AspectJ表达式和类加载器对象
        TypeFilter typeFilter = new AspectJTypeFilter(expression,CustomImportSelector.class.getClassLoader());

        //类型过滤器添加到扫描器中。添加的是包含扫描器。
        scanner.addIncludeFilter(typeFilter);



        //定义要扫描类的全限定类名的集合
        Set<String> classes = new HashSet<>();

        //遍历基础扫描类数组，得到要扫描的类的全限定名，并添加到集合中
        for (String basePackage: basePackages){
            //扫描基础包，获取扫描到的BeanDefinition集合
            Set<BeanDefinition> candidateComponents = scanner.findCandidateComponents(basePackage);
            //遍历。获取全限定名添加到集合中。
            for (BeanDefinition beanDefinition: candidateComponents){
                classes.add(beanDefinition.getBeanClassName());
            }

        }

        //返回集合
        return classes.toArray(new String[classes.size()]);
    }
}


/**
*配置类
*/

@Configuration
@Import({CustomImportSelector.class})
public class SpringConfig {
}

//还有两个业务接口和两个业务接口实现类和一个ConfigUtil，这两个业务实现类和ConfigUtil类都是要注册的组件。这里不再贴出，可以看上面包结构。

public class TestImportSelector {

    private AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);

    @Test
    public void TestImportSelector(){
        //根据类型获取bean
        try {
            ConfigUtil configUtil = (ConfigUtil) context.getBean(ConfigUtil.class);
            System.out.println(configUtil);
        }catch (Exception e){
            System.out.println(e.getMessage());
        }
        try {
            RoleService roleService = (RoleService) context.getBean(RoleService.class);
            System.out.println(roleService);
        }catch (Exception e){
            System.out.println(e.getMessage());
        }
        try {
            UserService userService = (UserService) context.getBean(UserService.class);
            System.out.println(userService);
        }catch (Exception e){
            System.out.println(e.getMessage());
        }

    }
}

配置文件：
在这里插入图片描述
执行结果：
在这里插入图片描述
分析：一个bean都没有注册成功，原因是：
配置类SpringConfig上没有使用@ComponentScan或者使用了但是没有配置扫描包。所以会扫描配置类所在包及其子包，看上面包结果。明显没有扫描到service包。所以两个业务实现类没有被注册到容器中。而ConfigUtil虽然被扫描到了，但是由于不符合AspectJ表达式而没有被添加到选择器中。

接下来我们使用@ComponentScan扫描指定包。

@Configuration
@ComponentScan(basePackages = "importselectdemo")
@Import({CustomImportSelector.class})
public class SpringConfig {
}

/**
*测试类
*/
public class TestImportSelector {

    private AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);

    @Test
    public void TestImportSelector(){
        //根据类型获取bean
        try {
            ConfigUtil configUtil = (ConfigUtil) context.getBean(ConfigUtil.class);
            System.out.println(configUtil);
        }catch (Exception e){
            System.out.println(e.getMessage());
        }
        try {
            RoleService roleService = (RoleService) context.getBean(RoleService.class);
            System.out.println(roleService);
        }catch (Exception e){
            System.out.println(e.getMessage());
        }
        try {
            UserService userService = (UserService) context.getBean(UserService.class);
            System.out.println(userService);
        }catch (Exception e){
            System.out.println(e.getMessage());
        }
        try {
            CustomImportSelector selector = (CustomImportSelector) context.getBean(CustomImportSelector.class);
            System.out.println(selector);
        }catch (Exception e){
            System.out.println(e.getMessage());
        }


        String[] beanNames = context.getBeanDefinitionNames();
        for (String beanName:beanNames){
            System.out.println(beanName);
        }
    }
}

执行结果：
在这里插入图片描述

注意：不能导入配置类自身，因为，这样会导致报错。
将表达式设置为：在这里插入图片描述
结果：

org.springframework.beans.factory.parsing.BeanDefinitionParsingException: Configuration problem: A circular @Import has been detected: Illegal attempt by @Configuration class 'SpringConfig' to import class 'SpringConfig' as 'SpringConfig' is already present in the current import stack [SpringConfig->SpringConfig]
Offending resource: importselectdemo.config.SpringConfig

使用上述方法只要符合CustomImportSelector规则，即使不使用@Component等注解也会注册到容器中。

ImportBeanDefinitionRegistrar

这个注册器不会把扫描到的类返回，而是把扫描到的类直接就在这里注册了。

demo（扫描逻辑与上面的CustomImportSelector一样）：

/**
 * @author YeHaocong
 * @decription 自定义的ImportBeanDefinitionRegistrar，导入注册器。
 * 1. 通过AspectJ表达式进行类型筛选。
 * 2. 当使用该选择器的配置类没有使用@ComponentScan注解指定扫描包时，会扫描该配置类所在包及其子包。
 * 3. CustomImportDefinitionRegistrar会扫描指定包里，符合AspectJ表达式的组件的类进行注册
 */

public class CustomImportDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

    //AspectJ表达式
    private String expression;

    public CustomImportDefinitionRegistrar() throws IOException {
        try {
            //载入配置文件，创建一个Properties对象
            Properties props = PropertiesLoaderUtils.loadAllProperties("import/custom-import-selector.properties");
            //获取配置文件配置的键为 expression的值,并赋值给expression变量
            expression = props.getProperty("expression");
            if (expression == null || expression.isEmpty()){
                throw new RuntimeException("配置文件import/custom-import-selector.properties 的expression 不存在");
            }
        }
        catch (RuntimeException e){
            throw e;
        }
    }

    /**
     * 
     * @param importingClassMetadata  参数是被Import注解作用的配置类的注解元信息
     * @param registry   BeanDefinition注册器，会将扫描到的类直接使用该注册器进行注册
     */
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        //定义要扫描的基础包
        String[] basePackages = null;

        //获取ComponentScan注解的全限定名称。
        String ComponentScanName = ComponentScan.class.getName();
        //判断被Import注解作用的类上是否有@ComponentScan注解
        if (importingClassMetadata.hasAnnotation(ComponentScanName)){
            //有@ComponentScan注解，获取该注解上的属性配置，封装成Map对象。
            Map<String,Object> attributes = importingClassMetadata.getAnnotationAttributes(ComponentScanName);
            //获取@ComponentScan注解的value属性或者basePackages属性，因为他们是互为别名，所以获取其中一个即可。
            basePackages = (String[]) attributes.get("basePackages");
        }

        //判断是否有ComponentScan注解或者ComponentScan注解是否有指定扫描包。
        //当basePackages为null时，表示没有ComponentScan注解。
        //当basePackages.length等于0时，表示有basePackages注解，但是没有指定扫描的包。
        if (basePackages == null || basePackages.length == 0){
            //如果@Import注解作用的配置类上没有ComponentScan注解或者有ComponentScan注解但是没有指定扫描包的情况下。
            //我们就扫描该配置类所在包及其子包。

            String basePackage = null;

            //获取被Import注解作用的配置类所在的包。
            try {
                basePackage = Class.forName(importingClassMetadata.getClass().getName()).getPackage().getName();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            //把包名设置到basePackages中。
            basePackages = new String[]{basePackage};
        }

        //创建类路径扫描器ClassPathBeanDefinitionScanner,参数的含义是不使用默认的过滤规则，与@ComponentScan注解的 useDefaultFilters属性一样。
        //registry参数是将扫描到的类使用指定的registry注册器注册
        ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(registry,false);
        //创建类型过滤器，此处使用AspectJ类型过滤器。传入参数是AspectJ表达式和类加载器对象
        TypeFilter typeFilter = new AspectJTypeFilter(expression,CustomImportSelector.class.getClassLoader());

        //类型过滤器添加到扫描器中。添加的是包含扫描器。
        scanner.addIncludeFilter(typeFilter);

        //进行扫描
        scanner.scan(basePackages);



    }
}


//配置类：
@Configuration
@ComponentScan(basePackages = "importselectdemo")
//使用CustomImportDefinitionRegistrar
@Import({CustomImportDefinitionRegistrar.class})
public class SpringConfig {
}

结果：
在这里插入图片描述
解析：

  1. ConfigUtil不符合AspectJ表达式规则，所以没有注册。
  2. 业务类注册成功。
  3. 实现ImportBeanDefinitionRegistrar接口的类不会被添加到容器中。
  4. 因为使用的是BeanDefinitionRegistry注册器，所以注册的bean id 默认是类的名字第一个转小写。而不是全限定名称。

使用上述方法只要符合CustomImportDefinitionRegistrar规则，即使不使用@Component等注解也会注册到容器中。

Spring注解篇：@Configuration详解
喵手的博客
12-16 1499
在Spring框架中，注解是实现Java配置的核心。它允许开发者以编程的方式定义Bean的创建过程，而不是使用XML文件。这种基于注解的配置方式，不仅简化了配置的复杂性，还提高了代码的可读性和可维护性。本文将详细介绍注解的用法和重要性。从基本概念到实际应用，再到源码解析，我们将全面了解如何使用注解来定义Spring的Bean。此外，还将分享使用案例和应用场景，以及对注解的优缺点进行分析。注解是Spring框架中用于标记配置类的注解。
ImportSelector和ImportBeanDefinitionRegistrar两种注入方式的源码分析
qq_32876231的博客
08-03 312
说明：带有 @Configuration 的配置类（4.2 版本之前只可以导入配置类，4.2 版本之后也可以导入普通类org.springframework.context.annotation.ConfigurationClassParser 这个配置类的解析类中的关于ImportSelector和ImportBeanDefinitionRegistrar.class的作用前面的文章专门简绍了。连接奉上。优快云。
spring Import,ImportSelector, ImportBeanDefinitionRegistrar
花花公子
04-25 379
给容器中注册组件； 1,包扫描+组件标注注解（@Controller/@Service/@Repository/@Component）[自己写的类] 2,@Bean[导入的第三方包里面的组件] 3,@Import[快速给容器中导入一个组件] 1）、@Import(要导入到容器中的组件)；容器中就会自动注册这个组件，id默认是全类名 ...
【备战大厂JAVA面试Spring篇】大白话解释一下Import注解，秒懂
最新发布
不朽的博客
10-17 605
摘要： @Import是Spring中用于显式导入配置类或Bean定义的工具，解决自动扫描无法覆盖的场景。支持三种用法：1）直接导入普通类，自动注册为Bean；2）导入配置类，批量加载其中定义的Bean；3）通过ImportSelector动态选择导入类（如按环境加载不同配置）。与@ComponentScan相比，@Import更灵活，可强制导入第三方库或未注解的类，适用于模块化配置、条件化装配等场景，是Spring模块化与扩展性的关键机制。
谈谈Spring的ImportSelector和ImportBeanDefinitionRegistrar
苦行僧
07-30 1584
1、@Import 在聊ImportSelector和ImportBeanDefinitioRegistar之前需要先知道@Import。 @Import是写在我们的配置类上的，如下： @Configuration @Import({XXX.class,XXX2.class}) public class AppConfig { } 当Spring扫描我们AppConfig后，就能拿到我们@Import中填的Class，并将其实例化后放到容器当中。 2、@Import中的三种类 @Import中填入的类可以
06 ImportSelector和ImportBeanDefinitionRegistrar
wyaoyao93的博客
11-18 848
文章目录1 介绍 1 介绍 我们注入bean对象时，可以选择的方式有很多种。 例如： 1、我们自己写的类，可以使用@Component，@Service,@Repository,@Controller等等 2、我们导入的第三方类库的类，可以使用@Bean注解，也可以使用@Import注解直接引入一个配置类 但是当我们的类很多的时候，在每个类上加注解会很繁琐，此时我们就可以采用自定义ImportSelector或者ImportBeanDefinitionRegistrar来实现。在SpringBoot中，@E
【Spring】@Import、ImportSelector、ImportBeanDefinitionRegistrar的使用与源码分析
morris
03-20 1875
@Import是一个注解，专门用来导入实现了ImportSelector和ImportBeanDefinitionRegistrar接口的类，当然也可以用来导入普通的Bean。 @Import的使用 @Import+普通Bean package com.morris.spring.demo.annotation; import com.morris.spring.entity.User; import org.junit.jupiter.api.Test; import org.springframewo
Spring注解系列 - @Import注解
vonlinee的博客
09-30 1174
大致流程如下图所示这三种方式都围绕ConfigurationClassParser#parse方法，用于解析配置类，获取配置类的所有可能配置的BeanDefinition，后续将其注册Bean到容器种简单总结一下三种方式的区别：执行时机。
详解Spring 注解之@Import 注入的各种花活
08-25
Spring @Import 注解的多种使用场景 Spring 框架中的 @Import 注解是一个非常强大的工具，可以用来实现组件的自动装配和配置。下面我们将详细介绍 @Import 注解的多种使用场景，并通过示例代码来演示其使用方法。 ...
spring注解@Import用法详解
08-25
Spring 注解 @Import 用法详解 Spring 框架中，@Import 注解是一个非常重要的注解，它可以将外部的配置文件或类导入到当前的应用程序中，以实现模块化和解耦合。在本文中，我们将详细介绍 @Import 注解的用法和实现...
Spring中@Import的各种用法以及ImportAware接口详解
08-25
Spring 中 @Import 的各种用法以及 ImportAware 接口详解 @Import 注解是 Spring 框架中一个非常重要的注解，它提供了和 XML 中 `<import/>` 元素等价的功能，实现导入的一个或多个配置类。@Import 即可以在类上...
Spring - @Import和ImportSelector以及ImportBeanDefinitionRegistrar
大后生大大大的博客
06-20 335
上几篇文章导入Bean用到的是@Bean注解，这里还有一个@ Import 注解也能向Spring的IOC容器中添加Bean实例，默认实例名就是类的全类名
Spring注解驱动开发第9讲——在@Import注解中使用ImportSelector接口导入bean
李阿昀的博客
11-30 4974
写在前面 在上一讲关于Spring的@Import注解的文章中，我们简单介绍了如何使用@Import注解给容器中快速导入一个组件，而我们知道，@Import注解总共包含三种使用方法，上一讲已经讲解完第一种方式了，今天我们就一起来学习下关于@Import注解非常重要的第二种方式，即ImportSelector接口的方式。 ImportSelector接口概述 ImportSelector接口是Spring中导入外部配置的核心接口，在Spring Boot的自动化配置和@EnableXXX（功能性注解）都有它的
spring注解@Import、ImportSelector、ImportBeanDefinitionRegistrar向IOC容器中导入组建
qq_36722039的博客
08-11 2182
* 在容器中注册组建 * 1:包扫描：带用注解的组建(@Controller、@Service、@Repotitory...) * 2:bean注解导入组建【导入第三方包里的组建】 * 3:@Import快速向容器中导入组建 * 1.@Import(需要导入的组建)；容器中会自动注册组建，默认id是全类名 * 2.I...
根据注解 自动注册bean ImportBeanDefinitionRegistrar
qq_1141193930的博客
10-13 433
简介 ImportBeanDefinitionRegistrar类只能通过其他类@Import的方式来加载，通常是启动类或配置类。 使用@Import，如果括号中的类是ImportBeanDefinitionRegistrar的实现类，则会调用接口方法，将其中要注册的类注册成bean。 实现该接口的类拥有注册bean的能力。 手动把一个类注册成bean 首先写一个类，最终要把它注册为bean。 public class HelloService { } 自定义ImportBeanDefin..
Import注解
weixin_45723046的博客
05-02 654
五、Import注解 向Spring容器中注册bean 1、@Configuration注解结合@Bean注解向Spring容器中注册bean； 2、可以按照条件向Spring容器中注册bean；（Conditional） 3、可以使用@Import注解向容器中快速导入bean对象；可以在@Import注解中使用ImportBeanDefinitionRegistrar向容器中注册bean。 4、向容器中注册Bean，实现FactoryBean<>接口； 1、使用@Import注解给容器中快速
spring源码解析------@Import注解解析与ImportSelector，ImportBeanDefinitionRegistrar以及DeferredImportSelector区别
szhlcy的博客
10-29 1821
1.@Import注解在springBoot中间接的广泛应用  在springboot中并没有直接显式的使用@Import标签，而是通过@Import标签来间接的提供了很多自动配置的注解。比如@EnableAutoConfiguration，@EnableConfigurationProperties等。这些标签的实现都是通过使用@Import标签来完成的。 ...... @Import(Auto...
ImportBeanDefinitionRegistrar解析
xianmingsu的博客
06-13 726
ImportBeanDefinitionRegistrar是spring提供的一个扩展点，和ImportSelector不同的是，ImportBeanDefinitionRegistrar提供了一个注册器registry，用于注册BeanDefinition。此外，ImportBeanDefinitionRegistrar还可以参与BeanDefinition的创建过程。 Mybatis的@MapperScan扫描指定包下的接口(这些接口并没有实现类)，进而完成数据库操作。底层正是基于动态代理和Import
Spring注册Bean--方法4：@Import+ImportSelector接口
IT利刃出鞘的博客
12-28 1029
本文介绍Spring注册Bean的方法：@Import+ImportSelector接口。
Spring的 `@Import`注解 详解
10-09
<think>我们被要求详细解释Spring框架中的@Import注解。根据提供的引用内容，我们可以总结如下： 引用[1]和[2]指出，@Import注解用于导入配置类，实现配置的模块化。它可以将一个或多个配置类引入到当前配置类中，类似于Spring XML配置文件中的`<import>`标签。@Import有三种使用方式：普通方式、ImportSelector方式、ImportBeanDefinitionRegistrar方式。 引用[4]展示了第一种方式：直接引入Bean。在配置类上使用@Import(ImportedBean.class)，就可以将ImportedBean注册到Spring容器中。 此外，引用[3]提到了在处理@Import注解时，会通过beanDefinition的元数据（metadata）来获取类的注解信息，进而处理@Import注解中的内容。 因此，我们需要详细解释@Import注解的三种用法，并给出相应的示例。 ### 详细解释 #### 1. 普通方式 直接导入一个或多个配置类或普通类（这些类会被注册为Bean）。语法：`@Import({类1.class, 类2.class, ...})` 示例： ```java public class MyService {} @Configuration @Import(MyService.class) public class AppConfig {} ``` 这样，MyService就会被注册为一个Spring Bean。 #### 2. ImportSelector方式 通过实现`ImportSelector`接口，可以编程式地选择要导入的配置类。该接口有一个方法`String[] selectImports(AnnotationMetadata importingClassMetadata)`，返回要导入的类的全限定名的数组。 示例： ```java public class MyImportSelector implements ImportSelector { @Override public String[] selectImports(AnnotationMetadata importingClassMetadata) { // 根据条件返回需要导入的类 return new String[]{"com.example.ServiceA", "com.example.ServiceB"}; } } @Configuration @Import(MyImportSelector.class) public class AppConfig {} ``` #### 3. ImportBeanDefinitionRegistrar方式 通过实现`ImportBeanDefinitionRegistrar`接口，可以编程式地注册Bean定义。该接口有一个方法`void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry)`，可以在其中使用BeanDefinitionRegistry来注册Bean。 示例： ```java public class MyBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar { @Override public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) { // 创建Bean定义 RootBeanDefinition beanDefinition = new RootBeanDefinition(MyBean.class); // 注册Bean定义 registry.registerBeanDefinition("myBean", beanDefinition); } } @Configuration @Import(MyBeanDefinitionRegistrar.class) public class AppConfig {} ``` ### 总结 @Import注解是Spring中用于模块化配置的重要注解，它提供了三种不同的方式来导入配置或Bean： 1. 直接导入类（普通方式） 2. 通过ImportSelector接口动态选择导入的类 3. 通过ImportBeanDefinitionRegistrar接口编程式注册Bean定义 使用@Import注解可以避免使用XML配置来组合配置，使得配置更加灵活和模块化。 ### 相关问题 1. @Import注解和@ComponentScan注解有什么区别？ 2. 如何在使用@Import导入的配置类中使用@Autowired注入其他Bean？ 3. 在Spring Boot中，@Import注解通常用在哪些场景？ </think>### Spring @Import 注解详细解释 `@Import` 是 Spring 框架的核心注解之一，用于**动态注册 Bean 到 IoC 容器**，实现配置的模块化。它有三种使用方式，每种方式对应不同的场景需求： #### 方式一：直接导入类（普通方式） - **作用**：将指定类注册为 Spring Bean - **语法**：`@Import(ClassName.class)` - **示例**： ```java public class DatabaseService {} // 待注册的类 @Configuration @Import(DatabaseService.class) // 直接导入 public class AppConfig {} ``` - **特点**： - 适用于简单场景 - 被导入的类无需额外注解（如 `@Component`） - 通过 `ApplicationContext.getBean(DatabaseService.class)` 可直接获取[^4] #### 方式二：实现 `ImportSelector` 接口 - **作用**：**动态选择**需要注册的 Bean - **核心方法**： ```java public interface ImportSelector { String[] selectImports(AnnotationMetadata importingClassMetadata); } ``` - **示例**： ```java public class DynamicImportSelector implements ImportSelector { @Override public String[] selectImports(AnnotationMetadata metadata) { // 根据条件动态返回类名 if (isProduction()) { return new String[]{ProdDataSource.class.getName()}; } return new String[]{DevDataSource.class.getName()}; } } @Configuration @Import(DynamicImportSelector.class) public class EnvConfig {} ``` - **特点**： - 实现条件化 Bean 注册 - 可读取导入类的元数据（`AnnotationMetadata`） - Spring Boot 的 `@EnableAutoConfiguration` 底层采用此机制[^2] #### 方式三：实现 `ImportBeanDefinitionRegistrar` 接口 - **作用**：**编程式注册 Bean 定义**（最灵活的方式） - **核心方法**： ```java public interface ImportBeanDefinitionRegistrar { void registerBeanDefinitions( AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry ); } ``` - **示例**： ```java public class CustomBeanRegistrar implements ImportBeanDefinitionRegistrar { @Override public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) { // 创建 Bean 定义 BeanDefinition definition = new RootBeanDefinition(CustomService.class); // 手动注册 Bean registry.registerBeanDefinition("customService", definition); } } @Configuration @Import(CustomBeanRegistrar.class) public class CustomConfig {} ``` - **特点**： - 完全控制 Bean 的注册过程 - 可访问 `BeanDefinitionRegistry` 进行高级操作 - 支持解析被导入类的元数据（如注解信息）[^3] --- ### 核心机制 1. **处理时机**：在容器启动时，Spring 解析 `@Import` 注解： - 检查 `BeanDefinition` 的元数据 (`getMetadata()`)[^3] - 递归处理所有导入的类或接口 2. **与 XML 等效操作**：等同于 XML 配置中的 `<import>` 标签： ```xml <!-- XML 等效配置 --> <import resource="database-config.xml"/> ``` 3. **模块化优势**： - 解耦大型项目配置 - 实现按需加载（如根据 Profile 加载不同配置） - 支持第三方库的无侵入整合（常见于 Spring Boot Starter） > 提示：三种方式可组合使用，例如 `@Import({ClassA.class, SelectorB.class})`
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值