Spring4 事务管理

最新推荐文章于 2023-09-16 21:38:44 发布

M_Jack

最新推荐文章于 2023-09-16 21:38:44 发布

阅读量291

点赞数

分类专栏： spring

spring 专栏收录该内容

19 篇文章

订阅专栏

Spring4 事务管理

本章是Spring4 教程中的最后一章，也是非常重要的一章。如果说学习IOC是入门，那学习事务管理就是提升。本章篇幅可能有一丢丢长，有一丢丢难，需要笔者细细品味。主要从三个方面开始：事务简介，基于注解的事务管理和基于xml的事务管理。

准备环境

mysql文件，两张表：一个用户表，字段有帐号和余额。一个商品表，字段有sku，售价和库存。

 
   [sql]  
   view plaincopy
DROP TABLE IF EXISTS `user`;  
CREATE TABLE `user` (  
  `id` bigint(20) NOT NULL,  
  `account` varchar(255) NOT NULL,  
  `balance` float DEFAULT NULL COMMENT '用户余额',  
  PRIMARY KEY (`id`)  
) ENGINE=InnoDB DEFAULT CHARSET=utf8;  
  
-- ----------------------------  
-- Records of user  
-- ----------------------------  
INSERT INTO user VALUES ('1', 'itdragon', '100');  

 
   [sql]  
   view plaincopy
DROP TABLE IF EXISTS `product`;  
CREATE TABLE `product` (  
  `id` bigint(20) NOT NULL,  
  `sku` varchar(255) NOT NULL COMMENT '商品的唯一标识',  
  `price` float NOT NULL COMMENT '商品价格',  
  `stock` int(11) NOT NULL COMMENT '商品库存',  
  PRIMARY KEY (`id`)  
) ENGINE=InnoDB DEFAULT CHARSET=utf8;  
  
-- ----------------------------  
-- Records of product  
-- ----------------------------  
INSERT INTO product VALUES ('1', 'java', '40', '10');  
INSERT INTO product VALUES ('2', 'spring', '50', '10');  

事务简介

什么是事务？

事务就是一系列的动作，一个独立的最小单元。这些动作要么都成功，要么都失败。这也是它的原子性特点。

事务的关键属性

原子性：一系列的动作，要么都成功，要么都失败。

一致性：数据和事务状态要保持一致。

隔离性：为了防止数据被破坏，每个事务之间都存在隔离性。

持久性：一旦事务完成, 无论发生什么系统错误, 它的结果都不应该受到影响。

什么是事务管理？

事务管理是企业级应用程序开发中必不可少的技术, 用来确保数据的完整性和一致性.

举个例子：

A给B转账，A出账500，B因为某种原因没有成功进账。若A出账的500不回滚到A账户余额中，就会出现数据的不完整性和不一致性的问题。

文章模拟的场景是用户购买商品。商场的逻辑是：用户下单后，先发货后设置用户余额。即先减库存后减余额。如果余额充足，库存充足的情况，是没有什么问题的。若余额不足的情况购买商品会出现，库存减少了，余额因为不足而抛出异常，但最后余额并没有扣，库存却减少了。现在我们用代码看看如何用事务管理解决该问题。

基于注解的事务管理

核心文件 applicationContext.xml。用到注解，就需要配置自动扫描包context:component-scan，还需要配置JdbcTempalte。最后要配置事务管理器和启动事务注解 tx:annotation-driven。

JDBC配置的事务管理器是DataSourceTransactionManager，

Hibernate配置的事务管理器是HibernateTransactionMannger 。两个的用法都是一样，只是配置事务管理时class指定的路径不同罢了。这是因为 Spring 在不同的事务管理 API 之上定义了一个抽象层。我们无需了解底层的API，就可以使用Spring的事务管理。

 
   [html]  
   view plaincopy
