【Spring】事务（transactional） - REQUIRES_NEW在JdbcTemplate、Mybatis中的不同表现

环境

数据库: oracle 11g

JAR:

• org.springframework:spring-jdbc:4.3.8.RELEASE
• org.mybatis:mybatis:3.4.2

概念

REQUIRED（默认）: 表示当前方法必须运行在事务中。如果当前事务存在，方法将会在该事务中运行。否则，会启动一个新的事务。

REQUIRED_NEW: 表示当前方法必须运行在它自己的事务中。一个新的事务将被启动，如果存在当前事务，在该方法执行期间，当前事务会被挂起。

早前对NEW的理解只是停留在: 当前方法会新开启一个事务，新事务的提交/回滚不会影响之前事务的提交/回滚。

但"当前事务会被挂起",那么NEW事务结束后,被挂起的当前事务应该是会恢复,但会恢复哪些东西了？

(摘自: 在Spring中使用PROPAGATION_REQUIRES_NEW带来的缓存问题?)

源码分析：

在TransactionTemplate的<T> T execute(TransactionCallback<T> action)中会通过TransactionManager的getTransaction方法来取得TransactionStatus

1、取得当前线程所关联的SessionHolder

2、若存在SessionHolder并且开启了事务(this.sessionHolder != null && this.sessionHolder.getTransaction() != null)，而且当前的的传播行为为PROPAGATION_REQUIRES_NEW

3、挂起当前线程绑定的事务及其事务同步器，取消当前线程和当前session和connection的绑定，并保存所有的挂起信息以供恢复

4、创建新的session，并开启新的事务

5、执行TransactionTemplate的TransactionCallback回调

6、在新事务提交后，会恢复上个事务的所有信息和执行

测试问题描述

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();
        }
    }
}