Mybatis整合Spring的事务控制与SqlSession线程安全问题

冷不防 2023-10-11 20:28 10阅读 0赞

在Spring与Mybatis框架整合中，主要有两个重要改动，分别是事务与SqlSession。mybatis-spring包中为以上两个问题提供了解决方案。

*  重要组件

1.  SpringManagedTransaction （Spring事务管理器）
2.  SqlSessionTemplate （SqlSession的实现）
3.  SqlSessionFactoryBean（整合中取代SqlSessionFactoryBuilder作用，创建SqlSessionFactory类）
4.  SpringManagedTransactionFactory（Spring事务工厂）

*  整合流程

（1）在MybatisAutoConfiguration中给容器中注入了一个SqlSessionFactory 。

@Bean
        @ConditionalOnMissingBean
        public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
        
            SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
            factory.setDataSource(dataSource);

而这个SqlSessionFactory 中的SpringManagedTransactionFactory，这个类实现了mybatis的顶级接口TransactionFactory，此时mybatis将不再管理事务，连接的获取和回滚也完全由Spring管理。

targetConfiguration.setEnvironment(new Environment(this.environment, (TransactionFactory)(this.transactionFactory == null ? new SpringManagedTransactionFactory() : this.transactionFactory), this.dataSource));

这样的话每次在mapper执行相关方法时都会创建一个事务对象，这里自然就是创建的Spring的事务对象。

public class SpringManagedTransaction implements Transaction {
        
        private static final Logger LOGGER = LoggerFactory.getLogger(SpringManagedTransaction.class);
        private final DataSource dataSource;
        private Connection connection;
        private boolean isConnectionTransactional;
        private boolean autoCommit;
    
        public SpringManagedTransaction(DataSource dataSource) {
        
            Assert.notNull(dataSource, "No DataSource specified");
            this.dataSource = dataSource;
        }
    
        public Connection getConnection() throws SQLException {
        
            if (this.connection == null) {
        
                this.openConnection();
            }
    
            return this.connection;
        }
    
        private void openConnection() throws SQLException {
        
            this.connection = DataSourceUtils.getConnection(this.dataSource);
            this.autoCommit = this.connection.getAutoCommit();
            this.isConnectionTransactional = DataSourceUtils.isConnectionTransactional(this.connection, this.dataSource);
            LOGGER.debug(() -> {
        
                return "JDBC Connection [" + this.connection + "] will" + (this.isConnectionTransactional ? " " : " not ") + "be managed by Spring";
            });
        }
    
        public void commit() throws SQLException {
        
            if (this.connection != null && !this.isConnectionTransactional && !this.autoCommit) {
        
                LOGGER.debug(() -> {
        
                    return "Committing JDBC Connection [" + this.connection + "]";
                });
                this.connection.commit();
            }
    
        }
    
        public void rollback() throws SQLException {
        
            if (this.connection != null && !this.isConnectionTransactional && !this.autoCommit) {
        
                LOGGER.debug(() -> {
        
                    return "Rolling back JDBC Connection [" + this.connection + "]";
                });
                this.connection.rollback();
            }
    
        }
    
        public void close() throws SQLException {
        
            DataSourceUtils.releaseConnection(this.connection, this.dataSource);
        }
    
        public Integer getTimeout() throws SQLException {
        
            ConnectionHolder holder = (ConnectionHolder)TransactionSynchronizationManager.getResource(this.dataSource);
            return holder != null && holder.hasTimeout() ? holder.getTimeToLiveInSeconds() : null;
        }
    }

在openConnection的时候，事务对象是从DataSourceUtils.getConnection(this.dataSource);此时Spring会往当前线程中存一个Connection连接,那么在同一个方法中，多个mapper在获取connection时，其实都是获取的一个connection，当整个service方法执行结束时，Spring的事务管理器会统一执行commit方法。

（2）MybatisAutoConfiguration中同时给容器中注入了一个SqlSessionTemplate。

@Bean
        @ConditionalOnMissingBean
        public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        
            ExecutorType executorType = this.properties.getExecutorType();
            return executorType != null ? new SqlSessionTemplate(sqlSessionFactory, executorType) : new SqlSessionTemplate(sqlSessionFactory);
        }