<?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:context="http://www.springframework.org/schema/context"  
    xmlns:tx="http://www.springframework.org/schema/tx"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd  
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">  
      
    <context:component-scan base-package="com.itdragon.spring"></context:component-scan>  
      
    <!-- 导入资源文件 -->  
    <context:property-placeholder location="classpath:db.properties"/>  
      
    <!-- 配置 C3P0 数据源 -->  
    <bean id="dataSource"  
        class="com.mchange.v2.c3p0.ComboPooledDataSource">  
        <property name="user" value="${jdbc.user}"></property>  
        <property name="password" value="${jdbc.password}"></property>  
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>  
        <property name="driverClass" value="${jdbc.driverClass}"></property>  
  
        <property name="initialPoolSize" value="${jdbc.initPoolSize}"></property>  
        <property name="maxPoolSize" value="${jdbc.maxPoolSize}"></property>  
    </bean>  
      
    <!-- 配置 Spirng 的 JdbcTemplate -->  
    <bean id="jdbcTemplate"   
        class="org.springframework.jdbc.core.JdbcTemplate">  
        <property name="dataSource" ref="dataSource"></property>  
    </bean>  
      
    <!-- 配置 NamedParameterJdbcTemplate, 该对象可以使用具名参数, 其没有无参数的构造器, 所以必须为其构造器指定参数 -->  
    <bean id="namedParameterJdbcTemplate"  
        class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">  
        <constructor-arg ref="dataSource"></constructor-arg>      
    </bean>  
      
    <!-- 配置事务管理器 -->  
    <bean id="transactionManager"   
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
        <property name="dataSource" ref="dataSource"></property>  
    </bean>  
      
    <!-- 启用事务注解  如果配置的事务管理器的id就是transactionManager ， 这里是可以省略transaction-manager -->  
    <tx:annotation-driven transaction-manager="transactionManager"/>  
      
</beans>  

接下来是事务的业务代码，所有类都放在了一个目录下，没别的原因，就是因为懒。

核心是消费事务类 PurchaseService。事务管理注解的用法。

其次是批量消费事务类BatchPurchaseService。用于配合PurchaseService 测试事务的传播性。

然后是事务测试类TransactionTest。主要负责测试和解释事务的各种特性。

最后是自定义异常类。是为了测试回滚事务属性。

消费事务类 PurchaseService（主要知识点类），测试时，将注解逐一放开。

 
   [java]  
   view plaincopy
import java.util.List;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Service;  
import org.springframework.transaction.annotation.Isolation;  
import org.springframework.transaction.annotation.Propagation;  
import org.springframework.transaction.annotation.Transactional;  
  
@Service  
public class PurchaseService {  
      
    @Autowired  
    private ShopDao shopDao;  
      
    /** 
     * 模拟用户购买商品，测事务回滚 
     * 最基本用法，直接在方法或者类上使用注解@Transactional。值得注意的是：只能在公共方法上使用 
     * 对应的测试方法是 basicTransaction() 
     */  
    @Transactional  
    /** 
     * 事务的传播 propagation=Propagation.REQUIRED 
     * 常用的有两种 REQUIRED，REQUIRES_NEW 
     * 对应的测试方法是  propagationTransaction() 
     */  
//  @Transactional(propagation=Propagation.REQUIRED)  
    /** 
     * 事务的隔离性 
     * 将事务隔离起来，减少在高并发的场景下发生 脏读，幻读和不可重复读的问题 
     * 默认值是READ_COMMITTED 只能避免脏读的情况。 
     * 不好演示，没有对应的测试方法。 
     */  
//  @Transactional(isolation=Isolation.READ_COMMITTED)  
    /** 
     * 回滚事务属性 
     * 默认情况下声明式事务对所有的运行时异常进行回滚，也可以指定某些异常回滚和某些异常不回滚。（意义不大） 
     * noRollbackFor 指定异常不回滚 
     * rollbackFor 指定异常回滚 
     */  
//  @Transactional(noRollbackFor={UserException.class, ProductException.class})  
    /** 
     * 超时和只读属性 
     * 超时：在指定时间内没有完成事务则回滚。可以减少资源占用。参数单位是秒 
     * 如果超时，则提示错误信息： 
     * org.springframework.transaction.TransactionTimedOutException: Transaction timed out 
     * 只读属性：指定事务是否为只读. 若事务只读数据则有利于数据库引擎优化事务。  
     * 因为该事务有修改数据的操作，若设置只读true，则提示错误信息 
     * nested exception is java.sql.SQLException: Connection is read-only. Queries leading to data modification are not allowed 
     * 对应的测试方法是 basicTransaction() 
     */  
//  @Transactional(timeout=5, readOnly=false)  
    public void purchase(String account, String sku) {  
        //1. 获取书的单价  
        float price = shopDao.getBookPriceBySku(sku);  
          
        //2. 更新数的库存  
        shopDao.updateBookStock(sku);  
          
        //3. 更新用户余额  
        shopDao.updateUserBalance(account, price);  
        // 测试超时用的  
        /*try { 
            Thread.sleep(6000); 
        } catch (InterruptedException e) { 
        }*/  
    }  
      
}  

