在数据持久层，数据源和事务是两个非常重要的组件，对数据持久层的影响很大，在实际开发中，一般会使用 Mybatis 集成第三方数据源组件，如：c3p0、Druid，另外，Mybatis 也提供了自己的数据库连接池实现，本文会通过 Mybatis 的源码实现来了解数据库连接池的设计。而事务方面，一般使用 Spring 进行事务的管理，这里不做详细分析。下面我们看一下 Mybatis 是如何对这两部分进行封装的。

1 DataSource

常见的数据源都会实现 javax.sql.DataSource 接口，Mybatis 中提供了两个该接口的实现类，分别是：PooledDataSource 和 UnpooledDataSource，并使用不同的工厂类分别管理这两个类的对象。

1.1 DataSourceFactory

DataSourceFactory 系列类 的设计比较简单，DataSourceFactory 作为顶级接口，UnpooledDataSourceFactory 实现了该接口，PooledDataSourceFactory 又继承了 UnpooledDataSourceFactory。

  1. public interface DataSourceFactory {
  3.   // 设置 DataSource 的属性，一般紧跟在 DataSource 初始化之后
  4.   void setProperties(Properties props);
  6.   // 获取 DataSource对象
  7.   DataSource getDataSource();
  8. }
  11. public class UnpooledDataSourceFactory implements DataSourceFactory {
  13.   private static final String DRIVER_PROPERTY_PREFIX = "driver.";
  14.   private static final int DRIVER_PROPERTY_PREFIX_LENGTH = DRIVER_PROPERTY_PREFIX.length();
  16.   protected DataSource dataSource;
  18.   // 在实例化该工厂时，就完成了 DataSource 的实例化
  19.   public UnpooledDataSourceFactory() {
  20.     this.dataSource = new UnpooledDataSource();
  21.   }
  23.   @Override
  24.   public void setProperties(Properties properties) {
  25.     Properties driverProperties = new Properties();
  26.     // 创建 dataSource 对应的 MetaObject
  27.     MetaObject metaDataSource = SystemMetaObject.forObject(dataSource);
  28.     // 处理 properties 中配置的数据源信息
  29.     for (Object key : properties.keySet()) {
  30.       String propertyName = (String) key;
  31.       if (propertyName.startsWith(DRIVER_PROPERTY_PREFIX)) {
  32.         // 以 "driver." 开头的配置项是对 DataSource 的配置，将其记录到 driverProperties 中
  33.         String value = properties.getProperty(propertyName);
  34.         driverProperties.setProperty(propertyName.substring(DRIVER_PROPERTY_PREFIX_LENGTH), value);
  35.       } else if (metaDataSource.hasSetter(propertyName)) {
  36.         String value = (String) properties.get(propertyName);
  37.         Object convertedValue = convertValue(metaDataSource, propertyName, value);
  38.         metaDataSource.setValue(propertyName, convertedValue);
  39.       } else {
  40.         throw new DataSourceException("Unknown DataSource property: " + propertyName);
  41.       }
  42.     }
  43.     if (driverProperties.size() > 0) {
  44.       // 设置数据源 UnpooledDataSource 的 driverProperties属性，
  45.       // PooledDataSource 中持有 UnpooledDataSource对象
  46.       metaDataSource.setValue("driverProperties", driverProperties);
  47.     }
  48.   }
  50.   @Override
  51.   public DataSource getDataSource() {
  52.     return dataSource;
  53.   }
  54. }
  57. public class PooledDataSourceFactory extends UnpooledDataSourceFactory {
  59.   // 与 UnpooledDataSourceFactory 的不同之处是，其初始化的 DataSource 为 PooledDataSource
  60.   public PooledDataSourceFactory() {
  61.     this.dataSource = new PooledDataSource();
  62.   }
  63. }

1.2 UnpooledDataSource

