天天看点
返回

Spring AOP框架使用ProxyBeanFactoryaop标签@AspectJ注解

在Spring AspectJ LTW中分析如果在类加载期织入切面，本篇中学习如何在运行时动态的注入切面，这种方式在实际项目中使用比较多，在Spring AOP框架中提供了三种方式在程序运行时注入切面：

  • ProxyBeanFactory
  • aop标签（Scheme风格）
  • @Aspect（元注解风格）

下面通过几个简单的例子演示如何通过这几种方式来织入切面。

ProxyBeanFactory

这个例子非常简单，给目标方法的调用前后各加一行日志。

编写一个接口，这不是必须的，是否需要接口完全由项目的应用场景来定，看看需要做相应的可扩展性设计，Spring框架也不限制切面目标类必须要实现接口，这里为了方便演示，定义了一个接口：

public interface IHelloWorldService {
	boolean sayHello(String param);
}

编写一个切面目标，代码非常简单，实现上述接口，上面说过了实现接口不是必须的，只会为了方便后面的演示：

public class HelloWorldService implements IHelloWorldService {
	public boolean sayHello(String param) {
		System.out.println(param + " say:Hello World!");
		return true;
	}
}

编写一个通知类，需要直接或间接的实现Advisor或Advice接口，我写的这个实现了MethodInterceptor接口：

public class LogInterceptor implements MethodInterceptor {

	@Override
	public Object invoke(MethodInvocation arg0) throws Throwable {
		Method method = arg0.getMethod();
		System.out.println(method.getName() + ":begin");
		Object retVal = arg0.proceed();
		System.out.println(method.getName() + ":end");
		return retVal;
	}

}

也可以通过实现MethodBeforeAdvice和AfterReturningAdvice接口实现同样的功能下面的LogAdvice和上面的LogInterceptor在作用上基本上是一样的：

public class LogAdvice implements MethodBeforeAdvice, AfterReturningAdvice {

	@Override
	public void afterReturning(Object returnValue, Method method,
			Object[] args, Object target) throws Throwable {
		System.out.println(method.getName() + ":end");
	}

	@Override
	public void before(Method method, Object[] args, Object target)
			throws Throwable {

		System.out.println(method.getName() + ":begin");
	}

}

配置通知bean和目标bean：

<bean id="logInterceptor" class="spring.aop.dw.proxyfb.LogInterceptor"></bean>
<bean id="helloWorldService" class="spring.aop.dw.proxyfb.HelloWorldService"></bean>

配置一个ProxyFactoryBean：

<bean class="org.springframework.aop.framework.ProxyFactoryBean"
	id="helloWorld">
	<property name="target" ref="helloWorldService"></property>
	<property name="interceptorNames">
		<value>logInterceptor</value>
	</property>
</bean>

target是目标bean，可以用targetName代理，interceptorNames是拦截器也即通知的bean名称，可以使用通配符*后缀，同时也可以配置多个，上面这段配置也可以写成下面这个样子：

<bean class="org.springframework.aop.framework.ProxyFactoryBean"
	id="helloWorld">
	<property name="targetName" value="helloWorldService"></property>
	<property name="interceptorNames">
		<list>
			<value>log*</value>
		</list>
	</property>
</bean>

AOP的核心就是为目标bean生成一个AOP代理来替代目标bean，当目标bean实现了接口时（前提是框架能检查到），框架会生成一个JDK动态代理，如果没有实现接口则会生成一个CGLIB代理。ProxyFactoryBean还有个interfaces属性用来设置目标bean所实现的接口，默认情况下框架会自动检查目标bean所实现的接口，所以这里即使不配置interfaces属性，框架也能检查出来目标bean实现了IHelloService接口会生成一个JDK动态代理，这里还有一个autodetectInterfaces属性，这个属性的作用是是否自动检查是否实现了接口，默认是true检查，如果把它设置成了false，并且没有设置interfaces属性，那么即使helloWorldService bean实现了接口，框架也会生成CGLIB代理，下面这段配置框架就会使用CGLIB代理技术：

<bean class="org.springframework.aop.framework.ProxyFactoryBean"
	id="helloWorld1">
	<property name="targetName" value="helloWorldService"></property>
	<property name="interceptorNames">
		<list>
			<value>logInterceptor</value>
		</list>
	</property>
	<property name="autodetectInterfaces" value="false"></property>
</bean>

测试一下：

IHelloWorldService helloWorld = (IHelloWorldService) context
		.getBean("helloWorld");
System.out.println(helloWorld.getClass());
helloWorld.sayHello("cyy");

