@Import注解：导入配置类的四种方式&源码解析

时间  2021-08-14
标签 html java git github web spring api 数组 微信 markdown 栏目 HTML 繁體版
原文   原文链接

微信搜索：码农StayUphtml

主页地址：gozhuyinglong.github.iojava

源码分享：github.com/gozhuyinglo…git

平时喜欢看源码的小伙伴，应该知道Spring中大量使用了@Import注解。该注解是Spring用来导入配置类的，等价于Spring XML中的<import/>元素。github

本文将对该注解进行介绍，并经过实例演示它导入配置类的四种方式，最后对该注解进行源码解析。web

话很少说，走起~spring

简介

@Import注解的全类名是org.springframework.context.annotation.Import。其只有一个默认的value属性，该属性类型为Class<?>[]，表示能够传入一个或多个Class对象。api

经过注释能够看出，该注解有以下做用：数组

  • 能够导入一个或多个组件类（一般是@Configuration配置类）
  • 该注解的功能与Spring XML中的<import/>元素相同。能够导入@Configuration配置类、ImportSelect和ImportBeanDefinitionRegistrar的实现类。从4.2版本开始，还能够引用常规组件类（普通类），该功能相似于AnnotationConfigApplicationContext.register方法。
  • 该注解能够在类中声明，也能够在元注解中声明。
  • 若是须要导入XML或其余非@Configuration定义的资源，可使用@ImportResource注释。

导入配置类的四种方式

源码注释写得很清楚，该注解有四种导入方式：微信

  1. 普通类
  2. @Configuration配置类
  3. ImportSelector的实现类
  4. ImportBeanDefinitionRegistrar的实现类

下面咱们逐个来介绍~markdown

准备工做

建立四个配置类：ConfigA、ConfigB、ConfigC、ConfigD。其中ConfigB中增长@Configuration注解，表示为配置类，其他三个均为普通类。

ConfigA：

public class ConfigA {

    public void print() {
        System.out.println("输出：ConfigA.class");
    }
}
复制代码

ConfigB：

@Configuration
public class ConfigB {

    public void print() {
        System.out.println("输出：ConfigB.class");
    }

}
复制代码

ConfigC：

public class ConfigC {

    public void print() {
        System.out.println("输出：ConfigC.class");
    }

}
复制代码

ConfigD：

public class ConfigD {
    
    public void print() {
        System.out.println("输出：ConfigD.class");
    }

}
复制代码

再建立一个主配置类Config，并试图经过@Resource注解将上面四个配置类进行注入。固然，这样是不成功的，还须要将它们进行导入。

@Configuration
public class Config {

    @Resource
    ConfigA configA;

    @Resource
    ConfigB configB;

    @Resource
    ConfigC configC;

    @Resource
    ConfigD configD;


    public void print() {
        configA.print();
        configB.print();
        configC.print();
        configD.print();
    }
}
复制代码

方式一：导入普通类

导入普通类很是简单，只需在@Import传入类的Class对象便可。

@Configuration
@Import(ConfigA.class)
public class Config {
   ...
}
复制代码

方式二：导入@Configuration配置类

导入配置类与导入普通类同样，在@Import注解中传入目标类的Class对象。

@Configuration
@Import({ConfigA.class, ConfigB.class})
public class Config {
    ...
}
复制代码

方式三：导入ImportSelector的实现类

ImportSelector接口的全类名为org.springframework.context.annotationImportSelector。其主要做用的是收集须要导入的配置类，并根据条件来肯定哪些配置类须要被导入。

该接口的实现类同时还能够实现如下任意一个Aware接口，它们各自的方法将在selectImport以前被调用：

另外，该接口实现类能够提供一个或多个具备如下形参类型的构造函数：

若是你想要推迟导入配置类，直处处理完全部的@Configuration。那么你可使用DeferredImportSelector

下面咱们建立一个实现该接口的类 MyImportSelector。

看下面示例：

在selectImports方法中，入参AnnotationMetadata为主配置类 Config 的注解元数据。 返回值为目标配置类 ConfigC 的全类名，这里是一个数组，表示能够导入多个配置类。

