spring事务管理

2018-07-23 本文已影响0人 embers1996

什么事务？

事务指逻辑上的一组操作，这组操作要么全部成功，要么全部失败。

举一个栗子：取钱。
比如你去ATM机取1000块钱，大体有两个步骤：首先输入密码金额，银行卡扣掉1000元钱；然后ATM出1000元钱。这两个步骤必须是要么都执行要么都不执行。如果银行卡扣除了1000块但是ATM出钱失败的话，你将会损失1000元；如果银行卡扣钱失败但是ATM却出了1000块，那么银行将损失1000元。所以，如果一个步骤成功另一个步骤失败对双方都不是好事，如果不管哪一个步骤失败了以后，整个取钱过程都能回滚，也就是完全取消所有操作的话，这对双方都是极好的。
事务就是用来解决类似问题的。事务是一系列的动作，它们综合在一起才是一个完整的工作单元，这些动作必须全部完成，如果有一个失败的话，那么事务就会回滚到最开始的状态，仿佛什么都没发生过一样。
在企业级应用程序开发中，事务管理必不可少的技术，用来确保数据的完整性和一致性。

事物的特性

事务的特性	含义
原子性（Atomic）	事务是一个不可分割的工作单位,事务中的操作要么都发生,要么都不发生。
一致性（Consistent）	事务处理前后数据的完整性必须保持一致。
隔离性（Isolated）	多个用户并发访问数据库时,一个用户的事务不能被其他用户的事务所干扰,多个并发事务之间数据要相互隔离。
持久性（Durable）	一个事务一旦被提交,它对数据库中数据的改变就是永久性的,即使数据库发生故障也不应该对其有任何影响。

Spring事务管理高层抽象主要包括3个接口

Platform TransactionManager 事务管理器（提交、回滚事务）

Spring为不同的持久化框架提供了不同的Platform TransactionManager接口实现。如：
使用Spring JDBC或iBatis进行持久化数据时使用DataSourceTransactionManager
使用Hibernate3.0版本进行持久化数据时使用HibernateTransactionManage
TransactionDefinition 事务定义信息（隔离、传播、超时、只读）
如果不考虑事务的安全性会引发以下问题：
（1）.脏读：
一个事务读取了另一个事务改写但还未提交的数据，如果这些数据被回滚，则读到的数据是无效的。
（2）.不可重复读：
在同一个事务中，多次读取同一数据返回的结果有所不同。
（3）.幻读：
一个事务读取了几行记录后，另一个事务插入一些记录，幻读就发生了。再后来的查询中，第一个事务就会发现有些原来没有的记录。

事务隔离级别：（五种）

隔离级别	含义
DEFAULT	使用后端数据库默认的隔离级别（Spring中的选择项）
READ_UNCOMMITED	允许你读取还未提交的改变了的数据。可能导致脏、幻、不可重复读
READ_COMMITTED	允许在并发事务已经提交后读取。可防止脏读，但幻读和不可重复读仍可发生
REPEATABLE_READ	对相同字段的多次读取是一致的，除非数据被事务本身改变。可防止脏、不可重复读，但幻读仍可能发生
SERIALIZABLE	完全服从ACID的隔离级别，确保不发生脏、幻、不可重复读。这在所有的隔离级别中是最慢的，它是典型的通过完全锁定在事务中涉及的数据表来完成的

注：其中，MySQL默认采用REPEATABLE_READ隔离级别；Oracle默认采用READ_COMMITTED隔离级别

事务传播行为：（七种）

事务传播行为	含义
REQUIRED	支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
SUPPORTS	支持当前事务，如果当前没有事务，就以非事务方式执行
MANDATORY	支持当前事务，如果当前没有事务，就抛出异常。
REQUIRES_NEW	以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
NOT_SUPPORTED	以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
NEVER	以非事务方式执行，如果当前存在事务，则抛出异常。
NESTED	如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与REQUIRED类似的操作。拥有多个可以回滚的保存点，内部回滚不会对外部事务产生影响。只对DataSourceTransactionManager有效。

TransactionStatus 事务具体运行状态

