Spring：了解@Import注解的三种用法

一、前言

  在 Spring 框架中，@Import 注解用于导入配置类，使得你可以在一个配置类中引入另一个或多个配置类，从而实现配置的模块化。这对于组织大型应用程序的配置非常有用，因为它允许你将配置分散到多个类中，然后再将它们组合在一起。

  本文将详细介绍@Import注解的三种方式，并通过示例演示它们的用法。通过对本文的阅读，读者将更好地理解@Import注解在Spring框架中的作用和应用。

二、 @Import 的三种用法

1. 导入普通的配置类

  当你有多个配置类，并且想要将它们组合成一个更大的配置时，可以使用 @Import 来导入其他配置类。

代码示例：

// 配置类 A  
@Configuration  
public class MyConfigA {  
    @Bean  
    public MyServiceA myServiceA() {  
        return new MyServiceA();  
    }  
}  

// 配置类 B，它导入了配置类 A  
@Configuration  
@Import(MyConfigA.class)  
public class MyConfigB {  
  
    @Bean  
    public MyServiceB myServiceB(MyServiceA myServiceA) {  
        return new MyServiceB(myServiceA);  
    }  
}  

// 服务类 A  
public class MyServiceA {  
    // 业务处理 
}  

// 服务类 B  
public class MyServiceB {  
  
    private final MyServiceA myServiceA;  
  
    public MyServiceB(MyServiceA myServiceA) {  
        this.myServiceA = myServiceA;  
    }  
  
    // 代码逻辑 
}

  在上面例子中，MyConfigB 通过 @Import 导入了 MyConfigA，从而能够在 MyServiceB 中注入 MyService。

2. 导入实现了 ImportSelector 接口的类

  当你想根据条件动态地导入配置类时，可以实现 ImportSelector 接口。

代码示例：

// ImportSelector 实现类  
public class MyImportSelector implements ImportSelector {  
  
    @Override  
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {  
        // 这里简单起见，始终返回 MyConfigA.class 的名称  
        return new String[]{MyConfigA.class.getName()};  
    }  
}  

// 配置类 B，它导入了 MyImportSelector  
@Configuration  
@Import(MyImportSelector.class)  
public class MyConfigB {  
    // 代码逻辑  
} 

  在这个例子中，MyConfigB 通过 @Import 导入了 MyImportSelector，而 MyImportSelector 会根据条件选择性地返回要导入的配置类名称。在这个简单的例子中，它始终返回 MyConfigA.class 的名称。

3. 导入实现了 ImportBeanDefinitionRegistrar 接口的类

  当你想在导入配置时直接注册 BeanDefinition 到 Spring 容器中时，可以实现 ImportBeanDefinitionRegistrar 接口。

代码示例：

// ImportBeanDefinitionRegistrar 实现类  
public class MyBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {  
  
    @Override  
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {  
        RootBeanDefinition beanDefinition = new RootBeanDefinition(MyServiceA.class);  
        registry.registerBeanDefinition("myServiceA", beanDefinition);  
    }  
}  

// 配置类 B，它导入了 MyBeanDefinitionRegistrar  
@Configuration  
@Import(MyBeanDefinitionRegistrar.class)  
public class MyConfigB {  
  
    @Bean  
    public MyServiceB myServiceB(MyServiceA myServiceA) {  
        return new MyServiceB(myServiceA);  
    }  
}  

  在这个例子中，MyConfigB 通过 @Import 导入了 MyBeanDefinitionRegistrar，而 MyBeanDefinitionRegistrar 在 registerBeanDefinitions 方法中直接注册了一个 MyServiceA 的 BeanDefinition 到 Spring 容器中。这样，即使没有 MyConfigA 类，MyServiceB 也可以依赖注入 MyServiceA。

三、 项目实战

1. 准备一个实体类

package com.example.yddemo.test;

public class User {

    private String name;

    private Integer age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

2. 定义TestDefinitionRegistrar

package com.example.yddemo.test;

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

public class TestDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata,
                                        BeanDefinitionRegistry beanDefinitionRegistry) {
        boolean beanDefinition = beanDefinitionRegistry.containsBeanDefinition("com.example.yddemo.test.User");
        if(beanDefinition){
            RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(User.class);
            beanDefinitionRegistry.registerBeanDefinition("user",rootBeanDefinition);

        }
    }

}

3. 定义MySelector 选择器

package com.example.yddemo.test;

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

public class MySelector {

    public class SuperSelector implements ImportSelector {
        @Override
        public String[] selectImports(AnnotationMetadata annotationMetadata) {

            return new String[]{
                    "com.example.yddemo.test.User"
            };
        }
    }


}

4. 定义配置类

package com.example.yddemo.test;

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration
@Import({User.class, MySelector.class,TestDefinitionRegistrar.class})
public class TestConfig {
}

5. 运行输出结果

package com.example.yddemo.test;

import org.junit.jupiter.api.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TestDemo {
    AnnotationConfigApplicationContext applicationContext =
            new AnnotationConfigApplicationContext(TestConfig.class);

    @Test
    public void testImport(){
        printBeans(applicationContext);
        User user = applicationContext.getBean(User.class);
        System.out.println("==================" + user);
    }


    private void printBeans(AnnotationConfigApplicationContext applicationContext){
        String[] definitionNames = applicationContext.getBeanDefinitionNames();
        for (String name : definitionNames) {
            System.out.println(name);
        }
    }
}

总结：
  在本文中，我们介绍了Spring框架中的@Import注解及其三种方式。通过使用@Import注解，开发人员可以灵活地导入不同的配置类、依赖项以及自定义配置，从而更好地组织和管理应用程序的配置。通过示例演示，我们展示了@Import注解在不同场景下的用法，并强调了它在提高代码可维护性和可读性方面的重要性。通过阅读本文，读者可以更好地理解@Import注解在Spring框架中的作用和应用。