SpringBoot中@Import注解如何正确使用

简介

由于最近的项目需求，需要在把配置类导入到容器中，通过查询，使用@Import注解就能实现这个功能，@Import注解能够帮我们吧普通配置类（定义为Bean的类）导入到IOC容器中。该注解我们也能过在源码中经常看到，是框架层实现的重要注解。下面是我对@import注解的使用做的简单的总结。希望能够帮助各位，同时如果有问题的话，也恳请各位提出宝贵的意见。

一、功能简介

引入普通类 引入配置类（@Configuration注解修饰的）

引入ImportSelector的实现类

• 静态import场景（注入已知的类）

• 动态import场景（注入指定条件的类）

引入ImportBeanDefinitionRegister的实现类

二、示例

1.引入普通类

@Import类引入普通的类可以帮我们把普通的类定义为Bean

@Import可以添加在@SpringBootApplication(启动类)、@Configuration(配置类)、@Component(组件类)对应的类上。

注意：@RestController、@Service、@Repository都属于@Component

// 通过@Import注解把普通添加到IOC容器里面去
@Import(ImportAnnotationTest.class)
@SpringBootApplication
public class SpringBootDemoApplication {
   public static void main(String[] args) {
       ConfigurableApplicationContext context = SpringApplication.run(SpringBootDemoApplication.class, args);
       ImportAnnotationTest bean = context.getBean(ImportAnnotationTest.class);
       context.close();
   }
}

引入配置类（@Configuration注解修饰的）

@Import除了可以把普通的类定义为Bean，@Import还可以引入一个@Configuration修饰的类(引入配置类)，从而把让配置类生效(配置类下的所有Bean添加到IOC容器里面去)。在自定义starter的时候经常会用到。

如果配置类在标准的SpringBoot包结构下(SpringBootApplication启动类包的根目录下)。是不需要@Import导入配置类的，SpringBoot自动帮做了。

springboot项目会默认将启动类同目录及其子目录下的组件扫描到ioc容器当中去，无需手动扫描。

上面的情况一般用于@Configuration配置类不在标准的SpringBoot包结构下面。所以一般在自定义starter的时候用到。

@Configuration(proxyBeanMethods = false)
@Import({  // import了两个哈
       XXXDataConfiguration.XXXPartOneConfiguration.class,
       XXXDataConfiguration.XXXPartTwoConfiguration.class
})
public class XXXDataAutoConfiguration {
}

public class XXXDataConfiguration {
   @Configuration(proxyBeanMethods = false)
   static class XXXPartOneConfiguration {
       @Bean
       @ConditionalOnMissingBean
       public BeanForIoc beanForIoc() {
           return new BeanForIoc();
       }
   }
   @Configuration(proxyBeanMethods = false)
   static class XXXPartTwoConfiguration {
       /**
        * 省略了@Bean的使用
        */
   }
}

2.引入ImportSelector的实现类

@Import还可以引入ImportSelector的实现类，把ImportSelector接口selectImports()方法返回的Class名称都定义为bean。

注意selectImports()方法的参数AnnotationMetadata，通过这个参数我们可以获取到@Import标注的Class的各种信息。这一点特别有用，用于做一些参数的传递。在SpringBoot的自动化配置和@EnableXXX(功能性注解)都有它的存在。

public interface ImportSelector {
   /**
    * 用于指定需要注册为bean的Class名称
    * 当在@Configuration标注的Class上使用@Import引入了一个ImportSelector实现类后，会把实现类中返回的Class名称都定义为bean。
    *
    * 通过其参数AnnotationMetadata importingClassMetadata可以获取到@Import标注的Class的各种信息，
    * 包括其Class名称，实现的接口名称、父类名称、添加的其它注解等信息，通过这些额外的信息可以辅助我们选择需要定义为Spring bean的Class名称
    */
   String[] selectImports(AnnotationMetadata importingClassMetadata);
}

用例如下：

@Configuration
@Import(value = {Person.class,MyImportSelector.class})
public class MyBeanDefinitionRegister {
}

配置类中导入实现了ImportSelector 的类

实现了ImportSelector接口的类

