Spring中的事务管理

Spring在不同的事务管理API之上定义了一个抽象层，我们不必了解底层的事务管理API（即不用管是使用JDBC、Hibernate还是Mybatis），就可以使用Spring的事务管理机制。

Spring的事务管理有两种方式：

• 编程式事务管理
  将事务管理代码嵌入到业务方法中来控制事务的提交和回滚。在编程式管理事务时，必须在每个事务操作中包含额外的事务管理代码。
• 声明式事务管理
  大多数情况下比编程式事务管理更好用，它将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理，事务管理作为一种横切关注点，可以通过AOP方法模块化。Spring通过Spring AOP框架支持声明式事务管理。

Spring的核心事务管理抽象是TransactionManager，管理封装了一组独立于技术的方法，无论使用Spring的哪种事务管理策略（编程式或声明式），事务管理器都是必须的。

Spring中的声明式事务

步骤：

• 在配置文件中配置事务管理器且启用事务注解。

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

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

• 在需要使用声明式事务的方法中使用@Transactional进行注解。

例如：

//添加事务注解。
@Transactional
public void purchase(...) {
   ....
}

事务传播属性

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

事务的传播行为可以由传播属性指定，Spring定义了7种类传播行为，我们在此讲解两种比较常用的。

• REQUIRED
  如果有事务在运行，当前的方法就在这个事务内运行；否则就启动一个新事务，并在自己的事务内运行。
• REQUIRES_NEW
  当前的方法必须启动新事务，并在它自己的事务内运行；如果有事务正在运行，则应该将它挂起。

我们通过下面的例子来讲解这两种事务传播行为的区别：

假设我们现在有一个事务方法purchase()，该方法是买一本书。然后我们还有一个事务方法checkout()，该方法为结账，即调用n次的purchase()。此时即是事务套事务，假设我们现在用户的余额为130，然后要买两本价格为100和70的书籍（买一本书籍对应于一个purchase()），然后使用默认的

