前段時間，為了校驗介面資料方便，實現了一個簡易的引數校驗功能。通過引數上加註解並且配置spring aop實現的。

大概配置如下：

public Object ArroundParamCheck(ProceedingJoinPoint pj) throws Throwable{
		if(null == pj){
			log.info("傳入的物件是空的！！！！！！！！！！");
		}
		log.info("引數校驗開始================");
		Object[] obs = pj.getArgs();
		Response_CM resp = paramCheckService.paramCheck(obs);
		log.info("引數校驗結束==============" + resp.toString());
		if(!CodeMsgConstant.CODE_000000.equals(resp.getRespCode())){
			MethodSignature methodSg = (MethodSignature) pj.getSignature();
			Class<?> returnType = methodSg.getReturnType();
			return paramCheckService.getCheckResult(returnType, resp);
		}
		Object pjResult = pj.proceed();
		return pjResult;
		
	}
 

<bean id="paramCheckAop" class="com.huateng.iccs.pre.corp.aop.ParamCheckAop"></bean> 
 <aop:config>
    	<aop:pointcut expression="execution(* com.huateng.iccs.pre.corp.service.impl.ScfContractServiceImpl.*(..))" 
    	id="scfContractPc"/>
    	<aop:pointcut expression="execution(* com.huateng.iccs.pre.corp.service.impl.ScfCustomerServiceImpl.*(..))" 
    	id="scfCustomerPc"/>
    	<aop:pointcut expression="execution(* com.huateng.iccs.pre.corp.service.impl.ClientInformServiceImpl.*(..))" 
    	id="clientInformPc"/>
    	<aop:aspect id = "paramCheck" ref ="paramCheckAop">
    		<aop:around pointcut-ref="scfContractPc" method="ArroundParamCheck"/>
    		<aop:around pointcut-ref="scfCustomerPc" method="ArroundParamCheck"/>
    		<aop:around pointcut-ref="clientInformPc" method="ArroundParamCheck"/>
    	</aop:aspect>
    </aop:config> 
 

但是引入的系統時候需要顯性的設定一個環繞增強，並且要在xml中配置切面切點。

        使用過@Transactional的註解的應該都知道，只需要在方法或者類上標註@Transactional註解，就可以開啟spring事務。使用起來比較便捷。為了作者練手，並且使用方便，於是便想引數校驗做成類似模式。

1、spring下自定義xml解析的實現

    使用@Transactional需要在spring xml下配置<tx:annotation-driven />來開啟註解事務。同樣這種方式的校驗也是從自定義xml解析開始。  

    這裡的xml解析很簡單

• 編寫對應的xsd

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<xsd:schema xmlns="http://www.component.org/schema/avd"
		xmlns:xsd="http://www.w3.org/2001/XMLSchema"
		xmlns:beans="http://www.springframework.org/schema/beans"
		xmlns:tool="http://www.springframework.org/schema/tool"
		targetNamespace="http://www.component.org/schema/avd"
		elementFormDefault="qualified"
		attributeFormDefault="unqualified">
	<xsd:import namespace="http://www.springframework.org/schema/beans"></xsd:import>
	<xsd:element name="annotation-driven"></xsd:element>
</xsd:schema>
 

    這裡的xsd編寫也很簡單，因為只是一個標記，表示開啟自動引數解析，只需要配置一個element，不需要額外的配置。

<xsd:element name="annotation-driven"></xsd:element>

• 編寫對應的NamespaceHandlerSupport和BeanDefinitionParser。

固定寫法。AvdNamespaceHandler繼承NamespaceHandlerSupport 重寫init方法。AvdAnnotationDrivenBeanDefinitionParse實現BeanDefinitionParse重寫parse方法。

public class AvdNamespaceHandler extends NamespaceHandlerSupport{

	@Override
	public void init() {
		registerBeanDefinitionParser("annotation-driven", new AvdAnnotationDrivenBeanDefinitionParser());
	}

}

public class AvdAnnotationDrivenBeanDefinitionParser implements BeanDefinitionParser{

	public static final String AVD_ADVISOR_BEAN_NAME = "com.fosun.component.validate.interceptor.avdAdvisor";
	@Override
	public BeanDefinition parse(Element element, ParserContext parserContext) {
		configureAutoProxyCreator(element,parserContext);
		return null;
	}
	
