AOP及其在Spring中的应用（二）

Spring中AOP的实现就是通过动态代理来实现的。动态代理的实现在上篇blog中已经涉及。Spring中目前最为实用的AOP应用，非用其实现的事务管理机制莫属。也正是这一点，使得Spring AOP大方异彩。

那么我们继续围绕上节的例子来探讨一下Spring中AOP机制的应用与开发。
　　首先，看看AOP中几个基本的概念对应在AOP中的实现：

? 切点(PointCut)

　　一系列连接点的集合，它指明处理方式（Advice）将在何时被触发。

　　对于我们开发而言，“何时触发”的条件大多是面向Bean的方法进行制定。像Spring的配置化事务管理时针对方法名称可进行PointCut设置，从而指定对所有以声明字符开头的方法进行基于AOP的事务管理。那么同样，对于我们自己实现的AOP组件而言，我们也可以以方法名作为触发判定条件。

我们可以通过在XML配置文件中配置以下节点，为我们的组件设定触发条件。

<bean id="myPointcutAdvisor"

class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">

<property name="advice">

<ref local="MyInterceptor" />

</property>

<property name="patterns">

<list>

<value>.*save.*</value>

<value>.*do.*</value>

</list>

</property>

</bean>

　　上面我们针对MyInterceptor设定了一个基于方法名的触发条件，也就是说，当目标类的指定方法运行时，MyInterceptor即被触发。

　　? 处理方式（Advice）

　　也就是说要实现一个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;

/**

* @author xkf

**/

public class LockInterceptor implements MethodInterceptor {

private Logger logger = Logger.getLogger(this.getClass().getName());

public Object invoke(MethodInvocation invocation) throws Throwable {

// TODO Auto-generated method stub

lock();

Object ret= invocation.proceed();

unlock();

return ret;

}

private void lock(){

logger.info("lock domain object...");

}

private void unlock(){

logger.info("unlock domain object...");

}

}

　　实现后，对应的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>

<property name="target">

<ref local="impl" />

</property>

<property name="interceptorNames">

<value>myPointcutAdvisor</value>

</property>

</bean>

<bean id="impl" class="test.aop.spring.DomainObjDAOImpl"/>

万事大吉！写一个TestCase来看一下运行结果：

package test.aop.spring;

import junit.framework.TestCase;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.FileSystemXmlApplicationContext;

/**

* @author xkf

*/

public class SpringTestCase extends TestCase {

DomainObjDAO test=null;

protected void setUp() throws Exception {

super.setUp();

ApplicationContext ctx=new FileSystemXmlApplicationContext("test/Bean.xml");

test = (DomainObjDAO) ctx.getBean("myAOPProxy");

}

protected void tearDown() throws Exception {

super.tearDown();

}

public void testSave(){

test.save();

}

}

运行结果如下：

信息: Creating shared instance of singleton bean ''MyInterceptor''

2004-12-7 23:50:11 test.aop.spring.LockInterceptor lock

信息: 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中事务以及持久化的实现。