Spring事务管理（XML配置声明式）

java事务管理主要有三种：JDBC事务、JTA事务、容器事务，主要来看一下容器事务。
首先来回顾一下什么是事务。
事务:指逻辑上的一组操作，这组操作要么全部成功，要么全部失败。
事务的特性（ACID）：
1、原子性：事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。
2、一致性：事务执行的前后数据的完整性必须保持一致。
3、隔离性：多个用户并发访问数据库时，一个用户的事务不能被其他用户的事务所干扰，多个并发事务之间数据要相互隔离。
4、持久性：一个事务一旦被提交，它对数据库中数据的改变就是永久性的，即使数据库发生故障也不应该对其有任何影响。

Spring事务管理主要接口：
1、Platform TransactionManager 事务管理器（提交、回滚...）
2、TransactionDefinition 事务定义信息（隔离、传播、超时、只读...）
事务隔离级别：
（1）default：使用后端数据库默认的隔离级别（MYSQL默认采用PEPEATABLE_READ隔离级别，ORACLE默认采用READ_COMMITED隔离级别）
（2）READ_UNCOMMITED：允许读取还未提交的改变了的数据，可导致脏读，幻读，不可重复读。
（3）READ_COMMITED：允许在并发事务已经提交后读取，可防止脏读，但幻读和不可重复读仍可发生。
（4）PEPEATABLE_READ:对相同字段的多次读取是一致的，除非数据被事务本身改变。可防止脏读、不可重复读，但幻读仍可能发生。
（5）SERIALIZABLE：完全服从ACID隔离级别，确保不发生脏读、幻读、不可重复读。在所有隔离级别中最慢的，典型的通过完全锁定在事务中涉及的数据表来完成的。
事务传播行为：
（1）*（保证同一事务）PROPAGATION_REQUIRED:支持当前事务，如果不存在就新建一个事务
（2）PROPAGATION_SUPPORTS:支持当前事务，如果不存在,就不使用事务
（3）PROPAGATION_MANDATORY:支持当前事务，如果不存在,就抛异常
（4）*（保证非同一事务）PROPAGATION_REQUIRES_NEW:如果有事务存在，挂起当前事务，创建一个新事务
（5）PROPAGATION_NOT_SUPPORTED:以非事务方式运行，如果有事务存在，挂起当前事务
（6）PROPAGATION_NEVER：以非事务方式运行，如果有事务存在，抛出异常
（7）*（嵌套事务）PROPAGATION_NESTED：如果当前事务存在，嵌套事务运行
3、TransactionStatus 事务具体运行状态（是否提交、是否有保存点、是否是新事务...）
Spring在进行事务管理时，会首先根据事务定义信息(TransactionDefinition）,然后由平台事务管理器（Platform TransactionManager）进行事务管理，在进行事务管理的过程中事务产生的相应状态保存在TransactionStatus对象中。Spring为不同的持久化框架提供了不同Platform TransactionManager接口实现。
Spring事务管理方式：
1、编程式的事务管理（不常用）
2、使用XML配置声明式事务管理（通过AOP实现）
简单实例：张三转账给李四，这个操作应该分为两步，先从张三账户扣除要转账金额，再将转账金额加到李四账户，若果在两个操作之间发生异常，那么就会出现张三账户扣除了要转金额而李四账户没有收到转账金额，利用spring事务管理使两个操作要么都成功要么都失败，避免上述丢钱情况。
jdbc.properties:
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc\:mysql\://localhost\:3306/test
jdbc.username=root
jdbc.password=root
dao层代码，接口略：
public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {
    /*
     * @param out:转出账户
     * @param money:转出金额
     */
    @Override
    public void outMoney(String out, Double money) {
        String sql="update account set money = money - ? where name = ?";
        this.getJdbcTemplate().update(sql, money, out);
    }
    /*
     * @param in:转入账户
     * @param money:转入金额
     */
    @Override
    public void inMoney(String in, Double money) {
        String sql="update account set money = money + ? where name = ?";
        this.getJdbcTemplate().update(sql, money, in);
    }
}
service层代码，接口略：
/*
 * @Transactional注解中的属性：
 * propagation 事务的传播行为
 * isolation 事务隔离级别
 * readOnly 是否只读
 * noRollbackFor 哪些异常不回滚
 * rollbackFor 哪些异常回滚
 *  
 */
**@Transactional(propagation=Propagation.REQUIRED,isolation=Isolation.DEFAULT,readOnly=false)(第二种基于注解方式)
public class AccountServiceImpl implements AccountService {
    private AccountDao accountDao;
    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }
    /*
     * @param out:转出账户
     * @param in：转入账户
     * @param money：转账金额
     */
    @Override
    public void transfer(String out, String in, Double money) {
        accountDao.outMoney(out, money);
        int a=1/0;//异常
        accountDao.inMoney(in, money);
    }
}
以上类除了AccountServiceImpl**处以外不变化，以下配置及测试类根据不同方式写法不同，主要区别于配置事务管理器之后的内容：
Spring的声明式事务管理的方式一：基于TransactionProxyFactoryBean的方式
applicationContext.xml:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd">
<!-- 引入外部属性文件 -->
<context:property-placeholder location="classpath:jdbc.properties" />
<!-- 配置c3p0连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
  <property name="driverClass" value="${jdbc.driverClass}"></property>
  <property name="jdbcUrl" value="${jdbc.url}"></property>
  <property name="user" value="${jdbc.username}"></property>
  <property name="password" value="${jdbc.password}"></property>