	private void configureAutoProxyCreator(Element element, ParserContext parserContext){
		/**
		 * 如果必要開啟自動建立代理物件
		 * 此方法可以將targetClass委託給spring讓spring為符合切點的目標類自動建立代理物件
		 */
		AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(parserContext, element);
		String avdAdvisorName = AVD_ADVISOR_BEAN_NAME;
		if(!parserContext.getRegistry().containsBeanDefinition(avdAdvisorName)){
			Object eleSource = parserContext.extractSource(element);
			RootBeanDefinition sourceDef = new RootBeanDefinition(AnnotationAvdAttributeSource.class);
			sourceDef.setSource(eleSource);
			sourceDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
			String sourceName = parserContext.getReaderContext().registerWithGeneratedName(sourceDef);
			
			RootBeanDefinition interceptorDef = new RootBeanDefinition(AutoAvdInterceptor.class);
			interceptorDef.setSource(eleSource);
			interceptorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
			String interceptorName = parserContext.getReaderContext().registerWithGeneratedName(interceptorDef);
			
			
			RootBeanDefinition advisorDef = new RootBeanDefinition(BeanFactoryAutoAvdDefineAdvisor.class);
			advisorDef.setSource(eleSource);
			advisorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
			advisorDef.getPropertyValues().add("avdAttributeSource", new RuntimeBeanReference(sourceName));
			advisorDef.getPropertyValues().add("adviceBeanName", interceptorName);
			parserContext.getRegistry().registerBeanDefinition(avdAdvisorName, advisorDef);
			
			CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), eleSource);
			compositeDef.addNestedComponent(new BeanComponentDefinition(sourceDef, sourceName));
			compositeDef.addNestedComponent(new BeanComponentDefinition(interceptorDef, interceptorName));
			compositeDef.addNestedComponent(new BeanComponentDefinition(advisorDef, avdAdvisorName));
			parserContext.registerComponent(compositeDef);
		}
		
	}

}

• 配置spring.handlers和spring.schmas

兩個檔案的目錄格式如上圖所示（嚴格按照）spring.handlers

http\://www.component.org/schema/avd = com.fosun.component.validate.config.AvdNamespaceHandler

spring.schemas

http\://www.component.org/schema/avd.xsd = com/fosun/component/validate/config/component-avd-1.0.xsd

• pom檔案配置

        作者使用maven打jar，需要在pom檔案下做如下配置，不然打的jar中不包含spring.handlers、spring.schemas這兩個檔案

	<build><plugins>
		<plugin>
			<artifactId>maven-jar-plugin</artifactId>
			<configuration>					
				<classesDirectory>target/classes/</classesDirectory>
				<archive>
					<addMavenDescriptor>false</addMavenDescriptor>
				</archive>
			</configuration>
		</plugin>
	</plugins></build>

• spring配置檔案中使用

如上圖在配置檔案中增加

xmlns:avd="http://www.component.org/schema/avd"

http://www.component.org/schema/avd http://www.component.org/schema/avd.xsd

<avd:annotation-driven/>

2、Spring aop實現

    同樣，如同普通的aop實現一樣，這種方式也需要配置增強、切點和切面。同時，需要宣告一個類似@Transactional的註解，用來標記在方法或者類上來表示該方法或者類開啟校驗。作者在這裡定義了@AutoAvd註解

• 切點類

繼承StaticMethodMatcherPointcut表示這是一個靜態切點。這個方法的主要目的就是匹配目標方法或者類是否標記了@AutoAvd註解。

public abstract class AutoAvdDefinePointcut extends StaticMethodMatcherPointcut{

	@Override
	public boolean matches(Method method, Class<?> targetClass) {
		AvdAttributeSource aad = getAvdAttributeSource();
		return (aad == null || aad.getAutoAvdDefine(method, targetClass) != null);
	}
	
	public abstract AvdAttributeSource getAvdAttributeSource();

}

• 增強類

實現MethodInterceptor介面，標識這是一個環繞增強。

public class AutoAvdInterceptor implements MethodInterceptor{
	
	private final Logger log = LoggerFactory.getLogger(getClass());
	
	@Autowired
	ParamCheckService paramCheckService;

	@Override
	public Object invoke(MethodInvocation invocation) throws Throwable {
		// TODO Auto-generated method stub
//		Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
		Object[] obs = invocation.getArguments();
		log.info("引數校驗開始================");
		Response_CM resp = paramCheckService.paramCheck(obs);
		log.info("引數校驗結束==============" + resp.toString());
		if(!CodeMsgConstant.CODE_000000.equals(resp.getRespCode())){
			Method method = invocation.getMethod();
			Class<?> returnType = method.getReturnType();
			return paramCheckService.getCheckResult(returnType, resp);
		}
		return invocation.proceed();
	}

}

• advisor

繼承AbstractBeanFactoryPointcutAdvisor重寫getPointcut()方法。

BeanFactoryAutoAvdDefineAdvisor中的AvdAttributeSource用來解析@AutoAvd註解的內容，

public class BeanFactoryAutoAvdDefineAdvisor extends AbstractBeanFactoryPointcutAdvisor{
	
	private AvdAttributeSource avdAttributeSource;
	
	private AutoAvdDefinePointcut aadPointcut = new AutoAvdDefinePointcut() {
		@Override
		public AvdAttributeSource getAvdAttributeSource() {
			return avdAttributeSource;
		}
	};

	public void setAvdAttributeSource(AvdAttributeSource avdAttributeSource) {
		this.avdAttributeSource = avdAttributeSource;
	}

	@Override
	public Pointcut getPointcut() {
		return this.aadPointcut;
	}

}

