聊一聊Spring中的@Import注解

标签：configClass getMetadata Spring Bean 聊一聊 Import class sourceClass

[!NOTE]

**Spring版本：**5.3.27

**JDK版本：**1.8

一、@Import在何处处理

// ConfigurationClassParser

/**
 * 通过从源类（理解为配置类）中读取注解、成员和方法，获取到完成的配置类
 * 由于一个配置类可能关联其他的配置类等，所以这个方法可能会被调用多次
 */
protected final SourceClass doProcessConfigurationClass(
        ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
        throws IOException {

    if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
        // 先递归处理成员类
        processMemberClasses(configClass, sourceClass, filter);
    }

    // 处理@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");
        }
    }

    // 处理@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());
            // 如果找到其他的配置类，在需要的情况下递归解析
            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());
                }
            }
        }
    }

    // 处理@Import注解  本文要探讨的注解
    processImports(configClass, sourceClass, getImports(sourceClass), filter, true);

    // 处理@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);
        }
    }

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

    // 处理接口上的默认方法
    processInterfaces(configClass, sourceClass);

    // 超类处理
    if (sourceClass.getMetadata().hasSuperClass()) {
        String superclass = sourceClass.getMetadata().getSuperClassName();
        if (superclass != null && !superclass.startsWith("java") &&
                !this.knownSuperclasses.containsKey(superclass)) {
            this.knownSuperclasses.put(superclass, configClass);
            // 发现超类, 返回元注解并递归
            return sourceClass.getSuperClass();
        }
    }

    // 没有超类 -> 处理完成
    return null;
}

// 获取通过@Import导入的类
private Set<SourceClass> getImports(SourceClass sourceClass) throws IOException {
    Set<SourceClass> imports = new LinkedHashSet<>();
    Set<SourceClass> visited = new LinkedHashSet<>();
    collectImports(sourceClass, imports, visited);
    return imports;
}

/**
 * 递归收集通过@Import导入的类
 * 检查每个源类上的注解，如果不是@Import，把这个注解当成源类，继续收集
 * 最终的结果就是获取到所有源类上所有层次@Import上的value
 */
private void collectImports(SourceClass sourceClass, Set<SourceClass> imports, Set<SourceClass> visited)
        throws IOException {

    if (visited.add(sourceClass)) {
        for (SourceClass annotation : sourceClass.getAnnotations()) {
            String annName = annotation.getMetadata().getClassName();
            if (!annName.equals(Import.class.getName())) {
                collectImports(annotation, imports, visited);
            }
        }
        imports.addAll(sourceClass.getAnnotationAttributes(Import.class.getName(), "value"));
    }
}

/**
 * importCandidates是上一步收集到的所有@Import注解的value
 */
private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
        Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter,
        boolean checkForCircularImports) {

    // 省略部分代码...
    
    // 遍历处理所有@Import注解的value
    for (SourceClass candidate : importCandidates) {
        if (candidate.isAssignable(ImportSelector.class)) {
            // 候选类是ImportSelector -> 委托给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) {
                this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
            }
            else {
                String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
                Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
                processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
            }
        }
        else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
            // 候选类是ImportBeanDefinitionRegistrar ->
            // 委托给ImportBeanDefinitionRegistrar注册额外的bean定义信息
            Class<?> candidateClass = candidate.loadClass();
            ImportBeanDefinitionRegistrar registrar =
                    ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
                            this.environment, this.resourceLoader, this.registry);
            configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
        }
        else {
            // 候选类不是ImportSelector或ImportBeanDefinitionRegistrar ->
            // 当成配置类处理（@Configuration注解的类）
            this.importStack.registerImport(
                    currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
            processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
        }
    }
}

二、@Import引入的三种类型

1、引入普通组件

package com.lazy.snail;

/**
 * @ClassName NormalComponent
 * @Description TODO
 * @Author lazysnail
 * @Date 2024/10/22 9:35
 * @Version 1.0
 */
public class NormalComponent {
}

package com.lazy.snail;

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration
@Import({NormalComponent.class})
public class AppConfig {

}

2、引入ImportSelector

package com.lazy.snail;

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;

@Configuration
@EnableAsync
public class AppConfig {

}

// EnableAsync

// 省略部分代码...