TransactionStatus接口用来记录事务的状态。该接口定义了一组方法,用来获取或判断事务的相应状态信息。

平台事务管理器(PlatformTransactionManager)会根据TransactionDefinition中定义的事务信息(包括隔离级别、传播行为)来进行事务的管理,在管理的过程中事务可能产生了保存点或事务是新的事务等情况，那么这些信息都会记录在TransactionStatus的对象中。

Spring提供了以下方法控制事务

编程式事务管理(基于Java编程控制，很少使用
利用TransactionTemplate将多个DAO操作封装起来
声明式事务管理(基于Spring的AOP配置控制)
(1).基于TransactionProxyFactoryBean的方式.(很少使用)
需要为每个进行事务管理的类,配置一个TransactionProxyFactoryBean进行增强.
(2).基于XML配置(经常使用)
一旦配置好之后,类上不需要添加任何东西。
如果Action作为目标对象切入事务，需要在<aop:config>元素里添加proxy-target-class="true"属性。原因是通知Spring框架采用CGLIB技术生成具有事务管理功能的Action类。
(3).基于注解(配置简单，经常使用)
在applicationContext.xml中开启事务注解配置。(applicationContext.xml中只需定义Bean并追加以下元素)

示例（银行转账）

首先创建数据库，新建一张accountI表。

CREATE TABLE `account` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(20) NOT NULL,
  `money` double DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
INSERT INTO `account` VALUES ('1', 'aaa', '1000');
INSERT INTO `account` VALUES ('2', 'bbb', '1000');
INSERT INTO `account` VALUES ('3', 'ccc', '1000');

编程式方式

/** 
 * @Description:转账案例的DAO层接口 
 * 
 */
public interface AccountDao { 
 /** 
 * @param out 
 * :转出账号 
 * @param money 
 * :转账金额 
 */
 public void outMoney(String out, Double money); 
  
 /** 
 * 
 * @param in 
 * :转入账号 
 * @param money 
 * :转账金额 
 */
 public void inMoney(String in, Double money); 
}

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);
    }
}

/** 
 * @Description:转账案例的业务接口 
 * 
 */
public interface AccountService { 
 /** 
 * @param out :转出账号 
 * @param in :转入账号 
 * @param money :转账金额 
 */
 public void transfer(String out,String in,Double money); 
}

/**
 * @Description:转账案例的DAO层实现类
 */
/**
 * @Description:转账案例的业务层实现类
 */
public class AccountServiceImpl implements AccountService {
    // 注入转账的DAO 
    private AccountDao accountDao;

    // 注入事务管理的模板 
    private TransactionTemplate transactionTemplate;

    /**
     * @param out
     * :转出账号 
     * @param in
     * :转入账号 
     * @param money
     * :转账金额 
     */
    @Override
    public void transfer(final String out, final String in, final Double money) {

        // 未经事务控制的业务处理操作，如果过程中出异常，则导致前面的操作能完成，后面的不能，即转账成功但未收到转账款 
        // accountDao.outMoney(out, money); 
        // int i = 1/0; 
        // accountDao.inMoney(in, money); 

        transactionTemplate.execute(new TransactionCallbackWithoutResult() {

            @Override
            protected void doInTransactionWithoutResult(
                    TransactionStatus transactionStatus) {
                accountDao.outMoney(out, money);
                // int i = 1 / 0;//事务控制，即出现异常，该段内代码都执行失效 
                accountDao.inMoney(in, money);
            }
        });
    }

    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    public void setTransactionTemplate(TransactionTemplate transactionTemplate) {
        this.transactionTemplate = transactionTemplate;
    }
}

配置文件：applicationContext1.xml

<!-- 引入外部的属性文件 -->
<context:property-placeholder location="classpath:jdbc.properties"/>

   <!-- 配置c3p0连接池 -->
  <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
  <property name="driverClass" value="${jdbc.driverClass}" />
  <property name="jdbcUrl" value="${jdbc.url}" />
  <property name="user" value="${jdbc.username}" />
  <property name="password" value="${jdbc.password}" />
