文章目录
本文首先会讲述MyBatis的数据源的分类；然后会介绍数据源是如何加载和使用的；紧接着将分类介绍UNPOOLED、POOLED和JNDI类型的数据源组织；期间我们会重点讲解POOLED类型的数据源和其实现的连接池原理。
二、数据源ORM框架：Hibernate和Mybatis都是ORM框架
ORM框架，数据源的组织是必须的，要不然要你这个框架干嘛？
2.1 MyBatis三种数据源
MyBatis数据源实现是在以下四个包中：
四个包分别对应一个基本包和三种数据源
MyBatis把数据源DataSource分为三种：
(1) UNPOOLED 不使用连接池的数据源
(2) POOLED 使用连接池的数据源
(3) JNDI 使用JNDI实现的数据源
即：
相应地，MyBatis内部分别定义了实现了java.sql.DataSource接口的UnpooledDataSource，PooledDataSource类来表示UNPOOLED、POOLED类型的数据源。 如下图所示：
对于JNDI类型的数据源DataSource，则是通过JNDI上下文中取值。
问题：Mybatis三种数据源？
回答：四个包分别对应一个基本包和三种数据源，MyBatis把数据源DataSource分为三种：
（1）UNPOOLED 不使用连接池的数据源
（2）POOLED 使用连接池的数据源
（3）JNDI 使用JNDI实现的数据源
问题：三种数据源的关系？
回答：PooledDataSource和UnPooledDataSource都实现了java.sql.DataSource接口，并且PooledDataSource持有一个UnPooledDataSource的引用，当PooledDataSource需要创建一个java.sql.DataSource实例对象时，还是通过UnPooledDataSource来创建。PooledDataSource只是提供一种缓存连接池实例。
2.2 Mybatis初始化时创建数据源工厂和数据源
MyBatis数据源DataSource对象的创建发生在MyBatis初始化的过程中。下面让我们一步步地了解MyBatis是如何创建数据源DataSource的。
在mybatis的XML配置文件中，使用<dataSource>元素来配置数据源：
1、MyBatis在初始化时，解析此文件，根据的type属性来创建相应类型的的数据源DataSource，即：
type=”POOLED” ：MyBatis会创建PooledDataSource实例
type=”UNPOOLED” ：MyBatis会创建UnpooledDataSource实例
type=”JNDI” ：MyBatis会从JNDI服务上查找DataSource实例，然后返回使用
2、MyBatis是通过工厂模式来创建数据源DataSource对象的，MyBatis定义了抽象的工厂接 口:org.apache.ibatis.datasource.DataSourceFactory,通过其getDataSource()方法返回数据源DataSource：
定义如下：
public interface DataSourceFactory {
void setProperties(Properties props);
//生产DataSource
DataSource getDataSource();
}
上述三种不同类型的type，则有对应的以下dataSource工厂：
（1）POOLED PooledDataSourceFactory
（2）UNPOOLED UnpooledDataSourceFactory
（3）JNDI JndiDataSourceFactory
其类图如下所示：
3、MyBatis创建了DataSource实例后，会将其放到Configuration对象内的Environment对象中， 供以后使用。
初始化的时候反射创建数据源工厂，数据源是通过数据源工厂来创建的，三种数据源对应三种数据源工厂，在工厂类的工厂方法中使用new来创建对应数据源，如下：
数据源工厂的构造函数中new数据源很重要，只要反射新建了数据源工厂，就是新建数据源了。
那么，数据源工厂又是怎么创建的呢？是mybatis解析xml通过反射创建的。
XMLConfigBuilder类中的parse()方法，parse()中调用parseConfiguration()方法，parseConfiguration()中调用environmentsElement()方法，environmentsElement()中调用dataSourceElement()方法。
2.3 DataSource延迟到执行SQL语句的时候才创建Connection对象
当我们需要创建SqlSession对象并需要执行SQL语句时，这时候MyBatis才会去调用dataSource对象来创建java.sql.Connection对象。也就是说，java.sql.Connection对象的创建一直延迟到执行SQL语句的时候。
比如，我们有如下方法执行一个简单的SQL语句：
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
sqlSession.selectList("SELECT * FROM STUDENTS");
前4句都不会导致java.sql.Connection对象的创建，只有当第5句sqlSession.selectList(“SELECT * FROM STUDENTS”)，才会触发MyBatis在底层执行下面这个方法来创建java.sql.Connection对象：
protected void openConnection() throws SQLException {
if (log.isDebugEnabled()) {
log.debug("Opening JDBC Connection");
}
connection = dataSource.getConnection();
if (level != null) {
connection.setTransactionIsolation(level.getLevel());
}
setDesiredAutoCommit(autoCommmit);
}
而对于DataSource的UNPOOLED的类型的实现UnpooledDataSource是怎样实现getConnection()方法的呢？请看下一节。
问题：从sqlSession.selectList到事务中的openConnection()
回答：
3.1 不使用连接池：UnpooledDataSource时序图
当 <dataSource>的type属性被配置成了”UNPOOLED”，MyBatis首先会实例化一个UnpooledDataSourceFactory工厂实例，然后通过getDataSource()方法返回一个UnpooledDataSource实例对象引用，我们假定为dataSource。
使用UnpooledDataSource的getConnection(),每调用一次就会产生一个新的Connection实例对象。UnPooledDataSource的getConnection()方法实现如下：
/*
UnpooledDataSource类中的的getConnection()实现
*/
public Connection getConnection() throws SQLException
{
return doGetConnection(username, password);
}
private Connection doGetConnection(String username, String password) throws SQLException
{
//封装username和password成properties
Properties props = new Properties();
if (driverProperties != null)
{
props.putAll(driverProperties);
}
if (username != null)
{
props.setProperty("user", username);
}
if (password != null)
{
props.setProperty("password", password);
}
return doGetConnection(props);
}
/*
* 获取数据连接
*/
private Connection doGetConnection(Properties properties) throws SQLException
{
//1.初始化驱动
initializeDriver();
//2.从DriverManager中获取连接，获取新的Connection对象
Connection connection = DriverManager.getConnection(url, properties);
//3.配置connection属性
configureConnection(connection);
//4.返回Connection对象
return connection;
}
如上代码所示，UnpooledDataSource会做以下事情：
-
初始化驱动： 判断driver驱动是否已经加载到内存中，如果还没有加载，则会动态地加载driver类，并实例化一个Driver对象，使用DriverManager.registerDriver()方法将其注册到内存中，以供后续使用。
-
创建Connection对象： 使用DriverManager.getConnection()方法创建连接。
-
配置Connection对象： 设置是否自动提交autoCommit和隔离级别isolationLevel。
-
返回Connection对象。
上述的时序图如下所示：
总结：从上述的代码中可以看到，我们每调用一次getConnection()方法，都会通过DriverManager.getConnection()返回新的java.sql.Connection实例。
3.2 不使用连接池：每次新建一个Connection代价太大
1、创建一个java.sql.Connection实例对象的代价
首先让我们来看一下创建一个java.sql.Connection对象的资源消耗。我们通过连接Oracle数据库，创建创建Connection对象，来看创建一个Connection对象、执行SQL语句各消耗多长时间。代码如下：
public static void main(String[] args) throws Exception
{
String sql = "select * from hr.employees where employee_id < ? and employee_id >= ?";
PreparedStatement st = null;
ResultSet rs = null;
long beforeTimeOffset = -1L; //创建Connection对象前时间
long afterTimeOffset = -1L; //创建Connection对象后时间
long executeTimeOffset = -1L; //创建Connection对象后时间
Connection con = null;
Class.forName("oracle.jdbc.driver.OracleDriver");
beforeTimeOffset = new Date().getTime();
System.out.println("before:\t" + beforeTimeOffset);
con = DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:xe", "louluan", "123456");
afterTimeOffset = new Date().getTime();
System.out.println("after:\t\t" + afterTimeOffset);
System.out.println("Create Costs:\t\t" + (afterTimeOffset - beforeTimeOffset) + " ms");
st = con.prepareStatement(sql);
//设置参数
st.setInt(1, 101);
st.setInt(2, 0);
//查询，得出结果集
rs = st.executeQuery();
executeTimeOffset = new Date().getTime();
System.out.println("Exec Costs:\t\t" + (executeTimeOffset - afterTimeOffset) + " ms");
}
上述程序在我笔记本上的执行结果为：
从此结果可以清楚地看出，创建一个Connection对象，用了250 毫秒；而执行SQL的时间用了170毫秒。
创建一个Connection对象用了250毫秒！这个时间对计算机来说可以说是一个非常奢侈的！
这仅仅是一个Connection对象就有这么大的代价，设想一下另外一种情况：如果我们在Web应用程序中，为用户的每一个请求就操作一次数据库，当有10000个在线用户并发操作的话，对计算机而言，仅仅创建Connection对象不包括做业务的时间就要损耗10000×250ms= 250 0000 ms = 2500 s = 41.6667 min,竟然要41分钟！！！如果对高用户群体使用这样的系统，简直就是开玩笑！
2、问题分析：
创建一个java.sql.Connection对象的代价是如此巨大，是因为创建一个Connection对象的过程，在底层就相当于和数据库建立的通信连接，在建立通信连接的过程，消耗了这么多的时间，而往往我们建立连接后（即创建Connection对象后），就执行一个简单的SQL语句，然后就要抛弃掉，这是一个非常大的资源浪费！
3、解决方案:
对于需要频繁地跟数据库交互的应用程序，可以在创建了Connection对象，并操作完数据库后，可以不释放掉资源，而是将它放到内存中，当下次需要操作数据库时，可以直接从内存中取出Connection对象，不需要再创建了，这样就极大地节省了创建Connection对象的资源消耗。由于内存也是有限和宝贵的，这又对我们对内存中的Connection对象怎么有效地维护提出了很高的要求。我们将在内存中存放Connection对象的容器称之为 连接池（Connection Pool）。下面让我们来看一下MyBatis的线程池是怎样实现的。
问题：底层是如何创建Connection的具体逻辑？
回答：逻辑复杂且没什么用，了解即可，从JdbcTransaction类的openConnection()出发，
（1）进入PooledDataSource类中popConnection()方法
（2）进入UnPooledDataSource类中的doGetConnection()方法
3.3 使用连接池：PooledDataSource类减少创建Connection的消耗
3.3.1 idleConnections和activeConnections
我们使用PooledDataSource的getConnection()方法来返回Connection对象。现在让我们看一下它的底层原理：PooledDataSource将java.sql.Connection对象包裹成PooledConnection对象放到了PoolState类型的容器中维护。 MyBatis将连接池中的PooledConnection分为两种状态： 空闲状态（idle）和活动状态(active)，这两种状态的PooledConnection对象分别被存储到PoolState容器内的 idleConnections 和 activeConnections 两个List集合中：
PoolState连接池的大致结构如下所示：
idleConnections集合
（1）存储：空闲(idle)状态PooledConnection对象被放置到此集合中，表示当前闲置的没有被使用的PooledConnection集合；
（2）取出：调用PooledDataSource的getConnection()方法时，会优先从此集合中取PooledConnection对象；
（3）放入：当用完一个java.sql.Connection对象时，MyBatis会将其包裹成PooledConnection对象放到此集合中。
activeConnections集合
（1）存储：活动(active)状态的PooledConnection对象被放置到名为activeConnections的ArrayList中，表示当前正在被使用的PooledConnection集合；
（2）放入：调用PooledDataSource的getConnection()方法时，会优先从idleConnections集合中取PooledConnection对象，如果没有，则看此集合是否已满，如果未满，PooledDataSource会创建出一个PooledConnection，添加到此集合中，并返回。
3.3.2 使用连接池：java.sql.Connection对象的获取
3.3.2.1 连接池创建Connection对象两步走
使用连接池，创建Connection对象两步走，先调用获取popConnection()方法得到一个PooledConnection对象，然后调用PooledConnection类的getProxyConnection()返回一个proxyConnection变量。下面让我们看一下PooledDataSource 的getConnection()方法获取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对象。
注意：这是独立的调用两个函数，不是一个函数中调用另一个函数
第一步，会从连接池中返回一个可用的PooledConnection对象；
第二步，调用getProxyConnection()方法最终返回Conection对象
3.3.2.2 popConnection()
现在让我们看一下popConnection()方法到底做了什么：
-
先看是否有空闲(idle)状态下的PooledConnection对象，如果有，就直接返回一个可用的PooledConnection对象；否则进行第2步。
-
查看活动状态的PooledConnection池activeConnections是否已满；如果没有满，则创建一个新的PooledConnection对象，然后放到activeConnections池中，然后返回此PooledConnection对象；否则进行第三步；
-
看最先进入activeConnections池中的PooledConnection对象是否已经过期：如果已经过期，从activeConnections池中移除此对象，然后创建一个新的PooledConnection对象，添加到activeConnections中，然后将此对象返回；否则进行第4步（金手指：如果没有过期就进入第4步）。
-
线程等待，循环2步（第4步转到第3步，因为第4步是第3步，所以，PooledConnection池activeConnections一定已满，所以，就是要在第3步找到一个过期的，如果目前还没有过期的，就不断花时间找，一直到找到为止）
/*
* 传递一个用户名和密码，从连接池中返回可用的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
{
// 如果没有满，则创建一个新的PooledConnection对象
// 然后放到activeConnections池中，然后返回此PooledConnection对象
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;
}
对应的处理流程图如下所示：
问题1：先看是否有空闲(idle)状态下的PooledConnection对象，如果有，就直接返回一个可用的PooledConnection对象
后面是else，不用执行，conn已经有值，可以跳出while(conn==null)，直接return conn;
如上所示,对于PooledDataSource的getConnection()方法内，先是调用类PooledDataSource的popConnection()方法返回了一个PooledConnection对象，然后调用了PooledConnection的getProxyConnection()来返回Connection对象。
3.3.2.3 getProxyConnection()
getProxyConnection()方法很简单，直接返回类中proxyConnection变量，后面的操作就都是使用proxyConnection变量了，而不是使用realConnection变量
如果使用连接池，在创建Connection对象的时候就确定了，得到的是一个proxyConnection变量了，而不是使用realConnection变量，后面的操作就都是使用proxyConnection变量了，其实对于proxyConnection变量中的所有方法，都是使用反射调用invoke,底层还是通过realConnection来完成的，唯一特殊的是，调用conn.close()不是关闭，而不是放到连接池中。如下：
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 { // else表示如果不是close()方法，就是代理connection和真是connection相同，
// 执行真实对象对象的方法，method.invoke(realConnection, args);
// 只有close()方法特殊处理 good
try {
if (!Object.class.equals(method.getDeclaringClass())) {
checkConnection();
}
return method.invoke(realConnection, args);
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
}
}
3.3.3 使用连接池：java.sql.Connection对象的回收
3.3.3.1 不使用连接池：con.close()，关闭connection连接，释放资源
不使用连接池的时候，con.close()，关闭connection连接，释放资源
当我们的程序中使用完Connection对象时，如果不使用数据库连接池，我们一般会调用 connection.close()方法，关闭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();
}
}
3.3.3.2 使用连接池：conn.close()，将Connection对象放到连接池中
调用con.close()方法：Connection对象所持有的资源会被全部释放掉，Connection对象也就不能再使用。那么，如果我们使用了连接池，我们在用完了Connection对象时，需要将它放在连接池中，该怎样做呢？
可能大家第一个在脑海里闪现出来的想法就是：我在应该调用con.close()方法的时候，不调用con.close()方法，将其换成将Connection对象放到连接池容器中的代码！
好，我们将上述的想法实现，首先定义一个简易连接池Pool，然后将上面的代码改写：
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();
}
}
}
conn.close()变为Pool.putConnection(con);
上述的代码就是将我们使用过的Connection对象放到Pool连接池中，我们需要Connection对象的话，只需要使用Pool.getConnection()方法从里面取即可。
是的,上述的代码完全可以实现此能力，不过有一个很不优雅的实现：就是我们需要手动地将Connection对象放到Pool连接池中，这是一个很傻的实现方式。这也和一般使用Connection对象的方式不一样：一般使用Connection的方式是使用完后，然后调用close()方法释放资源。
为了和一般的使用Conneciton对象的方式保持一致，我们希望当Connection使用完后，调用close()方法，而实际上Connection资源并没有被释放，而实际上被添加到了连接池中。这样可以做到吗？答案是可以。上述的要求从另外一个角度来描述就是：能否提供一种机制，让我们知道Connection对象调用了什么方法，从而根据不同的方法自定义相应的处理机制。恰好代理机制就可以完成上述要求（懂了 good）。
3.3.3.3 代理模式实现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 {
//......
private PooledDataSource dataSource; //数据源引用
private Connection realConnection; //真正的Connection对象
private Connection proxyConnection; //代理自己的代理Connection
//......
}
PooledConenction实现了InvocationHandler接口，并且，proxyConnection对象也是根据这个它来生成的代理对象：
public PooledConnection(Connection connection, PooledDataSource dataSource) {
this.hashCode = connection.hashCode(); // hashcode
this.realConnection = connection; // 真实connection
this.dataSource = dataSource; // 数据源
this.createdTimestamp = System.currentTimeMillis(); // 新建时间
this.lastUsedTimestamp = System.currentTimeMillis(); // 最后修改时间
this.valid = true; // valid
this.proxyConnection = (Connection) Proxy.newProxyInstance(Connection.class.getClassLoader(), IFACES, this); // 代理connection
}
实际上，对于开发程序员来说，调用PooledDataSource的getConnection()方法返回的就是这个proxyConnection对象，然后proxyConnection.getProxyConnection()。
当我们调用此proxyConnection对象上的任何方法时，都会调用PooledConnection对象内invoke()方法(就是基于反射)。
让我们看一下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 { // else表示如果不是close()方法，就是代理connection和真是connection相同，
// 执行真实对象对象的方法，method.invoke(realConnection, args);
// 只有close()方法特殊处理 good
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对象放到连接池中。
MyBatis定义了一个JndiDataSourceFactory工厂来创建通过JNDI形式生成的DataSource。
下面让我们看一下JndiDataSourceFactory的关键代码：
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));
}
面试金手指1：Mybatis三种数据源及其关系
第一，三种数据源：四个包分别对应一个基本包和三种数据源
MyBatis把数据源DataSource分为三种：
（1）UNPOOLED 不使用连接池的数据源
（2）POOLED 使用连接池的数据源
（3）JNDI 使用JNDI实现的数据源
第二，三种数据源的关系
PooledDataSource和UnPooledDataSource都实现了java.sql.DataSource接口，并且PooledDataSource持有一个UnPooledDataSource的引用，当PooledDataSource需要创建一个java.sql.DataSource实例对象时，还是通过UnPooledDataSource来创建。PooledDataSource只是提供一种缓存连接池实例。
面试金手指2：Mybatis初始化的时候创建数据源工厂和数据源
初始化的时候反射创建数据源工厂，数据源是通过数据源工厂来创建的，三种数据源对应三种数据源工厂，在工厂类的工厂方法中使用new来创建对应数据源，如下：
数据源工厂的构造函数中new数据源很重要，只要反射新建了数据源工厂，就是新建数据源了。
那么，数据源工厂又是怎么创建的呢？是mybatis解析xml通过反射创建的XMLConfigBuilder类中的parse()方法，parse()中的environmentsElement()方法，environmentsElement()中的dataSourceElement()方法，
面试金手指3：Mybatis延迟到执行SQL语句的时候才创建Connection对象
从sqlSession.selectList到事务中的openConnection()
面试金手指4：连接池的两个list
PoolState连接池的大致结构如下所示：
idleConnections集合：
（1）存储：空闲(idle)状态PooledConnection对象被放置到此集合中，表示当前闲置的没有被使用的PooledConnection集合；
（2）取出：调用PooledDataSource的getConnection()方法时，会优先从此集合中取PooledConnection对象；
（3）放入：当用完一个java.sql.Connection对象时，MyBatis会将其包裹成PooledConnection对象放到此集合中。
activeConnections集合：
（1）存储：活动(active)状态的PooledConnection对象被放置到名为activeConnections的ArrayList中，表示当前正在被使用的PooledConnection集合；
（2）放入：调用PooledDataSource的getConnection()方法时，会优先从idleConnections集合中取PooledConnection对象，如果没有，则看此集合是否已满，如果未满，PooledDataSource会创建出一个PooledConnection，添加到此集合中，并返回。
面试金手指5：连接池的java.sql.Connection对象的创建
用连接池，创建Connection对象两步走：
(1) 先调用获取popConnection()方法得到一个PooledConnection对象（很重要，详见3.3.2.2 popConnection() 对于两个队列的处理）；
(2) 然后调用PooledConnection类的getProxyConnection()返回一个proxyConnection变量
面试金手指6：连接池的java.sql.Connection对象的回收
一段程序处理所有疑问
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 { // else表示如果不是close()方法，就是代理connection和真是connection相同，
// 执行真实对象对象的方法，method.invoke(realConnection, args);
// 只有close()方法特殊处理 good
try {
if (!Object.class.equals(method.getDeclaringClass())) {
checkConnection();
}
return method.invoke(realConnection, args);
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
}
}
面试金手指7：JNDI类型的数据源DataSource
MyBatis定义了一个JndiDataSourceFactory工厂来创建通过JNDI形式生成的DataSource，定位JndiDataSourceFactory类：
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));
}
《加速，从数据源到连接池…》，完成了。
天天打码，天天进步！！！
