day16-声明式事务-02

声明式事务-02

3.事务的传播机制

事务的传播机制说明：

1. 当有多个事务处理并存时，如何控制？

2. 比如用户去购买两次商品（使用不同的方法），每个方法都是一个事务，那么如何控制呢？

   

   也就是说，某个方法本身是一个事务，然后该方法中又调用了其他一些方法，这些方法也是被@Transactional 修饰的，同样是事务。

3. 问题在于：里层方法的事务是被外层方法事务管理？还是它本身作为一个独立的事务呢？这就涉及到事务的传播机制问题。

3.1事务传播机制种类

• 事务传播的属性 / 种类：

传播属性	说明
REQUIRED	（默认）如果有事务在运行，当前的方法就在这个事务内运行，否则，就启动一个新的事务，并且在自己的事务内运行
REQUIRES_NEW	当前的方法必须启动新事务，并在它自己的事务内运行，如果有事务正在运行，应该将它挂起
SUPPORTS	如果有事务在运行，当前的方法就在这个事务内运行，否则它可以不运行在事务中
NOT_SUPPORTED	当前的方法不应该运行在事务中，如果有运行的事务，将它挂起
MANDATORY	当前的方法必须运行在事务内部，如果没有正在运行的事务，就抛出异常
NEVER	当前的方法不应该运行在事务中，如果有运行的事务，就抛出异常
NESTED	如果有事务在运行，当前的方法就应该在这个事务的嵌套事务内运行，否则，就启动一个新的事务，并在它自己的事务内运行

常用的只有前面两种：（1）REQUIRED，（2）REQUIRES_NEWREQUIRES_NEW

---

• 事务传播的属性/种类机制分析

重点分析 REQUIRED 和 REQUIRES_NEW 两种事务传播属性，其他知道即可。

如下，有一个multiTxTest()方法，该方法中又有f1()，f2() 方法。所有方法都分别开启了声明式事务。

@Transactional
public void multiTxTest() {
    f1(); //含事务

    f2(); //含事务
}

1. 如果f1()，f2() 的传播属性都是 REQUIRED，那么它们实际上是被Tx()的事务统一管理的。所有方法是一个整体，只要有一个方法的事务错误，那么两个方法都不会执行成功。

   

2. 如果f1()，f2() 的传播属性都是 REQUIRES_NEW，那么f1()，f2()实际上是独立的事务，不会受到Tx()事务的影响。如果f1()错误，不会影响到f2()，反之亦然。

   

3.2应用实例

需求说明：

1. 用户要去购买两次商品（使用不同的方法），每个方法都是一个事务，那么如何控制呢？
2. 看一个具体的案例（用 required 和 requires_new 测试）

代码实现

1.GoodsDao.java

分别有6个方法：queryPriceById，queryPriceById2，updateBalance，updateBalance2，updateAmount，updateAmount2。

package com.li.tx.dao;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import javax.annotation.Resource;

/**
 * @author 李
 * @version 1.0
 */
@Repository //将GoodsDao对象 注入到 spring 容器
public class GoodsDao {
    @Resource
    private JdbcTemplate jdbcTemplate;

    /**
     * 根据商品id，查询对应的商品价格
     * @param id
     * @return
     */
    public Float queryPriceById(Integer id) {
        String sql = "select price from goods where goods_id = ?";
        Float price = jdbcTemplate.queryForObject(sql, Float.class, id);
        return price;
    }

    /**
     * 修改用户余额 [减少用户余额]
     * @param user_id
     * @param money
     */
    public void updateBalance(Integer user_id, Float money) {
        String sql = "update user_account set money=money-? where user_id=? ";
        jdbcTemplate.update(sql, money, user_id);
    }

    /**
     * 修改商品库存量
     * @param goods_id
     * @param amount
     */
    public void updateAmount(Integer goods_id, int amount) {
        String sql = "update goods_amount set goods_num=goods_num-? where goods_id=? ";
        jdbcTemplate.update(sql, amount, goods_id);
    }

    //和queryPriceById的操作是一样的
    public Float queryPriceById2(Integer id) {
        String sql = "select price from goods where goods_id = ?";
        Float price = jdbcTemplate.queryForObject(sql, Float.class, id);
        return price;
    }

