《深入理解mybatis原理》 Mybatis数据源与连接池

相同地。我们也是使用PooledDataSource的getConnection()方法来返回Connection对象。

如今让我们看一下它的基本原理：

 PooledDataSource将java.sql.Connection对象包裹成PooledConnection对象放到了PoolState类型的容器中维护。 MyBatis将连接池中的PooledConnection分为两种状态： 空暇状态（idle）和活动状态(active)，这两种状态的PooledConnection对象分别被存储到PoolState容器内的idleConnections和activeConnections两个List集合中：

idleConnections:空暇(idle)状态PooledConnection对象被放置到此集合中，表示当前闲置的没有被使用的PooledConnection集合，调用PooledDataSource的getConnection()方法时，会优先从此集合中取PooledConnection对象。当用完一个java.sql.Connection对象时，MyBatis会将其包裹成PooledConnection对象放到此集合中。

activeConnections:活动(active)状态的PooledConnection对象被放置到名为activeConnections的ArrayList中。表示当前正在被使用的PooledConnection集合，调用PooledDataSource的getConnection()方法时，会优先从idleConnections集合中取PooledConnection对象,假设没有。则看此集合是否已满。假设未满，PooledDataSource会创建出一个PooledConnection。加入到此集合中，并返回。

6.1 获取java.sql.Connection对象的过程

public Connection getConnection() throws SQLException {
return popConnection(dataSource.getUsername(), dataSource.getPassword()).getProxyConnection();
}

public Connection getConnection(String username, String password) throws SQLException {
return popConnection(username, password).getProxyConnection();
}

上述的popConnection()方法，会从连接池中返回一个可用的PooledConnection对象。然后再调用getProxyConnection()方法终于返回Conection对象。（至于为什么会有getProxyConnection(),请关注下一节）

如今让我们看一下popConnection()方法究竟做了什么：

1.  先看是否有空暇(idle)状态下的PooledConnection对象，假设有。就直接返回一个可用的PooledConnection对象；否则进行第2步。

2.  查看活动状态的PooledConnection池activeConnections是否已满。假设没有满。则创建一个新的PooledConnection对象。然后放到activeConnections池中。然后返回此PooledConnection对象；否则进行第三步；

3.  看最先进入activeConnections池中的PooledConnection对象是否已经过期：假设已经过期，从activeConnections池中移除此对象，然后创建一个新的PooledConnection对象，加入到activeConnections中，然后将此对象返回。否则进行第4步。

4.  线程等待，循环2步

/*
* 传递一个username与password。从连接池中返回可用的PooledConnection
*/
private PooledConnection popConnection(String username, String password) throws SQLException
{
boolean countedWait = false;
PooledConnection conn = null;
long t = System.currentTimeMillis();
int localBadConnectionCount = 0;

while (conn == null)
{
synchronized (state)
{
if (state.idleConnections.size() > 0)
{
// 连接池中有空暇连接。取出第一个
conn = state.idleConnections.remove(0);
if (log.isDebugEnabled())
{
log.debug("Checked out connection " + conn.getRealHashCode() + " from pool.");
}
}
else
{
// 连接池中没有空暇连接，则取当前正在使用的连接数小于最大限定值，
if (state.activeConnections.size() < poolMaximumActiveConnections)
{
// 创建一个新的connection对象
conn = new PooledConnection(dataSource.getConnection(), this);
@SuppressWarnings("unused")
//used in logging, if enabled
Connection realConn = conn.getRealConnection();
if (log.isDebugEnabled())
{
log.debug("Created connection " + conn.getRealHashCode() + ".");
}
}
else
{
// Cannot create new connection 当活动连接池已满，不能创建时，取出活动连接池的第一个，即最先进入连接池的PooledConnection对象
// 计算它的校验时间，假设校验时间大于连接池规定的最大校验时间。则觉得它已经过期了。利用这个PoolConnection内部的realConnection又一次生成一个PooledConnection
//
PooledConnection oldestActiveConnection = state.activeConnections.get(0);
long longestCheckoutTime = oldestActiveConnection.getCheckoutTime();
if (longestCheckoutTime > poolMaximumCheckoutTime)
{
// Can claim overdue connection
state.claimedOverdueConnectionCount++;
state.accumulatedCheckoutTimeOfOverdueConnections += longestCheckoutTime;
state.accumulatedCheckoutTime += longestCheckoutTime;
state.activeConnections.remove(oldestActiveConnection);
if (!oldestActiveConnection.getRealConnection().getAutoCommit())
{
oldestActiveConnection.getRealConnection().rollback();
}
conn = new PooledConnection(oldestActiveConnection.getRealConnection(), this);
oldestActiveConnection.invalidate();
if (log.isDebugEnabled())
{
log.debug("Claimed overdue connection " + conn.getRealHashCode() + ".");
}
}
else
{

//假设不能释放。则必须等待有
// Must wait
try
{
if (!countedWait)
{
state.hadToWaitCount++;
countedWait = true;
}
if (log.isDebugEnabled())
{
log.debug("Waiting as long as " + poolTimeToWait + " milliseconds for connection.");
}
long wt = System.currentTimeMillis();
state.wait(poolTimeToWait);
state.accumulatedWaitTime += System.currentTimeMillis() - wt;
}
catch (InterruptedException e)
{
break;
}
}
}
}

//假设获取PooledConnection成功。则更新其信息

if (conn != null)
{
if (conn.isValid())
{
if (!conn.getRealConnection().getAutoCommit())
{
conn.getRealConnection().rollback();
}
conn.setConnectionTypeCode(assembleConnectionTypeCode(dataSource.getUrl(), username, password));
conn.setCheckoutTimestamp(System.currentTimeMillis());
conn.setLastUsedTimestamp(System.currentTimeMillis());
state.activeConnections.add(conn);
state.requestCount++;
state.accumulatedRequestTime += System.currentTimeMillis() - t;
}
else
{
if (log.isDebugEnabled())
{
log.debug("A bad connection (" + conn.getRealHashCode() + ") was returned from the pool, getting another connection.");
}
state.badConnectionCount++;
localBadConnectionCount++;
conn = null;
if (localBadConnectionCount > (poolMaximumIdleConnections + 3))
{
if (log.isDebugEnabled())
{
log.debug("PooledDataSource: Could not get a good connection to the database.");
}
throw new SQLException("PooledDataSource: Could not get a good connection to the database.");
}
}
}
}

}

if (conn == null)
{
if (log.isDebugEnabled())
{
log.debug("PooledDataSource: Unknown severe error condition.  The connection pool returned a null connection.");
}
throw new SQLException("PooledDataSource: Unknown severe error condition.  The connection pool returned a null connection.");
}

return conn;
}