public class MyImportSelector implements ImportSelector {
    
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{"io.github.gozhuyinglong.importanalysis.config.ConfigC"};
    }
}
复制代码

在配置类 Config 中导入 MyImportSelector 类。

@Configuration
@Import({ConfigA.class, ConfigB.class, MyImportSelector.class})
public class Config {
    ...
}
复制代码

方式四：导入ImportBeanDefinitionRegistrar的实现类

该接口的目的是有选择性的进行注册Bean，注册时能够指定Bean名称，而且能够定义bean的级别。其余功能与ImportSelector相似，这里就再也不赘述。

下面来看示例：

建立一个实现 ImportBeanDefinitionRegistrar 接口的类 MyImportBeanDefinitionRegistrar，并在 registerBeanDefinitions方法中注册 configD 类。 入参 AnnotationMetadata为主配置类 Config 的注解元数据；BeanDefinitionRegistry参数能够注册Bean的定义信息。

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        registry.registerBeanDefinition("configD", new RootBeanDefinition(ConfigD.class));
    }
}
复制代码

在配置类 Config 中导入 MyImportBeanDefinitionRegistrar 类。

@Configuration
@Import({ConfigA.class, ConfigB.class, MyImportSelector.class, MyImportBeanDefinitionRegistrar.class})
public class Config {
    ...
}
复制代码

测试结果

建立一个测试类 ImportDemo，看上面四个配置类是否被注入。

public class ImportDemo {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(Config.class);
        Config config = ctx.getBean(Config.class);
        config.print();
    }
}
复制代码

输出结果：

输出：ConfigA.class
输出：ConfigB.class
输出：ConfigC.class
输出：ConfigD.class
复制代码

经过输出结果能够看出，这四个配置类被导入到主配置类中，并成功注入。

源码解析

ConfigurationClassParser类为Spring的工具类，主要用于分析配置类，并产生一组ConfigurationClass对象（由于一个配置类中可能会经过@Import注解来导入其它配置类）。也就是说，其会递归的处理全部配置类。

doProcessConfigurationClass

其中的doProcessConfigurationClass方法是处理全部配置类的过程，其按下面步骤来处理：

  1. @Component注解
  2. @PropertySource注解
  3. @ComponentScan注解
  4. @Import注解
  5. @ImportResource注解
  6. @Bean注解
  7. 配置类的接口上的默认方法
  8. 配置类的超类
@Nullable
protected final SourceClass doProcessConfigurationClass( ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter) throws IOException {

    if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
        // 1.首先会递归的处理全部成员类，即@Component注解
        processMemberClasses(configClass, sourceClass, filter);
    }

    // 2.处理全部@PropertySource注解
    for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
        sourceClass.getMetadata(), PropertySources.class,
        org.springframework.context.annotation.PropertySource.class)) {
        if (this.environment instanceof ConfigurableEnvironment) {
            processPropertySource(propertySource);
        }
        else {
            logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
                        "]. Reason: Environment must implement ConfigurableEnvironment");
        }
    }

    // 3.处理全部@ComponentScan注解
    Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
        sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
    if (!componentScans.isEmpty() &&
        !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
        for (AnnotationAttributes componentScan : componentScans) {
            // 配置类的注解为@ComponentScan-> 当即执行扫描
            Set<BeanDefinitionHolder> scannedBeanDefinitions =
                this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
            // 检查扫描过的BeanDefinition集合，看看是否有其余配置类，若是须要，递归解析
            for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
                BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
                if (bdCand == null) {
                    bdCand = holder.getBeanDefinition();
                }
                if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
                    parse(bdCand.getBeanClassName(), holder.getBeanName());
                }
            }
        }
    }

    // 4.处理全部@Import注解
    processImports(configClass, sourceClass, getImports(sourceClass), filter, true);

    // 5.处理全部@ImportResource注解
    AnnotationAttributes importResource =
        AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
    if (importResource != null) {
        String[] resources = importResource.getStringArray("locations");
        Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
        for (String resource : resources) {
            String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
            configClass.addImportedResource(resolvedResource, readerClass);
        }
    }

    // 6.处理标注为@Bean注解的方法
    Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
    for (MethodMetadata methodMetadata : beanMethods) {
        configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
    }

    // 7.处理配置类的接口上的默认方法
    processInterfaces(configClass, sourceClass);

    // 8.处理配置类的超类（若是有的话）
    if (sourceClass.getMetadata().hasSuperClass()) {
        String superclass = sourceClass.getMetadata().getSuperClassName();
        if (superclass != null && !superclass.startsWith("java") &&
            !this.knownSuperclasses.containsKey(superclass)) {
            this.knownSuperclasses.put(superclass, configClass);
            // Superclass found, return its annotation metadata and recurse
            return sourceClass.getSuperClass();
        }
    }

    // 处理完成
    return null;
}
复制代码