输出下面日志说明通知生效，而且获取到的bean并不是目标bean的类型而是一个代理类型：

class $Proxy4
sayHello:begin
cyy say:Hello World!
sayHello:end

从使用上来讲，通过ProxyFactoryBean来实现AOP并不是很方便，每个目标必须要配置一个ProxyFactoryBean，当被通知的目标bean数量非常多的时候配置量会非常大。下面来看看另外两种方式，这两种方式使用上就方便多了。

aop标签

Spring提供了一个aop名称空间，可以使用该名称空间下的标签实现aop。在介绍这种方式之前，首先需要了解一下切点表达式，正是因为切点表达式的存在，使得AOP的配置大大简化。

切点表达式

切入点包含切入点指示符和类型匹配表达式

Spring AOP支持下面几种切点指示符：

execution：用于匹配方法执行的连接点；

within：用于匹配指定类型内的方法执行；

this：用于匹配当前AOP代理对象类型的执行方法；注意是AOP代理对象的类型匹配，这样就可能包括引入接口也类型匹配；

target：用于匹配当前目标对象类型的执行方法；注意是目标对象的类型匹配，这样就不包括引入接口也类型匹配；

args：用于匹配当前执行的方法传入的参数为指定类型的执行方法；

在切点表达式语法中有三个通配符：

* ：匹配任何数量字符；

.. ：（两个点）匹配任何数量字符的重复，如在类型模式中匹配任何数量子包；而在方法参数模式中匹配任何数量参数。 

+ ：匹配指定类型的子类型；仅能作为后缀放在类型模式后边。

java.lang.Integer：匹配Integer类型

java.*.Integer：匹配java包下任何一级包下的Integer类，匹配java.lang.Integer，但是不匹配java.lang.ll.Integer

java..*：匹配java包下所有类型

java.lang.*ger：匹配任何java.lang包下的以ger结尾的类型

java.lang.AbstractStringBuilder+：匹配任意java.lang.AbstractStringBuilder的子类型，如匹配java.lang.StringBuilder，也匹配java.lang.StringBuffer

切点表达式可以通过&&、||、！来组合切点表达式，下面是几个切点表达式的例子（从开涛大神的博客AOP 之 6.5 AspectJ切入点语法详解 ——跟我学spring3摘抄）：

execution

表达式 描述
public * *(..) 任何公共方法的执行
* cn.javass..IPointcutService.*() cn.javass包及所有子包下IPointcutService接口中的任何无参方法
* cn.javass..*.*(..) cn.javass包及所有子包下任何类的任何方法
* cn.javass..IPointcutService.*(*) cn.javass包及所有子包下IPointcutService接口的任何只有一个参数方法
* (!cn.javass..IPointcutService+).*(..) 非“cn.javass包及所有子包下IPointcutService接口及子类型”的任何方法
* cn.javass..IPointcutService+.*() cn.javass包及所有子包下IPointcutService接口及子类型的的任何无参方法
* cn.javass..IPointcut*.test*(java.util.Date)

cn.javass包及所有子包下IPointcut前缀类型的的以test开头的只有一个参数类型为java.util.Date的方法，注意该匹配是根据方法签名的参数类型进行匹配的，而不是根据执行时传入的参数类型决定的

如定义方法：public void test(Object obj);即使执行时传入java.util.Date，也不会匹配的；

* cn.javass..IPointcut*.test*(..)  throws

 IllegalArgumentException, ArrayIndexOutOfBoundsException

 cn.javass包及所有子包下IPointcut前缀类型的的任何方法，且抛出IllegalArgumentException和ArrayIndexOutOfBoundsException异常

* (cn.javass..IPointcutService+

&& java.io.Serializable+).*(..)

 任何实现了cn.javass包及所有子包下IPointcutService接口和java.io.Serializable接口的类型的任何方法
@java.lang.Deprecated * *(..) 任何持有@java.lang.Deprecated注解的方法
@java.lang.Deprecated @cn.javass..Secure  * *(..) 任何持有@java.lang.Deprecated和@cn.javass..Secure注解的方法
@(java.lang.Deprecated || cn.javass..Secure) * *(..) 任何持有@java.lang.Deprecated或@ cn.javass..Secure注解的方法
(@cn.javass..Secure  *)  *(..) 任何返回值类型持有@cn.javass..Secure的方法
*  (@cn.javass..Secure *).*(..) 任何定义方法的类型持有@cn.javass..Secure的方法
* *(@cn.javass..Secure (*) , @cn.javass..Secure (*))

任何签名带有两个参数的方法，且这个两个参数都被@ Secure标记了，

如public void test(@Secure String str1,

 @Secure String str1);

