I. Overview
This module is about transactions. I looked at the code. If it is not deep, I just have an idea after reading it. Does this realize the transaction? Shouldn't it? how could be. Shouldn't it be more difficult? I really think these are simple implementations. It should not be the nest of affairs. Our usual project should use the set of affairs written in spring. For now, let's first look at what is going on.
Look at how many categories there are under the package
Two: TransactionFactory class
/**
* Copyright 2009-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.ibatis.transaction;
import java.sql.Connection;
import java.util.Properties;
import javax.sql.DataSource;
import org.apache.ibatis.session.TransactionIsolationLevel;
/**
* Creates {@link Transaction} instances.
*
* @author Clinton Begin
*/
public interface TransactionFactory {
/**
* Sets transaction factory custom properties.
*
* 这个加了default 所以实现类可以实现也可以不实现。JdbcTransactionFactory就没有进行实现
*
* 设置工厂的属性
*
* @param props 属性
*/
default void setProperties(Properties props) {
// NOP
}
/**
* Creates a {@link Transaction} out of an existing connection.
* 创建 Transaction 事务
*
* @param conn Existing database connection
* @return Transaction
* @since 3.1.0
*/
Transaction newTransaction(Connection conn);
/**
* Creates a {@link Transaction} out of a datasource.
* 创建 Transaction 事务
*
* @param dataSource DataSource to take the connection from
* @param level Desired isolation level
* @param autoCommit Desired autocommit
* @return Transaction
* @since 3.1.0
*/
Transaction newTransaction(DataSource dataSource, TransactionIsolationLevel level, boolean autoCommit);
}
JdbcTransactionFactory 类，就没有实现接口中的setProperties方法，代码如下/**
* Copyright 2009-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.ibatis.transaction.jdbc;
import java.sql.Connection;
import javax.sql.DataSource;
import org.apache.ibatis.session.TransactionIsolationLevel;
import org.apache.ibatis.transaction.Transaction;
import org.apache.ibatis.transaction.TransactionFactory;
/**
* Creates {@link JdbcTransaction} instances.
* 创建实例 JdbcTransaction 的工厂类
* @author Clinton Begin
*
* @see JdbcTransaction
*/
public class JdbcTransactionFactory implements TransactionFactory {
@Override
public Transaction newTransaction(Connection conn) {
// 创建 JdbcTransaction 对象
return new JdbcTransaction(conn);
}
@Override
public Transaction newTransaction(DataSource ds, TransactionIsolationLevel level, boolean autoCommit) {
// 创建 JdbcTransaction 对象
return new JdbcTransaction(ds, level, autoCommit);
}
}
ManagedTransactionFactory 类，/**
* Copyright 2009-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.ibatis.transaction.managed;
import java.sql.Connection;
import java.util.Properties;
import javax.sql.DataSource;
import org.apache.ibatis.session.TransactionIsolationLevel;
import org.apache.ibatis.transaction.Transaction;
import org.apache.ibatis.transaction.TransactionFactory;
/**
* Creates {@link ManagedTransaction} instances.
*
* @author Clinton Begin
*
* @see ManagedTransaction
*/
public class ManagedTransactionFactory implements TransactionFactory {
/**
* 是否关闭连接
*/
private boolean closeConnection = true;
@Override
public void setProperties(Properties props) {
// 获得是否关闭连接属性
if (props != null) {
String closeConnectionProperty = props.getProperty("closeConnection");
if (closeConnectionProperty != null) {
closeConnection = Boolean.parseBoolean(closeConnectionProperty);
}
}
}
@Override
public Transaction newTransaction(Connection conn) {
// 创建 ManagedTransaction 对象
return new ManagedTransaction(conn, closeConnection);
}
@Override
public Transaction newTransaction(DataSource ds, TransactionIsolationLevel level, boolean autoCommit) {
// Silently ignores autocommit and isolation level, as managed transactions are entirely
// controlled by an external manager. It's silently ignored so that
// code remains portable between managed and unmanaged configurations.
//静默忽略autocommit和隔离级别，因为托管事务是完全的
//由外部管理者控制。它被无声地忽略了
//代码在托管和非托管配置之间保持可移植性。
return new ManagedTransaction(ds, level, closeConnection);
}
}
TransactionFactory 和2个实现类的代码就是这么简单。说这个叫什么模式呢，工厂模式吗？我感觉不像，我也不知道他是什么鬼模式，反正代码先是这个样，等我以后知道了。再来补充Three: Transaction interface and its implementation class JdbcTransaction, ManagedTransaction
The transaction code is as follows:
/**
* Copyright 2009-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.ibatis.transaction;
import java.sql.Connection;
import java.sql.SQLException;
/**
* Wraps a database connection.
* Handles the connection lifecycle that comprises: its creation, preparation, commit/rollback and close.
*
* 封装数据库连接。
* 处理连接生命周期，包括:它的创建，准备，提交/回滚和关闭
* @author Clinton Begin
*/
public interface Transaction {
/**
* Retrieve inner database connection.
* 连接相关-》获得连接
*
* @return DataBase connection
* @throws SQLException
* the SQL exception
*/
Connection getConnection() throws SQLException;
/**
* 连接相关-》关闭连接
* Close inner database connection.
* @throws SQLException
* the SQL exception
*/
void close() throws SQLException;
/**
* 事务相关-》事务提交
*
* Commit inner database connection.
* @throws SQLException
* the SQL exception
*/
void commit() throws SQLException;
/**
* 事务相关-》事务回滚
*
* 只能回滚未提交的事务
* Rollback inner database connection.
* @throws SQLException
* the SQL exception
*/
void rollback() throws SQLException;
/**
* 事务相关-》获得事务超时时间
*
* Get transaction timeout if set.
*
* @return the timeout
* @throws SQLException
* the SQL exception
*/
Integer getTimeout() throws SQLException;
}
JdbcTransaction 类，这个类的close方法值得关注和思考。这个方法里面的Connection connection对象是代理对象还是真实的数据库连接对象。要想明白。我想了好一会。我嘛，比较菜。/**
* Copyright 2009-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.ibatis.transaction.jdbc;
import java.sql.Connection;
import java.sql.SQLException;
import javax.sql.DataSource;
import org.apache.ibatis.logging.Log;
import org.apache.ibatis.logging.LogFactory;
import org.apache.ibatis.session.TransactionIsolationLevel;
import org.apache.ibatis.transaction.Transaction;
import org.apache.ibatis.transaction.TransactionException;
/**
* {@link Transaction} that makes use of the JDBC commit and rollback facilities directly.
* It relies on the connection retrieved from the dataSource to manage the scope of the transaction.
* Delays connection retrieval until getConnection() is called.
* Ignores commit or rollback requests when autocommit is on.
*
* 它直接使用JDBC提交和回滚功能。
* *依赖于从数据源检索到的连接来管理事务的范围。
* *延迟连接检索，直到getConnection()被调用。
* *当自动提交时忽略提交或回滚请求。
* @author Clinton Begin
*
* @see JdbcTransactionFactory
*/
public class JdbcTransaction implements Transaction {
private static final Log log = LogFactory.getLog(JdbcTransaction.class);
/**
* Connection 对象
*/
protected Connection connection;
/**
* DataSource 对象
*/
protected DataSource dataSource;
/**
* 事务隔离级别
*/
protected TransactionIsolationLevel level;
/**
* 是否自动提交
*/
protected boolean autoCommit;
public JdbcTransaction(DataSource ds, TransactionIsolationLevel desiredLevel, boolean desiredAutoCommit) {
dataSource = ds;
level = desiredLevel;
autoCommit = desiredAutoCommit;
}
public JdbcTransaction(Connection connection) {
this.connection = connection;
}
@Override
public Connection getConnection() throws SQLException {
// 连接为空，进行创建
if (connection == null) {
openConnection();
}
return connection;
}
@Override
public void commit() throws SQLException {
// 非自动提交的事务，则可以提交事务
if (connection != null && !connection.getAutoCommit()) {
if (log.isDebugEnabled()) {
log.debug("Committing JDBC Connection [" + connection + "]");
}
connection.commit();
}
}
@Override
public void rollback() throws SQLException {
// 非自动提交的事务，则可以回滚事务
if (connection != null && !connection.getAutoCommit()) {
if (log.isDebugEnabled()) {
log.debug("Rolling back JDBC Connection [" + connection + "]");
}
connection.rollback();
}
}
/**
* 连接要关闭了。为啥要重置自动提交呢？ todo
* 数据源使用的是线程池PooledDataSource：
* 如果使用了连接池，也就是使用了PooledDataSource 里面的getConnection方法，那么获取到的连接就是一个代理对象
* 代理对象中。PooledConnection 类的invoke方法会对关闭进行拦截。会调用pushConnection方法。
* 这个方法在DataSource模块有说过的，这个方法就是把连接放到闲置的连接池中去。那么我们把这个自动提交进行重置就是正确的。因为害怕下次取的连接这个属性被设置过。
*
* 数据源使用的是 “非” 线程池PooledDataSource：
* 那么connection.close() 就是直接调用数据库中的关闭方法了。那么就算设置了自动提交，其实也无所谓的。
*
* @throws SQLException 异常。
*/
@Override
public void close() throws SQLException {
if (connection != null) {
// 重置为自动提交
resetAutoCommit();
if (log.isDebugEnabled()) {
log.debug("Closing JDBC Connection [" + connection + "]");
}
// 关闭连接
connection.close();
}
}
/**
* 设置指定的 autoCommit 属性
*
* @param desiredAutoCommit 是否自动提交的标识
*/
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);
}
}
/**
* 重置为自动提交。
*/
protected void resetAutoCommit() {
try {
if (!connection.getAutoCommit()) {
// MyBatis does not call commit/rollback on a connection if just selects were performed.
// Some databases start transactions with select statements
// and they mandate a commit/rollback before closing the connection.
// A workaround is setting the autocommit to true before closing the connection.
// Sybase throws an exception here.
if (log.isDebugEnabled()) {
log.debug("Resetting autocommit to true on JDBC Connection [" + connection + "]");
}
connection.setAutoCommit(true);
}
} catch (SQLException e) {
if (log.isDebugEnabled()) {
log.debug("Error resetting autocommit to true "
+ "before closing the connection. Cause: " + e);
}
}
}
protected void openConnection() throws SQLException {
if (log.isDebugEnabled()) {
log.debug("Opening JDBC Connection");
}
// 从数据库中获取连接
connection = dataSource.getConnection();
if (level != null) {
// 设置事务的级别
connection.setTransactionIsolation(level.getLevel());
}
// 设置自动提交
setDesiredAutoCommit(autoCommit);
}
@Override
public Integer getTimeout() throws SQLException {
return null;
}
}
ManagedTransaction 这个类里面干的事更少了。我就不相信这个类，单纯就靠这个类能实现事务。我认为这个肯定也只是个外壳。如果我以后看到了。会回来补充的。todo/**
* Copyright 2009-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.ibatis.transaction.managed;
import java.sql.Connection;
import java.sql.SQLException;
import javax.sql.DataSource;
import org.apache.ibatis.logging.Log;
import org.apache.ibatis.logging.LogFactory;
import org.apache.ibatis.session.TransactionIsolationLevel;
import org.apache.ibatis.transaction.Transaction;
/**
* {@link Transaction} that lets the container manage the full lifecycle of the transaction.
* 让容器管理事务的整个生命周期
* Delays connection retrieval until getConnection() is called.
* 延迟连接检索，直到getConnection()被调用
* Ignores all commit or rollback requests.
*忽略所有提交或回滚请求
* By default, it closes the connection but can be configured not to do it.
* 默认情况下，它关闭连接，但可以配置不这样做。
* @author Clinton Begin
*
* @see ManagedTransactionFactory
*/
public class ManagedTransaction implements Transaction {
private static final Log log = LogFactory.getLog(ManagedTransaction.class);
/**
* DataSource 对象
*/
private DataSource dataSource;
/**
* 事务隔离级别
*/
private TransactionIsolationLevel level;
/**
* Connection 对象
*/
private Connection connection;
/**
* 是否关闭连接
*
* 这个属性是和 {@link org.apache.ibatis.transaction.jdbc.JdbcTransaction} 不同的
*/
private final boolean closeConnection;
public ManagedTransaction(Connection connection, boolean closeConnection) {
this.connection = connection;
this.closeConnection = closeConnection;
}
public ManagedTransaction(DataSource ds, TransactionIsolationLevel level, boolean closeConnection) {
this.dataSource = ds;
this.level = level;
this.closeConnection = closeConnection;
}
@Override
public Connection getConnection() throws SQLException {
// 连接为空，进行创建
if (this.connection == null) {
openConnection();
}
return this.connection;
}
@Override
public void commit() throws SQLException {
// Does nothing
}
@Override
public void rollback() throws SQLException {
// Does nothing
}
@Override
public void close() throws SQLException {
// 如果开启关闭连接功能，则关闭连接
if (this.closeConnection && this.connection != null) {
if (log.isDebugEnabled()) {
log.debug("Closing JDBC Connection [" + this.connection + "]");
}
this.connection.close();
}
}
protected void openConnection() throws SQLException {
if (log.isDebugEnabled()) {
log.debug("Opening JDBC Connection");
}
// 获得连接
this.connection = this.dataSource.getConnection();
// 设置隔离级别
if (this.level != null) {
this.connection.setTransactionIsolation(this.level.getLevel());
}
}
@Override
public Integer getTimeout() throws SQLException {
return null;
}
}
Four: Summary
I will answer myself in the future
The ManagedTransaction class is too simple. I think it is impossible to achieve affairs in this way. Want to come back to add.
There are two implementation classes under the TransactionFactory interface. I think it's a simple interface, multiple implementations, not a design pattern. I haven't seen any design patterns yet, and I don't have a deep understanding of design patterns. I want to keep this question until I understand it. Come back to add
in conclusion
- Under this package, the only thing you need to think about is the JdbcTransaction class. The close method of this class is worthy of attention and consideration, and the other codes are relatively simple.
- ok! The first day of work. Finished the work. I worked overtime to write this blog. I hope useful to you. If you are like me. Some dishes, but not reconciled.
The next preview: Cache package code reading.