public class MyImportSelector implements ImportSelector {
   @Override
   public String[] selectImports(AnnotationMetadata importingClassMetadata) {
       return new String[]{"com.example.importannotation.importSelector.Dog","com.example.importannotation.importSelector.Cat"};
   }
}

（1）静态import场景（注入已知的类）

/**
* XXXConfigurationSelector一定要配合@Import使用
*/
public class XXXConfigurationSelector implements ImportSelector {
   @Override
   @NonNull
   public String[] selectImports(@NonNull AnnotationMetadata importingClassMetadata) {
       // 把XXX对应的类，定义为Bean
       return new String[]{XXX.class.getName()};
   }
}
/**
* 注意 @Import(XXXConfigurationSelector.class)
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(XXXConfigurationSelector.class)
public @interface EnableXXX {
}
@SpringBootApplication
@EnableXXX // 使之生效
public class MyBatisApplication {
   public static void main(String[] args) {
       SpringApplication.run(MyBatisApplication.class, args);
   }
}

（2）动态import场景（注入指定条件的类）

我们做一个这样的功能，我们需要把指定包路径下所有实现了HelloService接口的类做为bean添加到IOC容器里面去。@ComponentScan注解用来帮我们指定路径。具体实现如下：

@Configuration
@ComponentScan("com.example.importannotation") // 指定路径
@Import(DynamicSelectImport.class)
public class DynamicSelectConfig {
}

动态实现将实现某个接口的实现类加载到容器中

public class DynamicSelectImport implements ImportSelector {
   /**
    * DynamicSelectImport需要配合@Import()注解使用
    * <p>
    * 通过其参数AnnotationMetadata importingClassMetadata可以获取到@Import标注的Class的各种信息，
    * 包括其Class名称，实现的接口名称、父类名称、添加的其它注解等信息，
    * 通过这些额外的信息可以辅助我们选择需要定义为Spring bean的Class名称
    */
   @Override
   public String[] selectImports(AnnotationMetadata importingClassMetadata) {
       // 第一步：获取到通过ComponentScan指定的包路径
       String[] basePackages = null;
       // @Import注解对应的类上的ComponentScan注解
       if (importingClassMetadata.hasAnnotation(ComponentScan.class.getName())) {
           Map<String, Object> annotationAttributes = importingClassMetadata
                   .getAnnotationAttributes(ComponentScan.class.getName());
           basePackages = (String[]) annotationAttributes.get("basePackages");
       }
       if (basePackages == null || basePackages.length == 0) {
           //ComponentScan的basePackages默认为空数组
           String basePackage = null;
           try {
               // @Import注解对应的类的包名
               basePackage = Class.forName(importingClassMetadata.getClassName()).getPackage().getName();
           } catch (ClassNotFoundException e) {
               e.printStackTrace();
           }
           basePackages = new String[]{basePackage};
       }
       // 第2步，知道指定包路径下所有实现了HelloService接口的类
       // （ClassPathScanningCandidateComponentProvider的使用）
       ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(false);
       TypeFilter helloServiceFilter = new AssignableTypeFilter(HelloService.class);
       scanner.addIncludeFilter(helloServiceFilter);
       Set<String> classes = new HashSet<>();
       for (String basePackage : basePackages) {
           scanner.findCandidateComponents(basePackage)
                   .forEach(beanDefinition -> classes.add(beanDefinition.getBeanClassName()));
       }
       // 第三步，返回添加到IOC容器里面去
       return classes.toArray(new String[0]);
   }
}

接口

public interface HelloService {
   void function();
}

接口的实现类

public class DemoaClass implements HelloService{
   @Override
   public void function() {
   }
}

public class DemobClass implements HelloService{
   @Override
   public void function() {
   }
}

测试结果如下，两个实现类都加入到了IOC容器当中

3.引入ImportBeanDefinitionRegister的实现类

@Import引入ImportBeanDefinitionRegistrar的实现类。一般用来动态注册bean。最重要的一点是还可以对这些BeanDefinition进行额外的修改或增强。咱们经常使用的mybatis @MapperScan就是用这种方式实现的。

