Mybatis的事务接口如下：
public interface Transaction {
Connection getConnection() throws SQLException;
void commit() throws SQLException;
void rollback() throws SQLException;
void close() throws SQLException;
Integer getTimeout() throws SQLException;
}
事务类的继承体系如图：
事务的继承体系
JdbcTransaction是对JDBK commit & rollback简单封装。
ManagedTransaction托管事务，空壳事务管理器。在其它环境中应用时，把事务托管给其它框架，比如托管给Spring。
下面分析Mybatis的JdbcTransaction事务提交和管理过程相关源码。
在我们执行SqlSession.openSession()开启一个session的过程中，就已经开启了一个事务，并设置了事务的autocommit属性为false。
public SqlSession openSession() {
return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
}
private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
Transaction tx = null;
try {
final Environment environment = configuration.getEnvironment();
//通过TransactionFactory 事务工厂类生成一个新的事务实例
final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
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();
}
}
这里通过TransactionFactory 事务工厂类生成一个新的事务实例，TransactionFactory 事务工厂的类继承结构如下：
TransactionFactory 类继承结构
工厂类有类的实例获取方法，而且我们可以通过mybatis-config.xml中配置获取事务的工厂类：
<transactionManager type="JDBC"/>
而后我们对SqlSession进行各类更新操作，因为之前开启session时，设置了autocommit属性为false，所以事务会在调用Transaction.commit() | rollback()时才会提交或回滚。
最后我们手动调用SqlSession.commit()：
@Override
public void commit() {
commit(false);
}
@Override
public void commit(boolean force) {
try {
executor.commit(isCommitOrRollbackRequired(force));
dirty = false;
} catch (Exception e) {
throw ExceptionFactory.wrapException("Error committing transaction. Cause: " + e, e);
} finally {
ErrorContext.instance().reset();
}
}
这里会委托到具体的执行器Executor进行commit操作：
@Override
public void commit(boolean required) throws SQLException {
if (closed) {
throw new ExecutorException("Cannot commit, transaction is already closed");
}
clearLocalCache();
flushStatements();
if (required) {
transaction.commit();
}
}
委托到Transaction的commit操作：
public void commit() throws SQLException {
if (connection != null && !connection.getAutoCommit()) {
if (log.isDebugEnabled()) {
log.debug("Committing JDBC Connection [" + connection + "]");
}
connection.commit();
}
}
最终调用Connection.commit()进行事务的提交。
总结上述调用过程为：
Mybatis事务调用过程
几个注意点
1. 一个SqlSession的生命周期内，可以有无数个事务提交。
如以下代码：
User user2 = new User();
user2.setFirstName("firstname");
user2.setLastName("lastname");
session.insert("mybatis.dao.UserMapper.insert", user2);
session.commit();//第一次事务提交
session.insert("mybatis.dao.UserMapper.insert", user2);
session.commit();//第二次事务提交
从以上的源码分析可知，在SqlSession创建之初，即设置了Transaction的autocommit属性为false，那么每次执行update操作时：
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);
//预处理sql语句，这里获取数据库连接
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;
}
public Connection getConnection() throws SQLException {
//如果是首次获取connection连接，则新建一个数据库连接
if (connection == null) {
openConnection();
}
return connection;
}
protected Connection getConnection(Log statementLog) throws SQLException {
//从transaction实例中获取数据库连接
Connection connection = transaction.getConnection();
if (statementLog.isDebugEnabled()) {
return ConnectionLogger.newInstance(connection, statementLog, queryStack);
} else {
return connection;
}
}
protected void openConnection() throws SQLException {
if (log.isDebugEnabled()) {
log.debug("Opening JDBC Connection");
}
connection = dataSource.getConnection();
if (level != null) {
connection.setTransactionIsolation(level.getLevel());
}
//这里设置了autocommit参数为默认的false，事务不会自动提交，必须手动提交
setDesiredAutoCommit(autoCommmit);
}
protected void setDesiredAutoCommit(boolean desiredAutoCommit) {
try {
if (connection.getAutoCommit() != desiredAutoCommit) {
if (log.isDebugEnabled()) {
log.debug("Setting autocommit to " + desiredAutoCommit + " on JDBC Connection [" + connection + "]");
}
connection.setAutoCommit(desiredAutoCommit);
}
} catch (SQLException e) {
// Only a very poorly implemented driver would fail here,
// and there's not much we can do about that.
throw new TransactionException("Error configuring AutoCommit. "
+ "Your driver may not support getAutoCommit() or setAutoCommit(). "
+ "Requested setting: " + desiredAutoCommit + ". Cause: " + e, e);
}
}
所以，在同一个SqlSession的生命周期中，会复用一个connection连接，当调用SqlSession.commit()执行事务提交后，会提交生效上一次commit提交之后的所有数据库更改操作，当再次调用commit操作时，仍然会提交生效上一次commit提交之后的所有数据库更改操作。
2.如果没有执行commit操作，会是什么情况？
insert后，在事务的超时时间内，如果事务隔离级别是read uncommitted，我们可以查到该条记录。当超过超时时间，仍没有收到事务的commit，那么事务将会被回滚。
3.关于SqlSession.close()
正确的使用Mybatis的编程模型是：
String resource = "mybatis-config.xml";
InputStream inputStream = new ClassPathResource(resource).getInputStream();
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session = sqlSessionFactory.openSession();
try {
session.insert(……);
session.commit();
} catch (Exception e) {
session.rollback();
} finally {
session.close();
}
那么close操作到底执行了什么操作呢？如果我们不执行commit，直接执行close操作呢？
public void close() {
try {
//计算是否需要强制回滚
executor.close(isCommitOrRollbackRequired(false));
closeCursors();
dirty = false;
} finally {
ErrorContext.instance().reset();
}
}
private boolean isCommitOrRollbackRequired(boolean force) {
return (!autoCommit && dirty) || force;
}
isCommitOrRollbackRequired计算方法中，force=false, autoCommit=false，那么就看dirty的取值情况了。
通过分析可知，dirty其余情况都是==false，只有在update方法内部会设置为true
public int update(String statement, Object parameter) {
try {
dirty = true;
MappedStatement ms = configuration.getMappedStatement(statement);
return executor.update(ms, wrapCollection(parameter));
} catch (Exception e) {
throw ExceptionFactory.wrapException("Error updating database. Cause: " + e, e);
} finally {
ErrorContext.instance().reset();
}
}
在commit, rollback后，会设置为dirty=false。
所以针对上面的情况，事务中，执行了update操作，dirty=true，不执行commit，那么在close时，(!autoCommit && dirty) || force == (true && true ) || false = true，会执行回滚操作。
