前提

最近在某個公司實習，框架使用的是springmvc+spring+mybatis，具體名字就不說了，所有事務都沒有用無法回滾，導師叫我和db人員對接，我就寫了一個Jdbc的原生的測試測試程式碼如下:

 try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        //url寫測試中介軟體的,這裡我替換了
        String url="jdbc:mysql://localhost:3306/taotao?characterEncoding=utf-8"
 
;
        String username="root";
        String passwd="123456";
        Connection conn= null;
        try {
            conn = DriverManager.getConnection(url, username, passwd);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        try{
        conn.setAutoCommit(false);
 

        PreparedStatement pstmt = conn.prepareStatement("insert into lztt (text) VALUES (?)") ;
            pstmt.execute("start TRANSACTION ");
            pstmt.setString(1,"memeda");
        pstmt.executeUpdate();
            PreparedStatement pstmt1 = conn.prepareStatement("insert into lztt (text) VALUES (?)"
 
) ;
            pstmt1.setString(1,"dsajdijsaoidjiosajdoisajdoijsaoidjsaoijdoisajidjsoajdijsaidjsajdsad");

            pstmt1.executeUpdate();
            conn.commit();
        }catch (Exception e){
            try {
                System.out.println(1);
                conn.rollback();
                System.out.println(2);
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
            e.printStackTrace();
        }finally {
            try {
                conn.setAutoCommit(true);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

通過上面的程式碼發現，是setautocommit(flase)不起作用，不起作用咋辦，難道事務就這樣沒辦法回滾了嗎,這裡我們可以手動的使用pstmt來開啟事務這樣就可以了pstmt.execute(“start TRANSACTION “);這是我們原生的使用方法,但是非原生的使用怎麼辦，也就是我們使用框架mybatis和spring。接下來介紹我的思路:

思路一

修改Spring的事務管理器，看過Spring原始碼的朋友都知道DataSourceTransactionManager是我們管理Spring和Mybatis事務的地方，doBegin()方法就是我們建立事務的地方,doBegin方法程式碼如下:

@Override
    protected void doBegin(Object transaction, TransactionDefinition definition) {
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
        Connection con = null;

        try {
            if (txObject.getConnectionHolder() == null ||
                    txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
                Connection newCon = this.dataSource.getConnection();
                if (logger.isDebugEnabled()) {
                    logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");
                }
                txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
            }

            txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
            con = txObject.getConnectionHolder().getConnection();

            Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
            txObject.setPreviousIsolationLevel(previousIsolationLevel);

            // Switch to manual commit if necessary. This is very expensive in some JDBC drivers,
            // so we don't want to do it unnecessarily (for example if we've explicitly
            // configured the connection pool to set it already).
            if (con.getAutoCommit()) {
                txObject.setMustRestoreAutoCommit(true);
                if (logger.isDebugEnabled()) {
                    logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
                }
                con.setAutoCommit(false);
            }
            txObject.getConnectionHolder().setTransactionActive(true);

            int timeout = determineTimeout(definition);
            if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
                txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
            }

            // Bind the session holder to the thread.
            if (txObject.isNewConnectionHolder()) {
                TransactionSynchronizationManager.bindResource(getDataSource(), txObject.getConnectionHolder());
            }
        }

        catch (Throwable ex) {
            DataSourceUtils.releaseConnection(con, this.dataSource);
            throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", ex);
        }
    }

這裡有一句話:con.setAutoCommit(false);但是對我們的中介軟體不起作用,這時我的思路來了，繼承這個類然後重寫doBegin()方法，然而我發現這是不可能的，有些物件的方法是protected我子類根本沒辦法使用，這裡我放棄了。

思路二

所有程式碼重寫，這工作量太大，考慮了一會就沒想了

思路三

這也是我後面採取的思路,利用自定義註解加AOP的方法實現。我們可以利用AOP在方法執行之前就可以執行資料庫的東西，這下問題來了，我怎麼才能獲得資料庫連線了，看spring原始碼找了好久，找到了一個工具，利用資料庫連線池可以獲得繫結我們執行緒的連結。Connection connection = DataSourceUtils.getConnection(this.dataSource);
具體的切面:

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.Ordered;
import org.springframework.jdbc.datasource.DataSourceUtils;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.SQLException;

/**
 * Created by lz on 2016/7/11.
 */
@Component
@Aspect
public class TransactionBeforeAop {
    private static final Logger log = LoggerFactory.getLogger(TransactionBeforeAop.class);
    @Autowired
    private DataSource dataSource;
    @Before("@annotation(com.bank.TransactionBefore)")
    public void before(JoinPoint joinPoint){
        Connection connection = DataSourceUtils.getConnection(this.dataSource);

        try {
            connection.prepareStatement("").execute("start TRANSACTION");
        } catch (SQLException e) {
            log.error("occur Exception",e.getMessage());
        }
    }
}

註解定義如下:

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Created by lz on 2016/7/11.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface TransactionBefore {

}

完成後我們就可以在Service中使用了。