* *(

@cn.javass..Secure (@cn.javass..Secure *) ,

@ cn.javass..Secure (@cn.javass..Secure *))

 任何带有两个参数的方法，且这两个参数都被@ cn.javass..Secure标记了；且这两个参数的类型上都持有@ cn.javass..Secure；

* *(

java.util.Map<cn.javass..Model, cn.javass..Model>

, ..)

任何带有一个java.util.Map参数的方法，且该参数类型是以< cn.javass..Model, cn.javass..Model >为泛型参数；注意只匹配第一个参数为java.util.Map,不包括子类型；

如public void test(HashMap<Model, Model> map, String str);将不匹配，必须使用“* *(

java.util.HashMap<cn.javass..Model,cn.javass..Model>

, ..)”进行匹配；

而public void test(Map map, int i);也将不匹配，因为泛型参数不匹配
* *(java.util.Collection<@cn.javass..Secure *>)

任何带有一个参数（类型为java.util.Collection）的方法，且该参数类型是有一个泛型参数，该泛型参数类型上持有@cn.javass..Secure注解；

如public void test(Collection<Model> collection);Model类型上持有@cn.javass..Secure

* *((@ cn.javass..Secure *))或

* *(@ cn.javass..Secure *)

任何带有一个参数的方法，且该参数类型持有@ cn.javass..Secure；

如public void test(Model model);且Model类上持有@Secure注解

within

表达式 描述
within(cn.javass..*) cn.javass包及子包下的任何方法执行
within(cn.javass..IPointcutService+) cn.javass包或所有子包下IPointcutService类型及子类型的任何方法
within(@cn.javass..Secure *)

持有cn.javass..Secure注解的任何类型的任何方法

必须是在目标对象上声明这个注解，在接口上声明的对它不起作用

this

表达式 描述
this(cn.javass.spring.chapter6.service.IPointcutService) 当前AOP对象实现了 IPointcutService接口的任何方法
this(cn.javass.spring.chapter6.service.IIntroductionService)

当前AOP对象实现了 IIntroductionService接口的任何方法

也可能是引入接口

target

表达式 描述
target(cn.javass.spring.chapter6.service.IPointcutService) 当前目标对象（非AOP对象）实现了 IPointcutService接口的任何方法
target(cn.javass.spring.chapter6.service.IIntroductionService)

当前目标对象（非AOP对象） 实现了IIntroductionService 接口的任何方法

不可能是引入接口

args

表达式 描述
args (java.io.Serializable,..) 任何一个以接受“传入参数类型为 java.io.Serializable” 开头，且其后可跟任意个任意类型的参数的方法执行，args指定的参数类型是在运行时动态匹配的

下面通过一个简单的例子来演示如果通过aop标签来实现AOP，这个例子实现的功能是：拦截spring.aop.dw.namespace及其子包下所有方法，在方法调用前后各添加一行日志：

aop标签中提供了两个标签来定义切面，分别是aop:advisor和aop:aspect，下面分别看一下如何使用者两个标签：

使用aop:advisor定义切面 

<bean id="logAdvisor" class="spring.aop.dw.namespace.LogAdvisor"></bean>
<aop:config>
	<aop:pointcut id="pointcut"
		expression="execution(* spring.aop.dw.namespace..*.*(..))" />
	<aop:advisor advice-ref="logAdvisor" pointcut-ref="pointcut" />
</aop:config>

pointcut-ref属性设置切点，执行spring.aop.dw.namespace及其子包下所有方法对应的切点表达式是execution(* spring.aop.dw.namespace..*.*(..))

advice-ref属性设置通知，通知bean的类型是LogAdvisor，它必须要是实现Advice接口，下面是这个类的代码：

public class LogAdvisor implements MethodBeforeAdvice, AfterReturningAdvice {

	@Override
	public void afterReturning(Object returnValue, Method method,
			Object[] args, Object target) throws Throwable {
		System.out.println(method.getName() + ":end");
	}

	@Override
	public void before(Method method, Object[] args, Object target)
			throws Throwable {

		System.out.println(method.getName() + ":begin");
	}

}

before和afterReturning方法分别对应前通知和后通知，方法中传递了参数和返回值等。也可以通过实现MethodInterceptor接口来实现：

public class LogAdvisor implements MethodInterceptor {

	@Override
	public Object invoke(MethodInvocation arg0) throws Throwable {
		Method method = arg0.getMethod();
		System.out.println(method.getName() + ":begin");
		Object retVal = arg0.proceed();
		System.out.println(method.getName() + ":end");
		return retVal;
	}

}