批量消费事务类BatchPurchaseService

 
   [html]  
   view plaincopy
import java.util.List;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Service;  
import org.springframework.transaction.annotation.Transactional;  
  
@Service  
public class BatchPurchaseService {  
      
    @Autowired  
    private PurchaseService purchaseService;  
      
    // 批量采购书籍,事务里面有事务  
    @Transactional  
    public void batchPurchase(String username, List<String> skus) {  
        for (String sku : skus) {  
            purchaseService.purchase(username, sku);  
        }  
    }  
  
}  

事务测试类TransactionTest（主要的知识点说明）

 
   [java]  
   view plaincopy
import java.util.Arrays;  
import org.junit.Test;  
import org.springframework.context.ApplicationContext;  
import org.springframework.context.support.ClassPathXmlApplicationContext;  
  
public class TransactionTest {  
  
    private ApplicationContext ctx = null;  
    private PurchaseService purchaseService = null;  
    private BatchPurchaseService batchPurchaseService = null;  
      
    {  
        ctx = new ClassPathXmlApplicationContext("applicationContext.xml");  
        purchaseService = (PurchaseService) ctx.getBean("purchaseService");  
        batchPurchaseService = (BatchPurchaseService) ctx.getBean("batchPurchaseService");  
    }  
      
    /** 
     * 用户买一本书 
     * 基本用法-事务回滚 
     * 把@Transactional 注释。假设当前用户余额只有10元。单元测试后，用户余额没有变，spring的库存却减少了。赚了！！！ 
     * 把@Transactional 注释打开。假设当前用户余额只有10元。单元测试后，用户余额没有变，spring的库存也没有减少。这就是回滚。 
     * 回滚：按照业务逻辑，先更新库存，再更新余额。现在是库存更新成功了，但在余额逻辑抛出异常。最后数据库的值都没有变。也就是库存回滚了。 
     */  
    @Test  
    public void basicTransaction() {  
        System.out.println("^^^^^^^^^^^^^^^^^@Transactional 最基本的使用方法");  
        purchaseService.purchase("itdragon", "spring");  
    }  
      
    /** 
     * 用户买多本书 
     * 事务的传播性 -大事务中，有小事务，小事务的表现形式 
     * 用@Transactional, 当前用户余额50，是可以买一本书的。运行结束后，数据库中用户余额并没有减少，两本书的库存也都没有减少。 
     * 用@Transactional(propagation=Propagation.REQUIRED), 运行结果是一样的。 
     * 把REQUIRED 换成 REQUIRES_NEW 再运行 结果还是一样。。。。。 
     * 为什么呢？？？？ 因为我弄错了！！！！！ 
     * 既然是事务的传播性，那当然是一个事务传播给另一个事务。 
     * 需要新增一个事务类批量购买 batchPurchase事务， 包含了purchase事务。 
     * 把 REQUIRED 换成 REQUIRES_NEW 运行的结果是：用户余额减少了，第一本书的库存也减少了。 
     * REQUIRED：如果有事务在运行，当前的方法就在这个事务内运行。否则，就启动一个新的事务，并在自己的事务内运行。大事务回滚了，小事务跟着一起回滚。 
     * REQUIRES_NEW：当前的方法必须启动新事务，并在自己的事务内运行。如果有事务在运行，应该将它挂起。大事务虽然回滚了，但是小事务已经结束了。 
     */  
    @Test  
    public void propagationTransaction() {  
        System.out.println("^^^^^^^^^^^^^^^^^@Transactional(propagation) 事务的传播性");  
        batchPurchaseService.batchPurchase("itdragon", Arrays.asList("java", "spring"));  
    }  
      