    //和updateBalance的操作是一样的
    public void updateBalance2(Integer user_id, Float money) {
        String sql = "update user_account set money=money-? where user_id=? ";
        jdbcTemplate.update(sql, money, user_id);
    }

    //和updateAmount的操作是一样的
    public void updateAmount2(Integer goods_id, int amount) {
        String sql = "update goods_amount set goods_num=goods_num-? where goods_id=? ";
        jdbcTemplate.update(sql, amount, goods_id);
    }
}

2.GoodsService.java，分别有两个方法buyGoodsByTx，buyGoodsByTx02

package com.li.tx.service;

import com.li.tx.dao.GoodsDao;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.beans.Transient;

/**
 * @author 李
 * @version 1.0
 */
@Service //将GoodsService对象注入到容器中
public class GoodsService {
    @Resource
    private GoodsDao goodsDao;

    /**
     * 进行商品购买的方法
     * @param userId
     * @param goodsId
     * @param amount
     */
    @Transactional
    public void buyGoodsByTx(int userId, int goodsId, int amount) {
        //输出购买的相关信息
        System.out.println("用户购买信息 userId=" + userId
                + " goodsId=" + goodsId + " 购买数量=" + amount);

        //1.得到商品价格
        Float price = goodsDao.queryPriceById(goodsId);
        //2.减少用户余额
        goodsDao.updateBalance(userId, price * amount);
        //3.减少商品库存量
        goodsDao.updateAmount(goodsId, amount);

        System.out.println("用户购买成功...");
    }

    /**
     * 进行商品购买的方法02，调用的是GoodsDao的2后缀的方法
     * @param userId
     * @param goodsId
     * @param amount
     */
    @Transactional
    public void buyGoodsByTx02(int userId, int goodsId, int amount) {
        //输出购买的相关信息
        System.out.println("用户购买信息 userId=" + userId
                + " goodsId=" + goodsId + " 购买数量=" + amount);

        //1.得到商品价格
        Float price = goodsDao.queryPriceById2(goodsId);
        //2.减少用户余额
        goodsDao.updateBalance2(userId, price * amount);
        //3.减少商品库存量
        goodsDao.updateAmount2(goodsId, amount);

        System.out.println("用户购买成功...");
    }
}

3.MultiplyService.java

package com.li.tx.service;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;

/**
 * @author 李
 * @version 1.0
 */
@Service
public class MultiplyService {
    @Resource
    private GoodsService goodsService;

    /**
     * 说明
     * 1.multiBuyGoodsByTx() 方法中，有两次购商品的操作
     * 2.buyGoodsByTx 和 buyGoodsByTx02 都是声明式事务
     * 3.并且buyGoodsByTx 和 buyGoodsByTx02使用的传播属性为默认的 REQUIRED，
     * 即会当做一个整体事务来处理
     */
    @Transactional
    public void multiBuyGoodsByTx() {
        goodsService.buyGoodsByTx(1, 1, 1);
        goodsService.buyGoodsByTx02(1, 1, 1);
    }
}

4.测试

//测试事务的传播机制
@Test
public void multiBuyGoodsByTx(){
    ApplicationContext ioc =
            new ClassPathXmlApplicationContext("tx.xml");
    MultiplyService multiplyService = ioc.getBean(MultiplyService.class);

    multiplyService.multiBuyGoodsByTx();
}

测试结果：购买成功

测试前数据：

表结构详见上一篇

测试后数据：

5.在GoodsDao的updateAmount2()方法中添加错误字符，使其不能成功执行：

因为 buyGoodsByTx() 和buyGoodsByTx02() 的事务传播属性都是required，且都在multiBuyGoodsByTx()方法内部，因此它们被视为一个整体。当 buyGoodsByTx02() 执行出现错误，两个方法将会一起回滚。

执行4.的测试代码，测试结果：出现异常。

测试后数据：

仍然是之前的数据，说明两个方法一起进行了事务回滚。

6.将GoodsService 的 buyGoodsByTx() / buyGoodsByTx02() 方法的事务传播属性改为REQUIRES_NEW。