ImportBeanDefinitionRegistrar，我们一般会实现ImportBeanDefinitionRegistrar类，然后配合一个自定义的注解一起使用。而且在注解类上@Import我们的这个实现类。

通过自定义注解的配置，拿到注解的一些元数据。然后在ImportBeanDefinitionRegistrar的实现类里面做相应的逻辑处理，比如把自定义注解标记的类添加到Spring IOC容器里面去。

/**
* ImportBeanDefinitionRegistrar，我们一般会实现ImportBeanDefinitionRegistrar类，然后配合一个自定义的注解一起使用。而且在注解类上@Import我们的这个实现类。
* 通过自定义注解的配置，拿到注解的一些元数据。然后在ImportBeanDefinitionRegistrar的实现类里面做相应的逻辑处理，比如把自定义注解标记的类添加到Spring IOC容器里面去。
*/
public interface ImportBeanDefinitionRegistrar {
   /**
    * 根据注解的给定注释元数据，根据需要注册bean定义
    * @param importingClassMetadata 可以拿到@Import的这个class的Annotation Metadata
    * @param registry BeanDefinitionRegistry 就可以拿到目前所有注册的BeanDefinition，然后可以对这些BeanDefinition进行额外的修改或增强。
    */
   void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry);
}

关于@Import引入ImportBeanDefinitionRegistrar的使用强烈建议大家去看看mybatis关于@MapperScan的处理源码。特别有意思。我们也举一个非常简单的实例，来让大家直观的看到ImportBeanDefinitionRegistrar的使用，比如我们想把指定包路径下所有添加了BeanIoc注解的类注册为bean。具体实现如下：

/**
* 我们会把添加了该注解的类作为bean
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
public @interface BeanIoc {
}

/**
* 定义包路径。(指定包下所有添加了BeanIoc注解的类作为bean)
* 注意这里 @Import(BeanIocScannerRegister.class) 的使用
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(BeanIocScannerRegister.class)
public @interface BeanIocScan {
   String[] basePackages() default "";
}

/**
* 搜索指定包下所有添加了BeanIoc注解的类，并且把这些类添加到ioc容器里面去
*/
public class BeanIocScannerRegister implements ImportBeanDefinitionRegistrar, ResourceLoaderAware {
   private final static String PACKAGE_NAME_KEY = "basePackages";
   private ResourceLoader resourceLoader;
   @Override
   public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
       //1. 从BeanIocScan注解获取到我们要搜索的包路径
       AnnotationAttributes annoAttrs = AnnotationAttributes.fromMap(annotationMetadata.getAnnotationAttributes(BeanIocScan.class.getName()));
       if (annoAttrs == null || annoAttrs.isEmpty()) {
           return;
       }
       String[] basePackages = (String[]) annoAttrs.get(PACKAGE_NAME_KEY);
       // 2. 找到指定包路径下所有添加了BeanIoc注解的类，并且把这些类添加到IOC容器里面去
       ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(beanDefinitionRegistry, false);
       scanner.setResourceLoader(resourceLoader);
       scanner.addIncludeFilter(new AnnotationTypeFilter(BeanIoc.class));
       scanner.scan(basePackages);
   }
   @Override
   public void setResourceLoader(ResourceLoader resourceLoader) {
       this.resourceLoader = resourceLoader;
   }
}

/**
* 使用，使BeanIocScan生效
*/
@Configuration
@BeanIocScan(basePackages = "com.tuacy.collect.mybatis")
public class BeanIocScanConfig {
}

下面是一个具体的实现：

@Data
public class Car {
   private String id;
   private String name;
}

public class MyBeanDefinitionRegister implements ImportBeanDefinitionRegistrar {
   @Override
   public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
       RootBeanDefinition catDef = new RootBeanDefinition(Cat.class);
       RootBeanDefinition carDef = new RootBeanDefinition(Car.class);
       registry.registerBeanDefinition("cat", catDef);
       registry.registerBeanDefinition("car", carDef);
   }
}

@Configuration
@Import(value = {Person.class, MyBeanDefinitionRegister.class})
public class MyImportBeanDefinitionRegistrarConfig {
}

今天的@Import注解就讲解完了

来源：https://blog.csdn.net/qq_29235677/article/details/125253696