参考spring transaction management 简单的改造公司的persistence框架

╰+攻爆jí腚メ 2022-05-14 07:23 108阅读 0赞

> 公司的persistence是一个很久之前写的的框架了。期间经过了各种修修补补。最近要做的一个东西，需要支持数据库事务。  
> 看了下，居然不支持事务，这个猛。。。

下面是一个数据库操作的调用链  
![这里写图片描述][70]  
框架采用了命令模式，最后会调用到以下的代码里

UpdateDatabaseExecutor{
     public void invokeExecutor(...) throws Exception {
       ...
       java.sql.Connection con = null;
       con = ConnectionManager.getConnection();     
       //取到connection 后，并没有begin,rollback之类的事务支持
        stmt.beforeExecution();
        ret = stmt.executeUpdate(con);
        stmt.afterExecution(ret);
       ...
       PersistenceUtils.closeStuff(con, stmt, null);
     }
    }

由于知道所有的Connection都使用ConnectionManager.getConnection()，最后会调用到一个统一的代码里，如下

javax.sql.DataSource ds = (javax.sql.DataSource) result;
    final String username =getProperty("javax.sql.username", ctx_);
    final String password =getProperty("javax.sql.password", ctx_);
    if ((username != null) || (password != null)) {
     result = ds.getConnection(username, password);
    } else {
     result = ds.getConnection();
    }
    return result；

根据spring template transaction 里的源码的原理，begin的方法 取connection的并将connection放到threadlocal里。后面取得时候先判断threadlocal里是否已经存在Connection,如果存在的话，就从threadlocal里去取了。则可以改造代码加入如下

//加入的支持transaction处理开始
    transactionManager.setDataSource(ds);
    Connection connection = transactionManager.getConnection();
    if(connection!=null){
      return connection;
    }
    //加入的支持transaction处理结束
    javax.sql.DataSource ds = (javax.sql.DataSource) result;
        final String username =getProperty("javax.sql.username", ctx_);
        final String password =getProperty("javax.sql.password", ctx_);
        if ((username != null) || (password != null)) {
            result = ds.getConnection(username, password);
        } else {
            result = ds.getConnection();
        }
    return result；

那么关键就在于 transactionManager.getConnection();  
transactionManager也是我新加的一个类

public class TransactionManager { 
        //在线程上下文里存入一个ConnectionHolder的类
        private ThreadLocal<ConnectionHolder> ConnectionCache =new  
           ThreadLocal<ConnectionHolder>();
        private TransactionManager(){};
        //spring里dataSource可以有多个，而我的项目里只有一个
        private DataSource dataSource;
        private static TransactionManager instance = new TransactionManager(); 
        //单例
        public static TransactionManager getInstance(){
            return instance;
        }
        public DataSource getDataSource() {
            return dataSource;
        }
        public void setDataSource(DataSource dataSource) {
            this.dataSource = dataSource;
        }
        private ConnectionHolder get(){
            return ConnectionCache.get();
        }
        //getConnection的时候从上下文里先判断是否存在，如果有的就直接获取，没有就返回空
        public Connection getConnection() throws SQLException{
            Connection connection = null;
            ConnectionHolder holder =get();
            if(holder==null)
                return null;
            if(holder.getOwnerThread() == Thread.currentThread()){
                connection = holder.getConn();
            }
            if(connection!=null && !connection.isClosed() && !connection.getAutoCommit()){
                return connection;
            }
    
            return null;
        }
    
        public void setConnection(Connection conn) {
            ConnectionCache.set(new ConnectionHolder(conn,Thread.currentThread()));
        }
    
        public static class ConnectionHolder{ 
            private Connection conn;
            private Thread ownerThread;
            public ConnectionHolder(Connection conn, Thread ownerThread) {
                this.conn = conn;
                this.ownerThread = ownerThread;
            }
            public Connection getConn() {
                return conn;
            }
            public Thread getOwnerThread() {
                return ownerThread;
            }
        }
    
        public boolean hasConnectionInThread() throws SQLException{
            return getConnection()!=null;
        }
    
        public boolean hasConnectionInThread(Connection conn) throws SQLException{
            Connection connInThreadContext = getConnection();
            if(connInThreadContext==null)
                return false;
    
            if(connInThreadContext==conn)
                return true;
    
            return false;       
        }
           //调用doBegin,会将一个Connection放入到threadlocal里
        public Connection doBegin() throws ConnectionException, SQLException {
            Connection conn = null;
            conn = ConnectionManager.getConnection();
            conn.setAutoCommit(false);
            setConnection(conn);
            return conn;
        }
    
        public void commit() throws SQLException {
            getConnection().commit();
        }
    
        public void rollback() throws SQLException {
            getConnection().rollback();
        }
    
        public void close() throws SQLException {
            getConnection().close();
            ConnectionCache.remove();
        }          
    }

在调用的地方

public void processs(PendingUserValue pendingUserValue) {
             try {
                。。。
                TransactionManager.getInstance().doBegin();
                process(pendingUserValue);
                TransactionManager.getInstance().commit();
                       。。。
            }catch(Exception e){
               try {
                    TransactionManager.getInstance().rollback();                
            }finally{
                try {
                    TransactionManager.getInstance().close();
                } catch (SQLException e) {
                    。。。
                }
            }
    }

以为万事大吉了，在测试中发现，我们的数据库里的表的主键不是通过自增的方式来做的，而是通过一张主键表来维护的。  
也就是说process(pendingUserValue)里如果要插入一条记录，例如User， 就要先到主键表里获取到User的key,然后更新主键表里的User主键最大值，这样就需要执行commit操作。  
一旦commit的话，connection遇到错误就没法rollback了。这实际上是事务的传播机制里的 `RequiresNew`  
![当Transaction2执行的时候，transaction1需要挂起][Transaction2_transaction1]

当Transaction2执行的时候，transaction1需要挂起。

用我的项目里逻辑就是外面 process执行到需要获取主键时，获取的主键是一个单独的事务，这个单独事务不影响process的处理。因此看了下spring 对这部分的处理源码，然后在TransactionManager 里加入了如下代码

public class TransactionManager {
        //挂起
         public ConnectionHolder suspend() {
            ConnectionHolder holder= get();
            ConnectionCache.remove();
            return holder;
        }
        //恢复
        public void resume(ConnectionHolder holder) {
            ConnectionCache.set(holder);
        }
    }

获取主键的调用的时候，先挂起，再在finally里恢复，如下

TransactionManager.ConnectionHolder holder = null;
        try {
            if(TransactionManager.getInstance().hasConnectionInThread()){
                holder = TransactionManager.getInstance().suspend();
            }
            connection = ConnectionManager.getConnection();
            connection.commit(); 
        } finally {
            PersistenceUtils.closeStuff(connection, statement, resultSet);
            if(holder!=null)
                TransactionManager.getInstance().resume(holder);
    }

[70]: /images/20220514/ccb8f2c7dd7c4b11989ab72ced42ab87.png
[Transaction2_transaction1]: /images/20220514/247f9ef5514441409dae2444184a8f81.png