对于ORM框架而言。数据源的组织是一个很重要的一部分。这直接影响到框架的性能问题。

本文将通过对MyBatis框架的数据源结构进行详尽的分析，而且深入解析MyBatis的连接池。

    本文首先会讲述MyBatis的数据源的分类，然后会介绍数据源是怎样载入和使用的。紧接着将分类介绍UNPOOLED、POOLED和JNDI类型的数据源组织。期间我们会重点解说POOLED类型的数据源和事实上现的连接池原理。

下面是本章的组织结构：

• 一、MyBatis数据源DataSource分类
• 二、数据源DataSource的创建过程
• 三、 DataSource什么时候创建Connection对象
• 四、不使用连接池的UnpooledDataSource
• 五、为什么要使用连接池？
• 六、使用了连接池的PooledDataSource

一、MyBatis数据源DataSource分类

MyBatis数据源实现是在下面四个包中：

MyBatis把数据源DataSource分为三种：

         UNPOOLED    不使用连接池的数据源

         POOLED      使用连接池的数据源

         JNDI            使用JNDI实现的数据源

即：

对应地，MyBatis内部分别定义了实现了java.sql.DataSource接口的UnpooledDataSource，PooledDataSource类来表示UNPOOLED、POOLED类型的数据源。 例如以下图所看到的：

对于JNDI类型的数据源DataSource。则是通过JNDI上下文中取值。

二、数据源DataSource的创建过程

 MyBatis数据源DataSource对象的创建发生在MyBatis初始化的过程中。

以下让我们一步步地了解MyBatis是怎样创建数据源DataSource的。

在mybatis的XML配置文件里。使用<dataSource>元素来配置数据源：

1.  MyBatis在初始化时，解析此文件，依据<dataSource>的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工厂：

• POOLED        PooledDataSourceFactory
• UNPOOLED     UnpooledDataSourceFactory
• JNDI          JndiDataSourceFactory

   其类图例如以下所看到的：

3.  MyBatis创建了DataSource实例后，会将其放到Configuration对象内的Environment对象中。 供以后使用。

三、 DataSource什么时候创建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()方法的呢？请看下一节。

四、不使用连接池的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);    return connection;}

如上代码所看到的，UnpooledDataSource会做下面事情：

1.  初始化驱动：    推断driver驱动是否已经载入到内存中，假设还没有载入，则会动态地载入driver类。并实例化一个Driver对象，使用DriverManager.registerDriver()方法将其注冊到内存中，以供兴许使用。

2.  创建Connection对象：    使用DriverManager.getConnection()方法创建连接。

3.  配置Connection对象：    设置是否自己主动提交autoCommit和隔离级别isolationLevel。

4.  返回Connection对象。

 

上述的序列图例如以下所看到的：

总结：从上述的代码中能够看到，我们每调用一次getConnection()方法，都会通过DriverManager.getConnection()返回新的java.sql.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的线程池是如何实现的。

六、使用了连接池的PooledDataSource

相同地。我们也是使用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。加入到此集合中，并返回。

 

PoolState连接池的大致结构例如以下所看到的：

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

 

以下让我们看一下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对象。（至于为什么会有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对象的回收

       当我们的程序中使用完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(); } }

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

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

可能大家第一个在脑海里闪现出来的想法就是：我在应该调用con.close()方法的时候，不调用close()f方法，将其换成将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
      
        pool = new Vector
       
        ();        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()
        
         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;    //......}

PooledConenction

实现了

InvocationHandler

接口，而且，

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()方法。

让我们看一下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

对于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));}