我们现在有如下表：

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for account
-- ----------------------------
DROP TABLE IF EXISTS `account`;
CREATE TABLE `account`  (
  `username` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `balance` int(255) NULL DEFAULT NULL,
  PRIMARY KEY (`username`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Table structure for book
-- ----------------------------
DROP TABLE IF EXISTS `book`;
CREATE TABLE `book`  (
  `isbn` varchar(11) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `book_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `price` int(10) NULL DEFAULT NULL,
  PRIMARY KEY (`isbn`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Table structure for book_stock
-- ----------------------------
DROP TABLE IF EXISTS `book_stock`;
CREATE TABLE `book_stock`  (
  `isbn` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `stock` int(255) NULL DEFAULT NULL,
  PRIMARY KEY (`isbn`) USING BTREE,
  CONSTRAINT `isbn_id` FOREIGN KEY (`isbn`) REFERENCES `book` (`isbn`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;


SET FOREIGN_KEY_CHECKS = 1;

其中account表是用户表，username表示用户名，account表示余额。
其中book表是书表，isbn表示书籍编号，book_name表示书名，price表示书的价格。
其中book_stock表是书的库存表，isbn表示书籍编号，stock表示书的库存。

然后我们现在有一个图书Dao接口BookShopDao：

package com.spring.tx;

public interface BookShopDao {

    //根据书号获取书的单价
    public int findBookPriceByIsbn(String isbn);

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

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

其实现类BookShopDaoImpl如下：

package com.spring.tx;

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

@Repository("bookShopDao")
public class BookShopDaoImpl implements BookShopDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;


    @Override
    public int findBookPriceByIsbn(String isbn) {
        String sql = "select price from book where isbn = ?";
        return jdbcTemplate.queryForObject(sql,Integer.class,isbn);
    }

    @Override
    public void updateBookStock(String isbn) {
        //检查书的库存是否足够
        String sql2 = "select stock from book_stock where isbn = ?";
        int stock = jdbcTemplate.queryForObject(sql2,Integer.class,isbn);
        if (stock == 0){
            throw new BookStockException("库存不足");
        }

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

    @Override
    public void updateUserAccount(String username, int price) {
        //检查钱是否足够
        String sql2 = "select balance from account where username = ?";
        int balance = jdbcTemplate.queryForObject(sql2,Integer.class,username);
        if (balance < price){
            throw new UserAccountException("余额不足");
        }

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

还有一个BookShopService接口，其只有一个方法就是买书：

package com.spring.tx;

public interface BookShopService {
    public void purchase(String username,String isbn);
}

其实现类BookShopServiceImpl如下：

package com.spring.tx;

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

@Service("BookShopService")
public class BookShopServiceImpl implements BookShopService {

    @Autowired
    private BookShopDao bookShopDao;

    //添加事务注解。
    @Transactional
    @Override
    public void purchase(String username, String isbn) {
        //1.获取书的单价
        int price = bookShopDao.findBookPriceByIsbn(isbn);
        //2.更新书的库存
        bookShopDao.updateBookStock(isbn);
        //3.更新用户余额
        bookShopDao.updateUserAccount(username,price);
    }
}

我们还定义了一个付款接口Cashier

package com.spring.tx;

import java.util.List;

public interface Cashier {
    public void checkout(String username, List<String> isbns);

}

其实现类：

package com.spring.tx;

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

import java.util.List;

@Service("cashier")
public class CashierImpl implements Cashier {

    @Autowired
    private BookShopService bookShopService;

    @Transactional
    @Override
    public void checkout(String username, List < String > isbns) {
        for (String isbn : isbns){
            //checkout本身是一个事务方法，再去调用purchase这个事务方法
            bookShopService.purchase(username,isbn);
        }
    }
}

此时我们将BookShopServiceImpl中的purchase()定义为一个事务方法，而我们在CashierImpl中的部分代码片段如下：

 @Transactional
    @Override
    public void checkout(String username, List < String > isbns) {
        for (String isbn : isbns){
            //checkout本身是一个事务方法，再去调用purchase这个事务方法
            bookShopService.purchase(username,isbn);
        }
    }

即是说我们在一个事务方法(checkout())中再调用了一个事务方法(purchase())。
我们在测试类中：

package com.spring.tx;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.transaction.annotation.Transactional;

import java.util.Arrays;

import static org.junit.Assert.*;

public class BookMainTest {

    private ApplicationContext ctx = null;
    private BookShopDao bookShopDao = null;
    private BookShopService bookShopService = null;
    private Cashier cashier = null;

    {
        ctx = new ClassPathXmlApplicationContext("applicationContext-jdbc.xml");
        bookShopDao = ctx.getBean(BookShopDao.class);
        bookShopService = ctx.getBean(BookShopService.class);
        cashier = ctx.getBean(Cashier.class);
    }

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

}

该段代码的意思此时如果账户余额为130，然后我们买的两本书的价格分别为100和70。此时会发现购买这两本书（调用两次purchase()）都买不成功。
因为我们此时的事务传播属性默认是REQUIRED，即此时的事务可描述为如下图所示：

当purchase()被另一个事务方法checkout()调用时，它默认会在现有的事务内运行，因此checkout()的开始和结束内都只有一个事务，这个事务只有在checkout()方法结束的时候才会被提交，因为第二个purchase()完成不了，因此checkout()事务无法成功完成，事务回滚，第一个purchase()的操作也会被回滚。

如果将purchase()事务方法的传播属性改为REQUIRES_NEW，即：

 //使用propagation指定事务的传播行为，即当前的事务方法被另外一个事务方法调用时，如何使用事务，默认取值为：REQUIRED，即使用调用方法的事务
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    @Override
    public void purchase(String username, String isbn) {
        //1.获取书的单价
        int price = bookShopDao.findBookPriceByIsbn(isbn);
        //2.更新书的库存
        bookShopDao.updateBookStock(isbn);
        //3.更新用户余额
        bookShopDao.updateUserAccount(username,price);
    }

则事务会变成如下所示：

对于每一个事务方法都必须启动一个新事务，并且每个事务方法都在自己的事务内运行，如果有事务在运行，就应该先挂起它。现在我们的程序流程为：

• 先运行checkout()，然后调用了第一次purchase()，则checkout()事务挂起，然后第一个purchase()事务开启，并且运行，然后该事务结束了，则checkout()事务继续执行。
• 然后调用了第二次purchase()，则checkout()事务挂起，然后第二个purchase()事务执行失败，结束。则checkout()事务继续执行。
• checkout()事务执行结束。

因此虽然第二次purchase()执行失败，但是第一次purchase()会成功。

事务的其他属性

可以在@Transactional注解中加入其他的属性，具体属性可自行上网查询。

基于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"
       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/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tool http://www.springframework.org/schema/tool/spring-tool.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">


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

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

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

    <bean id="bookShopDao" class="com.spring.tx.xml.tx.service.impl.BookShopDaoImpl">
        <property name="jdbcTemplate" ref="jdbcTemplate"/>
    </bean>

    <bean id="bookShopService" class="com.spring.tx.xml.tx.service.impl.BookShopServiceImpl">
        <property name="bookShopDao" ref="bookShopDao"/>
    </bean>

    <bean id="cashier" class="com.spring.tx.xml.tx.CashierImpl">
        <property name="bookShopService" ref="bookShopService"/>
    </bean>

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

    <!-- 第二步：配置事务属性 -->
    <tx:advice id="txAdvice" transaction-manager="dataSourceTransactionManager">
        <tx:attributes>
            <!-- 根据方法名指定事务的属性-->
            <tx:method name="purchase" propagation="REQUIRES_NEW" />
            
        </tx:attributes>
    </tx:advice>

    <!-- 第三步：配置事务切点，以及把事务切入点和事务属性关联起来 -->
    <aop:config>
        <aop:pointcut id="txPointCut" expression="execution(* com.spring.tx.xml.tx.service.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
    </aop:config>

</beans>