Spring自定义注解驱动开发使用及源码分析

- 前言
- 注解驱动开发使用
- - 需求
  - 代码实现
  - 测试效果
- 源码分析
- - BeanDefinitionRegistryPostProcessor接口
  - 解析BeanDefinition
  - 处理Bean上配置的注解
  - 处理@Import注解
  - 校验
  - 加载BeanDefinition
  - 注册Bean到Spring容器
  - 初始化对象
  - 扩展知识
- 小结

前言

在我们实际开发中，你是不是也经常使用各种@Enablexxx（如@EnableAspectJAutoProxy、@EnableTransactionManagement）之类的注解呢？只要使用了它，某个功能（组件）就应用上了。为我们提供了很多便利。
下面我们就从自己模仿写一个Enablexxx注解开始，一步步揭开注解驱动开发背后真相。

注解驱动开发使用需求

假设有这样一个需求：有比较多的微服务，接口请求要打印下请求参数、请求地址什么的。
我的想法是使用AOP实现，可以把它封装成一个组件，引入项目中然后使用如@EnableWebLogAspect这样的注解就可以启用它了

这里方案排除Spring Boot自动装配spring.factories的方式。本章主角是注解驱动开发，其实Spring Boot @EnableAutoConfiguration的原理也是注解驱动。

代码实现

WebLogAspect.java拦截controller打印参数的地方。

注意：下面我使用了@Component，但其实它并不会因为这个注解初始化，因为我的扫描包路径是com.zzq.core。
之所以加@Component，是老版本要加Component、Bean、Configuration其一注解,或者派生,我用的是Spring 3.2.18的源码 registerBeanDefinitionForImportedConfigurationClass方法中ConfigurationClassUtils.checkConfigurationClassCandidate在检查，否则异常
Configuration problem: com.zzq.core.annotationdrivendevelopment.WebLogAspect was @Import’ed but is not annotated with @Configuration nor does it declare any @Bean methods; it does not implement ImportSelector or extend ImportBeanDefinitionRegistrar. Update the class to meet one of these requirements or do not attempt to @Import it.
我看了高版本的代码如 5.1.16.RELEASE没有这个限制，不用加注解

package com.zzq.annotationdrivendevelopment;

import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import com.fasterxml.jackson.databind.ObjectMapper;




@Component
@Aspect
public class WebLogAspect {
	 
	private final ObjectMapper objectMapper = new ObjectMapper();

    @Pointcut("execution(* com.*.core.controller..*.*(..))")
    public void webLog() {
    	System.out.println("webLog");
    }

    
    @Before("webLog()")
    public void doBefore(JoinPoint joinPoint) throws Throwable {
    	
    	Object [] args = joinPoint.getArgs();
    	 
        // 开始打印请求日志
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        Map parameterMap = request.getParameterMap();
        System.out.println("========================================== Request start ==========================================");
        System.out.println("URL            : " + request.getRequestURL().toString());
        System.out.println("HTTP Method    : " + request.getMethod());
        System.out.println("Class Method   : "+ joinPoint.getSignature().getDeclaringTypeName() +"."+ joinPoint.getSignature().getName());
        System.out.println("IP             :  " + request.getRemoteAddr());
        if (null != args && args.length>0) {
        	StringBuilder sb = new StringBuilder();
        	for (int i = 0; i < args.length; i++) {
        		sb.append(objectMapper.writeValueAsString(args[i]) + "t");
			}
        	System.out.println("Request Args   :  " +sb.toString());
		}else{
			System.out.println("Request Args   :  " );
		}
       
        System.out.println("========================================== Request end ==========================================");
    }

}

创建WebLogAspectImportSelector，选择导入刚才的WebLogAspect

 package com.zzq.annotationdrivendevelopment;
import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;

public class WebLogAspectImportSelector implements ImportSelector{

	@Override
	public String[] selectImports(AnnotationMetadata importingClassMetadata) {
		System.out.println("使用注解驱动  ImportSelector");
		return new String[]{WebLogAspect.class.getName()};
	}

}

创建注解EnableWebLogAspect，导入WebLogAspectImportSelector

package com.zzq.annotationdrivendevelopment;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.context.annotation.Import;


@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(WebLogAspectImportSelector.class)
public @interface EnableWebLogAspect {
}

前面的代码都可以封装成一个公共模块

新建配置类，ConfigurationTest使用EnableWebLogAspect注解

@Configuration
@ComponentScan("com.zzq.core")
@EnableWebLogAspect // 启用
public class ConfigurationTest {
}