本实现类实现了 DataSource 接口 中的 getConnection() 及其重载方法，用于获取数据库连接。其中的主要属性及方法如下：

  1. public class UnpooledDataSource implements DataSource {
  3.   // 加载 Driver驱动类 的类加载器
  4.   private ClassLoader driverClassLoader;
  6.   // 数据库连接驱动的相关配置，通过 UnpooledDataSourceFactory 的 setProperties()方法 设置进来的
  7.   private Properties driverProperties;
  9.   // 缓存所有已注册的 数据库连接驱动Driver
  10.   private static Map<String, Driver> registeredDrivers = new ConcurrentHashMap<>();
  12.   // 数据库连接驱动名称
  13.   private String driver;
  14.   // 数据库url
  15.   private String url;
  16.   // 用户名
  17.   private String username;
  18.   // 密码
  19.   private String password;
  21.   // 是否自动提交事务
  22.   private Boolean autoCommit;
  23.   // 默认的事务隔离级别
  24.   private Integer defaultTransactionIsolationLevel;
  25.   // 默认的网络连接超时时间
  26.   private Integer defaultNetworkTimeout;
  28.   /**
  29.    * UnpooledDataSource 被加载时，会通过该静态代码块将已经在 DriverManager
  30.    * 中注册的 JDBC Driver 注册到 registeredDrivers 中
  31.    */
  32.   static {
  33.     Enumeration<Driver> drivers = DriverManager.getDrivers();
  34.     while (drivers.hasMoreElements()) {
  35.       Driver driver = drivers.nextElement();
  36.       registeredDrivers.put(driver.getClass().getName(), driver);
  37.     }
  38.   }
  40.   // getConnection() 及其重载方法、doGetConnection(String username, String password)方法
  41.   // 最终都会调用本方法
  42.   private Connection doGetConnection(Properties properties) throws SQLException {
  43.     // 初始化数据库驱动，该方法会创建配置中指定的 Driver对象，
  44.     // 并将其注册到 DriverManager 和 registeredDrivers 中
  45.     initializeDriver();
  46.     Connection connection = DriverManager.getConnection(url, properties);
  47.     // 配置数据库连接属性，如：连接超时时间、是否自动提交事务、事务隔离级别
  48.     configureConnection(connection);
  49.     return connection;
  50.   }
  52.   private synchronized void initializeDriver() throws SQLException {
  53.     // 判断驱动是否已注册
  54.     if (!registeredDrivers.containsKey(driver)) {
  55.       Class<?> driverType;
  56.       try {
  57.         if (driverClassLoader != null) {
  58.           // 注册驱动
  59.           driverType = Class.forName(driver, true, driverClassLoader);
  60.         } else {
  61.           driverType = Resources.classForName(driver);
  62.         }
  63.         // 通过反射获取 Driver实例对象
  64.         Driver driverInstance = (Driver)driverType.newInstance();
  65.         // 注册驱动到 DriverManager，DriverProxy 是 UnpooledDataSource 的内部类
  66.         // 也是 Driver 的静态代理类
  67.         DriverManager.registerDriver(new DriverProxy(driverInstance));
  68.         // 将 driver 缓存到 registeredDrivers
  69.         registeredDrivers.put(driver, driverInstance);
  70.       } catch (Exception e) {
  71.         throw new SQLException("Error setting driver on UnpooledDataSource. Cause: " + e);
  72.       }
  73.     }
  74.   }
  76.   private void configureConnection(Connection conn) throws SQLException {
  77.     // 连接超时时间
  78.     if (defaultNetworkTimeout != null) {
  79.       conn.setNetworkTimeout(Executors.newSingleThreadExecutor(), defaultNetworkTimeout);
  80.     }
  81.     // 是否自动提交事务
  82.     if (autoCommit != null && autoCommit != conn.getAutoCommit()) {
  83.       conn.setAutoCommit(autoCommit);
  84.     }
  85.     // 事务隔离级别
  86.     if (defaultTransactionIsolationLevel != null) {
  87.       conn.setTransactionIsolation(defaultTransactionIsolationLevel);
  88.     }
  89.   }
  90. }

1.3 PooledDataSource

数据库建立连接是非常耗时的，且并发的连接数也非常有限。而数据库连接池可以实现数据库的重用、提高响应速度、防止数据库因连接过多而假死等。 数据库连接池的设计思路一般为：

  1. 连接池初始化时创建一定数量的连接，并添加到连接池中备用；
  2. 当程序需要使用数据库连接时，从连接池中请求，用完后会将其返还给连接池，而不是直接关闭；
  3. 连接池会控制总连接上限及空闲连接上线，如果连接池中的连接总数已达上限，且都被占用，后续的连接请求会短暂阻塞后重新尝试获取连接，如此循环，直到有连接可用；
  4. 如果连接池中空闲连接较多，已达到空闲连接上限，则返回的连接会被关闭掉，以降低系统开销。

PooledDataSource 实现了简易的数据库连接池功能，其创建数据库连接的功能依赖了上面的 UnpooledDataSource。

1.3.1 PooledConnection

PooledDataSource 通过管理 PooledConnection 来实现对 java.sql.Connection 的管理。PooledConnection 封装了 java.sql.Connection 数据库连接对象 及其代理对象（JDK 动态代理生成的）。PooledConnection 继承了 JDK 动态代理 的 InvocationHandler 接口。

  1. class PooledConnection implements InvocationHandler {
  3.   // 记录当前 PooledConnection对象 所属的 PooledDataSource对象
  4.   // 当调用 close()方法 时会将 PooledConnection 放回该 PooledDataSource
  5.   private final PooledDataSource dataSource;
  6.   // 真正的数据库连接对象
  7.   private final Connection realConnection;
  8.   // 代理连接对象
  9.   private final Connection proxyConnection;
  10.   // 从连接池中取出该连接时的时间戳
  11.   private long checkoutTimestamp;
  12.   // 创建该连接时的时间戳
  13.   private long createdTimestamp;
  14.   // 最后一次使用的 时间戳
  15.   private long lastUsedTimestamp;
  16.   // 由 数据库URL、用户名、密码 计算出来的 hash值，可用于标识该连接所在的连接池
  17.   private int connectionTypeCode;
  18.   // 检测当前 PooledConnection连接池连接对象 是否有效，主要用于 防止程序通过 close()方法 将
  19.   // 连接还给连接池之后，依然通过该连接操作数据库
  20.   private boolean valid;
  22.   /**
  23.    * invoke()方法 是本类的重点实现，也是 proxyConnection代理连接对象 的代理逻辑实现
  24.    * 它会对 close()方法 的调用进行处理，并在调用 realConnection对象 的方法之前进行校验
  25.    */
  26.   @Override
  27.   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  28.     String methodName = method.getName();
  29.     // 如果调用的是 close()方法，则将其放进连接池，而不是真的关闭连接
  30.     if (CLOSE.hashCode() == methodName.hashCode() && CLOSE.equals(methodName)) {
  31.       dataSource.pushConnection(this);
  32.       return null;
  33.     }
  34.     try {
  35.       if (!Object.class.equals(method.getDeclaringClass())) {
  36.         // 通过上面的 valid字段 校验连接是否有效
  37.         checkConnection();
  38.       }
  39.       // 调用 realConnection对象 的对应方法
  40.       return method.invoke(realConnection, args);
  41.     } catch (Throwable t) {
  42.       throw ExceptionUtil.unwrapThrowable(t);
  43.     }
  45.   }
  47.   private void checkConnection() throws SQLException {
  48.     if (!valid) {
  49.       throw new SQLException("Error accessing PooledConnection. Connection is invalid.");
  50.     }
  51.   }
  52. }