AnnotationAvdAttributeSource實現AvdAttributeSource來實現由@AutoAvd表示的內容。 

回顧切點的matches()方法，利用了AvdAttributeSource的getAutoAvdDefine()方法來具體判讀是否匹配切點。

public class AnnotationAvdAttributeSource implements AvdAttributeSource{
	private AutoAvdAnnotationParser annotationParser;
	
	public AnnotationAvdAttributeSource(){
		this.annotationParser = new SpringAutoAvdAnnotationParser();
	}

	@Override
	public AutoAvdDefine getAutoAvdDefine(Method method, Class<?> targetClass) {
		/**
		 * 先這麼寫
		 */
		return computerAutoAvdDefine(method,targetClass);
	}
	
	private AutoAvdDefine computerAutoAvdDefine(Method method, Class<?> targetClass){
		/**
		 * 不支援非public方法
		 */
		if ( !Modifier.isPublic(method.getModifiers())) {
			return null;
		}

		Class<?> userClass = ClassUtils.getUserClass(targetClass);
		Method specificMethod = ClassUtils.getMostSpecificMethod(method, userClass);
		specificMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);

		AutoAvdDefine aad = findAutoAvdAnnotationDefine(specificMethod);
		if (aad != null) {
			return aad;
		}

		aad = findAutoAvdAnnotationDefine(specificMethod.getDeclaringClass());
		if (aad != null) {
			return aad;
		}

		if (specificMethod != method) {
			aad = findAutoAvdAnnotationDefine(method);
			if (aad != null) {
				return aad;
			}
			return findAutoAvdAnnotationDefine(method.getDeclaringClass());
		}
		return null;
	}
	
	private AutoAvdDefine findAutoAvdAnnotationDefine(Method method){
		return determineAutoAvdDefine(method);
	}
	private AutoAvdDefine findAutoAvdAnnotationDefine(Class<?> targetClass){
		return determineAutoAvdDefine(targetClass);
	}
	private AutoAvdDefine determineAutoAvdDefine(AnnotatedElement ae){
		return this.annotationParser.parseAutoAvdAnnotation(ae);
	}
}

關鍵

        在第二步中，我們只是定義了切點，環繞增強，切面等。還未介紹如何將這些交給spring託管。並且為符合切點的物件生成代理物件。

private void configureAutoProxyCreator(Element element, ParserContext parserContext){
		/**
		 * 如果必要開啟自動建立代理物件
		 * 此方法可以將targetClass委託給spring讓spring為符合切點的目標類自動建立代理物件
		 */
		AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(parserContext, element);
		String avdAdvisorName = AVD_ADVISOR_BEAN_NAME;
		if(!parserContext.getRegistry().containsBeanDefinition(avdAdvisorName)){
			Object eleSource = parserContext.extractSource(element);
			RootBeanDefinition sourceDef = new RootBeanDefinition(AnnotationAvdAttributeSource.class);
			sourceDef.setSource(eleSource);
			sourceDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
			String sourceName = parserContext.getReaderContext().registerWithGeneratedName(sourceDef);
			
			RootBeanDefinition interceptorDef = new RootBeanDefinition(AutoAvdInterceptor.class);
			interceptorDef.setSource(eleSource);
			interceptorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
			String interceptorName = parserContext.getReaderContext().registerWithGeneratedName(interceptorDef);
			
			
			RootBeanDefinition advisorDef = new RootBeanDefinition(BeanFactoryAutoAvdDefineAdvisor.class);
			advisorDef.setSource(eleSource);
			advisorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
			advisorDef.getPropertyValues().add("avdAttributeSource", new RuntimeBeanReference(sourceName));/**<property name="name" ref=ref/>*/
			advisorDef.getPropertyValues().add("adviceBeanName", interceptorName);/**<property name="name" value="value"/>*/
			parserContext.getRegistry().registerBeanDefinition(avdAdvisorName, advisorDef);
			
			CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), eleSource);
			compositeDef.addNestedComponent(new BeanComponentDefinition(sourceDef, sourceName));
			compositeDef.addNestedComponent(new BeanComponentDefinition(interceptorDef, interceptorName));
			compositeDef.addNestedComponent(new BeanComponentDefinition(advisorDef, avdAdvisorName));
			parserContext.registerComponent(compositeDef);
		}
		
	}

        回顧AvdAnnotationDrivenBeanDefinitionParser的configureAutoProxyCreator()方法。在這裡將自動校驗的切點增強等邏輯交給spring託管並生成代理物件。        方法開始呼叫AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(parserContext, element);。熟悉spring aop的都清楚，在使用spring aop時，一般都需要在xml中配置<aop:aspectj-autoproxy proxy-target-class="true" />；。spring這對這個進行解析的時候最終就會呼叫AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(parserContext, element);方法。目的是為符合切點的容器中的bean自動建立代理物件。接下來就是將BeanFactoryAutoAvdDefineAdvisor等元件註冊到工廠中。