这样切面就定义好了，测试bean和代码就不列了，和ProxyFactoryBean的时一样的。

使用aop:aspect定义切面 

<bean id="logAspect" class="spring.aop.dw.namespace.LogAspect"></bean>
<aop:config>
	<aop:pointcut id="pointcut"
		expression="execution(* spring.aop.dw.namespace..*.*(..))" />
	<aop:aspect ref="logAspect">
		<aop:before method="before" pointcut-ref="pointcut" />
		<aop:after method="after" pointcut-ref="pointcut" />
	</aop:aspect>
</aop:config>

切点定义和使用aop:advisor时并没有区别，不同的是这种方式需要定义一个切面类，这个类不需要实现任何框架中的接口，类中的方法名没有任何限制，前提是method上面配置中的method属性和类中的方法能匹配上，aop:before属性设置前通知，aop:after设置后通知，除此之外还可以通过aop:around定义环绕通知，aop:after-throwing定义异常通知：

public class LogAspect {
	public void before() {
		System.out.println("before");
	}

	public void after() {
		System.out.println("after");
	}
}

before方法对应前通知，after方法对应后通知，一般情况下在打印信息的时候需要把方法和参数信息打印出来，我们可以通过在切面类的方法中加入JoinPoint参数（如果是环绕通知则是它的子类ProceedingJoinPoint）来实现，这个参数必须定义在方法的第一个参数：

public class LogAspect {
	public void before(JoinPoint jp) {
		Object arg = getArg(jp);
		System.out.println(jp.getTarget() + ":" + jp.getSignature().getName()
				+ ":before:" + arg);
	}

	public void after(JoinPoint jp) {
		Object arg = getArg(jp);
		System.out.println(jp.getTarget() + ":" + jp.getSignature().getName()
				+ ":after:" + arg);
	}

	private Object getArg(JoinPoint jp) {
		Object[] args = jp.getArgs();
		Object arg = null;
		if (args != null && args.length > 0) {
			arg = args[0];
		}
		return arg;
	}

}

通过对比发现使用aop:aspect定义切面无需切面实现框架中的接口，侵入性更小，而非侵入性是Spring框架的重要特质之一。

@AspectJ注解

@AspectJ注解方式和和aop:aspect步骤比较类似，只是把切点和通知定义放到了类的元注解中，切点表达式和Scheme风格的切点表达完全是一样的

首先定义个切面类，无需实现任何特殊的接口，通过注解定义切面和前、后通知：

@Aspect
public class LogAspect {
	@Pointcut(value = "execution(* spring.aop.dw.annotation..*.*(..))")
	public void pointcut() {

	}

	@Before(value = "pointcut()")
	public void before(JoinPoint jp) {
		Object arg = getArg(jp);
		System.out.println(jp.getTarget() + ":" + jp.getSignature().getName()
				+ ":before:" + arg);
	}

	@After(value = "pointcut()")
	public void after(JoinPoint jp) {
		Object arg = getArg(jp);
		System.out.println(jp.getTarget() + ":" + jp.getSignature().getName()
				+ ":after:" + arg);
	}

	private Object getArg(JoinPoint jp) {
		Object[] args = jp.getArgs();
		Object arg = null;
		if (args != null && args.length > 0) {
			arg = args[0];
		}
		return arg;
	}

}

@Pointcut注解定义切点，上面例子的切点的连接点是执行spring.aop.dw.annotation及其子包下所有方法

@Before定义前通知，value属性引用切点，注意要有括号。和aop:aspect方式一样，JoinPoint参数是可选的

@After定义后通知，value属性引用切点，和aop:aspect方式一样，JoinPoint参数是可选的

其它的注解及其只用可以参考AspectJ的使用文档

Spring框架默认是不支持@AspectJ注解的，需要在配置中添加<aop:aspectj-autoproxy />打开对@AspectJ注解的支持，此外在配置中还需要定义切面bean：

<aop:aspectj-autoproxy />
<bean id="helloWorldService" class="spring.aop.dw.annotation.HelloWorldService"></bean>
<bean id="aspect" class="spring.aop.dw.annotation.LogAspect" />

这样就通过@AspectJ注解完成了一个切面的定义，测试代码就不列了。

通过比较这几种AOP的实现方式，由于切点表达式的原因，ProxyFactoryBean的易用性远远落后另外两种方式，从非侵入性的角度考虑@AspectJ注解和aop:aspect方式优于aop:advisor。

下一篇学习这几种方式的实现原理。

编程技术 java spring 面向切面编程 动态织入切面 AOP使用
上一篇: 重温js—— 数字的存储,js精度问题
下一篇: js的数字精度

继续阅读