</bean>

        <!-- 配置业务层类 -->
<bean id="accountService" class="com.zs.spring.demo1.AccountServiceImpl">
  <property name="accountDao" ref="accountDao" />
  <!-- 注入事务管理的模板 -->
  <property name="transactionTemplate" ref="transactionTemplate" />
</bean>

        <!-- 配置DAO类(简化，会自动配置JdbcTemplate) -->
<bean id="accountDao" class="com.zs.spring.demo1.AccountDaoImpl">
  <property name="dataSource" ref="dataSource" />
</bean>

        <!-- 配置DAO类(未简化) -->
        <!-- <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> 
        <property name="dataSource" ref="dataSource" /> 
        </bean> 
        <bean id="accountDao" class="com.zs.spring.demo1.AccountDaoImpl"> 
        <property name="jdbcTemplate" ref="jdbcTemplate" /> 
        </bean> -->

        <!-- ==================================1.编程式的事务管理=============================================== -->
        <!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource" />
</bean>

        <!-- 配置事务管理的模板:Spring为了简化事务管理的代码而提供的类 -->
<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
  <property name="transactionManager" ref="transactionManager"/>
</bean>

测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext1.xml")
public class TransactionTest {
    @Resource(name = "accountService")
    private AccountService accountService;

    @Test
    public void demo1() {
        accountService.transfer("aaa", "bbb", 200d);
    }
}

基于TransactionProxyFactoryBean的方式

public class AccountServiceImpl implements AccountService {
    // 注入转账的DAO 
    private AccountDao accountDao;

    /**
     * @param out
     *  :转出账号 
     * @param in
     *  :转入账号 
     * @param money
     *  :转账金额 
     */
    @Override
    public void transfer(String out, String in, Double money) {
        accountDao.outMoney(out, money);
        // int i = 1/0; 
        accountDao.inMoney(in, money);
    }

    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }
}

applicationContext2.xml

<!-- 引入外部的属性文件 -->
<context:property-placeholder location="classpath:jdbc.properties"/>

        <!-- 配置c3p0连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="${jdbc.driverClass}" />
<property name="jdbcUrl" value="${jdbc.url}" />
<property name="user" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>

        <!-- 配置业务层类 -->
<bean id="accountService" class="com.zs.spring.demo2.AccountServiceImpl">
<property name="accountDao" ref="accountDao" />
</bean>

        <!-- 配置DAO类(简化，会自动配置JdbcTemplate) -->
<bean id="accountDao" class="com.zs.spring.demo2.AccountDaoImpl">
<property name="dataSource" ref="dataSource" />
</bean>

        <!-- ==================================2.使用XML配置声明式的事务管理(原始方式)=============================== -->

        <!-- 配置事务管理器 -->
<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>
<!-- 注入事务的属性 -->
<property name="transactionAttributes">
    <props>
        <!--
         prop的格式:
         * PROPAGATION :事务的传播行为
         * ISOTATION :事务的隔离级别
         * readOnly :只读
         * -EXCEPTION :发生哪些异常回滚事务
         * +EXCEPTION :发生哪些异常不回滚事务
         -->
        <prop key="transfer">PROPAGATION_REQUIRED</prop>
        <!-- <prop key="transfer">PROPAGATION_REQUIRED,readOnly</prop> -->
        <!-- <prop key="transfer">PROPAGATION_REQUIRED,+java.lang.ArithmeticException</prop> -->
    </props>
</property>
</bean>

测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext2.xml")
public class TransactionTest {
    /**
     * 一定要注入代理类:因为代理类进行增强的操作 
     */
    // @Resource(name="accountService") 
    @Resource(name = "accountServiceProxy")
    private AccountService accountService;

    @Test
    public void demo1() {
        accountService.transfer("aaa", "bbb", 200d);
    }
}

基于XML配置方式

public class AccountServiceImpl implements AccountService {
    // 注入转账的DAO 
    private AccountDao accountDao;

