@Import注解 -【Spring底层原理】

原创

ONESTAR一颗星 2021-11-18 15:20:36 博主文章分类：Spring框架底层原理 ©著作权

文章标签 spring 底层原理 Import注解类名递归 文章分类 代码人生

©著作权归作者所有：来自51CTO博客作者ONESTAR一颗星的原创作品，请联系作者获取转载授权，否则将追究法律责任

一、注解用法

@Import注解也是用来给容器注册组件的，使用@Import注解快速给容器中导入一个组件有三种方法

导入@Configuration注解的配置类使用@Import（要导入到容器中的组件）：容器中就会自动注册这个组件，ID默认为全类名
导入ImportSelector的实现类：通过实现ImportSelector类，实现selectImports方法，返回需要导入组件的全类名数组
导入ImportBeanDefinitionRegistrar的实现类：通过实现ImportBeanDefinitionRegistrar类，实现registerBeanDefinitions方法手动注册Bean到容器中

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Import {
Class<?>[] value();
}

通过注解源码可以看到，@Import注解作用在类上，并且参数可以是class类型的数组，从这里可以看出可以使用@Import注解一次导入多个组件到容器中

二、实例分析

从上面的注解用法来看，使用@Import注解给容器导入组件有三种方法，并且该注解作用在方法上，一次可以导入多个组件，因此，这里我们直接将三种方法都放在一个@Import注解来进行导入。如下案例需求：使用方法一注入User类、使用方法二注入Person类、使用方法三注入Animal类。

【1】导入@Configuration注解的配置类使用@Import

// 启动类，通过打印容器中的Bean来判断是否注入
@Test
public void TestMain(){
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
String[] beanNames = applicationContext.getBeanDefinitionNames();
for (String beanName : beanNames) {
System.out.println(beanName);
    }
}

// 待注入的User
public class User {
}

// 配置类
@Configuration
@Import(User.class)     //使用@Import导入组件，ID默认是组件的全类名
public class AppConfig {
}

通过在配置类上使用@Import注解，将User给注入进容器中，运行启动类，可以看到容器中有User对象：

@Import注解 -【Spring底层原理】_递归

image-20210226164625069

【2】导入ImportSelector的实现类

导入ImportSelector的实现类需要实现ImportSelector类，自定义逻辑返回需要导入的组件，返回的字符串数组即是要注入的组件，添加修改如下代码：

// ImportSelector实现类
public class MyImportSelector implements ImportSelector {
/**
* @description 获取要导入到容器的组件全类名
* @author ONESTAR
* @date 2021/2/25 15:49
* @param annotationMetadata：当前标注@Import注解类的所有注解信息
* @throws
* @return java.lang.String[]
*/
public String[] selectImports(AnnotationMetadata annotationMetadata) {
return new String[]{"bean.Person"};
    }
}

// 待注入的Person
public class Person {
}

// 配置类
@Configuration
@Import({User.class, MyImportSelector.class})     //使用@Import导入组件，ID默认是组件的全类名
public class AppConfig {
}

在ImportSelector实现类中获取要导入到容器的组件全类名，这里将ImportSelector实现类在配置类中使用@Import注解进行配置，运行启动类，可以看到容器中有Person对象：

@Import注解 -【Spring底层原理】_类名_02

image-20210227151242060

【3】导入ImportBeanDefinitionRegistrar的实现类

导入ImportBeanDefinitionRegistrar的实现类需要实现ImportBeanDefinitionRegistrar类，通过实现registerBeanDefinitions方法手动注册Bean到容器中，添加修改如下代码：

// ImportBeanDefinitionRegistrar实现类
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {

// 指定Bean的名称
RootBeanDefinition beanDefinition = new RootBeanDefinition(Animal.class);
beanDefinitionRegistry.registerBeanDefinition("Animal", beanDefinition);
    }
}

// 待注入的Animal
public class Animal {
}

// 配置类
@Configuration
@Import({User.class, MyImportSelector.class, MyImportBeanDefinitionRegistrar.class})     //使用@Import导入组件，ID默认是组件的全类名
public class AppConfig {
}

通过ImportBeanDefinitionRegistrar的实现类进行手动注册添加Bean，并在配置类中使用@Import注解进行配置，运行启动类，可以看到容器中有Animal对象：

@Import注解 -【Spring底层原理】_类名_03

image-20210227153057676

三、源码追踪

通过@Configuration注解，会进入到doProcessConfigurationClass方法，此时解析的是appConfigure，在doProcessConfigurationClass方法里面，有个执行@Import注解的方法，即processImports

this.processImports(configClass, sourceClass, this.getImports(sourceClass), filter, true);

@Import注解执行的时机，解析配置类的时候，由ConfigurationClassParser当中的processImports来处理，在分析processImports方法之前，咱们先来看看参数getImports方法：

【1】getImports方法

进入源码查看方法，这个方法就是获取所有的@import 里面的类，流程如下：