新建TestController,用于测试。

 
@Controller
@RequestMapping("/test")
public class TestController {
@RequestMapping(value ="/test8")
	@ResponseBody
	public String test8(com.zzq.core.dto.TestReq testReq){
		System.out.println("test8 controller " + testReq.getUserId());
		return "test8 result :" + testReq.getUserId();
	}
}

请求参数TestReq

package com.zzq.core.dto;
import java.lang.Integer;
public class TestReq {

	private Integer userId;

	public Integer getUserId() {
		return userId;
	}

	public void setUserId(Integer userId) {
		this.userId = userId;
	}
}

测试效果

浏览器访问：http://localhost:8080/test_web/test/test8?userId=2，打印如下图所示。

源码分析

下面我们就来揭开@EnableWebLogAspect使某功能(组件)启用的奥秘。

BeanDefinitionRegistryPostProcessor接口

首先我们要定位到ConfigurationClassPostProcessor类(这个类一直是Spring实现注解开发的核心之一，到了Spring Boot时代依旧如此)，它实现了BeanDefinitionRegistryPostProcessor接口，项目启动时就会去找BeanDefinitionRegistryPostProcessor的类，找到后for循环遍历调用其postProcessBeanDefinitionRegistry方法。代码片段如下图所示。

具体关于BeanDefinitionRegistryPostProcessor扩展接口详细信息，请参考拙作spring扩展 BeanDefinitionRegistryPostProcessor详解

定位到ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry

 public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
		RootBeanDefinition iabpp = new RootBeanDefinition(ImportAwareBeanPostProcessor.class);
		iabpp.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
		registry.registerBeanDefinition(IMPORT_AWARE_PROCESSOR_BEAN_NAME, iabpp);
		//取得registry的id并做判重处理或记录
		int registryId = System.identityHashCode(registry);
		if (this.registriesPostProcessed.contains(registryId)) {
			throw new IllegalStateException(
					"postProcessBeanDefinitionRegistry already called for this post-processor against " + registry);
		}
		if (this.factoriesPostProcessed.contains(registryId)) {
			throw new IllegalStateException(
					"postProcessBeanFactory already called for this post-processor against " + registry);
		}
		//保存处理过的registry，避免重复处理
		this.registriesPostProcessed.add(registryId);
		 //处理java配置形式的bean定义
		processConfigBeanDefinitions(registry);
	}

解析BeanDefinition

进入ConfigurationClassPostProcessor#processConfigBeanDefinitions

 public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
		Set configCandidates = new LinkedHashSet();
		//加载当前已知所有bean定义
		for (String beanName : registry.getBeanDefinitionNames()) {
			BeanDefinition beanDef = registry.getBeanDefinition(beanName);
			//   判断对应bean是否为配置类,如果是,则加入到configCandidates
			// Component、Bean、Configuration其一注解,或者派生
			if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
				configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
			}
		}

		// Return immediately if no @Configuration classes were found
		//如果找不到 Component、Bean、Configuration其一注解,或者派生的类，则立即返回
		if (configCandidates.isEmpty()) {
			return;
		}

		// Detect any custom bean name generation strategy supplied through the enclosing application context
		 // 3. 如果BeanDefinitionRegistry 是SingletonBeanRegistry 子类的话,由于我们当前传入的是DefaultListableBeanFactory,是
	    // SingletonBeanRegistry 的子类。因此会将registry强转为SingletonBeanRegistry
		SingletonBeanRegistry singletonRegistry = null;
		if (registry instanceof SingletonBeanRegistry) {
			singletonRegistry = (SingletonBeanRegistry) registry;
			if (!this.localBeanNameGeneratorSet && singletonRegistry.containsSingleton(CONFIGURATION_BEAN_NAME_GENERATOR)) {
				  // 如果localBeanNameGeneratorSet 等于false 并且SingletonBeanRegistry 中有 id 为 org.springframework.context.annotation.internalConfigurationBeanNameGenerator
	            // 的bean .则将componentScanBeanNameGenerator,importBeanNameGenerator 赋值为 该bean.
 
				BeanNameGenerator generator = (BeanNameGenerator) singletonRegistry.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
				this.componentScanBeanNameGenerator = generator;
				this.importBeanNameGenerator = generator;
			}
		}

		// Parse each @Configuration class
		 // 实例化ConfigurationClassParser 为了解析 各个配置类
		ConfigurationClassParser parser = new ConfigurationClassParser(
				this.metadataReaderFactory, this.problemReporter, this.environment,
				this.resourceLoader, this.componentScanBeanNameGenerator, registry);
		for (BeanDefinitionHolder holder : configCandidates) {
			BeanDefinition bd = holder.getBeanDefinition();
			System.out.println("ConfigurationClassPostProcessor bd " + bd.getBeanClassName());
			if (bd.getBeanClassName().equals("com.zzq.core.configuration.ConfigurationTest")) {
				System.out.println("ConfigurationClassPostProcessor com.zzq.core.configuration.ConfigurationTest ");
			}
			try {
				if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
					parser.parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
				}
				else {
					//ConfigurationTest 会进入这里
					parser.parse(bd.getBeanClassName(), holder.getBeanName());
				}
			}
			catch (IOException ex) {
				throw new BeanDefinitionStoreException("Failed to load bean class: " + bd.getBeanClassName(), ex);
			}
		}
		parser.validate();

		// Handle any @PropertySource annotations
		Stack> parsedPropertySources = parser.getPropertySources();
		if (!parsedPropertySources.isEmpty()) {
			if (!(this.environment instanceof ConfigurableEnvironment)) {
				logger.warn("Ignoring @PropertySource annotations. " +
						"Reason: Environment must implement ConfigurableEnvironment");
			}
			else {
				MutablePropertySources envPropertySources = ((ConfigurableEnvironment)this.environment).getPropertySources();
				while (!parsedPropertySources.isEmpty()) {
					envPropertySources.addLast(parsedPropertySources.pop());
				}
			}
		}

		// Read the model and create bean definitions based on its content
		if (this.reader == null) {
			this.reader = new ConfigurationClassBeanDefinitionReader(
					registry, this.sourceExtractor, this.problemReporter, this.metadataReaderFactory,
					this.resourceLoader, this.environment, this.importBeanNameGenerator);
		}
		// 加载 BeanDefinition，里面会完成注册逻辑
		this.reader.loadBeanDefinitions(parser.getConfigurationClasses());

		// Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
		if (singletonRegistry != null) {
			if (!singletonRegistry.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
				singletonRegistry.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
			}
		}

		if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
			((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
		}
	}

