前面学习Mybatis中Executor执行sql时，只研究了非事务执行时，直接DataSource.getConnection()创建连接。这里学习一下事务执行。
前提：SpringAOP——事务实现中学习到：Spring开启事务时会创建一个“事务连接”（需要手动提交的连接）然后通过ThreadLocal的方式，存储到当前线程中。
起因是面试官问了一个问题：spring中的事务连接和mybatis中的事务连接是否是同一个？
回答说：是同一个，但是说不出具体实现来(ThreadLocal)。
也就是说“事务连接”是Spring中创建的，Mybatis执行sql时，会从线程中取出“事务连接”，然后创建statement执行。结合前面学习的mybatis源码，用源码求证一下
一、复习mybatis与spring的交界处——代理实现
MapperFactoryBean.getObject()创建了一个接口的代理实例，InvocationHandler是MapperProxy类型，方法调用代码如下：
/* org.apache.ibatis.binding.MapperProxy#invoke */ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { try { if (Object.class.equals(method.getDeclaringClass())) { //Object的方法直接执行mapperProxy的方法 return method.invoke(this, args); } else if (isDefaultMethod(method)) { //静态方法直接执行 return invokeDefaultMethod(proxy, method, args); } } catch (Throwable t) { throw ExceptionUtil.unwrapThrowable(t); } //new MapperMethod(mapperInterface, method, configuration) //实际new sqlCommond(mapperInterface, mehod, configuration) //sqlCommond.name = mapperStatement.getId //sqlCommond.type = ms.getSqlCommondType()--insert|delete|update|select final MapperMethod mapperMethod = cachedMapperMethod(method); //sqlSession根据sqlCommondType执行对应sql，例如当sqlCommondType == select时 //sqlsession.select(sqlCommond.name) return mapperMethod.execute(sqlSession, args); } /* org.apache.ibatis.binding.MapperMethod#execute */ public Object execute(SqlSession sqlSession, Object[] args) { Object result; switch (command.getType()) { case INSERT: { Object param = method.convertArgsToSqlCommandParam(args); result = rowCountResult(sqlSession.insert(command.getName(), param)); break; } case UPDATE: { Object param = method.convertArgsToSqlCommandParam(args); result = rowCountResult(sqlSession.update(command.getName(), param)); break; } case DELETE: { Object param = method.convertArgsToSqlCommandParam(args); result = rowCountResult(sqlSession.delete(command.getName(), param)); break; } case SELECT: if (method.returnsVoid() && method.hasResultHandler()) { executeWithResultHandler(sqlSession, args); result = null; } else if (method.returnsMany()) { result = executeForMany(sqlSession, args); } else if (method.returnsMap()) { result = executeForMap(sqlSession, args); } else if (method.returnsCursor()) { result = executeForCursor(sqlSession, args); } else { Object param = method.convertArgsToSqlCommandParam(args); result = sqlSession.selectOne(command.getName(), param); } break; case FLUSH: result = sqlSession.flushStatements(); break; default: throw new BindingException("Unknown execution method for: " + command.getName()); } if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) { throw new BindingException("Mapper method '" + command.getName() + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ")."); } return result; }
二、mybatis中事务实现
以上面的insert为例，result = rowCountResult(sqlSession.insert(command.getName(), param));
sqlSession.insert()-->BaseExecutor.update()-->SimpleExecutor.doUpdate()
/* org.apache.ibatis.executor.SimpleExecutor#doUpdate */ public int doUpdate(MappedStatement ms, Object parameter) throws SQLException { Statement stmt = null; try { Configuration configuration = ms.getConfiguration(); StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null); //这里获取连接并创建statement stmt = prepareStatement(handler, ms.getStatementLog()); return handler.update(stmt); } finally { closeStatement(stmt); } } private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException { Statement stmt; //获取连接 Connection connection = getConnection(statementLog); stmt = handler.prepare(connection, transaction.getTimeout()); handler.parameterize(stmt); return stmt; } /* org.apache.ibatis.executor.BaseExecutor#getConnection */ protected Connection getConnection(Log statementLog) throws SQLException { //获取连接transaction.getconnection() Connection connection = transaction.getConnection(); if (statementLog.isDebugEnabled()) { return ConnectionLogger.newInstance(connection, statementLog, queryStack); } else { return connection; } }
重点是BaseExecutor初始化时，transaction属性的类型。
/* org.apache.ibatis.session.defaults.DefaultSqlSessionFactory#openSessionFromDataSource */ private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) { Transaction tx = null; try { final Environment environment = configuration.getEnvironment(); final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment); //transaction属性 tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit); final Executor executor = configuration.newExecutor(tx, execType); return new DefaultSqlSession(configuration, executor, autoCommit); } catch (Exception e) { closeTransaction(tx); // may have fetched a connection so lets call close() throw ExceptionFactory.wrapException("Error opening session. Cause: " + e, e); } finally { ErrorContext.instance().reset(); } } private TransactionFactory getTransactionFactoryFromEnvironment(Environment environment) { //需要确定environment.getTransactionFactory的类型 if (environment == null || environment.getTransactionFactory() == null) { return new ManagedTransactionFactory(); } return environment.getTransactionFactory(); }
确定environment.transactionFactory属性：SpringManagedTransactionFactory类型的实例
/* org.mybatis.spring.SqlSessionFactoryBean#buildSqlSessionFactory */ protected SqlSessionFactory buildSqlSessionFactory() throws IOException { Configuration configuration; //... if (this.transactionFactory == null) { this.transactionFactory = new SpringManagedTransactionFactory(); } //transactionFactory是SpringManagedTransactionFactory类型实例 configuration.setEnvironment(new Environment(this.environment, this.transactionFactory, this.dataSource)); //... return this.sqlSessionFactoryBuilder.build(configuration); }
所以transaction是SpringManagedTransaction类型实例
/* org.mybatis.spring.transaction.SpringManagedTransactionFactory#newTransaction(javax.sql.DataSource, org.apache.ibatis.session.TransactionIsolationLevel, boolean) */ public Transaction newTransaction(DataSource dataSource, TransactionIsolationLevel level, boolean autoCommit) { return new SpringManagedTransaction(dataSource); }
Mybatis事务最终获取连接：SpringManagedTransaction.getConnection()
/* org.mybatis.spring.transaction.SpringManagedTransaction#getConnection */ public Connection getConnection() throws SQLException { if (this.connection == null) { 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); if (LOGGER.isDebugEnabled()) { LOGGER.debug( "JDBC Connection [" + this.connection + "] will" + (this.isConnectionTransactional ? " " : " not ") + "be managed by Spring"); } } /* org.springframework.jdbc.datasource.DataSourceUtils#getConnection */ public static Connection getConnection(DataSource dataSource) throws CannotGetJdbcConnectionException { try { return doGetConnection(dataSource); } catch (SQLException ex) { throw new CannotGetJdbcConnectionException("Failed to obtain JDBC Connection", ex); } catch (IllegalStateException ex) { throw new CannotGetJdbcConnectionException("Failed to obtain JDBC Connection: " + ex.getMessage()); } } public static Connection doGetConnection(DataSource dataSource) throws SQLException { Assert.notNull(dataSource, "No DataSource specified"); //从当前线程中获取连接 //connectionHolder = Thread.currentThread().get("Transactinal resources").get(dataSource) ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource); if (conHolder != null && (conHolder.hasConnection() || conHolder.isSynchronizedWithTransaction())) { conHolder.requested(); if (!conHolder.hasConnection()) { //不是事务连接时，从DataSource获取一个连接 logger.debug("Fetching resumed JDBC Connection from DataSource"); conHolder.setConnection(fetchConnection(dataSource)); } //事务执行时，从Thread中获取spring创建的事务连接 //非事务执行时，直接从Datasource获取一个连接 return conHolder.getConnection(); } // Else we either got no holder or an empty thread-bound holder here. //获得一个没有事务连接的空封装器ConnectionHolder时，从DataSource获取一个连接 logger.debug("Fetching JDBC Connection from DataSource"); Connection con = fetchConnection(dataSource); if (TransactionSynchronizationManager.isSynchronizationActive()) { try { // Use same Connection for further JDBC actions within the transaction. // Thread-bound object will get removed by synchronization at transaction completion. ConnectionHolder holderToUse = conHolder; if (holderToUse == null) { holderToUse = new ConnectionHolder(con); } else { holderToUse.setConnection(con); } holderToUse.requested(); TransactionSynchronizationManager.registerSynchronization( new ConnectionSynchronization(holderToUse, dataSource)); holderToUse.setSynchronizedWithTransaction(true); if (holderToUse != conHolder) { TransactionSynchronizationManager.bindResource(dataSource, holderToUse); } } catch (RuntimeException ex) { // Unexpected exception from external delegation call -> close Connection and rethrow. releaseConnection(con, dataSource); throw ex; } } return con; }
验证完毕：
“事务连接”是Spring调用DataSource创建的，并放到线程中，Mybatis执行sql时，会从线程中取出“事务连接”，然后创建statement执行。（ThreadLocal实现）
“非事务连接”由mybatis直接调用DataSource创建。
补充：mybatis的两种config文件，需要注意传统配置文件，配置可能导致spring事务失效。
① 依赖mybatis-spring.jar后的配置文件，默认初始化SQLSessionFactoryBean时，初始化SpringManagedTransactionFactory放入到Environment中
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="dataSource"/> <property name="mapperLocations" value="mapper/UserMapper.xml"/> </bean>
② 传统的配置文件，<environment />有个属性<transactionManager />与上面transactionFactory对应，需要设置成SpringManagedTransactionFactory.class，否则Spring事务无效
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <!-- 配置文件的根元素 --> <configuration> <!-- ... --> <!-- 环境：配置mybatis的环境 --> <environments default="dev"> <!-- 环境变量：可以配置多个环境变量，比如使用多数据源时，就需要配置多个环境变量 --> <environment id="dev"> <!-- 事务管理器 --> <!-- "JDBC" == JdbcTransactionFactory.class 直接从datasource获取连接，会导致spring事务失效--> <transactionManager type="JDBC"></transactionManager> <!-- 数据源 --> <dataSource type="POOLED"> <property name="driver" value="${mysql.driver}"/> <property name="url" value="${mysql.url}"/> <property name="username" value="${mysql.username}"/> <property name="password" value="${mysql.password}"/> </dataSource> </environment> </environments> <!-- ... --> </configuration>