processImports

processImports方法为处理@Import注解导入的配置类，是咱们本篇的主题。

该方法会循环处理每个由@Import导入的类：

  1. ImportSelector类的处理
  2. ImportBeanDefinitionRegistrar类的处理
  3. 其它类统一按照@Configuration类来处理，因此加不加@Configuration注解都能被导入
/** * 处理配置类上的@Import注解引入的类 * * @param configClass 配置类，这里是Config类 * @param currentSourceClass 当前资源类 * @param importCandidates 该配置类中的@Import注解导入的候选类列表 * @param exclusionFilter 排除过滤器 * @param checkForCircularImports 是否循环检查导入 */
private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass, Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter, boolean checkForCircularImports) {
	// 若是该@Import注解导入的列表为空，直接返回
    if (importCandidates.isEmpty()) {
        return;
    }
	// 循环检查导入
    if (checkForCircularImports && isChainedImportOnStack(configClass)) {
        this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
    }
    else {
        this.importStack.push(configClass);
        try {
            // 循环处理每个由@Import导入的类
            for (SourceClass candidate : importCandidates) {
                if (candidate.isAssignable(ImportSelector.class)) {
                    // 1. ImportSelector类的处理
                    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) {
                        // 1.1 如果DeferredImportSelector接口的实现，则延时处理
                        this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
                    }
                    else {
                        // 1.2 在这里调用咱们的ImportSelector实现类的selectImports方法
                        String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
                        Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
                        // 1.3 递归处理每个selectImports方法返回的配置类
                        processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
                    }
                }
                else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
                     // 2. ImportBeanDefinitionRegistrar类的处理
                    Class<?> candidateClass = candidate.loadClass();
                    ImportBeanDefinitionRegistrar registrar =
                        ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
                                                             this.environment, this.resourceLoader, this.registry);
                    configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
                }
                else {
                    // 3. 其它类统一按照@Configuration类来处理，因此加不加@Configuration注解都能被导入
                    this.importStack.registerImport(
                        currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
                    processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
                }
            }
        }
        catch (BeanDefinitionStoreException ex) {
            throw ex;
        }
        catch (Throwable ex) {
            throw new BeanDefinitionStoreException(
                "Failed to process import candidates for configuration class [" +
                configClass.getMetadata().getClassName() + "]", ex);
        }
        finally {
            this.importStack.pop();
        }
    }
}
复制代码

总结

经过上面源码的解析能够看出，@Import注解主要做用是导入外部类的，而且普通类也会按照@Configuration类来处理。这大大方便了咱们将本身的组件类注入到容器中了（无需修改本身的组件类）。

源码分享

完整代码请访问个人Github，若对你有帮助，欢迎给个⭐，感谢~~🌹🌹🌹

github.com/gozhuyinglo…

推荐阅读

关于做者

项目 内容
公众号 码农StayUp（ID：AcmenStayUp）
主页 gozhuyinglong.github.io
CSDN blog.csdn.net/gozhuyinglo…
掘进 juejin.cn/user/123990…
Github github.com/gozhuyinglo…
Gitee gitee.com/gozhuyinglo…
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程