Spring 学习（二十四）——事务的传播行为

事务传播属性

•当事务方法被另一个事务方法调用时, 必须指定事务应该如何传播. 例如: 方法可能继续在现有事务中运行, 也可能开启一个新事务, 并在自己的事务中运行.

•事务的传播行为可以由传播属性指定. Spring 定义了 7 种类传播行为.

Spring 支持的事务传播行为

需求：

•新定义 Cashier 接口: 表示客户的结账操作

•修改数据表信息如下, 目的是用户 Tom 在结账时, 余额只能支付第一本书, 不够支付第二本书：

REQUIRED 传播行为

•当 bookService 的 purchase() 方法被另一个事务方法 checkout() 调用时, 它默认会在现有的事务内运行. 这个默认的传播行为就是 REQUIRED. 因此在 checkout() 方法的开始和终止边界内只有一个事务. 这个事务只在 checkout() 方法结束的时候被提交, 结果用户一本书都买不了

•事务传播属性可以在 @Transactional 注解的 propagation 属性中定义

REQUIRES_NEW 传播行为

•另一种常见的传播行为是 REQUIRES_NEW. 它表示该方法必须启动一个新事务, 并在自己的事务内运行. 如果有事务在运行, 就应该先挂起它.

在 Spring 2.x 事务通知中配置传播属性

•在 Spring 2.x 事务通知中, 可以像下面这样在 <tx:method> 元素中设定传播事务属性

代码示例：

1、数据库表的建立如下：

employee表

department表

2、目录结构

Spring
|——src
|——|——com.hzyc.spring.jdbc
|——|——|——employee.java
|——|——|——JdbcTest.java
|——|——application-context.xml
|——|——db.properties

2、db.properties

jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql:///spring
jdbc.user=root
jdbc.password=root

jdbc.initPoolSize=5
jdbc.maxPoolSize=10

3、application-context.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: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/context
	   http://www.springframework.org/schema/context/spring-context-4.0.xsd
	   http://www.springframework.org/schema/tx
	   http://www.springframework.org/schema/tx/spring-tx.xsd">

    <context:component-scan base-package="com.hzyc.spring"/>

    <!--导入资源文件-->
    <context:property-placeholder location="classpath:db.properties"/>

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

        <property name="initialPoolSize" value="${jdbc.initPoolSize}"/>
        <property name="maxPoolSize" value="${jdbc.maxPoolSize}"/>
    </bean>

    <!--配置 Spring 的 Jdbc Template-->
    <bean id="jdbcTemplate"
          class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--
        配置 NamedParameterJdbcTemplate, 该对象可以使用具名参数（具有名字）
        其没有无参的构造器，必须为其构造器指定参数
    -->
    <bean id="namedParameterJdbcTemplate"
          class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
        <constructor-arg ref="dataSource"/>
    </bean>

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

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

BookShopDao.java

package com.hzyc.spring.jdbc.transaction;

/**
 * @author xuehj2016
 * @Title: BookShopDao
 * @ProjectName Spring
 * @Description: TODO
 * @date 2018/12/21 20:32
 */
public interface BookShopDao {
    /**
     * 根据书号获取书的单价
     */
    public int getBookPriceById(String id);

    /**
     * 更新书的库存，使书号对应的库存 - 1
     */
    public void updateBookStock(String id);

    /**
     * 更新用户的账户余额 : 使 username 的 balance - price
     */
    public void updateUserAccount(String username, int price);
}

package com.hzyc.spring.jdbc.transaction;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

/**
 * @author xuehj2016
 * @Title: BookShopDaoImpl
 * @ProjectName Spring
 * @Description: TODO
 * @date 2018/12/21 20:39
 */
@Repository("bookShopDao")
public class BookShopDaoImpl implements BookShopDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    /**
     * 根据书号获取书的单价
     *
     * @param id
     */
    @Override
    public int getBookPriceById(String id) {
        String sql = "select price from book where id = ?";
        return jdbcTemplate.queryForObject(sql, Integer.class, id);
    }

    /**
     * 更新书的库存，使书号对应的库存 - 1
     *
     * @param id
     */
    @Override
    public void updateBookStock(String id) {
        //检查书的库存是否足够，若不够，则抛出异常
        String stockSql = "select stock from book_stock where id =?";
        int stock = jdbcTemplate.queryForObject(stockSql, Integer.class, id);
        if (stock == 0) {
            throw new BookStockException("库存不足！");
        }

        String sql = "update book_stock set stock = stock - 1 where id =?";
        jdbcTemplate.update(sql, id);
    }

    /**
     * 更新用户的账户余额 : 使 username 的 balance - price
     *
     * @param username
     * @param price
     */
    @Override
    public void updateUserAccount(String username, int price) {
        //因为 MySQL 不支持检查约束
        //验证用户的余额是否足够，若不够，则抛出异常
        String balanceSql = "select balance from account where username =?";
        int balance = jdbcTemplate.queryForObject(balanceSql, Integer.class, username);
        if (balance < price) {
            throw new UserAccountException("余额不足！");
        }

        String sql = "update account set balance = balance - ? where username =?";
        jdbcTemplate.update(sql, price, username);
    }
}

