TransactionProxyFactoryBean声明式事务

<bean id="hibernateTransProxy" abstract="true" lazy-init="true"
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="transactionManager">
<ref bean="hibernateTransManager" />
</property>
<property name="transactionAttributes">
<props>
<!-- 
transactionAttributes属性可以设置事务处理的方式，事务隔离级别，是否只读三个属性，用逗号隔开
事务隔离级别各数据库系统不完全支持，一般不设置，用默认的即可
事务处理选项有如下几个：（前面2个常用）
PROPAGATION_REQUIRED  － 需要事务处理。如果当前不存在事务环境，则创建一个
PROPAGATION_SUPPORTS  － 如果当前存在事务环境，则作为其中的一部分。如果不存在，则按非事务方式执行
PROPAGATION_REQUIRES_NEW  － 需要事务处理。并总是开启一个新事务。如果已经存在事务环境，则挂起之
PROPAGATION_MANDATORY  － 执行到指定方法时，必须已经存在事务环境，否则出错
PROPAGATION_NEVER  － 不支持事务操作，如果存在事务环境会出错
PROPAGATION_NOT_SUPPORTED  － 不支持事务操作。如果存在事务，则挂起
-->
<!-- find打头和get打头的方法事务处理方式为PROPAGATION_SUPPORTS，其他的采用PROPAGATION_REQUIRED -->
                <!-- readOnly 表示只读事务 ;-->
                <!-- -Exception 表示发生异常时回滚事务;+Exception 表示即使发生异常事务也不回滚;-->
<prop key="find*">PROPAGATION_SUPPORTS,readOnly</prop>
<prop key="get*">PROPAGATION_SUPPORTS,readOnly</prop>
<prop key="*">PROPAGATION_REQUIRED,-Exception</prop>


</props>
</property>

在使用hibernateTransProxy这个事务控制的时候，遇到的问题：

1.在一个方法执行的时候什么情况下事务会提交，什么情况下事务会回滚；
2.嵌套执行的事务提交和回滚的情况又是什么样子的；
 

org.springframework.transaction.interceptor.TransactionProxyFactoryBean
这个类就是以IOC为基础的面向切面编程的采用动态代理实现的声明式事务
面向切面编程:就是spring的AOP,它的思想就是在方法的调用前和方法的调用后来
做一些操作，包括日志、监控，甚至是改变方法的传入参数的值等；它的作用像管家
或者后勤，为方法的正常执行提供保障。
代理：就是控制，就像中介代理房东卖房子一样，spring替你控制，控制什么，控制bean;对于
TransactionProxyFactoryBean类来说就是控制bean的事务，而且它将事务的原子性
提高到方法这一层，而不是过去的一行代码一个事务；由此类代理的bean的一个方法
是一个事务。
声明式事务：就是说这个是由配置文件来实现的，配置在xml中，所以它是以IOC为基础的。


// ServiceClient没有事务，ServiceDAO有事务,testThrowException
// 抛出异常单独一个事务回滚，save2单独一个事务提交
public void testException() {
int result = 0;
try {
result = service.testThrowException("3", "一月又一月", "33");
} catch (Exception e1) {
e1.printStackTrace();
}
if (result == 1) {
try {
throw new Exception("ddd");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}


service.save2("2", "哈asdfas", "33");
service.save2("5", "哈哈哈", "33");
}


// ServiceClient没有事务，ServiceDAO有事务,testTryCatchException
// 捕获异常单独一个事务提交，save2单独一个事务提交
public void testTryCatchException() {
int result = 0;
result = service.testTryCatchException("3", "一月又一月", "33");
if (result == 1) {
try {
throw new Exception("ddd");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}


service.save2("2", "哈asdfas", "33");
service.save2("5", "哈哈哈", "33");
}

所以，问题1答案是：一个方法调用捕获异常，已经执行的持久化仍然提交；抛出异常持久化
将被回滚。同时应该注意如果持久化的方法以find和get打头，不管是否抛出异常
事务都不会回滚。


问题2实际上是有关事务的传播性，测试发现和在一个方法中还是不一样的。
   /**
* ServiceDAO有事务 BusinessClient也有事务
*/

// save2 正常执行 save1有异常抛出 ，save1回滚 save2也会滚
public void doWorkA() throws Exception {
service.save2("2", "哈哈哈", "33");


service.save1("1", "哈hhhh哈", "33");
}


// save1 有异常抛出 ，save2 根本执行不到
public void doWorkB() throws Exception {
service.save1("2", "哈哈哈", "33");


service.save2("1", "哈hhhh哈", "33");
}


// save2 正常执行 save1有异常抛出被捕获 ，save1回滚 save2也会滚
public void doWorkC() {


service.save2("1", "哈hhhh哈", "33");
try {
service.save1("2", "哈哈哈", "33");
} catch (Exception e) {
e.printStackTrace();
}
}

// 先是doWorkD1 调用save2 正常执行 而后save1有异常抛出被捕获 ，save1回滚 save2也会滚
public void doWorkD() {
doWorkD1();
try {
service.save1("2", "哈哈哈", "33");
} catch (Exception e) {
e.printStackTrace();
}
}


public void doWorkD1() {
service.save2("1", "哈hhhh哈", "33");
}
问题2的答案是嵌套调用的情况下，只要有异常不管是捕获还是抛出，事务都会被被回滚