相应的处理流程图例如以下所看到的：

如上所看到的,对于PooledDataSource的getConnection()方法内。先是调用类PooledDataSource的popConnection()方法返回了一个PooledConnection对象，然后调用了PooledConnection的getProxyConnection()来返回Connection对象。

6.2java.sql.Connection对象的回收

private void test() throws ClassNotFoundException, SQLException
{
String sql = "select * from hr.employees where employee_id < ?
 and employee_id >= ?";
PreparedStatement st = null;
ResultSet rs = null;

Connection con = null;
Class.forName("oracle.jdbc.driver.OracleDriver");
try
{
con = DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:xe", "louluan", "123456");
st = con.prepareStatement(sql);
//设置參数
st.setInt(1, 101);
st.setInt(2, 0);
//查询，得出结果集
rs = st.executeQuery();
//取数据，省略
//关闭，释放资源
con.close();
}
catch (SQLException e)
{
con.close();
e.printStackTrace();
}
}

调用过close()方法的Connection对象所持有的资源会被所有释放掉，Connection对象也就不能再使用。

那么。假设我们使用了连接池。我们在用完了Connection对象时。须要将它放在连接池中，该如何做呢？

可能大家第一个在脑海里闪现出来的想法就是：我在应该调用con.close()方法的时候，不调用close()f方法，将其换成将Connection对象放到连接池容器中的代码！

package com.foo.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Vector;

