AOP及其在Spring中的应用

小七

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

　　首先，看看AOP中几个基本的概念对应在AOP中的实现：
: s( L) W0 Y" [7 c" a, W$ c? 切点(PointCut)
% o, n+ X; M- z; p" U) h$ y　　一系列连接点的集合，它指明处理方式（Advice）将在何时被触发。
　　对于我们开发而言，“何时触发”的条件大多是面向Bean的方法进行制定。像Spring的配置化事务管理时针对方法名称可进行PointCut设置，从而指定对所有以声明字符开头的方法进行基于AOP的事务管理。那么同样，对于我们自己实现的AOP组件而言，我们也可以以方法名作为触发判定条件。
我们可以通过在XML配置文件中配置以下节点，为我们的组件设定触发条件。
<bean id="myPointcutAdvisor"
class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<property name="advice">
4 H2 b% e! K+ ?+ D0 s2 r/ m7 S<ref local="MyInterceptor" />
</property>
<property name="patterns">
! r5 w8 s& g8 O9 v$ B<list>
2 u( D: h% c, g: w1 A* m<value>.*save.*</value>
<value>.*do.*</value>
</list>
0 T9 G, a' _  g/ f5 m, Q5 A</property>
</bean>

　　上面我们针对MyInterceptor设定了一个基于方法名的触发条件，也就是说，当目标类的指定方法运行时，MyInterceptor即被触发。
, m! Q1 p# j  z* G4 H4 h. n　　? 处理方式（Advice）
: j& m$ C% @9 D$ [, m- P　　也就是说要实现一个Interceptor，以供在连接点时触发。Spring中采用了AOP联盟（AOP Alliance）的通用AOP接口（接口定义位aopalliance.jar）。这里我们采用aopalliance.jar中定义的MethodInterceptor作为我们的Advice实现接口。那么我们上节例子中的处理方式应实现为如下Interceptor：
package test.aop.spring;
6 S; Y, F& S3 k" Limport java.util.logging.Logger;
: J' j* n' o6 a* K- O: i- Himport org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

/**
* @author xkf
**/
  v5 C% F. F; f6 c) g5 fpublic class LockInterceptor implements MethodInterceptor {
2 z+ w; F% s; G" b9 T( Y) Xprivate Logger logger = Logger.getLogger(this.getClass().getName());
' }: d- i; D( P/ R& I/ N% Gpublic Object invoke(MethodInvocation invocation) throws Throwable {
  |$ _2 d, x  n8 H1 R5 p# J// TODO Auto-generated method stub
; D0 ?  F% Z% n5 [( Hlock();
Object ret= invocation.proceed();
unlock();
return ret;
3 V/ a/ o* {1 v( e}
private void lock(){
( v+ D$ e1 e1 E0 i4 Y8 Q. A5 Dlogger.info("lock domain object...");
}
& I0 z! K4 O- X% b4 _private void unlock(){
logger.info("unlock domain object...");
" a* o$ s0 b9 O/ y0 Y/ R}
5 a) T3 R7 }2 J5 e3 I- J3 K$ G}
　　实现后，对应的Interceptor实现类在配置文件中的体现如下：
　　<bean id="MyInterceptor" class="test.aop.spring.LockInterceptor"/>
( J& X" \3 }. g9 j' l6 f9 x　　最后，我们还需要定义一个Spring AOP ProxyFactory用于加载执行AOP组件，并且需要将Advice通过IOC的方式注入到接口以及实现类。
) q8 c6 |  d6 M" B; E　　对应的配置文件应如下配置从而实现这些内容：
<bean id="myAOPProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="proxyInterfaces">
2 J9 j+ u* {  b5 j* i<value>test.aop.spring.DomainObjDAO</value>
4 R3 A$ h- \2 y</property>
- x4 k  O2 S. C  I' \<property name="target">
  G, r# w1 ]" H8 {: v<ref local="impl" />
8 n* X. r% g3 \1 |( w% S/ l9 _5 ^/ ^  L2 Q</property>
1 m: L, Q- F5 a0 b' ]; _) M<property name="interceptorNames">
% ]* _8 P5 M( l! m& w<value>myPointcutAdvisor</value>
</property>
7 F) |8 }# E, x3 A</bean>
<bean id="impl" class="test.aop.spring.DomainObjDAOImpl"/>
0 J" j; H; B  ~5 w% I! k- O, C万事大吉！写一个TestCase来看一下运行结果：
9 I; J4 G( p1 T* P9 ?* I$ G. x6 Cpackage test.aop.spring;

import junit.framework.TestCase;
import org.springframework.context.ApplicationContext;
5 g- ^4 W- K: h7 t" I+ _5 J* eimport org.springframework.context.support.FileSystemXmlApplicationContext;

/**
* @author xkf
*/
public class SpringTestCase extends TestCase {
DomainObjDAO test=null;

protected void setUp() throws Exception {
) t5 S  L; I2 J1 `3 Esuper.setUp();
0 A- P4 S. _4 m' C- dApplicationContext ctx=new FileSystemXmlApplicationContext("test/Bean.xml");
' K! ~6 ~+ Z2 ]! N$ ytest = (DomainObjDAO) ctx.getBean("myAOPProxy");
}

protected void tearDown() throws Exception {
. t$ f& A' H. ^super.tearDown();
}
& X/ [! o5 T% J4 d" |8 c/ ?public void testSave(){
% l- C, L* x# x+ t; Ntest.save();
7 D* ~1 F0 s4 }2 `}
}
运行结果如下：
信息: Creating shared instance of singleton bean ''MyInterceptor''
' p  K' f; s* ?, a6 u3 F8 o1 E2004-12-7 23:50:11 test.aop.spring.LockInterceptor lock
信息: lock domain object...
saving domain object......
# l7 s0 t5 E, F( E2004-12-7 23:50:11 test.aop.spring.LockInterceptor unlock
. R$ A( C) F( X. a. L信息: unlock domain object...

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