1.3.2 PoolState

PoolState 主要用于管理 PooledConnection 对象状态，其通过持有两个 List<PooledConnection>集合 分别管理空闲状态的连接 和 活跃状态的连接。另外，PoolState 还定义了一系列用于统计的字段。

  1. public class PoolState {
  3.   // 所属的连接池对象
  4.   protected PooledDataSource dataSource;
  6.   // 空闲的连接
  7.   protected final List<PooledConnection> idleConnections = new ArrayList<>();
  8.   // 活跃的连接
  9.   protected final List<PooledConnection> activeConnections = new ArrayList<>();
  11.   // 请求数据库连接的次数
  12.   protected long requestCount = 0;
  13.   // 获取连接的累计时间（accumulate累计）
  14.   protected long accumulatedRequestTime = 0;
  15.   // CheckoutTime = 记录 应用从连接池取出连接到归还连接的时长
  16.   // accumulatedCheckoutTime = 所有连接累计的CheckoutTime
  17.   protected long accumulatedCheckoutTime = 0;
  18.   // 超时连接的个数（当连接长时间未归还给连接池时，会被认为连接超时）
  19.   protected long claimedOverdueConnectionCount = 0;
  20.   // 累计超时时间
  21.   protected long accumulatedCheckoutTimeOfOverdueConnections = 0;
  22.   // 累计等待时间
  23.   protected long accumulatedWaitTime = 0;
  24.   // 等待次数
  25.   protected long hadToWaitCount = 0;
  26.   // 无效的连接数
  27.   protected long badConnectionCount = 0;
  29.   public PoolState(PooledDataSource dataSource) {
  30.     this.dataSource = dataSource;
  31.   }
  33.   public synchronized long getRequestCount() {
  34.     return requestCount;
  35.   }
  37.   public synchronized long getAverageRequestTime() {
  38.     return requestCount == 0 ? 0 : accumulatedRequestTime / requestCount;
  39.   }
  41.   public synchronized long getAverageWaitTime() {
  42.     return hadToWaitCount == 0 ? 0 : accumulatedWaitTime / hadToWaitCount;
  44.   }
  46.   public synchronized long getHadToWaitCount() {
  47.     return hadToWaitCount;
  48.   }
  50.   public synchronized long getBadConnectionCount() {
  51.     return badConnectionCount;
  52.   }
  54.   public synchronized long getClaimedOverdueConnectionCount() {
  55.     return claimedOverdueConnectionCount;
  56.   }
  58.   public synchronized long getAverageOverdueCheckoutTime() {
  59.     return claimedOverdueConnectionCount == 0 ? 0 : accumulatedCheckoutTimeOfOverdueConnections / claimedOverdueConnectionCount;
  60.   }
  62.   public synchronized long getAverageCheckoutTime() {
  63.     return requestCount == 0 ? 0 : accumulatedCheckoutTime / requestCount;
  64.   }
  66.   public synchronized int getIdleConnectionCount() {
  67.     return idleConnections.size();
  68.   }
  70.   public synchronized int getActiveConnectionCount() {
  71.     return activeConnections.size();
  72.   }
  74.   @Override
  75.   public synchronized String toString() {
  76.     StringBuilder builder = new StringBuilder();
  77.     builder.append("\n===CONFINGURATION==============================================");
  78.     builder.append("\n jdbcDriver                     ").append(dataSource.getDriver());
  79.     builder.append("\n jdbcUrl                        ").append(dataSource.getUrl());
  80.     builder.append("\n jdbcUsername                   ").append(dataSource.getUsername());
  81.     builder.append("\n jdbcPassword                   ").append(dataSource.getPassword() == null ? "NULL" : "************");
  82.     builder.append("\n poolMaxActiveConnections       ").append(dataSource.poolMaximumActiveConnections);
  83.     builder.append("\n poolMaxIdleConnections         ").append(dataSource.poolMaximumIdleConnections);
  84.     builder.append("\n poolMaxCheckoutTime            ").append(dataSource.poolMaximumCheckoutTime);
  85.     builder.append("\n poolTimeToWait                 ").append(dataSource.poolTimeToWait);
  86.     builder.append("\n poolPingEnabled                ").append(dataSource.poolPingEnabled);
  87.     builder.append("\n poolPingQuery                  ").append(dataSource.poolPingQuery);
  88.     builder.append("\n poolPingConnectionsNotUsedFor  ").append(dataSource.poolPingConnectionsNotUsedFor);
  89.     builder.append("\n ---STATUS-----------------------------------------------------");
  90.     builder.append("\n activeConnections              ").append(getActiveConnectionCount());
  91.     builder.append("\n idleConnections                ").append(getIdleConnectionCount());
  92.     builder.append("\n requestCount                   ").append(getRequestCount());
  93.     builder.append("\n averageRequestTime             ").append(getAverageRequestTime());
  94.     builder.append("\n averageCheckoutTime            ").append(getAverageCheckoutTime());
  95.     builder.append("\n claimedOverdue                 ").append(getClaimedOverdueConnectionCount());
  96.     builder.append("\n averageOverdueCheckoutTime     ").append(getAverageOverdueCheckoutTime());
  97.     builder.append("\n hadToWait                      ").append(getHadToWaitCount());
  98.     builder.append("\n averageWaitTime                ").append(getAverageWaitTime());
  99.     builder.append("\n badConnectionCount             ").append(getBadConnectionCount());
  100.     builder.append("\n===============================================================");
  101.     return builder.toString();
  102.   }
  103. }

