SpringBoot 学习之@Import注解的使用方法（付代码）

浅浅的花香味﹌ 2022-12-03 05:25 203阅读 0赞

## 前言 ##

@Import注解用来帮助我们把一些需要定义为Bean的类导入到IOC容器里面。下面我们就对@Import注解的使用做一个简单的总结。

## 一 @Import引入普通类 ##

@Import引入普通的类可以帮助我们把普通的类定义为Bean。@Import可以添加在@SpringBootApplication(启动类)、@Configuration(配置类)、@Component(组件类)对应的类上。

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

@SpringBootApplication@Import(ImportBean.class) // 通过@Import注解把ImportBean添加到IOC容器里面去
    public class MyBatisApplication {
        
    
        public static void main(String[] args) {
        
            SpringApplication.run(MyBatisApplication.class, args);
        }
    }

## 二 @Import引入配置类(@Configuration修饰的类) ##

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

如果配置类在标准的SpringBoot包结构下(SpringBootApplication启动类包的根目录下)。是不需要@Import导入配置类的，SpringBoot自动帮做了。上面的情况一般用于@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的使用
             */
        }
    }

## 三 @Import引入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);
    
    }

关于@Import引入ImportSelector的实现类的使用，我们举几个简单的使用场景(实际开发肯定比这复杂的多的)。

3.1 静态import场景(注入已知的类)  
静态场景(注入已知的类)，很简单通过实现ImportSelector类把我们需要定义为bean的类直接返回就好， 比如下面的例子。我们来一个EnableXXX的注解，通过XXXConfigurationSelector注入一个已知的类XXX。

/**
    
     * 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);
        }
    
    }

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

public interface HelloService {
        
    
        void function();
    }
    
    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};
            }
            // 第er步，知道指定包路径下所有实现了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]);
        }
    }
    
    @Configuration
    @ComponentScan("com.tuacy.collect.mybatis") // 指定路径
    @Import(DynamicSelectImport.class)
    public class DynamicSelectConfig {
        
    }

## 四 @Import引入ImportBeanDefinitionRegistrar的实现类 ##

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

## 随手点个关注呀~ ##

![在这里插入图片描述][20200901230742670.gif_pic_center]

**我是偷影子的Tronhon ，从UP主回归CSDN博主，以后不定期更新Java后端技术博客文章，喜欢点个关注吧~**

[20200901230742670.gif_pic_center]: /images/20221123/619f6d92e7014359958786b046473a88.png