SqlSessionTemplate 替代了之前的sqlsession，用来解决mapper之间的线程安全问题。  
SqlSessionTemplate的getMapper代码如下：

public <T> T getMapper(Class<T> type) {
        
            return this.getConfiguration().getMapper(type, this);
        }

可以看到，此时依然是调用的configuration对象的getMapper方法，但是SqlSession对象传递的是this，而这里的this为sqlSessionTemplate对象，无论是通过mapper还是sqlId，在最终执行sql时，都是用的sqlSession对象。那么我们就看SqlSessionTemplate对象是如何执行sql的。

以selectList方法为例，我们发现sqlSessionTemplate中的相关方法都是通过sqlSessionProxy对象去执行的。

public <E> List<E> selectList(String statement) {
        
            return this.sqlSessionProxy.selectList(statement);
        }
    
        public <E> List<E> selectList(String statement, Object parameter) {
        
            return this.sqlSessionProxy.selectList(statement, parameter);
        }
    
        public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
        
            return this.sqlSessionProxy.selectList(statement, parameter, rowBounds);
        }

而通过构造方法排查，这个sqlSessionProxy竟然是个SqlSession的代理对象。

public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator) {
        
            Assert.notNull(sqlSessionFactory, "Property 'sqlSessionFactory' is required");
            Assert.notNull(executorType, "Property 'executorType' is required");
            this.sqlSessionFactory = sqlSessionFactory;
            this.executorType = executorType;
            this.exceptionTranslator = exceptionTranslator;
            this.sqlSessionProxy = (SqlSession)Proxy.newProxyInstance(SqlSessionFactory.class.getClassLoader(), new Class[]{
        SqlSession.class}, new SqlSessionTemplate.SqlSessionInterceptor());
        }

代理对象的实现逻辑封装在了SqlSessionTemplate.SqlSessionInterceptor类中，我们只需要弄清这个类的实现原理即可。

果不其然这个类实现了InvocationHandler接口

private class SqlSessionInterceptor implements InvocationHandler {
        
            private SqlSessionInterceptor() {
        
            }
    
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
                SqlSession sqlSession = SqlSessionUtils.getSqlSession(SqlSessionTemplate.this.sqlSessionFactory, SqlSessionTemplate.this.executorType, SqlSessionTemplate.this.exceptionTranslator);
    
                Object unwrapped;
                try {
        
                    Object result = method.invoke(sqlSession, args);
                    if (!SqlSessionUtils.isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) {
        
                        sqlSession.commit(true);
                    }
    
                    unwrapped = result;
                } catch (Throwable var11) {
        
                    unwrapped = ExceptionUtil.unwrapThrowable(var11);
                    if (SqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) {
        
                        SqlSessionUtils.closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
                        sqlSession = null;
                        Throwable translated = SqlSessionTemplate.this.exceptionTranslator.translateExceptionIfPossible((PersistenceException)unwrapped);
                        if (translated != null) {
        
                            unwrapped = translated;
                        }
                    }
    
                    throw (Throwable)unwrapped;
                } finally {
        
                    if (sqlSession != null) {
        
                        SqlSessionUtils.closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
                    }
    
                }
    
                return unwrapped;
            }
        }

在invoke方法中是通过 SqlSession sqlSession = SqlSessionUtils.getSqlSession(SqlSessionTemplate.this.sqlSessionFactory, SqlSessionTemplate.this.executorType, SqlSessionTemplate.this.exceptionTranslator);  
来获取sqlSession的，我们跟进这个方法。

![在这里插入图片描述][65c1622efbaf46fd97e6e7f51fb5e4b0.png]  
发现最终还是调用了openSession这个方法，但是这里要注意了，每次调用任何mapper的任何方法，都会重新开启一个openSession，每个session中的事务管理器也都是spring管理，这样的话就避免了线程安全问题，保证每一个mapper方法的调用都会有独立的sqlSession，同时事务又交由Spring管理。这样Mybatis可以与Spring进行整合，实现面向接口编程。

[65c1622efbaf46fd97e6e7f51fb5e4b0.png]: https://img-blog.csdnimg.cn/65c1622efbaf46fd97e6e7f51fb5e4b0.png