1.3.3 PooledDataSource

PooledDataSource 管理的数据库连接对象 是由其持有的 UnpooledDataSource 对象 创建的，并由 PoolState 管理所有连接的状态。 PooledDataSource 的 getConnection()方法 会首先调用 popConnection()方法 获取 PooledConnection 对象，然后通过 PooledConnection 的 getProxyConnection()方法 获取数据库连接的代理对象。popConnection()方法 是 PooledDataSource 的核心逻辑之一，其整体的逻辑关系如下图：

avatar

  1. public class PooledDataSource implements DataSource {
  3.   private static final Log log = LogFactory.getLog(PooledDataSource.class);
  5.   // 管理连接池状态 并统计连接信息
  6.   private final PoolState state = new PoolState(this);
  8.   // 该对象用于生成真正的数据库连接对象，构造函数中会初始化该字段
  9.   private final UnpooledDataSource dataSource;
  11.   // 最大活跃连接数
  12.   protected int poolMaximumActiveConnections = 10;
  13.   // 最大空闲连接数
  14.   protected int poolMaximumIdleConnections = 5;
  15.   // 最大Checkout时长
  16.   protected int poolMaximumCheckoutTime = 20000;
  17.   // 在无法获取连接时，线程需要等待的时间
  18.   protected int poolTimeToWait = 20000;
  19.   // 本地坏连接最大数
  20.   protected int poolMaximumLocalBadConnectionTolerance = 3;
  21.   // 检测数据库连接是否可用时，给数据库发送的sql语句
  22.   protected String poolPingQuery = "NO PING QUERY SET";
  23.   // 是否允许发送上述语句
  24.   protected boolean poolPingEnabled;
  25.   // 当连接超过poolPingConnectionsNotUsedFor毫秒未使用，
  26.   // 就发送一次上述sql，检测连接连接是否正常
  27.   protected int poolPingConnectionsNotUsedFor;
  29.   // 根据数据库URL、用户名、密码 生成的一个hash值，
  30.   // 该hash值用于标记当前的连接池，在构造函数中初始化
  31.   private int expectedConnectionTypeCode;
  33.   /**
  34.    * 下面的两个 getConnection()方法 都会调用 popConnection()
  35.    * 获取 PooledConnection对象，然后调用该对象的 getProxyConnection()方法
  36.    * 获取数据库连接的代理对象
  37.    */
  38.   @Override
  39.   public Connection getConnection() throws SQLException {
  40.     return popConnection(dataSource.getUsername(), dataSource.getPassword()).getProxyConnection();
  41.   }
  43.   @Override
  44.   public Connection getConnection(String username, String password) throws SQLException {
  45.     return popConnection(username, password).getProxyConnection();
  46.   }
  48.   /**
  49.    * 本方法实现了连接池获取连接对象的具体逻辑，是 PooledDataSource 的核心逻辑之一
  50.    */
  51.   private PooledConnection popConnection(String username, String password) throws SQLException {
  52.     boolean countedWait = false;
  53.     PooledConnection conn = null;
  54.     long t = System.currentTimeMillis();
  55.     int localBadConnectionCount = 0;
  57.     // 循环获取数据库连接对象，直到获取成功
  58.     while (conn == null) {
  59.       // 连接池的连接是公共资源，要对线程加锁
  60.       synchronized (state) {
  61.         // 如果连接池中有空闲的 数据库连接对象，就取出一个
  62.         if (!state.idleConnections.isEmpty()) {
  63.           conn = state.idleConnections.remove(0);
  64.           if (log.isDebugEnabled()) {
  65.             log.debug("Checked out connection " + conn.getRealHashCode() + " from pool.");
  66.           }
  67.         } else {
  68.           // 没有空闲的连接对象，就判断一下 活跃的连接数是否已达 设定的峰值
  69.           if (state.activeConnections.size() < poolMaximumActiveConnections) {
  70.             // 还没达到峰值 就创建一个新的连接
  71.             conn = new PooledConnection(dataSource.getConnection(), this);
  72.             if (log.isDebugEnabled()) {
  73.               log.debug("Created connection " + conn.getRealHashCode() + ".");
  74.             }
  75.           } else {
  76.             // 如果活跃的连接已达上限，就取出最老的活跃连接对象，判断其是否超时
  77.             PooledConnection oldestActiveConnection = state.activeConnections.get(0);
  78.             long longestCheckoutTime = oldestActiveConnection.getCheckoutTime();
  79.             if (longestCheckoutTime > poolMaximumCheckoutTime) {
  80.               // 如果最老的连接超时了，就在 PoolState 中记录一下相关信息，然后将该连接对象释放掉
  81.               state.claimedOverdueConnectionCount++;
  82.               state.accumulatedCheckoutTimeOfOverdueConnections += longestCheckoutTime;
  83.               state.accumulatedCheckoutTime += longestCheckoutTime;
  84.               state.activeConnections.remove(oldestActiveConnection);
  85.               // 如果最老的连接不是 自动提交事务的，就将事务回滚掉
  86.               if (!oldestActiveConnection.getRealConnection().getAutoCommit()) {
  87.                 try {
  88.                   oldestActiveConnection.getRealConnection().rollback();
  89.                 } catch (SQLException e) {
  90.                   /*
  91.                      Just log a message for debug and continue to execute the following
  92.                      statement like nothing happened.
  93.                      Wrap the bad connection with a new PooledConnection, this will help
  94.                      to not interrupt current executing thread and give current thread a
  95.                      chance to join the next competition for another valid/good database
  96.                      connection. At the end of this loop, bad {@link @conn} will be set as null.
  97.                    */
  98.                   log.debug("Bad connection. Could not roll back");
  99.                 }
  100.               }
  101.               // 从最老连接中取出真正的 数据库连接对象及相关信息，用来构建新的 PooledConnection对象
  102.               conn = new PooledConnection(oldestActiveConnection.getRealConnection(), this);
  103.               conn.setCreatedTimestamp(oldestActiveConnection.getCreatedTimestamp());
  104.               conn.setLastUsedTimestamp(oldestActiveConnection.getLastUsedTimestamp());
  105.               // 将最老活跃连接设为无效
  106.               oldestActiveConnection.invalidate();
  107.               if (log.isDebugEnabled()) {
  108.                 log.debug("Claimed overdue connection " + conn.getRealHashCode() + ".");
  109.               }
  110.             } else {
  111.               // 如果最老的连接对象也没超时，则进入阻塞等待，
  112.               // 等待时间 poolTimeToWait 可自行设置
  113.               try {
  114.                 if (!countedWait) {
  115.                   // 等待次数加一
  116.                   state.hadToWaitCount++;
  117.                   countedWait = true;
  118.                 }
  119.                 if (log.isDebugEnabled()) {
  120.                   log.debug("Waiting as long as " + poolTimeToWait + " milliseconds for connection.");
  121.                 }
  122.                 long wt = System.currentTimeMillis();
  123.                 // native方法，使执行到这里的线程阻塞等待 poolTimeToWait毫秒
  124.                 state.wait(poolTimeToWait);
  125.                 // 统计累计等待的时间
  126.                 state.accumulatedWaitTime += System.currentTimeMillis() - wt;
  127.               } catch (InterruptedException e) {
  128.                 break;
  129.               }
  130.             }
  131.           }
  132.         }
  133.         // 到了这里 基本上就获取到连接对象咯，但我们还要确认一下该连接对象是否是有效的 可用的
  134.         if (conn != null) {
  135.           // ping一下数据库服务器，确认该连接对象是否有效
  136.           if (conn.isValid()) {
  137.             // 如果事务提交配置为手动的，则先让该连接回滚一下事务，防止脏数据的出现
  138.             if (!conn.getRealConnection().getAutoCommit()) {
  139.               conn.getRealConnection().rollback();
  140.             }
  141.             // 设置 由数据库URL、用户名、密码 计算出来的hash值，可用于标识该连接所在的连接池
  142.             conn.setConnectionTypeCode(assembleConnectionTypeCode(dataSource.getUrl(), username, password));
  143.             // 设置 从连接池中取出该连接时的时间戳
  144.             conn.setCheckoutTimestamp(System.currentTimeMillis());
  145.             // 设置 最后一次使用的时间戳
  146.             conn.setLastUsedTimestamp(System.currentTimeMillis());
  147.             // 将该连接加入活跃的连接对象列表
  148.             state.activeConnections.add(conn);
  149.             // 请求数据库连接的次数加一
  150.             state.requestCount++;
  151.             // 计算 获取连接的累计时间（accumulate累计）
  152.             state.accumulatedRequestTime += System.currentTimeMillis() - t;
  153.           // 如果获取到的连接无效
  154.           } else {
  155.             if (log.isDebugEnabled()) {
  156.               log.debug("A bad connection (" + conn.getRealHashCode() + ") was returned from the pool, getting another connection.");
  157.             }
  158.             // 对无效连接进行统计
  159.             state.badConnectionCount++;
  160.             localBadConnectionCount++;
  161.             conn = null;
  162.             // 如果无效连接超出 阈值，则抛出异常
  163.             if (localBadConnectionCount > (poolMaximumIdleConnections + poolMaximumLocalBadConnectionTolerance)) {
  164.               if (log.isDebugEnabled()) {
  165.                 log.debug("PooledDataSource: Could not get a good connection to the database.");
  166.               }
  167.               throw new SQLException("PooledDataSource: Could not get a good connection to the database.");
  168.             }
  169.           }
  170.         }
  171.       }
  173.     }
  175.     // 如果到了这里 连接还为空，则抛出一个未知的服务异常
  176.     if (conn == null) {
  177.       if (log.isDebugEnabled()) {
  178.         log.debug("PooledDataSource: Unknown severe error condition.  The connection pool returned a null connection.");
  179.       }
  180.       throw new SQLException("PooledDataSource: Unknown severe error condition.  The connection pool returned a null connection.");
  181.     }
  183.     // 返回数据库连接对象
  184.     return conn;
  185.   }
  187.   /**
  188.    * 看一下之前讲过的 PooledConnection 中的 动态代理方法invoke()，可以发现
  189.    * 当调用数据库连接代理对象的 close()方法 时，并未关闭真正的数据库连接，
  190.    * 而是调用了本方法，将连接对象归还给连接池，方便后续使用，本方法也是 PooledDataSource 的核心逻辑之一
  191.    */
  192.   protected void pushConnection(PooledConnection conn) throws SQLException {
  193.     // 国际惯例，操作公共资源先上个锁
  194.     synchronized (state) {
  195.       // 先将该连接从活跃的连接对象列表中剔除
  196.       state.activeConnections.remove(conn);
  197.       // 如果该连接有效
  198.       if (conn.isValid()) {
  199.         // 如果连接池中的空闲连接数未达到阈值 且 该连接确实属于
  200.         // 本连接池（通过之前获取的 expectedConnectionTypeCode 进行校验）
  201.         if (state.idleConnections.size() < poolMaximumIdleConnections && conn.getConnectionTypeCode() == expectedConnectionTypeCode) {
  202.           // CheckoutTime = 应用从连接池取出连接到归还连接的时长
  203.           // accumulatedCheckoutTime = 所有连接累计的CheckoutTime
  204.           state.accumulatedCheckoutTime += conn.getCheckoutTime();
  205.           // 不是自动提交事务的连接 先回滚一波
  206.           if (!conn.getRealConnection().getAutoCommit()) {
  207.             conn.getRealConnection().rollback();
  208.           }
  209.           // 从 conn 中取出真正的 数据库连接对象，重新封装成 PooledConnection
  210.           PooledConnection newConn = new PooledConnection(conn.getRealConnection(), this);
  211.           // 将 newConn 放进空闲连接对象列表
  212.           state.idleConnections.add(newConn);
  213.           // 设置 newConn 的相关属性
  214.           newConn.setCreatedTimestamp(conn.getCreatedTimestamp());
  215.           newConn.setLastUsedTimestamp(conn.getLastUsedTimestamp());
  216.           // 将原本的 conn 作废
  217.           conn.invalidate();
  218.           if (log.isDebugEnabled()) {
  219.             log.debug("Returned connection " + newConn.getRealHashCode() + " to pool.");
  220.           }
  221.           // 唤醒阻塞等待的线程
  222.           state.notifyAll();
  223.         } else {
  224.           // 如果空闲连接已达阈值 或 该连接对象不属于本连接池，则做好统计数据
  225.           // 回滚连接的事务，关闭真正的连接，最后作废 该conn
  226.           state.accumulatedCheckoutTime += conn.getCheckoutTime();
  227.           if (!conn.getRealConnection().getAutoCommit()) {
  228.             conn.getRealConnection().rollback();
  229.           }
  230.           conn.getRealConnection().close();
  231.           if (log.isDebugEnabled()) {
  232.             log.debug("Closed connection " + conn.getRealHashCode() + ".");
  233.           }
  234.           conn.invalidate();
  235.         }
  236.       // 如果该连接是无效的，则记录一下无效的连接数
  237.       } else {
  238.         if (log.isDebugEnabled()) {
  239.           log.debug("A bad connection (" + conn.getRealHashCode() + ") attempted to return to the pool, discarding connection.");
  240.         }
  241.         state.badConnectionCount++;
  242.       }
  243.     }
  244.   }
  246.   /**
  247.    * 关闭连接池中 所有活跃的 及 空闲的连接
  248.    * 当修改连接池的配置（如：用户名、密码、URL等），都会调用本方法
  249.    */
  250.   public void forceCloseAll() {
  251.     // 日常上锁
  252.     synchronized (state) {
  253.       // 更新当前连接池的标识
  254.       expectedConnectionTypeCode = assembleConnectionTypeCode(dataSource.getUrl(), dataSource.getUsername(), dataSource.getPassword());
  255.       // 依次关闭活跃的连接对象
  256.       for (int i = state.activeConnections.size(); i > 0; i--) {
  257.         try {
  258.           PooledConnection conn = state.activeConnections.remove(i - 1);
  259.           conn.invalidate();
  261.           Connection realConn = conn.getRealConnection();
  262.           if (!realConn.getAutoCommit()) {
  263.             realConn.rollback();
  264.           }
  265.           realConn.close();
  266.         } catch (Exception e) {
  267.           // ignore
  268.         }
  269.       }
  270.       // 依次关闭空闲的连接对象
  271.       for (int i = state.idleConnections.size(); i > 0; i--) {
  272.         try {
  273.           PooledConnection conn = state.idleConnections.remove(i - 1);
  274.           conn.invalidate();
  276.           Connection realConn = conn.getRealConnection();
  277.           if (!realConn.getAutoCommit()) {
  278.             realConn.rollback();
  279.           }
  280.           realConn.close();
  281.         } catch (Exception e) {
  282.           // ignore
  283.         }
  284.       }
  285.     }
  286.     if (log.isDebugEnabled()) {
  287.       log.debug("PooledDataSource forcefully closed/removed all connections.");
  288.     }
  289.   }
  290. }

