一、事务的传播特性
事务的传播特性指的是当一个事务方法被另一个事务方法调用时,这个事务方法应该如何进行?
spring的事务传播行为一共有7种:
二、测试事务的传播特性
1、环境准备
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.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<context:property-placeholder location="classpath:db_config.properties"></context:property-placeholder>
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
<property name="url" value="${url}"></property>
<property name="driverClassName" value="${driverClassName}"></property>
</bean>
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<constructor-arg name="dataSource" ref="dataSource"></constructor-arg>
</bean>
<context:component-scan base-package="com.bobo"></context:component-scan>
<!--事务控制-->
<!--配置事务管理器的bean-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!--开启基于注解的事务控制模式,依赖tx名称空间-->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
</beans>
db_config.properties
jdbc.username=root
jdbc.password=root
url=jdbc:mysql://localhost:3306/tx
driverClassName=com.mysql.jdbc.Driver
BookDao.java
package com.bobo.dao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import org.springframework.jdbc.core.JdbcTemplate;
@Repository
public class BookDao {
@Autowired
private JdbcTemplate jdbcTemplate;
/**
* 按照图书的id来获取图书的价格
*
* @param id
* @return
*/
public int getPrice(int id) {
String sql = "select price from book where id=?";
return jdbcTemplate.queryForObject(sql, Integer.class, id);
}
/**
* 减去某个用户的余额
*
* @param username
* @param price
*/
public void updateBalance(String username, int price) {
String sql = "update account set balance=balance-? where username=?";
jdbcTemplate.update(sql, price, username);
}
/**
* 减库存,减去某本书的库存
*
* @param id
*/
public void updateStock(int id) {
String sql = "update book_stock set stock=stock-1 where id =?";
jdbcTemplate.update(sql, id);
}
/**
* 修改图书价格
* @param id
*/
public void updatePrice(int id) {
String sql = "update book set price=price-1 where id =?";
jdbcTemplate.update(sql, id);
}
}
BookService.java
package com.bobo.service;
import com.bobo.dao.BookDao;
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
public class BookService {
@Autowired
private BookDao bookDao;
/**
* 结账:传入哪个用户买了哪本书
* @param username
* @param id
*/
@Transactional(propagation = Propagation.REQUIRED)
public void checkout(String username, int id) {
int price = bookDao.getPrice(id);
bookDao.updateBalance(username, price);
bookDao.updateStock(id);
int i = 1 / 0;
}
@Transactional(propagation = Propagation.REQUIRED)
public void updatePrice(int id) {
bookDao.updatePrice(id);
// int i = 1 / 0;
}
}
MultiBookService.java
package com.bobo.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service
public class MultiBookService {
@Autowired
private BookService bookService;
@Transactional
public void multi(String username, int id) {
bookService.checkout(username, id);
bookService.updatePrice(id);
}
}
单元测试:
import com.bobo.service.BookService;
import com.bobo.service.MultiBookService;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
@Test
public void test01() {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("application_context.xml");
MultiBookService multiBookService = context.getBean(MultiBookService.class);
multiBookService.multi("lisi", 1);
}
}
2、Propagation.REQUIRED
通过上图的结果发现,如果设置的传播特性是Required,那么所有的事务都会统一成一个事务,一旦发生错误,所有的数据都要进行回滚。
3、Propagation.REQUIRES_NEW
1、将checkout()方法设置为REQUIRED,而updatePrice()方法设置为REQUIRES_NEW,并且在updatePrice()方法报出异常。
package com.bobo.service;
import com.bobo.dao.BookDao;
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
public class BookService {
@Autowired
private BookDao bookDao;
/**
* 结账:传入哪个用户买了哪本书
* @param username
* @param id
*/
@Transactional(propagation = Propagation.REQUIRED)
public void checkout(String username, int id) {
int price = bookDao.getPrice(id);
bookDao.updateBalance(username, price);
bookDao.updateStock(id);
}
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void updatePrice(int id) {
bookDao.updatePrice(id);
int i = 1 / 0;
}
}
测试结果:checkout和updatePrice方法都会回滚。
2、将checkout()方法设置为REQUIRES_NEW,而updatePrice()方法设置为REQUIRED,并且在updatePrice()方法报出异常。
package com.bobo.service;
import com.bobo.dao.BookDao;
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
public class BookService {
@Autowired
private BookDao bookDao;
/**
* 结账:传入哪个用户买了哪本书
* @param username
* @param id
*/
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void checkout(String username, int id) {
int price = bookDao.getPrice(id);
bookDao.updateBalance(username, price);
bookDao.updateStock(id);
}
@Transactional(propagation = Propagation.REQUIRED)
public void updatePrice(int id) {
bookDao.updatePrice(id);
int i = 1 / 0;
}
}
测试结果:checkout()方法不会回滚,updatePrice()方法会发生回滚
3、将checkout()方法设置为REQUIRES_NEW,而updatePrice()方法设置为REQUIRED,并且在multi()方法报出异常。
package com.bobo.service;
import com.bobo.dao.BookDao;
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
public class BookService {
@Autowired
private BookDao bookDao;
/**
* 结账:传入哪个用户买了哪本书
*
* @param username
* @param id
*/
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void checkout(String username, int id) {
int price = bookDao.getPrice(id);
bookDao.updateBalance(username, price);
bookDao.updateStock(id);
}
@Transactional(propagation = Propagation.REQUIRED)
public void updatePrice(int id) {
bookDao.updatePrice(id);
}
}
package com.bobo.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service
public class MultiBookService {
@Autowired
private BookService bookService;
@Transactional
public void multi(String username, int id) {
bookService.checkout(username, id);
bookService.updatePrice(id);
int i = 1 / 0;
}
}
测试发现:checkout()方法不会回滚,updatePrice()方法会回滚
4、将checkout()方法和updatePrice()都设置为REQUIRES_NEW,并且在updatePrice()方法报出异常。
package com.bobo.service;
import com.bobo.dao.BookDao;
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
public class BookService {
@Autowired
private BookDao bookDao;
/**
* 结账:传入哪个用户买了哪本书
*
* @param username
* @param id
*/
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void checkout(String username, int id) {
int price = bookDao.getPrice(id);
bookDao.updateBalance(username, price);
bookDao.updateStock(id);
}
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void updatePrice(int id) {
bookDao.updatePrice(id);
int i = 1 / 0;
}
}
测试发现:updatePrice()方法会回滚,checkout()方法不会回滚
4、Propagation.NESTED
1、将checkout()方法设置为Propagation.NESTED,updatePrice()设置为Propagation.REQUIRED,并且在updatePrice()方法报出异常。
package com.bobo.service;
import com.bobo.dao.BookDao;
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
public class BookService {
@Autowired
private BookDao bookDao;
/**
* 结账:传入哪个用户买了哪本书
*
* @param username
* @param id
*/
@Transactional(propagation = Propagation.NESTED)
public void checkout(String username, int id) {
int price = bookDao.getPrice(id);
bookDao.updateBalance(username, price);
bookDao.updateStock(id);
}
@Transactional(propagation = Propagation.REQUIRED)
public void updatePrice(int id) {
bookDao.updatePrice(id);
int i = 1 / 0;
}
}
测试发现:updatePrice()方法和checkout()方法都会回滚
2、将checkout()方法设置为Propagation.NESTED,updatePrice()设置为Propagation.REQUIRES_NEW,并且在updatePrice()方法报出异常。
package com.bobo.service;
import com.bobo.dao.BookDao;
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
public class BookService {
@Autowired
private BookDao bookDao;
/**
* 结账:传入哪个用户买了哪本书
*
* @param username
* @param id
*/
@Transactional(propagation = Propagation.NESTED)
public void checkout(String username, int id) {
int price = bookDao.getPrice(id);
bookDao.updateBalance(username, price);
bookDao.updateStock(id);
}
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void updatePrice(int id) {
bookDao.updatePrice(id);
int i = 1 / 0;
}
}
测试发现:updatePrice()方法和checkout()方法都会回滚,和上面一样的结果。
三、总结
- 事务传播级别是REQUIRED,当checkout()被调用时(假定被另一类中commit()调用),如果checkout()中的代码抛出异常,即便被捕获,commit()中的其他代码都会roll back。
- 是REQUIRES_NEW,如果checkout()中的代码抛出异常,并且被捕获,commit()中的其他代码不会roll back;如果commit()中的其他代码抛出异常,而且没有捕获,不会导致checkout()回滚。
- 是NESTED,如果checkout()中的代码抛出异常,并且被捕获,commit()中的其他代码不会roll back;如果commit()中的其他代码抛出异常,而且没有捕获,会导致checkout()回滚。
PROPAGATION_REQUIRES_NEW 启动一个新的, 不依赖于环境的 “内部” 事务. 这个事务将被完全 commited 或 rolled back 而不依赖于外部事务, 它拥有自己的隔离范围, 自己的锁, 等等. 当内部事务开始执行时, 外部事务将被挂起, 内务事务结束时, 外部事务将继续执行.
另一方面, PROPAGATION_NESTED 开始一个 “嵌套的” 事务, 它是已经存在事务的一个真正的子事务. 嵌套事务开始执行时, 它将取得一个 savepoint. 如果这个嵌套事务失败, 我们将回滚到此 savepoint. 潜套事务是外部事务的一部分, 只有外部事务结束后它才会被提交.
由此可见, PROPAGATION_REQUIRES_NEW 和 PROPAGATION_NESTED 的最大区别在于, PROPAGATION_REQUIRES_NEW 完全是一个新的事务, 而 PROPAGATION_NESTED 则是外部事务的子事务, 如果外部事务 commit, 嵌套事务也会被 commit, 这个规则同样适用于 roll back.