Spring @Import注解的使用和源码分析

梦里梦外; 2023-09-26 20:58 82阅读 0赞

## 介绍 ##

今天主要介绍Spring @Import注解，在Spring中@Import使用得比较频繁，它得作用是导入bean，具体的导入方式有多种，特别在SpringBoot项目中，很多地方都使用到了@Import注解，特别对于一些和SpringBoot整合的组件，其实现都大量使用了@Import，例如使用Feign集成SpringBoot时会加上注解@EnableFeignClients，使用Dubbo时会使用@EnableDubbo等，这些注解里面都使用了@Import注解来注册一些bean。

## @Import导入bean的三种方式 ##

@Import导入bean有三种方式，分别是导入`普通类`，实现`ImportSelector`接口的类，实现`ImportBeanDefinitionRegistrar`接口的类。

### 普通类 ###

在开放过程中，尽量保持类不要太过于庞大，类过于庞大的话会变得臃肿复杂，不好维护，一个配置类中需要配置很多bean，且逻辑实现也比较复杂，代码量大，如果全部都放在同一个配置类中，这显然不太理智，这时候我们可以将每个bean单独拿出来放到一个类里面，然后使用@Import注解导入，如下代码所示。

*  定义一个bean

@Data
    public class UserBean {
        private String username;
        private String sex;
    }
    复制代码

*  导入bean

@Configuration
    @Import(value = {UserBean.class})  //注入普通Bean
    public class ImportConfiguration {
    
    }
    复制代码

从上面可以看出只需要在配置类上面使用@Import注解导入对应Java Bean，然后这个bean就能注册进IOC容器中。

### ImportSelector接口 ###

ImportSelector是一个接口，可以通过实现它来完成bean的注册，它只有一个`selectImports()`方法，它会返回一个bean的名称数组，这个数组中的bean名称就会被注册进IOC容器中。

public class MyImportSelector implements ImportSelector {
        @Override
        public String[] selectImports(AnnotationMetadata importingClassMetadata) {
            return new String[]{UserBean.class.getName()};
        }
    }
    复制代码

### ImportBeanDefinitionRegistrar接口 ###

使用ImportBeanDefinitionRegistrar也可以注册bean，它会传入BeanDefinitionRegistry接口，然后进可以注册bean，这里注册的是bean的元信息BeanDefinition。

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    
        @Override
        public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
            String name = UserBean.class.getName();
            BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(UserBean.class);
            builder.addPropertyValue("sex","男");
            AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();
            registry.registerBeanDefinition(name, beanDefinition);
        }
    }
    复制代码

## 源码解析 ##

spring容器启动后，会在`ConfigurationClassParser`解析类中解析@Import注解，解析出需要注册的bean，下面就是最关键的代码，通过调用processImports方法，然后解析出对应的bean，可以看出有几个判断，分别判断是否是ImportSelector类型，ImportBeanDefinitionRegistrar类型，如果都不是，则证明是直接导入普通java类，如果是普通java类和ImportSelector类型，那么就会将要注册的bean加入一个Map集合configurationClasses中，后续会将它进行注册，如果是ImportBeanDefinitionRegistrar类型，那么会将其加入一个Map集合importBeanDefinitionRegistrars中，后续在扩展点会对它进行再次处理。

private void processImports(ConfigurationClass configClass, ConfigurationClassParser.SourceClass currentSourceClass,
                                    Collection<ConfigurationClassParser.SourceClass> importCandidates, Predicate<String> exclusionFilter,
                                    boolean checkForCircularImports) {
            if (candidate.isAssignable(ImportSelector.class)) {
                Class<?> candidateClass = candidate.loadClass();
                ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class,
                        this.environment, this.resourceLoader, this.registry);
                Predicate<String> selectorFilter = selector.getExclusionFilter();
                if (selectorFilter != null) {
                    exclusionFilter = exclusionFilter.or(selectorFilter);
                }
                if (selector instanceof DeferredImportSelector deferredImportSelector) {
                    this.deferredImportSelectorHandler.handle(configClass, deferredImportSelector);
                } else {
                    String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
                    Collection<ConfigurationClassParser.SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
                    processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
                }
            } else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
                Class<?> candidateClass = candidate.loadClass();
                ImportBeanDefinitionRegistrar registrar =
                        ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
                                this.environment, this.resourceLoader, this.registry);
                configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
            } else {
                this.importStack.registerImport(
                        currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
                processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
            }
        }
    复制代码

经过上面解析后，Spring会注册Bean的元信息，会通过`configClass.isImported()`判断bean是否是通过@Import方式导入的普通bean或者ImportSelector类型的导入的bean，如果是，则执行`registerBeanDefinitionForImportedConfigurationClass`，里面主要就是组装成BeanDefinition，然后注册进BeanFactory。

private void loadBeanDefinitionsForConfigurationClass(ConfigurationClass configClass, ConfigurationClassBeanDefinitionReader.TrackedConditionEvaluator trackedConditionEvaluator) {
            if (trackedConditionEvaluator.shouldSkip(configClass)) {
                String beanName = configClass.getBeanName();
                if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
                    this.registry.removeBeanDefinition(beanName);
                }
                this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
                return;
            }
            if (configClass.isImported()) {
                registerBeanDefinitionForImportedConfigurationClass(configClass);
            }
            for (BeanMethod beanMethod : configClass.getBeanMethods()) {
                loadBeanDefinitionsForBeanMethod(beanMethod);
            }
            loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
            loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
        }
    复制代码

如果是通过ImportBeanDefinitionRegistrar方式，则会调用loadBeanDefinitionsFromRegistrars，里面会循环去执行我们自定义的ImportBeanDefinitionRegistrar，然后进行bean的元信息注册。

private void loadBeanDefinitionsFromRegistrars(Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> registrars) {
        registrars.forEach((registrar, metadata) ->
            registrar.registerBeanDefinitions(metadata, this.registry, this.importBeanNameGenerator));
     }
    复制代码

> 从上面的源码解析中，我们看出通过@Import直接导入普通的java类和导入实现了ImportSelector接口的类是直接注册进BeanFactory，这两者本质是一样的，而通过实现ImportBeanDefinitionRegistrar接口方式的类则需要去实现我们自定义的注册bean元信息的逻辑。

## 总结 ##

上面我们介绍了@Import的一些场景，@Import用得最多还是一些和Spring结合的中间件里面，也介绍了它的几种使用方式，还对它的源码进行解析，当然，只是从它最主要的逻辑去分析，深入的逻辑就没去一一详解，掌握@Import有助于我们在使用一些其他框架的时候能够了解框架的实现原理，然后更好的去使用框架！