/**
 * 启用Spring的异步方法执行能力
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
// AsyncConfigurationSelector会被选择出来进行处理
@Import(AsyncConfigurationSelector.class)
public @interface EnableAsync {

	Class<? extends Annotation> annotation() default Annotation.class;

	boolean proxyTargetClass() default false;

	AdviceMode mode() default AdviceMode.PROXY;

	int order() default Ordered.LOWEST_PRECEDENCE;

}

// ConfigurationClassParser.processImports截取

if (candidate.isAssignable(ImportSelector.class)) {
    // Candidate class is an ImportSelector -> delegate to it to determine imports
    Class<?> candidateClass = candidate.loadClass();
    // 实例化了AsyncConfigurationSelector
    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);
    }
    // 这种类型后续SpringBoot自动装配再聊
    if (selector instanceof DeferredImportSelector) {
        this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
    } else {
        // 此处的selectImports调用的是AsyncConfigurationSelector父类AdviceModeImportSelector的selectImports
        // 各种选择逻辑后返回org.springframework.scheduling.annotation.ProxyAsyncConfiguration
        String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
        // 根据全限定名找源Class
        Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
        // 把上面找到的源类当做@Import引入的类，从走取经路
        // 就本案例而言,ProxyAsyncConfiguration是普通组件，只有一个@Bean方法，所以会在容器中注册一个AsyncAnnotationBeanPostProcessor
        processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
    }
}

// AdviceModeImportSelector
public final String[] selectImports(AnnotationMetadata importingClassMetadata) {
    // 省略部分代码...
    
    // AsyncConfigurationSelector的selectImports方法
    String[] imports = selectImports(adviceMode);
    if (imports == null) {
        throw new IllegalArgumentException("Unknown AdviceMode: " + adviceMode);
    }
    return imports;
}

// AsyncConfigurationSelector
/**
 * 这个方法返回了一个类的全限定名
 * org.springframework.scheduling.annotation.ProxyAsyncConfiguration
 */
public String[] selectImports(AdviceMode adviceMode) {
    switch (adviceMode) {
        case PROXY:
            return new String[] {ProxyAsyncConfiguration.class.getName()};
        case ASPECTJ:
            return new String[] {ASYNC_EXECUTION_ASPECT_CONFIGURATION_CLASS_NAME};
        default:
            return null;
    }
}

AsyncConfigurationSelector类结构图：

AdviceModeImportSelector

解析结束后，容器中的beanDefinitionMap:

3、引入ImportBeanDefinitionRegistrar

package com.lazy.snail;

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {

}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
// 此处导入了ImportBeanDefinitionRegistrar类型的注册器
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {

	boolean proxyTargetClass() default false;

	boolean exposeProxy() default false;

}

// ConfigurationClassParser.processImports

else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
    Class<?> candidateClass = candidate.loadClass();
    // AspectJAutoProxyRegistrar实例
    ImportBeanDefinitionRegistrar registrar =
            ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
                    this.environment, this.resourceLoader, this.registry);
    // 注册器加到了配置类importBeanDefinitionRegistrars中，这个集合中的注册器会在加载bean定义信息的时候使用
    configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
}

// ConfigurationClassPostProcessor.processConfigBeanDefinitions

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
    // 省略部分代码...
    this.reader.loadBeanDefinitions(configClasses);
    // 省略部分代码...
}

// ConfigurationClassBeanDefinitionReader.loadBeanDefinitionsForConfigurationClass
private void loadBeanDefinitionsForConfigurationClass(
        ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {

    // 省略部分代码...
    // 此处处理之前添加的注册器
    loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}

/**
 * 遍历注册器,调用注册器的registerBeanDefinitions方法
 */
private void loadBeanDefinitionsFromRegistrars(Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> registrars) {
    registrars.forEach((registrar, metadata) ->
            registrar.registerBeanDefinitions(metadata, this.registry, this.importBeanNameGenerator));
}

// AspectJAutoProxyRegistrar
class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {

	@Override
	public void registerBeanDefinitions(
			AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
		// 注册AspectJAnnotationAutoProxyCreator的bean定义信息
		AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

		AnnotationAttributes enableAspectJAutoProxy =
				AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
		if (enableAspectJAutoProxy != null) {
			if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
				AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
			}
			if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
				AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
			}
		}
	}

}

注册器处理完后，容器中的beanDefinitionMap中：

三、总结

1. 导入普通组件

使用方式：

@Import(SomeConfig.class)

处理机制：

