在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(cn.javass.spring.chapter6.service.IPointcutService) | 当前目标对象(非AOP对象)实现了 IPointcutService接口的任何方法 |
target(cn.javass.spring.chapter6.service.IIntroductionService) | 当前目标对象(非AOP对象) 实现了IIntroductionService 接口的任何方法 不可能是引入接口 |
表达式 | 描述 |
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。
下一篇学习这几种方式的实现原理。