    /** 
     * 测试异常不回滚，故意超买（不常用） 
     * 当前用户余额10元，买了一本价值40元的java书。运行结束后，余额没有少，java书的库存减少了（赚了！）。因为设置指定异常不回滚！ 
     * 指定异常回滚就不测了。 
     */  
    @Test  
    public void noRollbackForTransaction() {  
        System.out.println("^^^^^^^^^^^^^^^^^@Transactional(noRollbackFor) 设置回滚事务属性");  
        purchaseService.purchase("itdragon", "java");  
    }  
}  

业务处理接口以及接口实现类

 
   [java]  
   view plaincopy
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.jdbc.core.JdbcTemplate;  
import org.springframework.stereotype.Repository;  
  
@Repository("shopDao")  
public class ShopDaoImpl implements ShopDao {  
      
    @Autowired  
    private JdbcTemplate jdbcTemplate;  
  
    @Override  
    public float getBookPriceBySku(String sku) {  
        String sql = "SELECT price FROM product WHERE sku = ?";  
        /** 
         * 第二个参数要用封装数据类型，如果用float.class，会提示 Type mismatch affecting row number 0 and column type 'FLOAT':  
         * Value [40.0] is of type [java.lang.Float] and cannot be converted to required type [float] 错误 
         */  
        return jdbcTemplate.queryForObject(sql, Float.class, sku);  
    }  
  
    @Override  
    public void updateBookStock(String sku) {  
        // step1 防超卖，购买前先检查库存。若不够, 则抛出异常  
        String sql = "SELECT stock FROM product WHERE sku = ?";  
        int stock = jdbcTemplate.queryForObject(sql, Integer.class, sku);  
        System.out.println("^^^^^^^^^^^^^^^^^商品( " + sku + " )可用库存 : " + stock);  
        if(stock == 0){  
            throw new ProductException("库存不足!再看看其他产品吧！");  
        }  
        // step2 更新库存  
        jdbcTemplate.update("UPDATE product SET stock = stock -1 WHERE sku = ?", sku);  
    }  
  
    @Override  
    public void updateUserBalance(String account, float price) {  
        // step1 下单前验证余额是否足够, 若不足则抛出异常  
        String sql = "SELECT balance FROM user WHERE account = ?";  
        float balance = jdbcTemplate.queryForObject(sql, Float.class, account);  
        System.out.println("^^^^^^^^^^^^^^^^^您当前余额 : " + balance + ", 当前商品价格 : " + price);  
        if(balance < price){  
            throw new UserException("您的余额不足!不支持购买！");  
        }  
        // step2 更新用户余额  
        jdbcTemplate.update("UPDATE user SET balance = balance - ? WHERE account = ?", price, account);  
        // step3 查看用于余额  
        System.out.println("^^^^^^^^^^^^^^^^^您当前余额 : " + jdbcTemplate.queryForObject(sql, Float.class, account));  
    }  
  
}  

最后两个自定义的异常类

 
   [html]  
   view plaincopy
public class UserException extends RuntimeException{  
  
    private static final long serialVersionUID = 1L;  
  
    public UserException() {  
        super();  
    }  
  
    public UserException(String message) {  
        super(message);  
    }  
  
}  

 
   [java]  
   view plaincopy
public class ProductException extends RuntimeException{  
  
    private static final long serialVersionUID = 1L;  
  
    public ProductException() {  
        super();  
    }  
  
    public ProductException(String message) {  
        super(message);  
    }  
  
}  

当用户余额10元不够买售价为50的书，书的库存充足的情况。测试basicTransaction()方法打印的结果：用户余额不减少，库存也不减少

当用户余额50元准备购买两本总价为90的书，但余额只够买一本书，书的库存充足的情况，测试propagationTransaction()方法打印的结果：若用 REQUIRES_NEW则两本中可以买一本；若用REQUIRED则一本都买不了。（事务的传播性有7种，这里主要介绍常用的REQUIRED和REQUIRES_NEW）