这时两个方法的事务是独立的，buyGoodsByTx02() 失败不会造成 buyGoodsByTx() 的回滚。

7.再执行4.测试方法，结果如下：仍然出现异常

但是只有 buyGoodsByTx() 方法操作改变了数据。

测试前数据：

测试后数据：

说明只有 buyGoodsByTx02() 方法进行了回滚。

4.事务的隔离机制

4.1事务隔离级别说明

MySQL 隔离级别定义了事务与事务之间的隔离程度

MySQL隔离级别（4种）	脏读	不可重复读	幻读	加锁读
读未提交（Read uncommitted）	v	v	v	不加锁
读已提交（Read committed）	x	v	v	不加锁
可重复读（Repeatable read）	x	x	x	不加锁
可串行化（Serializable）	x	x	x	加锁

关于可重复读会不会发生幻读问题：

SQL92标准有，mysql数据库改进了，解决了这个级别的幻读问题。

• 事务隔离级别说明

1. Spring声明式事务的默认隔离级别，就是 mysql 数据库默认的隔离级别，一般为 REPREATABLE_READ

   查看源码可知：Use the default isolation level of the underlying datastore. All other levels correspond to the JDBC isolation levels.

2. 查看数据库的隔离级别 SELECT @@global.tx_isolation

4.2事务隔离级别的设置和测试

整体思路如下：

在开启了声明式事务的某方法中，查询两次数据。在第一次查询后，先在控制台中修改该数据（在终端中默认为自动提交），方法再进行第二次的查询。查看两次查询的数据是否相同。通过这样的方法来模拟两个客户端，测试声明式事务的隔离级别。

---

1.修改GoodsService.java，先测试默认隔离级别，增加方法 buyGoodsByTxISOLATION()

/**
 * 在默认下，声明式事务使用的隔离界别为 可重复读-Repeatable read
 */
@Transactional
public void buyGoodsByTxISOLATION() {
    //查询两次商品的价格
    Float price = goodsDao.queryPriceById(1);
    System.out.println("第一次查询的价格=" + price);

    Float price2 = goodsDao.queryPriceById(1);
    System.out.println("第二次查询的价格=" + price2);

}

并在方法如下位置打上断点

2.测试方法

//测试声明式事务的隔离级别
@Test
public void buyGoodsByTxISOLATIONTest() {
    ApplicationContext ioc =
            new ClassPathXmlApplicationContext("tx.xml");
    GoodsService goodsService = ioc.getBean(GoodsService.class);

    goodsService.buyGoodsByTxISOLATION();
}

3.点击debug，当光标跳转到断点时，可以看到第一次查询的 price=10

4.这时我们在控制台修改该数据为 15

5.然后点击Step Over，发现第二次查询的价格仍然为 10

这说明Spring的声明是事务的默认隔离级别为 可重复读。

6.将方法buyGoodsByTxISOLATION() 的事务隔离级别改为 读已提交

读已提交表示只要是提交的数据，在当前事务中都可以读取到最新数据

同时和之前一样打上断点。

7.测试方法不变，点击debug，光标跳转到断点时，可以看到第一次查询时 price=15

8.此时在控制台将该数据改为 20

9.点击Step Over，可以看到第二次查询的数据已经变成了 20

说明当前事务的隔离级别为 读已提交。

4.3事务的超时回滚

• 基本介绍

1. 如果一个事务执行的时间超过某个时间限制，就让该事务回滚。
2. 可以通过设置事务超时回滚来实现

• 基本语法

例子：超时回滚代码实现

1.GoodsService 中增加方法 buyGoodsByTxTimeout()，并设置事务超时时间为2s。为了模拟超时效果，在方法中休眠4s。

/**
 * 1.timeout = 2，表示该方法如果执行时间超过了两秒，就进行回滚
 * 2.如果没有设置 timeout，则默认该值为 -1，表示使用默认超时时间，
 *  一般为连接的数据库的默认超时时间
 */