定义一个 visited 的集合，用作是否已经判断过的标志
这里就是获取sourceClass 上面的所有的 annotation，并挨个判断，如果不是 @import ，那就进一步递归调用对应的 annotation,直到全部结束
加载sourceClass 里面的@Import annotation 里面对应的类名，最后返回

// 获取所有的`@import` 里面的类
private Set<ConfigurationClassParser.SourceClass> getImports(ConfigurationClassParser.SourceClass sourceClass) throws IOException {
Set<ConfigurationClassParser.SourceClass> imports = new LinkedHashSet();
Set<ConfigurationClassParser.SourceClass> visited = new LinkedHashSet();
this.collectImports(sourceClass, imports, visited);
return imports;
}

// 这里就是获取sourceClass 上面的 所有的 annotation， 如果不是 @import ,那就 进一步递归 调用 对应的 annotation,直到全部结束
private void collectImports(ConfigurationClassParser.SourceClass sourceClass, Set<ConfigurationClassParser.SourceClass> imports, Set<ConfigurationClassParser.SourceClass> visited) throws IOException {
if (visited.add(sourceClass)) {
Iterator var4 = sourceClass.getAnnotations().iterator();

while(var4.hasNext()) {
ConfigurationClassParser.SourceClass annotation = (ConfigurationClassParser.SourceClass)var4.next();
String annName = annotation.getMetadata().getClassName();
if (!annName.equals(Import.class.getName())) {
this.collectImports(annotation, imports, visited);
            }
        }

imports.addAll(sourceClass.getAnnotationAttributes(Import.class.getName(), "value"));
    }

}

【2】processImports 方法

获取到@Import里面的类后，再来执行processImports方法，进入源码进行查看：

private void processImports(ConfigurationClass configClass, ConfigurationClassParser.SourceClass currentSourceClass, Collection<ConfigurationClassParser.SourceClass> importCandidates, Predicate<String> exclusionFilter, boolean checkForCircularImports) {
// 准备注入的候选类集合为空 直接返回
if (!importCandidates.isEmpty()) {
// 循环注入的检查
if (checkForCircularImports && this.isChainedImportOnStack(configClass)) {
this.problemReporter.error(new ConfigurationClassParser.CircularImportProblem(configClass, this.importStack));
        } else {
// 当前configClass加入到ImportStack里面
this.importStack.push(configClass);

try {
Iterator var6 = importCandidates.iterator();

// 遍历注入的候选集合
while(var6.hasNext()) {
ConfigurationClassParser.SourceClass candidate = (ConfigurationClassParser.SourceClass)var6.next();
Class candidateClass;
// 如果是实现了ImportSelector接口的类
if (candidate.isAssignable(ImportSelector.class)) {
candidateClass = candidate.loadClass();
ImportSelector selector = (ImportSelector)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) {
this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector)selector);
                        } else {
// 调用selector当中的selectImports方法，得到要注入的类的全限定名
String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
Collection<ConfigurationClassParser.SourceClass> importSourceClasses = this.asSourceClasses(importClassNames, exclusionFilter);
this.processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
                        }
// 如果是ImportBeanDefinitionRegistrar 则configClass.addImportBeanDefinitionRegistrar 提前放到一个map当中
                    } else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
candidateClass = candidate.loadClass();
ImportBeanDefinitionRegistrar registrar = (ImportBeanDefinitionRegistrar)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());
this.processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
                    }
                }
            } catch (BeanDefinitionStoreException var17) {
throw var17;
            } catch (Throwable var18) {
throw new BeanDefinitionStoreException("Failed to process import candidates for configuration class [" + configClass.getMetadata().getClassName() + "]", var18);
            } finally {
this.importStack.pop();
            }
        }

    }
}

以上方法便是@Import注解的核心作用，可以总结为以下几点：

判断注入的候选集合 importCandidates 是否为空，为空则直接退出
循环注入检查：判断isChainedImportOnStack ，如果为true ,加入 problemReporter 里面的error ，并退出
把当前的 configClass 加入到 ImportStack里面，ImportStack 是继承了 ArrayDeque 和实现了 ImportRegistry
遍历注入的候选集合：对 getImports 里面获取到的需要import 的类进行遍历处理（三种类型的类执行不同的逻辑）
实现了ImportSelector接口的类，调用getExclusionFilter()方法，如果不为空，那么就进行过滤，过滤后调用selectImports方法，得到要注入的类的全限定名。根据类全限定名，得到类元信息。然后递归的调用processImports方法
实现了ImportBeanDefinitionRegistrar接口的类，会实例化这个类，放入集合importBeanDefinitionRegistrars当中
普通类型的类（上面两个都不满足），那么就把它当作是配置类来处理，调用processConfigurationClass方法，最终会放入到configurationClasses这个集合当中。
如果是 ImportBeanDefinitionRegistrar 类型，这里也是先实例一个对象，然后加入到 importBeanDefinitionRegistrars 里面，后续会在 ConfigurationClassBeanDefinitionReader 这个类里面的 loadBeanDefinitionsFromRegistrars 方法处理的
如果上面两种类型都不是，那就是当初普通的带有@Configuration 的类进行处理了