    /**
     * @param out
     *  :转出账号 
     * @param in
     *  :转入账号 
     * @param money
     *  :转账金额 
     */
    @Override
    public void transfer(String out, String in, Double money) {
        accountDao.outMoney(out, money);
        // int i = 1/0; 
        accountDao.inMoney(in, money);

    }

    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }
}

applicationContext3.xml

<!-- 引入外部的属性文件 -->
<context:property-placeholder location="classpath:jdbc.properties"/>

        <!-- 配置c3p0连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="${jdbc.driverClass}" />
<property name="jdbcUrl" value="${jdbc.url}" />
<property name="user" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>

        <!-- 配置业务层类 -->
<bean id="accountService" class="com.zs.spring.demo3.AccountServiceImpl">
<property name="accountDao" ref="accountDao" />
</bean>

        <!-- 配置DAO类(简化，会自动配置JdbcTemplate) -->
<bean id="accountDao" class="com.zs.spring.demo3.AccountDaoImpl">
<property name="dataSource" ref="dataSource" />
</bean>

        <!-- ==================================3.使用XML配置声明式的事务管理,基于tx/aop================================= -->

        <!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>

        <!-- 配置事务的通知 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
    <!-- 
    propagation :事务传播行为 
    isolation :事务的隔离级别 
    read-only :只读 
    rollback-for:发生哪些异常回滚 
    no-rollback-for :发生哪些异常不回滚 
    timeout :过期信息 
    -->
    <tx:method name="transfer" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>

        <!-- 配置切面 -->
<aop:config>
<!-- 配置切入点 -->
<aop:pointcut expression="execution(* com.zs.spring.demo3.AccountService+.*(..))" id="pointcut1"/>
<!-- 配置切面 -->
<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1"/>
</aop:config>

测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext3.xml")
public class TransactionTest {
 /**
  * 一定要注入代理类:因为代理类进行增强的操作 
  */
 @Resource(name = "accountService")
 private AccountService accountService;

 @Test
 public void demo1() {
  accountService.transfer("aaa", "bbb", 200d);
 }
}

基于注解

/**
 * @Transactional中的的属性 propagation :事务的传播行为 isolation :事务的隔离级别 readOnly :只读 
 *   rollbackFor :发生哪些异常回滚 noRollbackFor :发生哪些异常不回滚 
 *   rollbackForClassName 根据异常类名回滚 
 */
@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT, readOnly = false)
public class AccountServiceImpl implements AccountService {
 // 注入转账的DAO 
 private AccountDao accountDao;

 /**
  * @param out
  *  :转出账号 
  * @param in
  *  :转入账号 
  * @param money
  *  :转账金额 
  */
 @Override
 public void transfer(String out, String in, Double money) {
  accountDao.outMoney(out, money);
  // int i = 1/0; 
  accountDao.inMoney(in, money);
 }

 public void setAccountDao(AccountDao accountDao) {
  this.accountDao = accountDao;
 }
}

applicationContext4.xml

<!-- 引入外部的属性文件 -->
<context:property-placeholder location="classpath:jdbc.properties"/>

        <!-- 配置c3p0连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="${jdbc.driverClass}" />
<property name="jdbcUrl" value="${jdbc.url}" />
<property name="user" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>

        <!-- 配置业务层类 -->
<bean id="accountService" class="com.zs.spring.demo4.AccountServiceImpl">
<property name="accountDao" ref="accountDao" />
</bean>

        <!-- 配置DAO类(简化，会自动配置JdbcTemplate) -->
<bean id="accountDao" class="com.zs.spring.demo4.AccountDaoImpl">
<property name="dataSource" ref="dataSource" />
</bean>

        <!-- ==================================4.使用注解配置声明式事务============================================ -->

        <!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>

        <!-- 开启注解事务 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

测试：

@RunWith(SpringJUnit4ClassRunner.class) 
@ContextConfiguration("classpath:applicationContext4.xml") 
public class TransactionTest { 
 /** 
 * 一定要注入代理类:因为代理类进行增强的操作 
 */
 @Resource(name = "accountService") 
 private AccountService accountService; 
  
 @Test
 public void demo1() { 
 accountService.transfer("aaa", "bbb", 200d); 
 } 
}