@Transactional(timeout = 2)
public void buyGoodsByTxTimeout(int userId, int goodsId, int amount){
    //输出购买的相关信息
    System.out.println("用户购买信息 userId=" + userId
            + " goodsId=" + goodsId + " 购买数量=" + amount);
    //1.得到商品价格
    Float price = goodsDao.queryPriceById2(goodsId);
    //2.减少用户余额
    goodsDao.updateBalance2(userId, price * amount);
    //模拟超时
    System.out.println("==========超时开始4s=========");
    try {
        Thread.sleep(4000);//休眠4s
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("==========超时结束4s=========");

    //3.减少商品库存量
    goodsDao.updateAmount2(goodsId, amount);
    System.out.println("用户购买成功...");
}

2.测试方法

//测试超时 timeout 属性
@Test
public void buyGoodsByTxTimeoutTest() {
    ApplicationContext ioc =
            new ClassPathXmlApplicationContext("tx.xml");
    GoodsService goodsService = ioc.getBean(GoodsService.class);
    goodsService.buyGoodsByTxTimeout(1, 1, 1);
}

测试结果：出现异常，显示事务超时。

测试前数据：

测试后数据：

数据没有进行改变，说明事务超时，并进行了回滚。

5.练习

要求：模拟一个用户，进行银行转账，购买淘宝商品的业务。数据表，dao层，service层自己设置，要求保证数据一致性。

1. seller [卖家表]
2. buyer [买家表]
3. goods [商品表[有库存量属性]]
4. taoBao [taoBao表，提取入账成交额的 10%]
5. 要求简单实现，使用声明式事务完成
6. 要求创建新的spring容器文件 shopping_ioc.xml，完成测试

实现

1.创建表格，并插入初始数据

-- buyer表
CREATE TABLE `buyer`(
buyer_id INT UNSIGNED PRIMARY KEY AUTO_INCREMENT,
buyer_name VARCHAR(32) NOT NULL DEFAULT '',
buyer_money DOUBLE NOT NULL DEFAULT 0.0
)CHARSET=utf8;

INSERT INTO `buyer` VALUES(NULL,'张三', 1000);
INSERT INTO `buyer` VALUES(NULL,'李四', 2000);

-- seller表
CREATE TABLE `seller`(
seller_id INT UNSIGNED PRIMARY KEY AUTO_INCREMENT,
seller_name VARCHAR(32) NOT NULL DEFAULT '',
seller_money DOUBLE NOT NULL DEFAULT 0.0
)CHARSET=utf8 ;

INSERT INTO `seller` VALUES(NULL,'卖家1', 0);
INSERT INTO `seller` VALUES(NULL,'卖家2', 0);

-- goods表
CREATE TABLE `goods`(
goods_id INT UNSIGNED PRIMARY KEY AUTO_INCREMENT,
goods_name VARCHAR(32) NOT NULL DEFAULT '',
price DOUBLE NOT NULL DEFAULT 0.0,
seller_id INT UNSIGNED,
goods_num INT UNSIGNED DEFAULT 0
)CHARSET=utf8 ;

INSERT INTO `goods` VALUES(NULL,'小风扇', 10.00, 1, 100);
INSERT INTO `goods` VALUES(NULL,'小台灯', 12.00, 1, 100);
INSERT INTO `goods` VALUES(NULL,'可口可乐', 3.00, 2, 100);

-- taoBao表
CREATE TABLE `taoBao`(
taoBao_money DOUBLE NOT NULL DEFAULT 0.0
)CHARSET=utf8 ;

INSERT INTO `taoBao` VALUES(0);

2.ShopDao

package com.li.tx.hw.dao;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import javax.annotation.Resource;

/**
 * @author 李
 * @version 1.0
 */
@Repository
public class ShopDao {
    @Resource
    private JdbcTemplate jdbcTemplate;

    //通过商品id，查询商品价格
    public Double queryGoodsPrice(int goodsId) {
        String sql = "SELECT price FROM goods WHERE goods_id=?";
        return jdbcTemplate.queryForObject(sql, Double.class, goodsId);
    }

    //通过商品id，查询商品所属的卖家id
    public Integer queryGoodsOwner(int goodsId) {
        String sql = "SELECT seller_id FROM goods WHERE goods_id=?";
        return jdbcTemplate.queryForObject(sql, Integer.class, goodsId);
    }

    //通过商品id，修改商品库存量
    public void updateGoodsNum(int goodsId, int shopNum) {
        String sql = "UPDATE goods SET goods_num=goods_num-? WHERE goods_id=?";
        jdbcTemplate.update(sql, shopNum, goodsId);
    }

    //通过买家id，修改买家余额
    public void updateBuyerMoney(Integer buyerId, Double money) {
        String sql = "UPDATE buyer SET buyer_money=buyer_money-? WHERE buyer_id=?";
        jdbcTemplate.update(sql, money, buyerId);
    }

    //通过卖家id，修改卖家余额
    public void updateSellerMoney(Integer sellerId, Double money) {
        String sql = "UPDATE seller SET seller_money=seller_money+? WHERE seller_id=?";
        jdbcTemplate.update(sql, money, sellerId);
    }

    //修改 taoBao余额
    public void updateTaobaoMoney(Double money) {
        String sql = "UPDATE taoBao SET taoBao_money=taoBao_money+?";
        jdbcTemplate.update(sql, money);
    }
}

3.ShopService

package com.li.tx.hw.service;

import com.li.tx.hw.dao.ShopDao;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;

/**
 * @author 李
 * @version 1.0
 */
@Service
public class ShopService {
    @Resource
    private ShopDao shopDao;

    @Transactional
    public void shopping(int buyerId, int goodsId, int goodsNum) {
        System.out.println("用户购买信息 buyerId=" + buyerId
                + " goodsId=" + goodsId + " 购买数量=" + goodsNum);

        //查询商品价格
        Double goodsPrice = shopDao.queryGoodsPrice(goodsId);
        System.out.println("商品价格=" + goodsPrice);

        //查询商品卖家
        Integer sellerId = shopDao.queryGoodsOwner(goodsId);
        System.out.println("商品所属卖家=" + sellerId);

        //减少商品库存量
        shopDao.updateGoodsNum(goodsId, goodsNum);
        System.out.println("商品库存-" + goodsNum);

        //修改买家余额
        shopDao.updateBuyerMoney(buyerId, goodsPrice * goodsNum);
        System.out.println("买家余额-" + goodsPrice * goodsNum);

        //将成交额的 90% 转入卖家余额
        shopDao.updateSellerMoney(sellerId, goodsPrice * goodsNum * 0.9);
        System.out.println("卖家余额+" + goodsPrice * goodsNum * 0.9);

        //将成交额的 10% 转入taoBao余额
        shopDao.updateTaobaoMoney(goodsPrice * goodsNum * 0.1);
        System.out.println("taoBao余额+" + goodsPrice * goodsNum * 0.1);

        System.out.println("购买成功...");
    }
}

4.配置容器文件

<!--配置要扫描的包-->
<context:component-scan base-package="com.li.tx.hw"/>

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

<!--配置数据源对象-->
<bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSources">
    <property name="user" value="${jdbc.user}"/>
    <property name="password" value="${jdbc.pwd}"/>
    <property name="driverClass" value="${jdbc.driver}"/>
    <property name="jdbcUrl" value="${jdbc.url}"/>
</bean>

<bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate">
    <property name="dataSource" ref="dataSources"/>
</bean>

<!--配置事务管理器对象
    1.DataSourceTransactionManager 这个对象是进行事务管理的
    2.一定要配置数据源属性，即指定该事务管理器 是对哪个数据源进行事务控制
-->
<bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
      id="dataSourceTransactionManager">
    <property name="dataSource" ref="dataSources"/>
</bean>

<!--配置：启用基于注解的声明式事务管理功能-->
<tx:annotation-driven transaction-manager="dataSourceTransactionManager"/>

5.jdbc.properties

jdbc.user=root
jdbc.pwd=123456
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring

6.测试

@Test
public void shoppingTest() {
    ApplicationContext ioc =
            new ClassPathXmlApplicationContext("shopping_ioc.xml");
    ShopService shopService = ioc.getBean(ShopService.class);
    shopService.shopping(1, 1, 10);
}

测试结果：

测试后的数据：

7.测试数据一致性：

修改sql，使其无法执行：

测试结果：出现异常。

查看数据库表，数据没有改变。说明事务进行了回滚。