进入处理配置类ConfigurationClassParser#processConfigurationClass

 protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
		AnnotationMetadata metadata = configClass.getMetadata();
		if (this.environment != null && metadata.isAnnotated(Profile.class.getName())) {
			AnnotationAttributes profile = MetadataUtils.attributesFor(metadata, Profile.class);
			if (!this.environment.acceptsProfiles(profile.getStringArray("value"))) {
				return;
			}
		}

		if (this.configurationClasses.contains(configClass) && configClass.getBeanName() != null) {
			// Explicit bean definition found, probably replacing an import.
			// Let's remove the old one and go with the new one.
			this.configurationClasses.remove(configClass);
			for (Iterator it = this.knownSuperclasses.values().iterator(); it.hasNext();) {
				if (configClass.equals(it.next())) {
					it.remove();
				}
			}
		}

		// Recursively process the configuration class and its superclass hierarchy.
		do {
			// 处理Bean
			metadata = doProcessConfigurationClass(configClass, metadata);
		}
		while (metadata != null);
		// 添加到集合中
		this.configurationClasses.add(configClass);
	}

处理Bean上配置的注解

进入真正处理配置类的地方，要处理好几种注解ConfigurationClassParser#doProcessConfigurationClass

 protected AnnotationMetadata doProcessConfigurationClass(ConfigurationClass configClass, AnnotationMetadata metadata) throws IOException {
		// Recursively process any member (nested) classes first
		processMemberClasses(metadata);

		// Process any @PropertySource annotations
		//处理@PropertySource  加载外面资源文件
		AnnotationAttributes propertySource = MetadataUtils.attributesFor(metadata,
				org.springframework.context.annotation.PropertySource.class);
		if (propertySource != null) {
			processPropertySource(propertySource);
		}

		// Process any @ComponentScan annotations
		//处理  @ComponentScan 扫描包
		AnnotationAttributes componentScan = MetadataUtils.attributesFor(metadata, ComponentScan.class);
		if (componentScan != null) {
			// The config class is annotated with @ComponentScan -> perform the scan immediately
			Set scannedBeanDefinitions =
					this.componentScanParser.parse(componentScan, metadata.getClassName());
			// scannedBeanDefinitions 有可能是空元素，因为在扫描包时会事先注册好
			// Check the set of scanned definitions for any further config classes and parse recursively if necessary
			// 如果有配置类，递归解析
			for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
				if (ConfigurationClassUtils.checkConfigurationClassCandidate(holder.getBeanDefinition(), this.metadataReaderFactory)) {
					this.parse(holder.getBeanDefinition().getBeanClassName(), holder.getBeanName());
				}
			}
		}

		//处理@Import注解
		// Process any @Import annotations
		Set

Spring自定义注解驱动开发使用及源码分析

Java相关栏目本月热门文章