当用户余额10元不够买售价40元的书，书的库存充足的情况。测试noRollbackForTransaction()方法打印的结果：用户余额没有减少，但商品库存减少了，说明事务没有回滚。

细细品味后，其实也很简单。事务就是为了保证数据的一致性。出了问题就把之前修改过的数据回滚。

基于xml的事务管理

如果你理解了基于注解的事务管理，那基于xml的事务管理就简单多了。由于篇幅已经太长了，这里我长话短说。

首先把上面的java类中的所有IOC注解，@Transactional注解和@Autowired去掉。被@Autowired修饰的属性，还需要另外生成setter方法。

然后配置applicationContext.xml文件。将启动事务注解的代码删掉。将之前用自动扫描包的IOC注解和@Autowired注解的代码都配置bean（IOC知识），然后配置事务属性，最后配置事务切入点（AOP知识），这是系列博客，不懂的可以看前面几章。

 
   [html]  
   view plaincopy
<?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:context="http://www.springframework.org/schema/context"  
    xmlns:tx="http://www.springframework.org/schema/tx"  
    xmlns:aop="http://www.springframework.org/schema/aop"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd  
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd  
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">  
          
    <!-- 导入资源文件 -->  
    <context:property-placeholder location="classpath:db.properties"/>  
      
    <!-- 配置 C3P0 数据源 -->  
    <bean id="dataSource"  
        class="com.mchange.v2.c3p0.ComboPooledDataSource">  
        <property name="user" value="${jdbc.user}"></property>  
        <property name="password" value="${jdbc.password}"></property>  
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>  
        <property name="driverClass" value="${jdbc.driverClass}"></property>  
  
        <property name="initialPoolSize" value="${jdbc.initPoolSize}"></property>  
        <property name="maxPoolSize" value="${jdbc.maxPoolSize}"></property>  
    </bean>  
      
    <!-- 配置 Spirng 的 JdbcTemplate -->  
    <bean id="jdbcTemplate"   
        class="org.springframework.jdbc.core.JdbcTemplate">  
        <property name="dataSource" ref="dataSource"></property>  
    </bean>  
      
    <!-- 配置 NamedParameterJdbcTemplate, 该对象可以使用具名参数, 其没有无参数的构造器, 所以必须为其构造器指定参数 -->  
    <bean id="namedParameterJdbcTemplate"  
        class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">  
        <constructor-arg ref="dataSource"></constructor-arg>      
    </bean>  
      
    <bean id="shopDao" class="com.itdragon.spring.my.transactionxml.ShopDaoImpl">  
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>  
    </bean>  
    <bean id="purchaseService" class="com.itdragon.spring.my.transactionxml.PurchaseService">  
        <property name="shopDao" ref="shopDao"></property>  
    </bean>  
    <bean id="batchPurchaseService" class="com.itdragon.spring.my.transactionxml.BatchPurchaseService">  
        <property name="purchaseService" ref="purchaseService"></property>  
    </bean>  
      
    <!-- 配置事务管理器 -->  
    <bean id="transactionManager"   
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
        <property name="dataSource" ref="dataSource"></property>  
    </bean>  
      
    <!-- 配置事务属性 -->  
    <tx:advice id="txAdvice" transaction-manager="transactionManager">  
        <tx:attributes>  
            <!-- 根据方法名指定事务的属性 -->  
            <tx:method name="purchase"   
                propagation="REQUIRES_NEW"   
                timeout="3"   
                read-only="false"/>  
            <tx:method name="batchPurchase"/>  
        </tx:attributes>  
    </tx:advice>  
      
    <!-- 配置事务切入点 -->  
    <aop:config>  
        <aop:pointcut expression="execution(* com.itdragon.spring.my.transactionxml.PurchaseService.purchase(..))"   
            id="pointCut"/>  
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointCut"/>  
    </aop:config>  
    <aop:config>  
        <aop:pointcut expression="execution(* com.itdragon.spring.my.transactionxml.BatchPurchaseService.batchPurchase(..))"   
            id="batchPointCut"/>  
        <aop:advisor advice-ref="txAdvice" pointcut-ref="batchPointCut"/>  
    </aop:config>  
</beans>  