</bean>
<bean id="accountService" class="com.myhexin.service.AccountServiceImpl">
 <property name="accountDao" ref="accountDao"/>
</bean>
<bean id="accountDao" class="com.myhexin.dao.AccountDaoImpl">
  <property name="dataSource" ref="dataSource"/>
</bean>
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource"/>
</bean>
<!-- 配置业务层的代理器 -->
<bean id="accountServiceProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
  <!-- 配置目标对象 -->
  <property name="target" ref="accountService"/>
  <!-- 注入事务管理器 -->
  <property name="transactionManager" ref="transactionManager"/>
  <!-- 注入事务属性 -->
  <property name="transactionAttributes">
    <props>
      <!--
        props的格式：
          *PROPAGATION   :事务的传播行为
          *ISOLATION     :事务的隔离级别
          *readOnly      :只读
          *-Exception    :发生哪些异常回滚事务
          *+Exception    :发生哪些异常事务不回滚
       -->
      <prop key="transfer*">PROPAGATION_REQUIRED,-Exception</prop>
    </props>
  </property>
</bean>
</beans>
测试类Demo1：
/*
 * Spring的声明式事务管理的方式一：基于TransactionProxyFactoryBean的方式（不常用）
 * 需要为每个进行事务管理的类，配置一个TransactionProxyFactoryBean进行增强
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:applicationContext.xml"})
public class Demo1 {
    /*
     * 注入代理类，因为代理类进行了增强操作
     *
     */
    @Resource(name="accountServiceProxy")
    private AccountService accountService;
    @Test
    public void demo1(){
        accountService.transfer("张三", "李四", 200d);
    }
}
Spring的声明式事务管理的方式二：基于注解
applicationContext1.xml:
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource"/>
</bean>
<!-- 开启注解事务 -->
<tx:annotation-driven transaction-manager="transactionManager"
测试类Demo2：
/*
 * Spring的声明式事务管理的方式二：基于注解
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:applicationContext1.xml"})
public class Demo2 {
    /*
     * 注入代理类，因为代理类进行了增强操作
     */
    @Resource(name="accountService")
    private AccountService accountService;
    @Test
    public void demo2(){
        accountService.transfer("张三", "李四", 200d);
    }
}
Spring的声明式事务管理的方式三：基于AspectJ的XML方式的配置
applicationContext2.xml:
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource"/>
</bean>
<!-- 配置事务的通知:（事务的增强） -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
  <tx:attributes>
    <tx:method name="transfer*" isolation="DEFAULT" propagation="REQUIRED"/>
  </tx:attributes>
</tx:advice>
<!-- 配置切面 -->
<aop:config>
  <!-- 配置切点 -->
  <aop:pointcut expression="execution(* com.myhexin.service.AccountService+.*(..))" id="pointcut1"/>
  <!-- 配置切面 -->
  <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1"/>
</aop:config>
测试类Demo3：
/*
 * Spring的声明式事务管理的方式三：基于AspectJ的XML方式的配置
 *
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:applicationContext2.xml"})
public class Demo3 {
    /*
     * 注入代理类，因为代理类进行了增强操作
     */
    @Resource(name="accountService")
    private AccountService accountService;
    @Test
    public void demo3(){
        accountService.transfer("张三", "李四", 200d);
    }
}