Spring 框架中的 @Enable* 注解是怎样实现的？

概述

Spring 的项目中，我们经常会使用 @Enable 开头的注解到配置类中，添加了这种注解之后，便会开启一些功能特性。常用的注解如 @EnableWebMvc、@EnableTransactionManagement、@EnableAsync、@EnableScheduling 等等。集成到 Spring 的第三方的框架中，我们也经常会看到这样的注解，如阿里巴巴开源的缓存框架 jetcache，便需要使用注解 @EnableCreateCacheAnnotation 开启缓存能力。本篇将尝试对其实现进行分析，并实现一个自己的 @Enable* 注解。

@Enable* 注解实现分析

以 @EnableScheduling 注解为例，其源码如下。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Import(SchedulingConfiguration.class)
@Documented
public @interface EnableScheduling {

}

除了最常用的 Java 提供的元注解，这个 @EnableScheduling 使用了 @Import 注解，很明显 @Enable* 就是利用 @Import 注解实现的。查看 @Import 源码如下。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Import {

	/**
	 * {@link Configuration @Configuration}, {@link ImportSelector},
	 * {@link ImportBeanDefinitionRegistrar}, or regular component classes to import.
	 */
	Class<?>[] value();

}

@Import 可以标注在类型上，只有一个类型为 Class 的 value 属性，根据注释我们可以看到，value 属性值可以是 @Configuration 配置类、ImportSelector、ImportBeanDefinitionRegistrar 或者常规组件类。Spring 读取到这几个类型时的处理如下。

• @Configuration 配置类：Spring 对配置类进行解析。
• ImportSelector：实例化该接口实现类，提供元数据给接口中的方法，将返回的类型作为配置类进行解析。
• ImportBeanDefinitionRegistrar：实例化该类型，提供元数据给接口中的方法，由用户自己控制注入哪些 bean。
• 常规类：将该类作为 bean 进行注入。

value 值为配置类的时候 Spring 会对配置类进行解析，值为常规组件类的时候 Spring 会把组件类作为 Spring 的 bean 进行注入，这两个相对比较容易理解。下面对剩下的两个类型进行分析。

ImportSelector 定义
ImportSelector 接口定义如下。

public interface ImportSelector {

	/**
	 * 选择并返回哪些类应该被导入，导入的类将作为配置类再次进行解析
	 * AnnotationMetadata 是 @Configuration 配置类的元数据
	 */
	String[] selectImports(AnnotationMetadata importingClassMetadata);

	/**
	 * 排除导入的类
	 * @since 5.2.4
	 */
	@Nullable
	default Predicate<String> getExclusionFilter() {
		return null;
	}

}

ImportSelector#selectImports 方法中的参数 AnnotationMetadata 是使用 @Import 注解的配置类的元数据，返回值将作为配置类再次进行解析。如果返回值是实现 BeanFactoryPostProcessor 或者 BeanPostProcessor 接口的组件，我们将有机会在 Spring 应用上下文或 bean 的生命周期中做一些其他的操作。如果返回值是配置类，我们还能根据 @Conditional 注解根据条件注入一些 bean 。@Conditional 注解的使用见 Spring 条件注解 @Conditional 使用及其底层实现 。

ImportSelector#getExclusionFilter 方法则用于从导入的类中排除我们不想导入的类。

ImportBeanDefinitionRegistrar 定义
ImportBeanDefinitionRegistrar 定义如下。

public interface ImportBeanDefinitionRegistrar {
	// 注册 BeanDefinition
	default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry,
			BeanNameGenerator importBeanNameGenerator) {
		registerBeanDefinitions(importingClassMetadata, registry);
	}
	// 注册 BeanDefinition
	default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
	}
}

相比 ImportSelector 只能获取配置类的元数据，ImportBeanDefinitionRegistrar 接口提供了更为灵活的方法，还能收到参数 BeanDefinitionRegistry、BeanNameGenerator 。 BeanDefinitionRegistry 可以方便我们获取已注册的 BeanDefinition，注册自己定义的 BeanDefinition。BeanNameGenerator 则用于生成 bean 的名称。

@Import 实现分析

通过上面的描述，我们知道 @Enable* 注解是通过 @Import 实现的，而 @Import 的处理在 Spring 中的配置类解析过程中。解析 @Import 注解的核心代码位置为 ConfigurationClassParser#processImports，源码如下。

	/**
	 * 处理 @Import 注解
	 *
	 * @param configClass             标注或元标注 @Import 的配置类
	 * @param currentSourceClass      配置类对应的 SourceClass
	 * @param importCandidates        @Import 注解 value 属性值集合或 ImportSelector.selectImports 返回值
	 * @param exclusionFilter         不要处理配置类的过滤器
	 * @param checkForCircularImports 是否检查循环 @Import
	 */
	private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
			Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter,
			boolean checkForCircularImports) {

		if (importCandidates.isEmpty()) {
			return;
		}

		if (checkForCircularImports && isChainedImportOnStack(configClass)) {
			this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
		} else {
			this.importStack.push(configClass);
			try {
				for (SourceClass candidate : importCandidates) {
					// @Import value 属性值是 ImportSelector.class
					if (candidate.isAssignable(ImportSelector.class)) {
						// Candidate class is an ImportSelector -> delegate to it to determine imports
						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) {
							// @Import value 属性值是 DeferredImportSelector.class
							this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
						} else {
							String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
							Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames,
									exclusionFilter);
							// 递归处理 ImportSelector 返回的配置类
							processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter,
									false);
						}
					} else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
						// Candidate class is an ImportBeanDefinitionRegistrar ->
						// delegate to it to register additional bean definitions
						Class<?> candidateClass = candidate.loadClass();
						ImportBeanDefinitionRegistrar registrar =
								ParserStrategyUtils
										.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
												this.environment, this.resourceLoader, this.registry);
						configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
					} else {
						// Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
						// process it as an @Configuration class
						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();
			}
		}
	}

processImports 方法整体结构较为清晰，对 @Import 注解的 value 属性值进行循环处理。

1. 首先判断是否为 ImportSelector 类型，如果是则 调用 ImportSelector#selectImports 方法，并将取到的类型作为配置类，进行递归解析 @Import。
2. 否则如果类型为 ImportBeanDefinitionRegistrar，则对其实例化，并添加到 importBeanDefinitionRegistrars 中，后面将统一进行处理。
3. 否则将导入的类作为 bean 进行注册，然后作为配置类递归进行处理。

实现自己的 @Enable* 注解

下面尝试实现一个 @EnableHelloWorld ，配置类上使用了该注解后将自动注入一个 HelloWorld 的 bean。代码如下。

public class HelloWorld {

    public void sayHello(){
        System.out.println("hello,world");
    }
}

public class HelloWorldSelector implements ImportSelector {

    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{HelloWorld.class.getName()};
    }
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Import(HelloWorldSelector.class)
public @interface EnableHelloWorld {

}

@EnableHelloWorld
@Configuration
public class Application {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.scan("com.zzuhkp");
        context.refresh();
        context.getBean(HelloWorld.class).sayHello();
    }

}

程序执行后成功打印出“hello,world”，表明自定义 @Enable* 成功生效。

总结

@Enable* 注解通过 @Import 注解实现。@Import 注解在配置类解析过程中进行处理。通过 @Import 可以方便的注入自定义的 bean 。