当 @Import 注解的 value 中传入的是普通的组件类（包括普通的 Java 类和标记了 @Configuration 的类），Spring 容器会将这些类作为Bean直接注册到容器中。
解析顺序

：
- Spring 会将这些类当作标准的配置类进行处理（如果带有 @Configuration）。
- 如果是普通类（没有 @Configuration），也会作为普通的 Bean 定义注册进容器。

使用场景：

简单场景下，直接将某些普通组件或配置类引入容器进行自动装配和依赖注入。

2. 导入实现 `ImportSelector` 接口的类

使用方式：

@Import(MyImportSelector.class)

处理机制：

ImportSelector 是一个接口，其中最核心的方法是 selectImports，它返回一个字符串数组，表示要导入的类名。
解析顺序

：
- Spring 会调用 selectImports 方法，获取需要导入的 Bean 名称列表（这些类并不需要提前在 @Import 注解中明确声明）。
- Spring 根据返回的类名，动态地将这些类的定义加载到容器中。
- 可以通过条件、配置、逻辑判断来选择哪些类需要被导入，实现更灵活的组件注册。

使用场景：

需要基于逻辑条件动态引入配置类或组件，比如在某些场景下，按需引入特定 Bean。
常用于自动配置机制，例如 Spring Boot 的 @EnableAutoConfiguration，其背后通过 ImportSelector 实现了动态组件引入。

3. 导入实现 `ImportBeanDefinitionRegistrar` 接口的类

使用方式：

@Import(MyImportBeanDefinitionRegistrar.class)

处理机制：

ImportBeanDefinitionRegistrar 提供更底层的控制，它允许在 Spring Bean 定义的注册阶段，手动向容器中注册 Bean 定义信息。
解析顺序

：
- Spring 调用 registerBeanDefinitions 方法，该方法允许开发者直接向 BeanDefinitionRegistry 中注册 Bean 定义，而不仅仅是类名。
- 在这个方法里，开发者可以完全自定义 Bean 的定义、依赖关系、属性等。
- 这是最强大的扩展方式，因为它可以直接操作 Bean 定义元数据，而不仅仅是控制导入哪些类。

使用场景：

需要完全自定义 Bean 注册过程，甚至可以动态生成 BeanDefinition。
通常用于更复杂的场景，如框架级别的开发，动态注册特定类型的 Bean 或者与其他框架集成。

三者对比总结

形式	处理方式	使用场景
普通组件（类）	直接将类作为 Bean 注册到容器中	引入静态组件、配置类，或使用简单的 `@Configuration` 类
实现 `ImportSelector` 接口	通过返回类名字符串数组，动态选择和注册类	按条件动态选择要注册的 Bean，用于自动配置等场景
实现 `ImportBeanDefinitionRegistrar` 接口	手动操作 `BeanDefinitionRegistry` 注册 Bean 定义	完全自定义 Bean 的注册过程，实现更复杂的动态注册逻辑

标签：configClass,getMetadata,Spring,Bean,聊一聊,Import,class,sourceClass
From： https://blog.csdn.net/indolentSnail/article/details/143156333

聊一聊Spring中的@Import注解

一、@Import在何处处理

二、@Import引入的三种类型

1、引入普通组件

2、引入ImportSelector

3、引入ImportBeanDefinitionRegistrar

三、总结

1. 导入普通组件

使用方式：

处理机制：

使用场景：

2. 导入实现 `ImportSelector` 接口的类

使用方式：

处理机制：

使用场景：

3. 导入实现 `ImportBeanDefinitionRegistrar` 接口的类

使用方式：

处理机制：

使用场景：

三者对比总结

相关文章

赞助商

阅读排行

聊一聊Spring中的@Import注解

一、@Import在何处处理

二、@Import引入的三种类型

1、引入普通组件

2、引入ImportSelector

3、引入ImportBeanDefinitionRegistrar

三、总结

1. 导入普通组件

使用方式：

处理机制：

使用场景：

2. 导入实现 ImportSelector 接口的类

使用方式：

处理机制：

使用场景：

3. 导入实现 ImportBeanDefinitionRegistrar 接口的类

使用方式：

处理机制：

使用场景：

三者对比总结

相关文章

赞助商

阅读排行

2. 导入实现 `ImportSelector` 接口的类

3. 导入实现 `ImportBeanDefinitionRegistrar` 接口的类