最后，我们来看一下 popConnection() 和 pushConnection() 都调用了的 isValid()方法，该方法除了检测 PooledConnection 中的 valid 字段 外 还还会调用 PooledDataSource 中的 pingConnection()方法，让数据库连接对象 执行指定的 sql 语句，检测连接是否正常。

  1. class PooledConnection implements InvocationHandler {
  2.   /**
  3.    * 检测 PooledConnection对象 的有效性
  4.    */
  5.   public boolean isValid() {
  6.     return valid && realConnection != null && dataSource.pingConnection(this);
  7.   }
  8. }
  11. public class PooledDataSource implements DataSource {
  12.   /**
  13.    * ping 一下数据库，检测数据库连接是否正常
  14.    */
  15.   protected boolean pingConnection(PooledConnection conn) {
  16.     boolean result = true;
  18.     try {
  19.       result = !conn.getRealConnection().isClosed();
  20.     } catch (SQLException e) {
  21.       if (log.isDebugEnabled()) {
  22.         log.debug("Connection " + conn.getRealHashCode() + " is BAD: " + e.getMessage());
  23.       }
  24.       result = false;
  25.     }
  27.     if (result) {
  28.       // 是否允许发送检测语句，检测数据库连接是否正常，poolPingEnabled 可自行配置
  29.       // 该检测会牺牲一定的系统资源，以提高安全性
  30.       if (poolPingEnabled) {
  31.         // 超过 poolPingConnectionsNotUsedFor毫秒 未使用的连接 才会检测其连接状态
  32.         if (poolPingConnectionsNotUsedFor >= 0 && conn.getTimeElapsedSinceLastUse() > poolPingConnectionsNotUsedFor) {
  33.           try {
  34.             if (log.isDebugEnabled()) {
  35.               log.debug("Testing connection " + conn.getRealHashCode() + " ...");
  36.             }
  37.             // 获取真正的连接对象，执行 poolPingQuery = "NO PING QUERY SET" sql语句
  38.             Connection realConn = conn.getRealConnection();
  39.             try (Statement statement = realConn.createStatement()) {
  40.               statement.executeQuery(poolPingQuery).close();
  41.             }
  42.             if (!realConn.getAutoCommit()) {
  43.               realConn.rollback();
  44.             }
  45.             result = true;
  46.             if (log.isDebugEnabled()) {
  47.               log.debug("Connection " + conn.getRealHashCode() + " is GOOD!");
  48.             }
  49.             // 如果上面这段代码抛出异常，则说明数据库连接有问题，将该连接关闭，返回false
  50.           } catch (Exception e) {
  51.             log.warn("Execution of ping query '" + poolPingQuery + "' failed: " + e.getMessage());
  52.             try {
  53.               conn.getRealConnection().close();
  54.             } catch (Exception e2) {
  55.               //ignore
  56.             }
  57.             result = false;
  58.             if (log.isDebugEnabled()) {
  59.               log.debug("Connection " + conn.getRealHashCode() + " is BAD: " + e.getMessage());
  60.             }
  61.           }
  62.         }
  63.       }
  64.     }
  65.     return result;
  66.   }
  67. }

