谈谈spring中的嵌套事务

1.JDBC中的回滚点

再介绍spring的嵌套事务之前，我们先看看原生JDBC中的回滚点是怎么做的。如下代码

	 public static void main(String[] args) {
        Connection connection = null;
        try {
            connection = ConnectionUtil.getConnection();
            //关闭自动提交
            connection.setAutoCommit(false);
            insertTest(connection);
            insertTest1(connection);
            connection.commit();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                try {
                    selectAll(connection);
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public static void insertTest(Connection con){
        PreparedStatement stmt = null;
        Savepoint a1 = null;
        try {
            stmt = con.prepareStatement("insert into test(num) values (?)");
            stmt.setString(1, "q2");
            stmt.executeUpdate();
            System.out.println("Data inserted successfully");
            stmt.close();
            //设置回滚点
            a1 = con.setSavepoint("a1");
        } catch (SQLException e) {
            e.printStackTrace();
            if(a1 != null) {
                try {
                    con.rollback(a1);
                } catch (SQLException e1) {
                    e1.printStackTrace();
                }
            }
        }
    }

    public static void insertTest1(Connection con) throws SQLException {
        PreparedStatement stmt = null;
        Savepoint a2 = null;
        try {
            stmt = con.prepareStatement("insert into test1(num) values (?)");
            stmt.setString(1, "q3");
            stmt.executeUpdate();
            System.out.println("Data inserted successfully");
            stmt.close();
              //设置回滚点
            a2 = con.setSavepoint("a2");
        } catch (SQLException e) {
            e.printStackTrace();
            if(a2 != null) {
                try {
                    con.rollback(a2);
                } catch (SQLException e1) {
                    e1.printStackTrace();
                }
            }
        }
    }

insertTest和insertTest1方法都对连接对象设置了savepoint，作用是当方法抛出异常，jdbc会按照设置的回滚点进行回滚，而不是全部回滚。

2.spring中的嵌套事务

spring中的嵌套事务，是通过给事务注解设置传播属性Propagation.NESTED来实现的。
其内部实现原理，也是按照上述JDBC的写法，针对有设置Propagation.NESTED的方法，给连接对象设置回滚点。

我之前写过一篇博文spring事务中的陷阱:事务提交时回滚，我们将这篇博文中代码的事务传播属性改为nested

@Transactional
AService.method(){

	@Transactional(propagation = Propagation.NESTED)
	BService.method(){
	
	}

	@Transactional(propagation = Propagation.NESTED)
	CService.method(){
	
	
	}
}

对于BService的方法来说，spring运行时就会为该方法的连接对象设置savepoint，CService方法也是如此。
这样，就实现了spring的嵌套事务。

3.嵌套事务的陷阱

现在，我们改造下代码：C中throw异常

@Transactional
AService.method(){

	@Transactional(propagation = Propagation.NESTED)
	BService.method(){
	
	}

	@Transactional(propagation = Propagation.NESTED)
	CService.method(){
	    thorw E
	}
}

按照我们对回滚点的理解，C方法肯定会回滚，而B不会回滚。
但结果是：B、C都会回滚。为什么？我们来逐步分析。

1.首先CService的切面，肯定会捕获到抛出的异常，进入completeTransactionAfterThrowing方法。
2.经过层层调用，进入如下方法。

3.上述方法的红框处做了两件关键事情：回滚到spring为其设置的回滚点，于是CService回滚了；同时将rollbackOnly属性置为false了，这个在后面讲。
4.然后，AService切面也能捕获到异常，也进入completeTransactionAfterThrowing方法。由于该切面不是嵌套事务，所以会对连接直接进行回滚，而BService与AService用同一个连接，导致BService的数据也跟着回滚了。

所以，B、C都会回滚。

4.嵌套事务的正确运用

通过上述分析可知，这种场景似乎与我们使用嵌套事务的初衷有所违背。有没有解决办法？

我们改造下代码：B、C方法被try-catch，C中throw异常，但catch中不throw异常。

@Transactional
AService.method(){
try{
    @Transactional(propagation = Propagation.NESTED)
	BService.method(){
	  
	}
	
	@Transactional(propagation = Propagation.NESTED)
	CService.method(){
		throw E
	}
}catch(E e){
	e.print
}

在博文spring事务中的陷阱:事务提交时回滚中说过，如果是默认传播属性，上述过程的数据都会回滚。现在换了传播属性，spring处理的方式就点不一样了。

1.首先CService切面的执行过程与上述一致，不过还提到：在回滚到回滚点后，rollbackOnly属性被置为false了。
2.然后，由于异常没有往外抛，所以AService的切面不会捕获到异常，于是进入commitTransactionAfterReturning方法，进行提交逻辑，但是此时发现连接对象的rollbackOnly属性为false，于是它直接进行提交。

所以，B中的数据不会被回滚！