package com.hzyc.spring.jdbc.transaction;

/**
 * @author xuehj2016
 * @Title: BookShopService
 * @ProjectName Spring
 * @Description: TODO
 * @date 2018/12/21 21:22
 */
public interface BookShopService {

    public void purchase(String username, String id);

}

package com.hzyc.spring.jdbc.transaction;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

/**
 * @author xuehj2016
 * @Title: BookShopServiceImpl
 * @ProjectName Spring-3
 * @Description: TODO
 * @date 2018/12/21 21:24
 */
@Service("bookShopService")
public class BookShopServiceImpl implements BookShopService {

    @Autowired
    private BookShopDao bookShopDao;

    /**
     * 添加事务注解
     * 1.使用 propagation 指定事务的传播行为, 即当前的事务方法被另外一个事务方法调用时
     * 如何使用事务, 默认取值为 REQUIRED, 即使用调用方法的事务
     * REQUIRES_NEW: 事务自己的事务, 调用的事务方法的事务被挂起.
     *
     * @param username
     * @param id
     */
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    @Override
    public void purchase(String username, String id) {

        //1.获取书的单价
        int price = bookShopDao.getBookPriceById(id);

        //2.更新书的库存
        bookShopDao.updateBookStock(id);

        //3.更新用户余额
        bookShopDao.updateUserAccount(username, price);
    }
}

package com.hzyc.spring.jdbc.transaction;

/**
 * @author xuehj2016
 * @Title: BookStockException
 * @ProjectName Spring
 * @Description: TODO
 * @date 2018/12/21 21:10
 */
public class BookStockException extends RuntimeException {

    public BookStockException() {
    }

    public BookStockException(String message) {
        super(message);
    }

    public BookStockException(String message, Throwable cause) {
        super(message, cause);
    }

    public BookStockException(Throwable cause) {
        super(cause);
    }

    public BookStockException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

package com.hzyc.spring.jdbc.transaction;

import java.util.List;

/**
 * @author xuehj2016
 * @Title: Cashier
 * @ProjectName Spring-3
 * @Description: TODO
 * @date 2018/12/21 23:23
 */
public interface Cashier {

    public void checkout(String username, List<String> ids);
}

package com.hzyc.spring.jdbc.transaction;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * @author xuehj2016
 * @Title: CashierImpl
 * @ProjectName Spring-3
 * @Description: TODO
 * @date 2018/12/21 23:24
 */
@Service("cashier")
public class CashierImpl implements Cashier {

    @Autowired
    private BookShopService bookShopService;

    /**
     *
     * @param username
     * @param ids
     */
    @Transactional
    @Override
    public void checkout(String username, List<String> ids) {

        for (String id : ids) {
            bookShopService.purchase(username, id);
        }
    }
}

package com.hzyc.spring.jdbc.transaction;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.Arrays;

/**
 * @author xuehj2016
 * @Title: SpringTransactionTest
 * @ProjectName Spring
 * @Description: TODO
 * @date 2018/12/21 20:52
 */
public class SpringTransactionTest {
    private BookShopDao bookShopDao;
    private BookShopService bookShopService;
    private Cashier cashier;

    {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application-context.xml");
        bookShopDao = (BookShopDao) applicationContext.getBean("bookShopDao");
        bookShopService = (BookShopService) applicationContext.getBean("bookShopService");
        cashier = (Cashier) applicationContext.getBean("cashier");
    }

    @Test
    public void testBookShopGetBookPriceById() {
        System.out.println(bookShopDao.getBookPriceById("1001"));
    }

    @Test
    public void testBookShopUpdateBookStock() {
        bookShopDao.updateBookStock("1001");
    }

    @Test
    public void testBookShopUpdateUserAccount() {
        bookShopDao.updateUserAccount("xuehj", 50);
    }

    @Test
    public void testBookShopService() {
        bookShopService.purchase("xuehj", "1001");
    }

    @Test
    public void testTransactionalPropagation() {
        cashier.checkout("xuehj", Arrays.asList("1001", "1002"));
    }
}

package com.hzyc.spring.jdbc.transaction;

/**
 * @author xuehj2016
 * @Title: UserAccountException
 * @ProjectName Spring
 * @Description: TODO
 * @date 2018/12/21 21:16
 */
public class UserAccountException extends RuntimeException {

    public UserAccountException() {
    }

    public UserAccountException(String message) {
        super(message);
    }

    public UserAccountException(String message, Throwable cause) {
        super(message, cause);
    }

    public UserAccountException(Throwable cause) {
        super(cause);
    }

    public UserAccountException(String message, Throwable cause, boolean enableSuppression, boolean
            writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

Spring 学习（二十四）——事务的传播行为

猜你喜欢