對於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步

/*
 * 傳遞一個使用者名稱和密碼，從連線池中返回可用的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<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;
  
  //......
}

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