本篇内容介绍了“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()

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

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()

registerBeanDefinitionForImportedConfigurationClass

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元信息的逻辑。