一、事务概述：
- 事务就是一系列的动作, 它们被当做一个单独的工作单元. 这些动作要么全部完成, 要么全部不起作用；比如 用户购买图书；购买动作之前需要确认 ①图书的数量是否足够；②用户账号余额是否足够；如果①满足条件 那么 库存减-1 ；如果②满足条件 则账户余额- 书价 ；如果 ① 和②只要有一个不满足条件 则 图书库存回滚到之前的状态（此次操作之前的数量）且 用户余额回滚到原来的状态（此次操作之前的余额）；① 和②都满足条件 则 事务动作完成，事务就被提交.；
- 事务的四个关键属性(ACID)
- 原子性(atomicity): 事务是一个原子操作, 由一系列动作组成. 事务的原子性确保动作要么全部完成要么完全不起作用.
- 一致性(consistency): 一旦所有事务动作完成, 事务就被提交. 数据和资源就处于一种满足业务规则的一致性状态中.
- 隔离性(isolation): 可能有许多事务会同时处理相同的数据, 因此每个事物都应该与其他事务隔离开来, 防止数据损坏.
- 持久性(durability): 一旦事务完成, 无论发生什么系统错误, 它的结果都不应该受到影响. 通常情况下, 事务的结果被写到持久化存储器中.
- spring的事务管理
- 支持编程式事务管理：将事务管理代码 写入代码中；存在代码冗余；
- 支持声明式事务管理：将事务管理代码 从代码中分离，通过声明的方式来实现事务管理；应用更广泛更方便；
二、声明式事务注解配置
事务的配置以实例：
用户购买图书；购买动作之前需要确认 ①图书的数量是否足够；②用户账号余额是否足够；如果①满足条件 那么 库存减-1 ；如果②满足条件 则账户余额- 书价 ；如果 ① 和②只要有一个不满足条件 则 图书库存回滚到之前的状态（此次操作之前的数量）且 用户余额回滚到原来的状态（此次操作之前的余额）；① 和②都满足条件 则 事务动作完成，事务就被提交；
用户账户表表SQL：
1 CREATE TABLE `account` ( 2 `id` int(10) NOT NULL AUTO_INCREMENT, 3 `userName` varchar(20) NOT NULL, 4 `balance` varchar(20) NOT NULL, 5 PRIMARY KEY (`id`) 6 )
图书库存表bookstockSQL：
1 CREATE TABLE `bookstock` ( 2 `id` int(10) NOT NULL AUTO_INCREMENT, 3 `isbn` int(20) NOT NULL, 4 `stock` varchar(20) NOT NULL, 5 PRIMARY KEY (`id`) 6 )
图书表bookSQL:
1 CREATE TABLE `book` ( 2 `id` int(10) NOT NULL AUTO_INCREMENT, 3 `Isbn` int(20) NOT NULL, 4 `price` int(10) NOT NULL, 5 `bookName` varchar(20) CHARACTER SET utf8 NOT NULL, 6 PRIMARY KEY (`id`) 7 ) ;
1.配置事务管理器
1 <bean id="transactionManager" 2 class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 3 <property name="dataSource" ref="datasource">property> 4 bean>
2.启用事务注解
1 <tx:annotation-driven transaction-manager="transactionManager"/>
附上xml 文件 引入了context tx bean的命名空间：
1 xml version="1.0" encoding="UTF-8"?> 2 <beans xmlns="http://www.springframework.org/schema/beans" 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 4 xmlns:context="http://www.springframework.org/schema/context" 5 xmlns:tx="http://www.springframework.org/schema/tx" 6 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd 7 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd 8 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd"> 9 10 <context:component-scan base-package="lixiuming.spring.tx">context:component-scan> 11 12 <context:property-placeholder location="classpath:db.properties"/> 13 14 <bean id="datasource" class="com.mchange.v2.c3p0.ComboPooledDataSource" > 15 <property name="user" value="${jdbc.user}">property> 16 <property name="password" value="${jdbc.password}">property> 17 <property name="driverClass" value="${jdbc.driverClass}">property> 18 <property name="jdbcUrl" value="${jdbc.jdbcUrl}">property> 19 20 <property name="initialPoolSize" value="${jdbc.initPoolSize}">property> 21 <property name="maxPoolSize" value="${jdbc.maxPoolSize}">property> 22 <property name="maxStatements" value="${jdbc.maxStatements}">property> 23 bean> 24 25 26 <bean id="namedParameterJdbcTemplate" class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate"> 27 <constructor-arg ref="datasource">constructor-arg> 28 bean> 29 30 31 <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> 32 <property name="dataSource" ref="datasource">property> 33 bean> 34 35 36 <bean id="transactionManager" 37 class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 38 <property name="dataSource" ref="datasource">property> 39 bean> 40 41 42 <tx:annotation-driven transaction-manager="transactionManager"/> 43 beans>
db.properties:
1 jdbc.user=root 2 jdbc.password= 3 jdbc.driverClass=com.mysql.jdbc.Driver 4 jdbc.jdbcUrl=jdbc:mysql:///test 5 6 7 jdbc.initPoolSize =5 8 jdbc.maxPoolSize = 10 9 jdbc.maxStatements=0
3.添加事务注解@Transactional
DAO层：
1 package lixiuming.spring.tx; 2 3 public interface BookShopDao { 4 5 /** 6 * 根据书号查找书的价格 7 * 8 * @param Isbn 9 * @return 10 */ 11 public int findBookPriceByIsbn(int Isbn); 12 13 /** 14 * 使书号对应的库存减一 15 */ 16 public void updateBookSock(int Isbn); 17 18 /** 19 * 更新用户的账户余额：blance -price 20 */ 21 public void updatUserAccount(String userName, int price); 22 23 }
1 package lixiuming.spring.tx; 2 3 import org.springframework.beans.factory.annotation.Autowired; 4 import org.springframework.jdbc.core.JdbcTemplate; 5 import org.springframework.stereotype.Repository; 6 7 @Repository("bookShopImpl") 8 public class BookShopImpl implements BookShopDao { 9 10 @Autowired 11 private JdbcTemplate jdbcTemplate; 12 13 @Override 14 public int findBookPriceByIsbn(int Isbn) { 15 String sql = "select price from book where isbn = ? "; 16 return jdbcTemplate.queryForObject(sql, Integer.class, Isbn); 17 } 18 19 @Override 20 public void updateBookSock(int Isbn) { 21 // 检查书的库存是否足够，若不够则抛出异常 22 String sql2 = "select stock from bookstock where isbn =?"; 23 int stock = jdbcTemplate.queryForObject(sql2, Integer.class, Isbn); 24 if (stock == 0) { 25 throw new BookStockException("库存不足"); 26 } 27 28 String sql = "update bookstock set stock = stock-1 where Isbn = ?"; 29 jdbcTemplate.update(sql, Isbn); 30 31 } 32 33 @Override 34 public void updatUserAccount(String userName, int price) { 35 String sql2 = "select balance from account where userName =?"; 36 int account = jdbcTemplate.queryForObject(sql2, Integer.class, userName); 37 if (account < price) { 38 throw new UserAccountException("余额不足"); 39 } 40 String sql = "update account set balance = balance-? where userName =?"; 41 jdbcTemplate.update(sql, price, userName); 42 } 43 44 }
Service层：
1 package lixiuming.spring.tx; 2 3 public interface BookShopService { 4 5 public void purchase(String userName,int isbn); 6 7 }
1 package lixiuming.spring.tx; 2 3 import org.springframework.beans.factory.annotation.Autowired; 4 import org.springframework.stereotype.Service; 5 import org.springframework.transaction.annotation.Propagation; 6 import org.springframework.transaction.annotation.Transactional; 7 8 @Service("bookShopServiceImpl") 9 public class BookShopServiceImpl implements BookShopService { 10 11 @Autowired 12 private BookShopDao dao; 13 14 @Transactional15 @Override 16 public void purchase(String userName, int isbn) { 17 // 书的单价 18 int price = dao.findBookPriceByIsbn(isbn); 19 // 更新库存 20 dao.updateBookSock(isbn); 21 // 更新余额 22 dao.updatUserAccount(userName, price); 23 24 } 25 26 }
其他(自定义异常)：
- 库存异常
1 package lixiuming.spring.tx; 2 3 public class BookStockException extends RuntimeException { 4 5 /** 6 * 7 */ 8 private static final long serialVersionUID = 4237643951857538899L; 9 10 /** 11 * 12 */ 13 14 public BookStockException() { 15 super(); 16 // TODO Auto-generated constructor stub 17 } 18 19 public BookStockException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { 20 super(message, cause, enableSuppression, writableStackTrace); 21 // TODO Auto-generated constructor stub 22 } 23 24 public BookStockException(String message, Throwable cause) { 25 super(message, cause); 26 // TODO Auto-generated constructor stub 27 } 28 29 public BookStockException(String message) { 30 super(message); 31 // TODO Auto-generated constructor stub 32 } 33 34 public BookStockException(Throwable cause) { 35 super(cause); 36 // TODO Auto-generated constructor stub 37 } 38 39 }
- 用户账户异常
1 package lixiuming.spring.tx; 2 3 public class UserAccountException extends RuntimeException { 4 5 /** 6 * 7 */ 8 private static final long serialVersionUID = -3973495734669194251L; 9 10 /** 11 * 12 */ 13 14 public UserAccountException() { 15 super(); 16 // TODO Auto-generated constructor stub 17 } 18 19 public UserAccountException(String message, Throwable cause, boolean enableSuppression, 20 boolean writableStackTrace) { 21 super(message, cause, enableSuppression, writableStackTrace); 22 // TODO Auto-generated constructor stub 23 } 24 25 public UserAccountException(String message, Throwable cause) { 26 super(message, cause); 27 // TODO Auto-generated constructor stub 28 } 29 30 public UserAccountException(String message) { 31 super(message); 32 // TODO Auto-generated constructor stub 33 } 34 35 public UserAccountException(Throwable cause) { 36 super(cause); 37 // TODO Auto-generated constructor stub 38 } 39 40 }
测试方法：
1 package lixiuming.spring.tx; 2 3 import org.junit.Test; 4 import org.springframework.context.ApplicationContext; 5 import org.springframework.context.support.ClassPathXmlApplicationContext; 6 7 public class SpringTransactionTest { 8 9 private ApplicationContext cxt = null; 10 private BookShopService parchase = null; 11 12 { 13 cxt = new ClassPathXmlApplicationContext("application_transaction.xml"); 14 parchase = cxt.getBean(BookShopService.class); 15 } 16 17 @Test 18 public void testpurchase() { 19 parchase.purchase("aa", 1001); 20 } 21 22 }
4.测试
测试前提：用户账户表 账户金额为120 ； 书号1001的图书库存为 10 ；
当第一次运行testpurchase 时，没有异常 ； 书号为1001的库存为 9 ，账户金额为20；当第二次执行testpurchase时，抛出异常；异常内容为 余额不足且 书号为1001的库存为 9 ，账户金额为20；
三、声明式事务的事务传播行为
- 当事务方法被另一个事务方法调用时, 必须指定事务应该如何传播. 例如: 方法可能继续在现有事务中运行, 也可能开启一个新事务, 并在自己的事务中运行.
-
使用propagation指定事务的传播行为，
- 事务的传播行为可以由传播属性指定. Spring 定义了 7 种类传播行为.默认为REQUIRED，常用为REQUIRED和REQUIRED_NEW;
1.REQUIRED
上一节 用户购买图书的实例。添加另外一个方法事务方法checkout，checkout 调用purchase 方法来测试 事务的传播行为；
添加 Cashier接口及其实现类：
1 package lixiuming.spring.tx; 2 3 import java.util.List; 4 5 public interface Cashier { 6 7 public void checkout(String username, Listisbns); 8 9 }
1 package lixiuming.spring.tx; 2 3 import java.util.List; 4 5 import org.springframework.beans.factory.annotation.Autowired; 6 import org.springframework.stereotype.Service; 7 import org.springframework.transaction.annotation.Transactional; 8 9 @Service("cashierImpl") 10 public class CashierImpl implements Cashier { 11 12 @Autowired 13 private BookShopService bookShopService; 14 15 @Transactional 16 @Override 17 public void checkout(String username, Listisbns) { 18 for (Integer isbn : isbns) { 19 bookShopService.purchase(username, isbn); 20 } 21 } 22 23 }
测试方法：
1 package lixiuming.spring.tx; 2 3 import java.util.Arrays; 4 5 import org.junit.Test; 6 import org.springframework.context.ApplicationContext; 7 import org.springframework.context.support.ClassPathXmlApplicationContext; 8 9 public class SpringTransactionTest { 10 11 private ApplicationContext cxt = null; 12 private BookShopService parchase = null; 13 private Cashier c = null; 14 15 { 16 cxt = new ClassPathXmlApplicationContext("application_transaction.xml"); 17 parchase = cxt.getBean(BookShopService.class); 18 c = cxt.getBean(Cashier.class); 19 } 20 21 @Test 22 public void testCheckout() { 23 c.checkout("aa", Arrays.asList(1001, 1002)); 24 25 } 26 27 @Test 28 public void testpurchase() { 29 parchase.purchase("aa", 1001); 30 } 31 32 }
测试：
测试前提：用户账户表 账户金额为120 ； 书号1001和1002的图书库存为 10 ；购买第一本书时，账户余额是够的，但是第二本书钱不够；
当第一次运行testCheckout时，报错为余额不足； 书号1001和1002的图书库存为 还是为10；用户账户表 账户金额为120 ；
REQUIRED_NEW：
更改purchase方法：设置事务的传播行为为REQUIRES_NEW（即：@Transactional(propagation = Propagation.REQUIRES_NEW）
REQUIRES_NEW使用自己的事务，调用事务被挂起
1 @Transactional(propagation = Propagation.REQUIRES_NEW) 2 @Override 3 public void purchase(String userName, int isbn) { 4 // 书的单价 5 int price = dao.findBookPriceByIsbn(isbn); 6 // 更新库存 7 dao.updateBookSock(isbn); 8 // 更新余额 9 dao.updatUserAccount(userName, price); 10 11 }
测试：
测试前提：用户账户表 账户金额为120 ； 书号1001和1002的图书库存为 10 ；购买第一本书时，账户余额是够的，但是第二本书钱不够；
当第一次运行testCheckout时，报错为余额不足； 书号1001的图书库存为 还是为9，书号1002的图书库存为 10 ；用户账户表 账户金额为20 ；
四、事务的隔离级别和设置回滚事务属性
1.事务的隔离级别
- 使用isolation指定事务的隔离级别，最常用的是READ_COMMITTED
- 默认情况下声明试事务对运行时异常进行回滚，也可以对对应的属性进行设置
2.回滚事务属性（rollbackFor 、noRollbackFor ）
- rollbackFor: 遇到时必须进行回滚
- noRollbackFor: 一组异常类，遇到时必须不回滚
示例：
@Transactional(propagation=Propagation.REQUIRES_NEW ,isolation=Isolation.READ_COMMITTED,,noRollbackFor = {UserAccountException.class})
通常情况，不对其进行设置；
五、超时和只读属性
- 超时事务属性: 事务在强制回滚之前可以保持多久. 这样可以防止长期运行的事务占用资源.
- 只读事务属性: 表示这个事务只读取数据但不更新数据, 这样可以帮助数据库引擎优化事务.
超时：
更改 purchase方法：使用timeout=1，指定强制回滚之前事务可以占用时间，单位：秒,例如线程暂停5秒，则强制退出
1 @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.READ_COMMITTED, timeout = 1) 2 @Override 3 public void purchase(String userName, int isbn) { 4 try { 5 Thread.sleep(5000); 6 } catch (InterruptedException e) { 7 } 8 9 // 书的单价 10 int price = dao.findBookPriceByIsbn(isbn); 11 // 更新库存 12 dao.updateBookSock(isbn); 13 // 更新余额 14 dao.updatUserAccount(userName, price); 15 16 }
测试：
测试前提：用户账户表 账户金额为120 ； 书号1001和1002的图书库存为 10 ；购买第一本书时，账户余额是够；
运行testpurchase 方法；只买1001书：
报错：org.springframework.transaction.TransactionTimedOutException: Transaction timed out: deadline was Sun Nov 07 22:29:18 CST 2021...
用户账户表 账户金额为120 ； 书号1001和1002的图书库存为 10
只读
使用readOnly指定事务是否只读‘readOnly=false’若只读取数据库方法readOnly=true:
更改 purchase方法：
1 @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.READ_COMMITTED, readOnly = true) 2 @Override 3 public void purchase(String userName, int isbn) { 4 // 书的单价 5 int price = dao.findBookPriceByIsbn(isbn); 6 // 更新库存 7 dao.updateBookSock(isbn); 8 // 更新余额 9 dao.updatUserAccount(userName, price); 10 11 }
测试：
测试前提：用户账户表 账户金额为120 ； 书号1001和1002的图书库存为 10 ；购买第一本书时，账户余额是够；
运行testpurchase 方法；只买1001书：
报错：
org.springframework.dao.TransientDataAccessResourceException: PreparedStatementCallback; SQL [update bookstock set stock = stock-1 where Isbn = ?]; Connection is read-only. Queries leading to data modification are not allowed...
用户账户表 账户金额为120 ； 书号1001和1002的图书库存为 10