Spring的事务通知

Spring 1.x文档中说：在Spring声明式事务管理中，可以通过TransacationProxyFactoryBean的preInterceptors和postInterceptors属性设置“前”或“后”通知来提供额外的拦截行为，并可以设置任意数量的“前”“后”通知，他们的类型可以使Advisor、MethodInterceptor或则被当前Spring配置所支持的通知类型，如BeforeAdvice和AfterReturningAdvice等等。

看到这里有一些疑惑，在事务声明中，如果一个事务代理设置给preInterceptors属性一个通知，按照Spring文档中的理解，这个通知将在事务方法开始前进行通知，反之亦然。但是如果给preInterceptors设置一个实现了AfterReturningAdvice接口的通知呢？执行结果会如何，通知在方法执行前还是后呢？为了解惑，写了一个小例子，来真实的模拟一下事务中通知是如何运作的，Spring版本1.2.6。

首先，一个简单的service及实现
MyService.java
[code]
package com.ccb.tra;

public interface MyService {
public void getAll();
}
[/code]
MyServiceImpl.java
[code]
package com.ccb.tra;

public class MyServiceImpl implements MyService{

public void getAll() {
try {
System.out.println("getAll Method........");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
[/code]

为了更真实的观察，这里建立三个类型的通知，分别实现MethodBeforeAdvice、MethodInterceptor、AfterReturningAdvice接口
MyBeforeAdvice.java
[code]
package com.ccb.tra;

import java.lang.reflect.Method;

import org.springframework.aop.MethodBeforeAdvice;

public class MyBeforeAdvice implements MethodBeforeAdvice {
public void before(Method method, Object[] object, Object object0) throws Throwable {
System.out.println("MethodBeforeAdvice.............");
}
}
[/code]

MyInterceptor.java
[code]
package com.ccb.tra;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class MyInterceptor implements MethodInterceptor
{
public Object invoke(MethodInvocation invocation) throws Throwable {
System.out.println("MethodInterceptor.................");
return invocation.proceed();
}
}
[/code]

MyAfterAdvice.java
[code]
package com.ccb.tra;

import java.lang.reflect.Method;

import org.springframework.aop.AfterReturningAdvice;

public class MyAfterAdvice implements AfterReturningAdvice {
public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws

Throwable {
System.out.println("AfterReturningAdvice.............");
}
}
[/code]

可以看到在每个通知被使用时，将会在控制台打印一条信息。三个通知所实现的接口的作用不再过多的描述,用法请参考Spring开发文档.

然后,写Spring配置文件.
tra.xml
[code]
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-

method="close">
<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/>
<property name="url" value="jdbc:oracle:thin:@192.168.1.110:1521:xmldb" />
<property name="username" value="neohkdev1" />
<property name="password" value="xml" />
<property name="initialSize" value="5"/>
<property name="maxActive" value="5"/>
</bean>
<!-- service target -->
<bean id="myServiceTarget" class="com.ccb.tra.MyServiceImpl"/>

<!-- before -->
<bean id="myBeforeAdvice" class="com.ccb.tra.MyBeforeAdvice"/>
<!-- Interceptor -->
<bean id="myInterceptor" class="com.ccb.tra.MyInterceptor"/>
<!-- myAfterAdvice -->
<bean id="myAfterAdvice" class="com.ccb.tra.MyAfterAdvice"/>

<bean id="traManager"

class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource">
<ref local="dataSource"/>
</property>
</bean>

<bean id="myService"

class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="transactionManager">
<ref bean="traManager"/>
</property>
<property name="target">
<ref bean="myServiceTarget"/>
</property>
<!-- preInterceptors属性，包含三个通知 -->
<property name="preInterceptors">
<list>
<ref bean="myBeforeAdvice"/>
<ref bean="myInterceptor"/>
<ref bean="myAfterAdvice"/>
</list>
</property>
<property name="transactionAttributes">
<props>
<prop key="get*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
</beans>
[/code]
配置文件中可以看到为Service定义了一个简单的事务,并定义了三个通知，并将这些通知注入到TransactionProxyFactoryBean的preInterceptors属性中，按照spring对preInterceptors属性的描述来看，这三个通知都将在service方法执行前执行。

写一个简单的测试类测试一下他们的执行结果
Main.java
[code]
package com.ccb.tra;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext("tra.xml");

MyService myService = (MyService)ctx.getBean("myService");
myService.getAll();
}
}
[/code]

好了，运行Main.java看下执行结果
[code]
MethodBeforeAdvice.............

MethodInterceptor.................

getAll Method........

AfterReturningAdvice.............
[/code]
貌似结果不对，AfterReturningAdvice通知竟然在service方法执行后才执行，怪异，和Spring所描述的preInterceptors属性的作用不符，但是和AOP中描述的通知接口的作用一致，察看TransactionProxyFactoryBean源码发现了对这两个属性定义的操作方式,

[code]
public void afterPropertiesSet() {
this.transactionInterceptor.afterPropertiesSet();

if (this.target == null) {
throw new IllegalArgumentException("'target' is required");
}
if (this.target instanceof String) {
throw new IllegalArgumentException("'target' needs to be a bean

reference, not a bean name as value");
}

ProxyFactory proxyFactory = new ProxyFactory();

//preInterceptors属性
if (this.preInterceptors != null) {
for (int i = 0; i < this.preInterceptors.length; i++) {
//请注意这一句代码
proxyFactory.addAdvisor(this.advisorAdapterRegistry.wrap

(this.preInterceptors[i]));
}
}

if (this.pointcut != null) {
Advisor advice = new DefaultPointcutAdvisor(this.pointcut,

this.transactionInterceptor);
proxyFactory.addAdvisor(advice);
}
else {
// Rely on default pointcut.
proxyFactory.addAdvisor(new TransactionAttributeSourceAdvisor

(this.transactionInterceptor));
// Could just do the following, but it's usually less efficient because

of AOP advice chain caching.
// proxyFactory.addAdvice(transactionInterceptor);
}
//postInterceptors属性

if (this.postInterceptors != null) {
for (int i = 0; i < this.postInterceptors.length; i++) {
//请注意这一句代码
proxyFactory.addAdvisor(this.advisorAdapterRegistry.wrap

(this.postInterceptors[i]));
}
}

proxyFactory.copyFrom(this);

TargetSource targetSource = createTargetSource(this.target);
proxyFactory.setTargetSource(targetSource);

if (this.proxyInterfaces != null) {
proxyFactory.setInterfaces(this.proxyInterfaces);
}
else if (!isProxyTargetClass()) {
// Rely on AOP infrastructure to tell us what interfaces to proxy.
proxyFactory.setInterfaces(ClassUtils.getAllInterfacesForClass

(targetSource.getTargetClass()));
}

this.proxy = getProxy(proxyFactory);
}
[/code]
上面的一段代码的作用我的理解是将preInterceptors和postInterceptors中所包含的通知注入到proxyFactory.

通知在注入到proxyFactory后,由proxyFactory负责管理通知,这个我想和普通AOP的通知管理是一样的,按照通知所实现的接口来判断通知的调用顺序,而TransactionProxyFactoryBean将这些通知交给proxyFactory后就撒手不管了,而且在进行处理preInterceptors和postInterceptors所包含的通知时没有任何的区别.
处理preInterceptors
[code]
if (this.preInterceptors != null) {
for (int i = 0; i < this.preInterceptors.length; i++) {
proxyFactory.addAdvisor(this.advisorAdapterRegistry.wrap

(this.preInterceptors[i]));
}
}
[/code]

处理postInterceptors
[code]
if (this.postInterceptors != null) {
for (int i = 0; i < this.postInterceptors.length; i++) {
proxyFactory.addAdvisor(this.advisorAdapterRegistry.wrap

(this.postInterceptors[i]));
}
}
[/code]

实际上通知的执行顺序并不由将通知定义在preInterceptors或是postInterceptors中所决定,而是决定于通知实现与哪一个通知接口.

Spring 2.0貌似改进了这点,<tx:advice>标签可以不分前后，但TransactionProxyFactoryBean中看不到什么改变，仅仅是将一些方法继承自AbstractSingletonProxyFactoryBean?正在研究,有看法的话写出来大家一起讨论.