/**
*
* 一个线程安全的简易连接池实现。此连接池是单例的
*  putConnection()将Connection加入到连接池中
*  getConnection()返回一个Connection对象
*/
public class Pool {

private static Vector<Connection> pool = new Vector<Connection>();

private static int MAX_CONNECTION =100;

private static String DRIVER="oracle.jdbc.driver.OracleDriver";
private static String URL = "jdbc:oracle:thin:@127.0.0.1:1521:xe";
private static String USERNAME = "louluan";
private static String PASSWROD = "123456";

static {
try {
Class.forName(DRIVER);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}

/**
* 将一个Connection对象放置到连接池中
*/
public static  void putConnection(Connection connection){

synchronized(pool)
{
if(pool.size()<MAX_CONNECTION)
{
pool.add(connection);
}
}
}

/**
* 返回一个Connection对象，假设连接池内有元素，则pop出第一个元素。
* 假设连接池Pool中没有元素。则创建一个connection对象，然后加入到pool中
* @return Connection
*/
public static Connection getConnection(){
Connection connection = null;
synchronized(pool)
{
if(pool.size()>0)
{
connection = pool.get(0);
pool.remove(0);
}
else
{
connection = createConnection();
pool.add(connection);
}
}
return connection;
}

/**
* 创建一个新的Connection对象
*/
private static Connection createConnection()
{
Connection connection = null;
try {
connection = DriverManager.getConnection(URL, USERNAME,PASSWROD);
} catch (SQLException e) {
e.printStackTrace();
}
return connection;
}

}

package com.foo.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Vector;

public class PoolTest
{

private void test() throws ClassNotFoundException, SQLException
{
String sql = "select * from hr.employees where employee_id < ?
 and employee_id >= ?";
PreparedStatement st = null;
ResultSet rs = null;

Connection con = null;
Class.forName("oracle.jdbc.driver.OracleDriver");
try
{
con = DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:xe", "louluan", "123456");
st = con.prepareStatement(sql);
//设置參数
st.setInt(1, 101);
st.setInt(2, 0);
//查询。得出结果集
rs = st.executeQuery();
//取数据。省略
//将不再使用的Connection对象放到连接池中。供以后使用
Pool.putConnection(con);
}
catch (SQLException e)
{
e.printStackTrace();
}
}
}

上述的代码就是将我们使用过的Connection对象放到Pool连接池中，我们须要Connection对象的话，仅仅须要使用Pool.getConnection()方法从里面取就可以。

是的,上述的代码全然能够实现此能力。只是有一个非常不优雅的实现：就是我们须要手动地将Connection对象放到Pool连接池中。这是一个非常傻的实现方式。

这也和一般使用Connection对象的方式不一样：一般使用Connection的方式是使用完后，然后调用.close()方法释放资源。

为了和一般的使用Conneciton对象的方式保持一致。我们希望当Connection使用完后。调用.close()方法，而实际上Connection资源并没有被释放，而实际上被加入到了连接池中。

这样能够做到吗？答案是能够。

上述的要求从另外一个角度来描写叙述就是：是否能提供一种机制。让我们知道Connection对象调用了什么方法，从而依据不同的方法自己定义对应的处理机制。

恰好代理机制就能够完毕上述要求.

如何实现Connection对象调用了close()方法，而实际是将其加入到连接池中

这是要使用代理模式，为真正的Connection对象创建一个代理对象，代理对象全部的方法都是调用对应的真正Connection对象的方法实现。

当代理对象运行close()方法时，要特殊处理，不调用真正Connection对象的close()方法，而是将Connection对象加入到连接池中。

MyBatis的PooledDataSource的PoolState内部维护的对象是PooledConnection类型的对象，而PooledConnection则是对真正的数据库连接java.sql.Connection实例对象的包裹器。

PooledConnection对象内持有一个真正的数据库连接java.sql.Connection实例对象和一个java.sql.Connection的代理：

其部分定义例如以下：

class PooledConnection implements InvocationHandler {

//......
//所创建它的datasource引用
private PooledDataSource dataSource;
//真正的Connection对象
private Connection realConnection;
//代理自己的代理Connection
private Connection proxyConnection;

//......
}

public PooledConnection(Connection connection, PooledDataSource dataSource) {
this.hashCode = connection.hashCode();
this.realConnection = connection;
this.dataSource = dataSource;
this.createdTimestamp = System.currentTimeMillis();
this.lastUsedTimestamp = System.currentTimeMillis();
this.valid = true;
this.proxyConnection = (Connection) Proxy.newProxyInstance(Connection.class.getClassLoader(), IFACES, this);
}

实际上。我们调用PooledDataSource的getConnection()方法返回的就是这个proxyConnection对象。

当我们调用此proxyConnection对象上的不论什么方法时，都会调用PooledConnection对象内invoke()方法。

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String methodName = method.getName();
//当调用关闭的时候，回收此Connection到PooledDataSource中
if (CLOSE.hashCode() == methodName.hashCode() && CLOSE.equals(methodName)) {
dataSource.pushConnection(this);
return null;
} else {
try {
if (!Object.class.equals(method.getDeclaringClass())) {
checkConnection();
}
return method.invoke(realConnection, args);
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
}
}

从上述代码能够看到，当我们使用了pooledDataSource.getConnection()返回的Connection对象的close()方法时，不会调用真正Connection的close()方法。而是将此Connection对象放到连接池中。

对于JNDI类型的数据源DataSource的获取就比較简单，MyBatis定义了一个JndiDataSourceFactory工厂来创建通过JNDI形式生成的DataSource。

if (properties.containsKey(INITIAL_CONTEXT)
&& properties.containsKey(DATA_SOURCE))
{
//从JNDI上下文中找到DataSource并返回
Context ctx = (Context) initCtx.lookup(properties.getProperty(INITIAL_CONTEXT));
dataSource = (DataSource) ctx.lookup(properties.getProperty(DATA_SOURCE));
}
else if (properties.containsKey(DATA_SOURCE))
{
// //从JNDI上下文中找到DataSource并返回
dataSource = (DataSource) initCtx.lookup(properties.getProperty(DATA_SOURCE));
}