2 Transaction

遵循 “接口-实现类” 的设计原则，Mybatis 也是先使用 Transaction 接口 对数据库事务做了抽象，而实现类则只提供了两个，即：JdbcTransaction 和 ManagedTransaction。这两种对象的获取，使用了两个对应的工厂类 JdbcTransactionFactory 和 ManagedTransactionFactory。 不过一般我们并不会使用 Mybatis 管理事务，而是将 Mybatis 集成到 Spring，由 Spring 进行事务的管理。细节部分会在后面的文章中详细讲解。

  1. public interface Transaction {
  3.   /**
  4.    * 获取连接对象
  5.    */
  6.   Connection getConnection() throws SQLException;
  8.   /**
  9.    * 提交事务
  10.    */
  11.   void commit() throws SQLException;
  13.   /**
  14.    * 回滚事务
  15.    */
  16.   void rollback() throws SQLException;
  18.   /**
  19.    * 关闭数据库连接
  20.    */
  21.   void close() throws SQLException;
  23.   /**
  24.    * 获取配置的事务超时时间
  25.    */
  26.   Integer getTimeout() throws SQLException;
  27. }
  29. public class JdbcTransaction implements Transaction {
  31.   private static final Log log = LogFactory.getLog(JdbcTransaction.class);
  33.   // 当前事务对应的数据库连接
  34.   protected Connection connection;
  35.   // 当前事务对应的数据源
  36.   protected DataSource dataSource;
  37.   // 事务隔离级别
  38.   protected TransactionIsolationLevel level;
  39.   // 是否自动提交
  40.   protected boolean autoCommit;
  42.   public JdbcTransaction(DataSource ds, TransactionIsolationLevel desiredLevel, boolean desiredAutoCommit) {
  43.     dataSource = ds;
  44.     level = desiredLevel;
  45.     autoCommit = desiredAutoCommit;
  46.   }
  48.   public JdbcTransaction(Connection connection) {
  49.     this.connection = connection;
  50.   }
  52.   @Override
  53.   public Connection getConnection() throws SQLException {
  54.     if (connection == null) {
  55.       openConnection();
  56.     }
  57.     return connection;
  58.   }
  60.   // 提交、回滚、关闭等操作的代码都比较简单，只对原生的 JDBC操作 做了简单封装
  61.   @Override
  62.   public void commit() throws SQLException {
  63.     if (connection != null && !connection.getAutoCommit()) {
  64.       if (log.isDebugEnabled()) {
  65.         log.debug("Committing JDBC Connection [" + connection + "]");
  66.       }
  67.       connection.commit();
  68.     }
  69.   }
  71.   @Override
  72.   public void rollback() throws SQLException {
  73.     if (connection != null && !connection.getAutoCommit()) {
  74.       if (log.isDebugEnabled()) {
  75.         log.debug("Rolling back JDBC Connection [" + connection + "]");
  76.       }
  77.       connection.rollback();
  78.     }
  79.   }
  81.   @Override
  82.   public void close() throws SQLException {
  83.     if (connection != null) {
  84.       resetAutoCommit();
  85.       if (log.isDebugEnabled()) {
  86.         log.debug("Closing JDBC Connection [" + connection + "]");
  87.       }
  88.       connection.close();
  89.     }
  90.   }
  92.   protected void setDesiredAutoCommit(boolean desiredAutoCommit) {
  93.     try {
  94.       if (connection.getAutoCommit() != desiredAutoCommit) {
  95.         if (log.isDebugEnabled()) {
  96.           log.debug("Setting autocommit to " + desiredAutoCommit + " on JDBC Connection [" + connection + "]");
  97.         }
  98.         connection.setAutoCommit(desiredAutoCommit);
  99.       }
  100.     } catch (SQLException e) {
  101.       // Only a very poorly implemented driver would fail here,
  102.       // and there's not much we can do about that.
  103.       throw new TransactionException("Error configuring AutoCommit.  "
  104.           + "Your driver may not support getAutoCommit() or setAutoCommit(). "
  105.           + "Requested setting: " + desiredAutoCommit + ".  Cause: " + e, e);
  106.     }
  107.   }
  109.   protected void resetAutoCommit() {
  110.     try {
  111.       if (!connection.getAutoCommit()) {
  112.         // MyBatis does not call commit/rollback on a connection if just selects were performed.
  113.         // Some databases start transactions with select statements
  114.         // and they mandate a commit/rollback before closing the connection.
  115.         // A workaround is setting the autocommit to true before closing the connection.
  116.         // Sybase throws an exception here.
  117.         if (log.isDebugEnabled()) {
  118.           log.debug("Resetting autocommit to true on JDBC Connection [" + connection + "]");
  119.         }
  120.         connection.setAutoCommit(true);
  121.       }
  122.     } catch (SQLException e) {
  123.       if (log.isDebugEnabled()) {
  124.         log.debug("Error resetting autocommit to true "
  125.             + "before closing the connection.  Cause: " + e);
  126.       }
  127.     }
  128.   }
  130.   protected void openConnection() throws SQLException {
  131.     if (log.isDebugEnabled()) {
  132.       log.debug("Opening JDBC Connection");
  133.     }
  134.     connection = dataSource.getConnection();
  135.     if (level != null) {
  136.       connection.setTransactionIsolation(level.getLevel());
  137.     }
  138.     setDesiredAutoCommit(autoCommit);
  139.   }
  141.   @Override
  142.   public Integer getTimeout() throws SQLException {
  143.     return null;
  144.   }
  146. }
  148. public class ManagedTransaction implements Transaction {
  150.   private static final Log log = LogFactory.getLog(ManagedTransaction.class);
  152.   // 数据源
  153.   private DataSource dataSource;
  154.   // 事务隔离级别
  155.   private TransactionIsolationLevel level;
  156.   // 对应的数据库连接
  157.   private Connection connection;
  158.   // 控制是否关闭持有的连接，在 close()方法 中用其判断是否真的关闭连接
  159.   private final boolean closeConnection;
  161.   // 本类的实现也很简单，commit()、rollback()方法 都是空实现
  162.   public ManagedTransaction(Connection connection, boolean closeConnection) {
  163.     this.connection = connection;
  164.     this.closeConnection = closeConnection;
  165.   }
  167.   public ManagedTransaction(DataSource ds, TransactionIsolationLevel level, boolean closeConnection) {
  168.     this.dataSource = ds;
  169.     this.level = level;
  170.     this.closeConnection = closeConnection;
  171.   }
  173.   @Override
  174.   public Connection getConnection() throws SQLException {
  175.     if (this.connection == null) {
  176.       openConnection();
  177.     }
  178.     return this.connection;
  179.   }
  181.   @Override
  182.   public void commit() throws SQLException {
  183.     // Does nothing
  184.   }
  186.   @Override
  187.   public void rollback() throws SQLException {
  188.     // Does nothing
  189.   }
  191.   @Override
  192.   public void close() throws SQLException {
  193.     if (this.closeConnection && this.connection != null) {
  194.       if (log.isDebugEnabled()) {
  195.         log.debug("Closing JDBC Connection [" + this.connection + "]");
  196.       }
  197.       this.connection.close();
  198.     }
  199.   }
  201.   protected void openConnection() throws SQLException {
  202.     if (log.isDebugEnabled()) {
  203.       log.debug("Opening JDBC Connection");
  204.     }
  205.     this.connection = this.dataSource.getConnection();
  206.     if (this.level != null) {
  207.       this.connection.setTransactionIsolation(this.level.getLevel());
  208.     }
  209.   }
  211.   @Override
  212.   public Integer getTimeout() throws SQLException {
  213.     return null;
  214.   }
  216. }
  218. public interface TransactionFactory {
  220.   /**
  221.    * 配置 TransactionFactory对象，一般会在完成 TransactionFactory对象
  222.    * 初始化之后 就进行自定义属性配置
  223.    */
  224.   default void setProperties(Properties props) {
  225.     // NOP
  226.   }
  228.   /**
  229.    * 在指定的数据库连接上创建 Transaction事务对象
  230.    */
  231.   Transaction newTransaction(Connection conn);
  233.   /**
  234.    * 从指定数据源获取数据库连接，并在此连接上创建 Transaction对象
  235.    */
  236.   Transaction newTransaction(DataSource dataSource, TransactionIsolationLevel level, boolean autoCommit);
  237. }
  239. public class JdbcTransactionFactory implements TransactionFactory {
  241.   @Override
  242.   public Transaction newTransaction(Connection conn) {
  243.     return new JdbcTransaction(conn);
  244.   }
  246.   @Override
  247.   public Transaction newTransaction(DataSource ds, TransactionIsolationLevel level, boolean autoCommit) {
  248.     return new JdbcTransaction(ds, level, autoCommit);
  249.   }
  250. }
  252. public class ManagedTransactionFactory implements TransactionFactory {
  254.   private boolean closeConnection = true;
  256.   @Override
  257.   public void setProperties(Properties props) {
  258.     if (props != null) {
  259.       String closeConnectionProperty = props.getProperty("closeConnection");
  260.       if (closeConnectionProperty != null) {
  261.         closeConnection = Boolean.valueOf(closeConnectionProperty);
  262.       }
  263.     }
  264.   }
  266.   @Override
  267.   public Transaction newTransaction(Connection conn) {
  268.     return new ManagedTransaction(conn, closeConnection);
  269.   }
  271.   @Override
  272.   public Transaction newTransaction(DataSource ds, TransactionIsolationLevel level, boolean autoCommit) {
  273.     // Silently ignores autocommit and isolation level, as managed transactions are entirely
  274.     // controlled by an external manager.  It's silently ignored so that
  275.     // code remains portable between managed and unmanaged configurations.
  276.     return new ManagedTransaction(ds, level, closeConnection);
  277.   }
  278. }