环境
数据库: oracle 11g
JAR:
- org.springframework:spring-jdbc:4.3.8.RELEASE
- org.mybatis:mybatis:3.4.2
概念
REQUIRED（默认）: 表示当前方法必须运行在事务中。如果当前事务存在，方法将会在该事务中运行。否则，会启动一个新的事务。
REQUIRED_NEW: 表示当前方法必须运行在它自己的事务中。一个新的事务将被启动，如果存在当前事务，在该方法执行期间，当前事务会被挂起。
早前对NEW的理解只是停留在: 当前方法会新开启一个事务，新事务的提交/回滚不会影响之前事务的提交/回滚。
但"当前事务会被挂起",那么NEW事务结束后,被挂起的当前事务应该是会恢复,但会恢复哪些东西了？
测试问题描述
1、 method_A（T1事务）中查询了某条记录A（A.name = 1）；然后调用method_B(T2事务，并且是REQUIRES_NEW )
2、在 method_B中修改了记录A并提交保存（A.name = 2）;（method_B方法结束，T2事务提交）
3、然后回到 method_A 中再次查询这条记录A，发现得到的A.name = 1；但是此时数据库中的A.name = 2 。
用hibernate/mybatis得到的都是以上结果, 即在T1中查到的A.name = 1.
但是，我用spring的JdbcTemplate测试却发现: 本来在(3)得到A.name=1，但实际A.name =2。
为什么mybatis&hibernate得到的结果与JdbcTemplate不一样了？事务不是统一交给spring控制的吗？
(见问题: Spring事务REQUIRES_NEW的问题?)
个人理解
最初, 我以为在(3)一定会得到是A.name = 2。但实际在hibernate中得到的是A.name =1。(当时遇到问题用的是hibernate。)
然后我就重新去理解了REQUIRES_NEW, 发现应该是要得到A.name = 1, 即mybatis&hibernate得到的就是正确的。
但无意用JdbcTemplate测试却发现和mybatis&hibernate得到的不一样, 所以就迷茫了。完全不知道怎么理解。
现在在想一想, 到底什么是"事务控制"？ 其实现在我也不知道怎么理解, 渣狗一只, 汪汪~~
可以参考:
spring jdbcTemplate 事务，各种诡异，包你醍醐灌顶！
spring事务源码解析 （这个可以细看）
但为什么觉得mybatis&hibernate的结果更正确呢?
1、更能体现出事务的一致性。
因为对t1事务来说,并没有改变过A.name。所以,从始至终都应该得到A.name =1。
一、spring boot公共部分
@SpringBootApplication
public class TransactionApplication {
public final static String ID = "1"; public static void main(String[] args) {
SpringApplication app = new SpringApplication(TransactionApplication.class);
app.run(args);
}
}
TransactionApplication.java
#### 28.1.2. 连接到一个生产环境数据库
## 注：其他的连接池可以手动配置。如果你定义自己的DataSource bean，自动配置不会发生。
## 详细属性配置参考：https://segmentfault.com/a/1190000004316491
#### ## Spring Boot能够从大多数数据库的url上推断出driver-class-name，那么你就不需要再指定它了。
spring.datasource.driver-class-name=oracle.jdbc.driver.OracleDriver
## 默认会从url推断driver class
spring.datasource.url=jdbc:oracle:thin:@127.0.0.1:1521:orcl
spring.datasource.username=vergilyn
spring.datasource.password=409839163 ## JDNI
# spring.datasource.jndi-name=java:jboss/datasources/customers
application.properties
public class Parent implements Serializable{
private int parentId;
private String parentName;
public Parent() {
}
public Parent(int parentId, String parentName) {
this.parentId = parentId;
this.parentName = parentName;
}
public int getParentId() {
return parentId;
}
public void setParentId(int parentId) {
this.parentId = parentId;
}
public String getParentName() {
return parentName;
}
public void setParentName(String parentName) {
this.parentName = parentName;
}
@Override
public String toString() {
return "Parent{" +"parentId=" + parentId +", parentName='" + parentName + '\'' +'}';
}
}
Parent.java
数据库:
二、JdbcTemplate测试
@Service
public class JdbcMainService {
@Autowired
private JdbcParentDao parentDao;
@Autowired
private JdbcNewService newService; @Transactional(propagation = Propagation.REQUIRED)
public void updateCur() {
Parent init = parentDao.getEntity(TransactionApplication.ID);
System.out.println("init select: " + init); Parent curu = this.updateCur(init);
System.out.println("curu update: " + curu); Parent curs = parentDao.getEntity(TransactionApplication.ID);
System.out.println("curs select: " + curs); Parent news = newService.getEntity(TransactionApplication.ID);
System.out.println("news select: " + news);
} @Transactional(propagation = Propagation.REQUIRED)
public void updateNew() {
Parent init = parentDao.getEntity(TransactionApplication.ID);
System.out.println("init select: " + init); Parent newu = newService.updateNew(init);
System.out.println("newu update: " + newu); Parent curs = parentDao.getEntity(TransactionApplication.ID);
System.out.println("curs select: " + curs); Parent news = newService.getEntity(TransactionApplication.ID);
System.out.println("news select: " + news);
} @Transactional(propagation = Propagation.REQUIRED)
public Parent updateCur(Parent parent) {
Parent p2 = new Parent();
p2.setParentId(parent.getParentId());
p2.setParentName(parent.getParentName() + "@cur");
parentDao.update(p2);
return p2;
}
}
JdbcMainService.java
@Service
public class JdbcNewService {
@Autowired
private JdbcParentDao jdbcParentDao; @Transactional(propagation = Propagation.REQUIRES_NEW)
public Parent updateNew(Parent parent){
Parent p2 = new Parent();
p2.setParentId(parent.getParentId());
p2.setParentName(parent.getParentName() + "@new");
jdbcParentDao.update(p2); return p2;
} @Transactional(propagation = Propagation.REQUIRES_NEW)
public Parent getEntity(String id) {
return jdbcParentDao.getEntity(id);
}
}
JdbcNewService.java
@Repository
public class JdbcParentDao {
@Autowired
private JdbcTemplate jdbcTemplate; @Autowired
private NamedParameterJdbcTemplate namedJdbc; public Parent getEntity(String id){
String sql = "select * from parent where parent_id = ?"; return this.jdbcTemplate.queryForObject(sql,new Object[]{id},new BeanPropertyRowMapper<Parent>(Parent.class));
} public void update(Parent parent){
String sql = "update parent set parent_name = ? where parent_id = ?";
this.jdbcTemplate.update(sql,new Object[]{parent.getParentName(),parent.getParentId()});
}
}
JdbcParentDao.java
2.1 说明
JdbcMainService: 其中的方法全是REQUIRED，且此class是主要的测试class。
JdbcNewService: 其中的方法全是REQUIRES_NEW。
JdbcParentDao: 共用的dao层方法。
2.2 测试JdbcMainService.updateCur()
@Transactional(propagation = Propagation.REQUIRED)
public void updateCur() {
Parent init = parentDao.getEntity(TransactionApplication.ID);
System.out.println("init select: " + init); // init select: Parent{parentId=1, parentName='周父'} Parent curu = this.updateCur(init);
System.out.println("curu update: " + curu); // curu update: Parent{parentId=1, parentName='周父@cur'} Parent curs = parentDao.getEntity(TransactionApplication.ID);
System.out.println("curs select: " + curs); // curs select: Parent{parentId=1, parentName='周父@cur'}
// 此时数据库的实际值是: parentName='周父', 因为cur方法还未结束, 即cur事务还未提交。 Parent news = newService.getEntity(TransactionApplication.ID);
System.out.println("news select: " + news); // news select: Parent{parentId=1, parentName='周父'}
}
分析: 以上结果都在预料之内。因为update是在cur事务中, 所以cur事务中再次select可以得到cur事务的更新但未提交的数据, 即"curs select"得到的是CUR事务update后的值, 而非当前数据库中的值。
这也证明了CUR事务、NEW事务是两个完全独立的事务。
回去再看NEW描述中的"当前事务会被挂起", 是否是在NEW事务执行完返回CUR事务, 会恢复CUR事务的所有信息和执行。
2.2 测试JdbcMainService.updateNew()
@Transactional(propagation = Propagation.REQUIRED)
public void updateNew() {
Parent init = parentDao.getEntity(TransactionApplication.ID);
System.out.println("init select: " + init); // init select: Parent{parentId=1, parentName='周父'} Parent newu = newService.updateNew(init);
System.out.println("newu update: " + newu); // newu update: Parent{parentId=1, parentName='周父@new'}
// 用REQUIRES_NEW更新, 此时数据库已是最新值 parentName='周父@new' Parent curs = parentDao.getEntity(TransactionApplication.ID);
System.out.println("curs select: " + curs); // curs select: Parent{parentId=1, parentName='周父@new'} Parent news = newService.getEntity(TransactionApplication.ID);
System.out.println("news select: " + news); // news select: Parent{parentId=1, parentName='周父@new'}
}
问题: 为什么"curs select"得到的会是parentName='周父@new'?
针对之前对REQUIRED与REQUIRES_NEW的理解, 返回到CUR事务中查询到的结果应该是与"init select"一样才对。但现在明显得到的是数据库最新值。
三、mybatis测试
@Service
public class MybatisMainService {
@Autowired
private MybatisParentMapper parentMapper;
@Autowired
private MybatisNewService newService; @Transactional(propagation = Propagation.REQUIRED)
public void updateCur(){
Parent init = parentMapper.getEntity(TransactionApplication.ID);
System.out.println("init select: " + init); Parent curu = this.updateCur(init);
System.out.println("curu update: " + curu); Parent curs = parentMapper.getEntity(TransactionApplication.ID);
System.out.println("curs select: " + curs); Parent news = newService.getEntity(TransactionApplication.ID);
System.out.println("news select: " + news); Parent nocs = parentMapper.getNoCacheEntity(TransactionApplication.ID);
System.out.println("nocs select: " + nocs);
} @Transactional(propagation = Propagation.REQUIRED)
public void updateNew(){
Parent init = parentMapper.getEntity(TransactionApplication.ID);
System.out.println("init select: " + init); Parent newu = newService.updateNew(init);
System.out.println("newu update: " + newu); Parent curs = parentMapper.getEntity(TransactionApplication.ID);
System.out.println("curs select: " + curs); Parent news = newService.getEntity(TransactionApplication.ID);
System.out.println("news select: " + news); Parent nocs = parentMapper.getNoCacheEntity(TransactionApplication.ID);
System.out.println("nocs select: " + nocs);
} @Transactional(propagation = Propagation.REQUIRED)
public Parent updateCur(Parent parent){
Parent p2 = new Parent();
p2.setParentId(parent.getParentId());
p2.setParentName(parent.getParentName() + "@cur");
parentMapper.update(p2); return p2;
}
}
MybatisMainService.java
@Service
public class MybatisNewService {
@Autowired
private MybatisParentMapper parentMapper; @Transactional(propagation = Propagation.REQUIRES_NEW)
public Parent updateNew(Parent parent){
Parent p2 = new Parent();
p2.setParentId(parent.getParentId());
p2.setParentName(parent.getParentName() + "@new");
parentMapper.update(p2); return p2;
} @Transactional(propagation = Propagation.REQUIRES_NEW)
public Parent getEntity(String id) {
return parentMapper.getEntity(id);
}
}
MybatisNewService.java
@Mapper
public interface MybatisParentMapper { @Select("select * from parent where PARENT_ID = #{id}")
@Results({
@Result(id = true, column = "PARENT_ID", property = "parentId"),
@Result(column = "PARENT_NAME", property = "parentName")
})
Parent getEntity(@Param("id") String id); @Select("select * from parent where PARENT_ID = #{id}")
@Results({
@Result(id = true, column = "PARENT_ID", property = "parentId"),
@Result(column = "PARENT_NAME", property = "parentName")
})
@Options(flushCache = Options.FlushCachePolicy.TRUE,useCache = false)
Parent getNoCacheEntity(@Param("id") String id); @Update("update parent set PARENT_NAME=#{parentName} where PARENT_ID = #{parentId}")
@Results({
@Result(id = true, column = "PARENT_ID", property = "parentId"),
@Result(column = "PARENT_NAME", property = "parentName")
})
void update(Parent parent);
}
MybatisParentMapper.java
3.1 说明
MybatisMainService: 其中的方法全是REQUIRED，且此class是主要的测试class。
MybatisNewService: 其中的方法全是REQUIRES_NEW。
MybatisParentMapper: mybatis纯注解的共用dao。
3.2 测试MybatisMainService.updateCur()
@Transactional(propagation = Propagation.REQUIRED)
public void updateCur(){
Parent init = parentMapper.getEntity(TransactionApplication.ID);
System.out.println("init select: " + init); // init select: Parent{parentId=1, parentName='周父'} Parent curu = this.updateCur(init);
System.out.println("curu update: " + curu); // curu update: Parent{parentId=1, parentName='周父@cur'} Parent curs = parentMapper.getEntity(TransactionApplication.ID);
System.out.println("curs select: " + curs); // curs select: Parent{parentId=1, parentName='周父@cur'} Parent news = newService.getEntity(TransactionApplication.ID);
System.out.println("news select: " + news); // news select: Parent{parentId=1, parentName='周父'} Parent nocs = parentMapper.getNoCacheEntity(TransactionApplication.ID);
System.out.println("nocs select: " + nocs); // nocs select: Parent{parentId=1, parentName='周父@cur'}
}
1) "curs select"确实是得到当前事务的结果(即使是未提交的)。
2) "news select"得到的是现在数据库中的结果。
3) "nocs select"指定了@Options(flushCache = Options.FlushCachePolicy.TRUE,useCache = false),为什么得到的会是parentName='周父@cur',而不是parentName='周父'。
虽然现在数据库中的值是parentName='周父',但是当前事务下当前数据库中的值是parentName='周父@cur'(未提交)。
所以,当前事务中即使是useCache=flase,重新从数据库去查询,当前事务下的最新值就是parentName='周父'。
3.3 测试MybatisMainService.updateNew()
@Transactional(propagation = Propagation.REQUIRED)
public void updateNew(){
Parent init = parentMapper.getEntity(TransactionApplication.ID);
System.out.println("init select: " + init); // init select: Parent{parentId=1, parentName='周父'} Parent newu = newService.updateNew(init);
System.out.println("newu update: " + newu); // newu update: Parent{parentId=1, parentName='周父@new'} Parent curs = parentMapper.getEntity(TransactionApplication.ID);
System.out.println("curs select: " + curs); // curs select: Parent{parentId=1, parentName='周父'} Parent news = newService.getEntity(TransactionApplication.ID);
System.out.println("news select: " + news); // news select: Parent{parentId=1, parentName='周父@new'} Parent nocs = parentMapper.getNoCacheEntity(TransactionApplication.ID);
System.out.println("nocs select: " + nocs); // nocs select: Parent{parentId=1, parentName='周父@new'} Parent curs2 = parentMapper.getEntity(TransactionApplication.ID);
System.out.println("curs2 select: " + curs2); // curs2 select: Parent{parentId=1, parentName='周父@new'}
}
1) "curs select"得到当前事务的结果,所以parentName='周父'。
2) "news select"&"nocs select"为什么得到parentName='周父@new'?
按3.2的测试结论,如果nocs得到的是当前事务下的最新结果,那么当前事务的最新结果是什么? 从结果看,是parentName='周父@new'。
个人又觉得为了事务的一致性,觉得应该得到parentName='周父'。即应该和"curs select"得到一样的结果。
这种对事务的理解是对的吗(不管是交由spring控制的,还是oracle等数据库实际的事务控制)?
先说个人在此对"nocs select"得到结果的解释: 当前事务中的最新值就是parentName='周父@new',即new事务提交后的结果已经对cur可见。
现在用PL/SQL做这么2个测试:
这是否可以证明:
只要更新被提交后,更新后的值对别的事务即是可见的。所以,别的事务得到的结果就是数据库当前的值=别的事务更新后的值。
未提交的,对别的事务是不可见的,即别的事务得到的还是数据库目前的值。
3) "curs select"为什么得到parentName='周父'?
按2)中的说法,new更新已经提交了那么得到的不应该是parentName='周父@new'吗? (回过去看JdbcTemplate此处得到的是什么, parentName='周父@new')
现在是不是觉得JdbcTemplate才是最纯粹的原始事务呢,那为什么mybatis&hibernate中会得到此结果呢?
这主要是mybatis&hibernate中都存在缓存(主要是一级缓存造成的),所以JdbcTemplate与mybatis&hibernate的差异是因为缓存造成的。(JdbcTemplate无缓存一说)
4) "curs2 select"为什么得到parentName='周父@new'?
因为在"curs2 select"执行过"nocs select","nocs select"清空了缓存,并把查询到的结果重新放入缓存。这之后"curs2 select"又是从缓存中取的结果。所以得到的是parentName='周父@new'。
四、总结JdbcTemplate、mybatis的查询
// 以下是 JdbcTemplate @Transactional(propagation = Propagation.REQUIRED)
public void getCur(){
Parent s1 = parentDao.getEntity(TransactionApplication.ID);
System.out.println("s1 select: " + s1); // s1 select: Parent{parentId=1, parentName='周父'}
// 利用断点: 手动修改数据库的值 '周父' -> '周父s2'
Parent s2 = parentDao.getEntity(TransactionApplication.ID);
System.out.println("s2 select: " + s2); // s2 select: Parent{parentId=1, parentName='周父s2'} // 利用断点: 手动修改数据库的值 '周父' -> '周父s3'
Parent s3 = parentDao.getEntity(TransactionApplication.ID);
System.out.println("s3 select: " + s3); // s3 select: Parent{parentId=1, parentName='周父s3'}
}
// 以下是 mybatis @Transactional(propagation = Propagation.REQUIRED)
public void getCur(){
Parent s1 = parentMapper.getEntity(TransactionApplication.ID);
System.out.println("s1 select: " + s1); // s1 select: Parent{parentId=1, parentName='周父'} // 利用断点: 手动修改数据库的值 '周父' -> '周父s2'
Parent s2 = parentMapper.getEntity(TransactionApplication.ID);
System.out.println("s2 select: " + s2); // s2 select: Parent{parentId=1, parentName='周父'} // 利用断点: 手动修改数据库的值 '周父' -> '周父s3'
Parent s3 = parentMapper.getEntity(TransactionApplication.ID);
System.out.println("s3 select: " + s3); // s3 select: Parent{parentId=1, parentName='周父'}
}
// 以下是mybatis noCache混用测试
@Transactional(propagation = Propagation.REQUIRED)
public void getNoCache(){
Parent s1 = parentMapper.getEntity(TransactionApplication.ID);
System.out.println("s1 select: " + s1); // s1 select: Parent{parentId=1, parentName='周父'} // 利用断点: 手动修改数据库的值 '周父' -> '周父s2'
Parent s2 = parentMapper.getEntity(TransactionApplication.ID);
System.out.println("s2 select: " + s2); // s2 select: Parent{parentId=1, parentName='周父'} 从缓存取值,所以s2=s1
Parent s3 = parentMapper.getNoCacheEntity(TransactionApplication.ID);
System.out.println("s3 select: " + s3); // s3 select: Parent{parentId=1, parentName='周父s2'} 清空缓存重新查询
Parent s4 = parentMapper.getEntity(TransactionApplication.ID);
System.out.println("s4 select: " + s4); // s4 select: Parent{parentId=1, parentName='周父s2'} 从缓存取值,所以s4=s3 // 利用断点: 手动修改数据库的值 '周父' -> '周父s3'
Parent s5 = parentMapper.getNoCacheEntity(TransactionApplication.ID);
System.out.println("s5 select: " + s5); // s5 select: Parent{parentId=1, parentName='周父s3'}
}
现在在回来看这两种select得到的两种结果。(个人从以上测试得到结论,并不一定正确,希望高人指出正确的理解)
1) mybatis的观念: (默认情况下)从始至终当前事务都不应该看到别的事务的结果,即使是别的事务已经提交。
2) jdbcTemplate(或oracle)的观念: 只要事务被提交,另一个事务中就可以看到它提交的结果。
所以,现在看来也不能说哪种更好,只是个人偏向于mybatis。最主要的知道了有这差异(感觉主要是对mybatis&hibernate的缓存最用不够理解,只是知道存在缓存这一说)
五、题外话
在测试JdbcTemplate的时候,可能有一种猜测是: 并没有在一个事务中,或者并没有在同一个连接中,所以JdbcTemplate得到的查询结果永远是最新的。
这个可以很容易证明是同一个连接。见源码: org.springframework.jdbc.datasource.DataSourceUtils
package org.springframework.jdbc.datasource;
public abstract class DataSourceUtils {
public static final int CONNECTION_SYNCHRONIZATION_ORDER = 1000;
private static final Log logger = LogFactory.getLog(DataSourceUtils.class);
public DataSourceUtils() {
}
public static Connection getConnection(DataSource dataSource) throws CannotGetJdbcConnectionException {
try {
return doGetConnection(dataSource);
} catch (SQLException var2) {
throw new CannotGetJdbcConnectionException("Could not get JDBC Connection", var2);
}
}
public static Connection doGetConnection(DataSource dataSource) throws SQLException {
Assert.notNull(dataSource, "No DataSource specified");
ConnectionHolder conHolder = (ConnectionHolder)TransactionSynchronizationManager.getResource(dataSource);
if(conHolder == null || !conHolder.hasConnection() && !conHolder.isSynchronizedWithTransaction()) {
logger.debug("Fetching JDBC Connection from DataSource");
Connection con = dataSource.getConnection();
if(TransactionSynchronizationManager.isSynchronizationActive()) {
logger.debug("Registering transaction synchronization for JDBC Connection");
ConnectionHolder holderToUse = conHolder;
if(conHolder == null) {
holderToUse = new ConnectionHolder(con);
} else {
conHolder.setConnection(con);
}
holderToUse.requested();
TransactionSynchronizationManager.registerSynchronization(new DataSourceUtils.ConnectionSynchronization(holderToUse, dataSource));
holderToUse.setSynchronizedWithTransaction(true);
if(holderToUse != conHolder) {
TransactionSynchronizationManager.bindResource(dataSource, holderToUse);
}
}
System.out.println("datasource cur: " + con);
return con;
} else {
conHolder.requested();
if(!conHolder.hasConnection()) {
logger.debug("Fetching resumed JDBC Connection from DataSource");
conHolder.setConnection(dataSource.getConnection());
}
System.out.println("datasource new: " + conHolder.getConnection());
return conHolder.getConnection();
}
}
}