AOP及其在Spring中的应用

小七

spring中AOP的实现就是通过动态代理来实现的。动态代理的实现在上篇blog中已经涉及。Spring中目前最为实用的AOP应用，非用其实现的事务管理机制莫属。也正是这一点，使得Spring AOP大方异彩。
那么我们继续围绕上节的例子来探讨一下Spring中AOP机制的应用与开发。

　　首先，看看AOP中几个基本的概念对应在AOP中的实现：
? 切点(PointCut)
　　一系列连接点的集合，它指明处理方式（Advice）将在何时被触发。
! n! ]9 G0 A( M; D　　对于我们开发而言，“何时触发”的条件大多是面向Bean的方法进行制定。像Spring的配置化事务管理时针对方法名称可进行PointCut设置，从而指定对所有以声明字符开头的方法进行基于AOP的事务管理。那么同样，对于我们自己实现的AOP组件而言，我们也可以以方法名作为触发判定条件。
/ k9 H( C) o* h8 w, Q我们可以通过在XML配置文件中配置以下节点，为我们的组件设定触发条件。
9 J" F. C( ~5 m0 }5 }% t3 [<bean id="myPointcutAdvisor"
) t) ^6 G7 f) r/ ^# U$ tclass="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
$ {. x8 w% q9 @<property name="advice">
<ref local="MyInterceptor" />
</property>
* {9 b" _# p$ W! }2 s) ~) @& Q<property name="patterns">
<list>
<value>.*save.*</value>
" d  ]9 O; y- W3 g3 M, X+ f<value>.*do.*</value>
</list>
/ x% N, w* v; E" I</property>
</bean>

　　上面我们针对MyInterceptor设定了一个基于方法名的触发条件，也就是说，当目标类的指定方法运行时，MyInterceptor即被触发。
　　? 处理方式（Advice）
' |0 {3 X. c% J2 a$ ^& E$ @. p　　也就是说要实现一个Interceptor，以供在连接点时触发。Spring中采用了AOP联盟（AOP Alliance）的通用AOP接口（接口定义位aopalliance.jar）。这里我们采用aopalliance.jar中定义的MethodInterceptor作为我们的Advice实现接口。那么我们上节例子中的处理方式应实现为如下Interceptor：
package test.aop.spring;
import java.util.logging.Logger;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

/**
. ?; i) |( G! I  {* @author xkf
**/
public class LockInterceptor implements MethodInterceptor {
private Logger logger = Logger.getLogger(this.getClass().getName());
5 q" S- t( k  ~  epublic Object invoke(MethodInvocation invocation) throws Throwable {
2 d* u& Y0 y2 v. O  Q// TODO Auto-generated method stub
lock();
2 J. f5 G5 e4 eObject ret= invocation.proceed();
. M& }* [7 Q" Z) @+ `% sunlock();
( s- D- X2 m; u' v* Jreturn ret;
}
private void lock(){
9 w% U7 g, U) m) d; ^0 Slogger.info("lock domain object...");
0 i, y$ D( K6 Z" {}
private void unlock(){
: r- g' j+ z8 r, |; U8 {0 Dlogger.info("unlock domain object...");
( l2 J6 }+ H+ x8 o9 q6 c( w}
}
　　实现后，对应的Interceptor实现类在配置文件中的体现如下：
　　<bean id="MyInterceptor" class="test.aop.spring.LockInterceptor"/>
　　最后，我们还需要定义一个Spring AOP ProxyFactory用于加载执行AOP组件，并且需要将Advice通过IOC的方式注入到接口以及实现类。
　　对应的配置文件应如下配置从而实现这些内容：
<bean id="myAOPProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="proxyInterfaces">
<value>test.aop.spring.DomainObjDAO</value>
</property>
$ K8 @- ~7 J$ |( n+ h<property name="target">
/ q% F/ X: o# s" x: g. k<ref local="impl" />
0 `: X. j) X& A9 d/ s</property>
$ X! Y) h( v4 S+ e$ s0 o<property name="interceptorNames">
<value>myPointcutAdvisor</value>
</property>
$ Q8 H1 |2 t( `6 ^; B</bean>
1 X9 |9 Q4 B$ v: v6 [<bean id="impl" class="test.aop.spring.DomainObjDAOImpl"/>
万事大吉！写一个TestCase来看一下运行结果：
, m% P. O, e1 f) U' q  p' }4 a0 `package test.aop.spring;

import junit.framework.TestCase;
1 O% x# U# x6 [import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

/**
- @! M" O2 G+ w) H0 M1 b# j2 v  o8 b* @author xkf
*/
4 o3 Y8 d6 z' g; j9 z- W. m  Npublic class SpringTestCase extends TestCase {
DomainObjDAO test=null;

protected void setUp() throws Exception {
super.setUp();
) j. R8 a. e5 y. xApplicationContext ctx=new FileSystemXmlApplicationContext("test/Bean.xml");
, Z$ E1 m$ n, k; X- Y4 C0 g& {- htest = (DomainObjDAO) ctx.getBean("myAOPProxy");
}

protected void tearDown() throws Exception {
! m  u5 L( u4 d( a4 F* Y% t8 asuper.tearDown();
, ?" g; e2 @, y$ r/ l. y: U}
public void testSave(){
. }3 h. d* s, u5 `test.save();
7 p; P+ w& T0 n. U3 W5 ^% L3 }* Z}
}
8 w0 Z' P$ j" S4 E7 q运行结果如下：
$ U: p* z, W8 Y0 d+ u& s, e信息: Creating shared instance of singleton bean ''MyInterceptor''
1 ?# M8 x6 Y/ l0 q$ y# }2 z- x2004-12-7 23:50:11 test.aop.spring.LockInterceptor lock
& l+ e, W5 h. v- V+ G1 ~6 o# i5 A信息: lock domain object...
saving domain object......
2004-12-7 23:50:11 test.aop.spring.LockInterceptor unlock
信息: unlock domain object...

　　OK！至此，我们已经探讨了AOP动态代理的实现以及其在Spring中的应用，接下来的Blog中我将会关注Spring中事务以及持久化的实现。