終結(jié)篇：MyBatis原理深入解析（二）

8 MyBatis數(shù)據(jù)源與連接池#

8.1 MyBatis數(shù)據(jù)源DataSource分類##

MyBatis數(shù)據(jù)源實(shí)現(xiàn)是在以下四個包中：

MyBatis數(shù)據(jù)源實(shí)現(xiàn)包

MyBatis把數(shù)據(jù)源DataSource分為三種：

UNPOOLED 不使用連接池的數(shù)據(jù)源

POOLED 使用連接池的數(shù)據(jù)源

JNDI 使用JNDI實(shí)現(xiàn)的數(shù)據(jù)源

即：

MyBatis三種數(shù)據(jù)源

相應(yīng)地，MyBatis內(nèi)部分別定義了實(shí)現(xiàn)了java.sql.DataSource接口的UnpooledDataSource，PooledDataSource類來表示UNPOOLED、POOLED類型的數(shù)據(jù)源。 如下圖所示：

MyBatis DataSource實(shí)現(xiàn)UML圖

對于JNDI類型的數(shù)據(jù)源DataSource，則是通過JNDI上下文中取值。

8.2 數(shù)據(jù)源DataSource的創(chuàng)建過程##

MyBatis數(shù)據(jù)源DataSource對象的創(chuàng)建發(fā)生在MyBatis初始化的過程中。下面讓我們一步步地了解MyBatis是如何創(chuàng)建數(shù)據(jù)源DataSource的。

在mybatis的XML配置文件中，使用<dataSource>元素來配置數(shù)據(jù)源：

<dataSource>元素配置數(shù)據(jù)源
  1. MyBatis在初始化時，解析此文件，根據(jù)<dataSource>的type屬性來創(chuàng)建相應(yīng)類型的的數(shù)據(jù)源DataSource，即：

type=”POOLED” ：MyBatis會創(chuàng)建PooledDataSource實(shí)例

type=”UNPOOLED” ：MyBatis會創(chuàng)建UnpooledDataSource實(shí)例

type=”JNDI” ：MyBatis會從JNDI服務(wù)上查找DataSource實(shí)例，然后返回使用

  1. 順便說一下，MyBatis是通過工廠模式來創(chuàng)建數(shù)據(jù)源DataSource對象的，MyBatis定義了抽象的工廠接口:org.apache.ibatis.datasource.DataSourceFactory,通過其getDataSource()方法返回數(shù)據(jù)源DataSource：
public interface DataSourceFactory { 
      void setProperties(Properties props);  
      // 生產(chǎn)DataSource  
      DataSource getDataSource();  
}

上述三種不同類型的type，則有對應(yīng)的以下dataSource工廠：

POOLED PooledDataSourceFactory

UNPOOLED UnpooledDataSourceFactory

JNDI JndiDataSourceFactory

其類圖如下所示：

DataSource工廠UML類圖
  1. MyBatis創(chuàng)建了DataSource實(shí)例后，會將其放到Configuration對象內(nèi)的Environment對象中，供以后使用。

8.3 DataSource什么時候創(chuàng)建Connection對象##

當(dāng)我們需要創(chuàng)建SqlSession對象并需要執(zhí)行SQL語句時，這時候MyBatis才會去調(diào)用dataSource對象來創(chuàng)建java.sql.Connection對象。也就是說，java.sql.Connection對象的創(chuàng)建一直延遲到執(zhí)行SQL語句的時候。

比如，我們有如下方法執(zhí)行一個簡單的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句都不會導(dǎo)致java.sql.Connection對象的創(chuàng)建，只有當(dāng)?shù)?句sqlSession.selectList("SELECT * FROM STUDENTS")，才會觸發(fā)MyBatis在底層執(zhí)行下面這個方法來創(chuàng)建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);  
}

8.4 不使用連接池的UnpooledDataSource##

當(dāng) <dataSource>的type屬性被配置成了”UNPOOLED”，MyBatis首先會實(shí)例化一個UnpooledDataSourceFactory工廠實(shí)例，然后通過.getDataSource()方法返回一個UnpooledDataSource實(shí)例對象引用，我們假定為dataSource。

使用UnpooledDataSource的getConnection(),每調(diào)用一次就會產(chǎn)生一個新的Connection實(shí)例對象。

UnPooledDataSource的getConnection()方法實(shí)現(xiàn)如下：

/* 
 * UnpooledDataSource的getConnection()實(shí)現(xiàn) 
 */  
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);  
}  
  
/* 
 *  獲取數(shù)據(jù)連接 
 */  
private Connection doGetConnection(Properties properties) throws SQLException  
{  
    //1.初始化驅(qū)動  
    initializeDriver();  
    //2.從DriverManager中獲取連接，獲取新的Connection對象  
    Connection connection = DriverManager.getConnection(url, properties);  
    //3.配置connection屬性  
    configureConnection(connection);  
    return connection;  
}

如上代碼所示，UnpooledDataSource會做以下事情：

  1. 初始化驅(qū)動：判斷driver驅(qū)動是否已經(jīng)加載到內(nèi)存中，如果還沒有加載，則會動態(tài)地加載driver類，并實(shí)例化一個Driver對象，使用DriverManager.registerDriver()方法將其注冊到內(nèi)存中，以供后續(xù)使用。

  2. 創(chuàng)建Connection對象：使用DriverManager.getConnection()方法創(chuàng)建連接。

  3. 配置Connection對象：設(shè)置是否自動提交autoCommit和隔離級別isolationLevel。

  4. 返回Connection對象。

上述的序列圖如下所示：

UnPooledDataSource序列圖

總結(jié)：從上述的代碼中可以看到，我們每調(diào)用一次getConnection()方法，都會通過DriverManager.getConnection()返回新的java.sql.Connection實(shí)例。

8.5 為什么要使用連接池？##

  1. 創(chuàng)建一個java.sql.Connection實(shí)例對象的代價

首先讓我們來看一下創(chuàng)建一個java.sql.Connection對象的資源消耗。我們通過連接Oracle數(shù)據(jù)庫，創(chuàng)建創(chuàng)建Connection對象，來看創(chuàng)建一個Connection對象、執(zhí)行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; //創(chuàng)建Connection對象前時間  
     long afterTimeOffset = -1L; //創(chuàng)建Connection對象后時間  
     long executeTimeOffset = -1L; //執(zhí)行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);  
     //設(shè)置參數(shù)  
     st.setInt(1, 101);  
     st.setInt(2, 0);  
     //查詢，得出結(jié)果集  
     rs = st.executeQuery();  
     executeTimeOffset = new Date().getTime();  
     System.out.println("Exec Costs:\t\t" + (executeTimeOffset - afterTimeOffset) + " ms");  
}
上述程序的執(zhí)行結(jié)果

從此結(jié)果可以清楚地看出，創(chuàng)建一個Connection對象，用了250 毫秒；而執(zhí)行SQL的時間用了170毫秒。

創(chuàng)建一個Connection對象用了250毫秒！這個時間對計算機(jī)來說可以說是一個非常奢侈的！

這僅僅是一個Connection對象就有這么大的代價，設(shè)想一下另外一種情況：如果我們在Web應(yīng)用程序中，為用戶的每一個請求就操作一次數(shù)據(jù)庫，當(dāng)有10000個在線用戶并發(fā)操作的話，對計算機(jī)而言，僅僅創(chuàng)建Connection對象不包括做業(yè)務(wù)的時間就要損耗10000×250ms= 250 0000 ms = 2500 s = 41.6667 min,竟然要41分鐘?。?！如果對高用戶群體使用這樣的系統(tǒng)，簡直就是開玩笑！

  1. 問題分析：

創(chuàng)建一個java.sql.Connection對象的代價是如此巨大，是因?yàn)閯?chuàng)建一個Connection對象的過程，在底層就相當(dāng)于和數(shù)據(jù)庫建立的通信連接，在建立通信連接的過程，消耗了這么多的時間，而往往我們建立連接后（即創(chuàng)建Connection對象后），就執(zhí)行一個簡單的SQL語句，然后就要拋棄掉，這是一個非常大的資源浪費(fèi)！

  1. 解決方案：

對于需要頻繁地跟數(shù)據(jù)庫交互的應(yīng)用程序，可以在創(chuàng)建了Connection對象，并操作完數(shù)據(jù)庫后，可以不釋放掉資源，而是將它放到內(nèi)存中，當(dāng)下次需要操作數(shù)據(jù)庫時，可以直接從內(nèi)存中取出Connection對象，不需要再創(chuàng)建了，這樣就極大地節(jié)省了創(chuàng)建Connection對象的資源消耗。由于內(nèi)存也是有限和寶貴的，這又對我們對內(nèi)存中的Connection對象怎么有效地維護(hù)提出了很高的要求。我們將在內(nèi)存中存放Connection對象的容器稱之為連接池（Connection Pool）。下面讓我們來看一下MyBatis的連接池是怎樣實(shí)現(xiàn)的。

8.6 使用了連接池的PooledDataSource##

同樣地，我們也是使用PooledDataSource的getConnection()方法來返回Connection對象?，F(xiàn)在讓我們看一下它的基本原理：

PooledDataSource將java.sql.Connection對象包裹成PooledConnection對象放到了PoolState類型的容器中維護(hù)。 MyBatis將連接池中的PooledConnection分為兩種狀態(tài)：空閑狀態(tài)（idle）和活動狀態(tài)(active)，這兩種狀態(tài)的PooledConnection對象分別被存儲到PoolState容器內(nèi)的idleConnections和activeConnections兩個List集合中：

idleConnections：空閑(idle)狀態(tài)PooledConnection對象被放置到此集合中，表示當(dāng)前閑置的沒有被使用的PooledConnection集合，調(diào)用PooledDataSource的getConnection()方法時，會優(yōu)先從此集合中取PooledConnection對象。當(dāng)用完一個java.sql.Connection對象時，MyBatis會將其包裹成PooledConnection對象放到此集合中。

activeConnections：活動(active)狀態(tài)的PooledConnection對象被放置到名為activeConnections的ArrayList中，表示當(dāng)前正在被使用的PooledConnection集合，調(diào)用PooledDataSource的getConnection()方法時，會優(yōu)先從idleConnections集合中取PooledConnection對象,如果沒有，則看此集合是否已滿，如果未滿，PooledDataSource會創(chuàng)建出一個PooledConnection，添加到此集合中，并返回。

PoolState連接池的大致結(jié)構(gòu)如下所示：

PoolState連接池結(jié)構(gòu)圖
  1. 獲取java.sql.Connection對象的過程

下面讓我們看一下PooledDataSource 的getConnection()方法獲取Connection對象的實(shí)現(xiàn)：

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對象，然后再調(diào)用getProxyConnection()方法最終返回Conection對象。（至于為什么會有g(shù)etProxyConnection()，請關(guān)注下一節(jié)）。

現(xiàn)在讓我們看一下popConnection()方法到底做了什么：

  1. 先看是否有空閑(idle)狀態(tài)下的PooledConnection對象，如果有，就直接返回一個可用的PooledConnection對象；否則進(jìn)行第2步。

  2. 查看活動狀態(tài)的PooledConnection池activeConnections是否已滿；如果沒有滿，則創(chuàng)建一個新的PooledConnection對象，然后放到activeConnections池中，然后返回此PooledConnection對象；否則進(jìn)行第三步；

  3. 看最先進(jìn)入activeConnections池中的PooledConnection對象是否已經(jīng)過期：如果已經(jīng)過期，從activeConnections池中移除此對象，然后創(chuàng)建一個新的PooledConnection對象，添加到activeConnections中，然后將此對象返回；否則進(jìn)行第4步。

  4. 線程等待，循環(huán)至第1步

/* 
   * 傳遞一個用戶名和密碼，從連接池中返回可用的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  
              {  
                  // 連接池中沒有空閑連接，則取當(dāng)前正在使用的連接數(shù)小于最大限定值，  
                  if (state.activeConnections.size() < poolMaximumActiveConnections)  
                  {  
                      // 創(chuàng)建一個新的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 當(dāng)活動連接池已滿，不能創(chuàng)建時，取出活動連接池的第一個，即最先進(jìn)入連接池的PooledConnection對象  
                      // 計算它的校驗(yàn)時間，如果校驗(yàn)時間大于連接池規(guī)定的最大校驗(yàn)時間，則認(rèn)為它已經(jīng)過期了，利用這個PoolConnection內(nèi)部的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;  
}

對應(yīng)的處理流程圖如下所示：

PooledDataSource popConnection()流程圖

如上所示,對于PooledDataSource的getConnection()方法內(nèi)，先是調(diào)用類PooledDataSource的popConnection()方法返回了一個PooledConnection對象，然后調(diào)用了PooledConnection的getProxyConnection()來返回Connection對象。

  1. java.sql.Connection對象的回收

當(dāng)我們的程序中使用完Connection對象時，如果不使用數(shù)據(jù)庫連接池，我們一般會調(diào)用 connection.close()方法，關(guān)閉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);  
         //設(shè)置參數(shù)  
         st.setInt(1, 101);  
         st.setInt(2, 0);  
         //查詢，得出結(jié)果集  
         rs = st.executeQuery();  
         //取數(shù)據(jù)，省略  
         //關(guān)閉，釋放資源  
         con.close();  
     }  
     catch (SQLException e)  
     {  
         con.close();  
         e.printStackTrace();  
     }  
}

調(diào)用過close()方法的Connection對象所持有的資源會被全部釋放掉，Connection對象也就不能再使用。

那么，如果我們使用了連接池，我們在用完了Connection對象時，需要將它放在連接池中，該怎樣做呢？

為了和一般的使用Conneciton對象的方式保持一致，我們希望當(dāng)Connection使用完后，調(diào)用.close()方法，而實(shí)際上Connection資源并沒有被釋放，而實(shí)際上被添加到了連接池中。這樣可以做到嗎？答案是可以。上述的要求從另外一個角度來描述就是：能否提供一種機(jī)制，讓我們知道Connection對象調(diào)用了什么方法，從而根據(jù)不同的方法自定義相應(yīng)的處理機(jī)制。恰好代理機(jī)制就可以完成上述要求.

怎樣實(shí)現(xiàn)Connection對象調(diào)用了close()方法，而實(shí)際是將其添加到連接池中：

這是要使用代理模式，為真正的Connection對象創(chuàng)建一個代理對象，代理對象所有的方法都是調(diào)用相應(yīng)的真正Connection對象的方法實(shí)現(xiàn)。當(dāng)代理對象執(zhí)行close()方法時，要特殊處理，不調(diào)用真正Connection對象的close()方法，而是將Connection對象添加到連接池中。

MyBatis的PooledDataSource的PoolState內(nèi)部維護(hù)的對象是PooledConnection類型的對象，而PooledConnection則是對真正的數(shù)據(jù)庫連接java.sql.Connection實(shí)例對象的包裹器。

PooledConnection對象內(nèi)持有一個真正的數(shù)據(jù)庫連接java.sql.Connection實(shí)例對象和一個java.sql.Connection的代理，其部分定義如下：

class PooledConnection implements InvocationHandler {  
      //......  
      //所創(chuàng)建它的datasource引用  
      private PooledDataSource dataSource;  
      //真正的Connection對象  
      private Connection realConnection;  
      //代理自己的代理Connection  
      private Connection proxyConnection;  
   
      //......  
}

PooledConenction實(shí)現(xiàn)了InvocationHandler接口，并且，proxyConnection對象也是根據(jù)這個它來生成的代理對象：

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

實(shí)際上，我們調(diào)用PooledDataSource的getConnection()方法返回的就是這個proxyConnection對象。當(dāng)我們調(diào)用此proxyConnection對象上的任何方法時，都會調(diào)用PooledConnection對象內(nèi)invoke()方法。

讓我們看一下PooledConnection類中的invoke()方法定義：

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
      String methodName = method.getName();  
      //當(dāng)調(diào)用關(guān)閉的時候，回收此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);  
          }  
      }  
}

從上述代碼可以看到，當(dāng)我們使用了pooledDataSource.getConnection()返回的Connection對象的close()方法時，不會調(diào)用真正Connection的close()方法，而是將此Connection對象放到連接池中。

8.7 JNDI類型的數(shù)據(jù)源DataSource##

對于JNDI類型的數(shù)據(jù)源DataSource的獲取就比較簡單，MyBatis定義了一個JndiDataSourceFactory工廠來創(chuàng)建通過JNDI形式生成的DataSource。下面讓我們看一下JndiDataSourceFactory的關(guān)鍵代碼：

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

9 MyBatis事務(wù)管理機(jī)制#

9.1 概述##

對數(shù)據(jù)庫的事務(wù)而言，應(yīng)該具有以下幾點(diǎn)：創(chuàng)建（create）、提交（commit）、回滾（rollback）、關(guān)閉（close）。對應(yīng)地，MyBatis將事務(wù)抽象成了Transaction接口：

MyBatis將事務(wù)抽象成了Transaction接口

MyBatis的事務(wù)管理分為兩種形式：

  1. 使用JDBC的事務(wù)管理機(jī)制：即利用java.sql.Connection對象完成對事務(wù)的提交（commit()）、回滾（rollback()）、關(guān)閉（close()）等。
  2. 使用MANAGED的事務(wù)管理機(jī)制：這種機(jī)制MyBatis自身不會去實(shí)現(xiàn)事務(wù)管理，而是讓程序的容器如（JBOSS，Weblogic）來實(shí)現(xiàn)對事務(wù)的管理。

這兩者的類圖如下所示：

MyBatis的事務(wù)管理分為兩種形式

9.2 事務(wù)的配置、創(chuàng)建和使用##

  1. 事務(wù)的配置

我們在使用MyBatis時，一般會在MyBatisXML配置文件中定義類似如下的信息：

MyBatis事務(wù)的配置

<environment>節(jié)點(diǎn)定義了連接某個數(shù)據(jù)庫的信息，其子節(jié)點(diǎn)<transactionManager> 的type會決定我們用什么類型的事務(wù)管理機(jī)制。

  1. 事務(wù)工廠的創(chuàng)建

MyBatis事務(wù)的創(chuàng)建是交給TransactionFactory 事務(wù)工廠來創(chuàng)建的，如果我們將<transactionManager>的type 配置為"JDBC",那么，在MyBatis初始化解析<environment>節(jié)點(diǎn)時，會根據(jù)type="JDBC"創(chuàng)建一個JdbcTransactionFactory工廠，其源碼如下：

/** 
   * 解析<transactionManager>節(jié)點(diǎn)，創(chuàng)建對應(yīng)的TransactionFactory 
   * @param context 
   * @return 
   * @throws Exception 
   */  
private TransactionFactory transactionManagerElement(XNode context) throws Exception {  
      if (context != null) {  
          String type = context.getStringAttribute("type");  
          Properties props = context.getChildrenAsProperties();  
          /* 
           * 在Configuration初始化的時候，會通過以下語句，給JDBC和MANAGED對應(yīng)的工廠類 
           * typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class); 
           * typeAliasRegistry.registerAlias("MANAGED", ManagedTransactionFactory.class); 
           * 下述的resolveClass(type).newInstance()會創(chuàng)建對應(yīng)的工廠實(shí)例 
           */  
          TransactionFactory factory = (TransactionFactory) resolveClass(type).newInstance();  
          factory.setProperties(props);  
          return factory;  
      }
      throw new BuilderException("Environment declaration requires a TransactionFactory.");  
}

如上述代碼所示，如果type = "JDBC",則MyBatis會創(chuàng)建一個JdbcTransactionFactory.class 實(shí)例；如果type="MANAGED"，則MyBatis會創(chuàng)建一個MangedTransactionFactory.class實(shí)例。

MyBatis對<transactionManager>節(jié)點(diǎn)的解析會生成TransactionFactory實(shí)例；而對<dataSource>解析會生成datasouce實(shí)例，作為<environment>節(jié)點(diǎn)，會根據(jù)TransactionFactory和DataSource實(shí)例創(chuàng)建一個Environment對象，代碼如下所示：

private void environmentsElement(XNode context) throws Exception {  
      if (context != null) {  
          if (environment == null) {  
              environment = context.getStringAttribute("default");  
          }  
          for (XNode child : context.getChildren()) {  
              String id = child.getStringAttribute("id");  
              //是和默認(rèn)的環(huán)境相同時，解析之  
              if (isSpecifiedEnvironment(id)) {  
                  //1.解析<transactionManager>節(jié)點(diǎn)，決定創(chuàng)建什么類型的TransactionFactory  
                  TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));  
                  //2. 創(chuàng)建dataSource  
                  DataSourceFactory dsFactory = dataSourceElement(child.evalNode("dataSource"));  
                  DataSource dataSource = dsFactory.getDataSource();  
                  //3. 使用了Environment內(nèi)置的構(gòu)造器Builder，傳遞id 事務(wù)工廠TransactionFactory和數(shù)據(jù)源DataSource  
                  Environment.Builder environmentBuilder = new Environment.Builder(id)  
                  .transactionFactory(txFactory)  
                  .dataSource(dataSource);  
                  configuration.setEnvironment(environmentBuilder.build());  
              }  
          }  
      }  
}

Environment表示著一個數(shù)據(jù)庫的連接，生成后的Environment對象會被設(shè)置到Configuration實(shí)例中，以供后續(xù)的使用。

Environment組成結(jié)構(gòu)圖

上述一直在講事務(wù)工廠TransactionFactory來創(chuàng)建的Transaction，現(xiàn)在讓我們看一下MyBatis中的TransactionFactory的定義吧。

  1. 事務(wù)工廠TransactionFactory

事務(wù)工廠Transaction定義了創(chuàng)建Transaction的兩個方法：一個是通過指定的Connection對象創(chuàng)建Transaction，另外是通過數(shù)據(jù)源DataSource來創(chuàng)建Transaction。與JDBC 和MANAGED兩種Transaction相對應(yīng)，TransactionFactory有兩個對應(yīng)的實(shí)現(xiàn)的子類：

TransactionFactory兩個對應(yīng)的實(shí)現(xiàn)的子類
  1. 事務(wù)Transaction的創(chuàng)建

通過事務(wù)工廠TransactionFactory很容易獲取到Transaction對象實(shí)例。我們以JdbcTransaction為例，看一下JdbcTransactionFactory是怎樣生成JdbcTransaction的，代碼如下：

public class JdbcTransactionFactory implements TransactionFactory {  
 
      public void setProperties(Properties props) {  
      }  
 
      /** 
       * 根據(jù)給定的數(shù)據(jù)庫連接Connection創(chuàng)建Transaction 
       * @param conn Existing database connection 
       * @return 
       */  
      public Transaction newTransaction(Connection conn) {  
          return new JdbcTransaction(conn);  
      }  
 
      /** 
       * 根據(jù)DataSource、隔離級別和是否自動提交創(chuàng)建Transacion 
       * 
       * @param ds 
       * @param level Desired isolation level 
       * @param autoCommit Desired autocommit 
       * @return 
       */  
      public Transaction newTransaction(DataSource ds, TransactionIsolationLevel level, boolean autoCommit) {  
          return new JdbcTransaction(ds, level, autoCommit);  
      }  
}

如上說是，JdbcTransactionFactory會創(chuàng)建JDBC類型的Transaction，即JdbcTransaction。類似地，ManagedTransactionFactory也會創(chuàng)建ManagedTransaction。下面我們會分別深入JdbcTranaction 和ManagedTransaction，看它們到底是怎樣實(shí)現(xiàn)事務(wù)管理的。

  1. JdbcTransaction

JdbcTransaction直接使用JDBC的提交和回滾事務(wù)管理機(jī)制。它依賴與從dataSource中取得的連接connection 來管理transaction 的作用域，connection對象的獲取被延遲到調(diào)用getConnection()方法。如果autocommit設(shè)置為on，開啟狀態(tài)的話，它會忽略commit和rollback。

直觀地講，就是JdbcTransaction是使用的java.sql.Connection 上的commit和rollback功能，JdbcTransaction只是相當(dāng)于對java.sql.Connection事務(wù)處理進(jìn)行了一次包裝（wrapper），Transaction的事務(wù)管理都是通過java.sql.Connection實(shí)現(xiàn)的。JdbcTransaction的代碼實(shí)現(xiàn)如下：

public class JdbcTransaction implements Transaction {  
 
      private static final Log log = LogFactory.getLog(JdbcTransaction.class);  
 
      //數(shù)據(jù)庫連接  
      protected Connection connection;  
      //數(shù)據(jù)源  
      protected DataSource dataSource;  
      //隔離級別  
      protected TransactionIsolationLevel level;  
      //是否為自動提交  
      protected boolean autoCommmit;  
 
      public JdbcTransaction(DataSource ds, TransactionIsolationLevel desiredLevel, boolean desiredAutoCommit) {  
          dataSource = ds;  
          level = desiredLevel;  
          autoCommmit = desiredAutoCommit;  
      }  
 
      public JdbcTransaction(Connection connection) {  
          this.connection = connection;  
      }  
 
      public Connection getConnection() throws SQLException {  
          if (connection == null) {  
              openConnection();  
          }  
          return connection;  
      }  
 
      /** 
       * commit()功能 使用connection的commit() 
       * @throws SQLException 
       */  
      public void commit() throws SQLException {  
          if (connection != null && !connection.getAutoCommit()) {  
              if (log.isDebugEnabled()) {  
                  log.debug("Committing JDBC Connection [" + connection + "]");  
              }  
              connection.commit();  
          }  
      }  
 
      /** 
       * rollback()功能 使用connection的rollback() 
       * @throws SQLException 
       */  
      public void rollback() throws SQLException {  
          if (connection != null && !connection.getAutoCommit()) {  
              if (log.isDebugEnabled()) {  
                  log.debug("Rolling back JDBC Connection [" + connection + "]");  
              }  
              connection.rollback();  
          }  
      }  
 
      /** 
       * close()功能 使用connection的close() 
       * @throws SQLException 
       */  
      public void close() throws SQLException {  
          if (connection != null) {  
              resetAutoCommit();  
              if (log.isDebugEnabled()) {  
                  log.debug("Closing JDBC Connection [" + connection + "]");  
              }  
              connection.close();  
          }  
      }  
 
      protected void setDesiredAutoCommit(boolean desiredAutoCommit) {  
          try {  
              if (connection.getAutoCommit() != desiredAutoCommit) {  
                  if (log.isDebugEnabled()) {  
                      log.debug("Setting autocommit to " + desiredAutoCommit + " on JDBC Connection [" + connection + "]");  
                  }  
                  connection.setAutoCommit(desiredAutoCommit);  
              }  
          } catch (SQLException e) {  
              // Only a very poorly implemented driver would fail here,  
              // and there's not much we can do about that.  
              throw new TransactionException("Error configuring AutoCommit.  "  
               + "Your driver may not support getAutoCommit() or setAutoCommit(). "  
               + "Requested setting: " + desiredAutoCommit + ".  Cause: " + e, e);  
          }  
      }  
 
      protected void resetAutoCommit() {  
          try {  
              if (!connection.getAutoCommit()) {  
                  // MyBatis does not call commit/rollback on a connection if just selects were performed.  
                  // Some databases start transactions with select statements  
                  // and they mandate a commit/rollback before closing the connection.  
                  // A workaround is setting the autocommit to true before closing the connection.  
                  // Sybase throws an exception here.  
                  if (log.isDebugEnabled()) {  
                      log.debug("Resetting autocommit to true on JDBC Connection [" + connection + "]");  
                  }  
                  connection.setAutoCommit(true);  
              }  
          } catch (SQLException e) {  
              log.debug("Error resetting autocommit to true "  
               + "before closing the connection.  Cause: " + e);  
          }  
      }  
 
      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);  
      }
}
  1. ManagedTransaction

ManagedTransaction讓容器來管理事務(wù)Transaction的整個生命周期，意思就是說，使用ManagedTransaction的commit和rollback功能不會對事務(wù)有任何的影響，它什么都不會做，它將事務(wù)管理的權(quán)利移交給了容器來實(shí)現(xiàn)?？慈缦翸anaged的實(shí)現(xiàn)代碼大家就會一目了然：

/** 
   *  
   * 讓容器管理事務(wù)transaction的整個生命周期 
   * connection的獲取延遲到getConnection()方法的調(diào)用 
   * 忽略所有的commit和rollback操作 
   * 默認(rèn)情況下，可以關(guān)閉一個連接connection，也可以配置它不可以關(guān)閉一個連接 
   * 讓容器來管理transaction的整個生命周期 
   * @see ManagedTransactionFactory 
   */   
public class ManagedTransaction implements Transaction {  
 
      private static final Log log = LogFactory.getLog(ManagedTransaction.class);  
 
      private DataSource dataSource;  
      private TransactionIsolationLevel level;  
      private Connection connection;  
      private boolean closeConnection;  
 
      public ManagedTransaction(Connection connection, boolean closeConnection) {  
          this.connection = connection;  
          this.closeConnection = closeConnection;  
      }  
 
      public ManagedTransaction(DataSource ds, TransactionIsolationLevel level, boolean closeConnection) {  
          this.dataSource = ds;  
          this.level = level;  
          this.closeConnection = closeConnection;  
      }  
 
      public Connection getConnection() throws SQLException {  
          if (this.connection == null) {  
              openConnection();  
          }  
          return this.connection;  
      }  
 
      public void commit() throws SQLException {  
          // Does nothing  
      }  
 
      public void rollback() throws SQLException {  
          // Does nothing  
      }  
 
      public void close() throws SQLException {  
          if (this.closeConnection && this.connection != null) {  
              if (log.isDebugEnabled()) {  
                  log.debug("Closing JDBC Connection [" + this.connection + "]");  
              }  
              this.connection.close();  
          }  
      }  
 
      protected void openConnection() throws SQLException {  
          if (log.isDebugEnabled()) {  
              log.debug("Opening JDBC Connection");  
          }  
          this.connection = this.dataSource.getConnection();  
          if (this.level != null) {  
              this.connection.setTransactionIsolation(this.level.getLevel());  
          }  
      }
}

注意：如果我們使用MyBatis構(gòu)建本地程序，即不是WEB程序，若將type設(shè)置成"MANAGED"，那么，我們執(zhí)行的任何update操作，即使我們最后執(zhí)行了commit操作，數(shù)據(jù)也不會保留，不會對數(shù)據(jù)庫造成任何影響。因?yàn)槲覀儗yBatis配置成了“MANAGED”，即MyBatis自己不管理事務(wù)，而我們又是運(yùn)行的本地程序，沒有事務(wù)管理功能，所以對數(shù)據(jù)庫的update操作都是無效的。

10 MyBatis關(guān)聯(lián)查詢#

MyBatis 提供了高級的關(guān)聯(lián)查詢功能，可以很方便地將數(shù)據(jù)庫獲取的結(jié)果集映射到定義的Java Bean中。下面通過一個實(shí)例，來展示一下Mybatis對于常見的一對多和多對一關(guān)系復(fù)雜映射是怎樣處理的。

設(shè)計一個簡單的博客系統(tǒng)，一個用戶可以開多個博客，在博客中可以發(fā)表文章，允許發(fā)表評論，可以為文章加標(biāo)簽。博客系統(tǒng)主要有以下幾張表構(gòu)成：

Author表：作者信息表，記錄作者的信息，用戶名和密碼，郵箱等。

Blog表：博客表，一個作者可以開多個博客，即Author和Blog的關(guān)系是一對多。

Post表：文章記錄表，記錄文章發(fā)表時間，標(biāo)題，正文等信息；一個博客下可以有很多篇文章，Blog 和Post的關(guān)系是一對多。

Comments表：文章評論表，記錄文章的評論，一篇文章可以有很多個評論：Post和Comments的對應(yīng)關(guān)系是一對多。

Tag表：標(biāo)簽表，表示文章的標(biāo)簽分類，一篇文章可以有多個標(biāo)簽，而一個標(biāo)簽可以應(yīng)用到不同的文章上，所以Tag和Post的關(guān)系是多對多的關(guān)系；（Tag和Post的多對多關(guān)系通過Post_Tag表體現(xiàn)）

Post_Tag表：記錄 文章和標(biāo)簽的對應(yīng)關(guān)系。

博客系統(tǒng)主要表關(guān)系

一般情況下，我們會根據(jù)每一張表的結(jié)構(gòu)創(chuàng)建與此相對應(yīng)的JavaBean（或者Pojo），來完成對表的基本CRUD操作。

表結(jié)構(gòu)和Java Bean對應(yīng)關(guān)系

上述對單個表的JavaBean定義有時候不能滿足業(yè)務(wù)上的需求。在業(yè)務(wù)上，一個Blog對象應(yīng)該有其作者的信息和一個文章列表，如下圖所示：

一個Blog對象應(yīng)該有其作者的信息和一個文章列表

如果想得到這樣的類的實(shí)例，則最起碼要有一下幾步：

  1. 通過Blog 的id 到Blog表里查詢Blog信息，將查詢到的blogId 和title 賦到Blog對象內(nèi)；

  2. 根據(jù)查詢到到blog信息中的authorId 去 Author表獲取對應(yīng)的author信息，獲取Author對象，然后賦到Blog對象內(nèi)；

  3. 根據(jù) blogId 去 Post表里查詢 對應(yīng)的 Post文章列表，將List<Post>對象賦到Blog對象中；

這樣的話，在底層最起碼調(diào)用三次查詢語句，請看下列的代碼：

/* 
 * 通過blogId獲取BlogInfo對象 
 */  
public static BlogInfo ordinaryQueryOnTest(String blogId)  
{  
    BigDecimal id = new BigDecimal(blogId);  
    SqlSession session = sqlSessionFactory.openSession();  
    BlogInfo blogInfo = new BlogInfo();  
    //1.根據(jù)blogid 查詢Blog對象，將值設(shè)置到blogInfo中  
    Blog blog = (Blog)session.selectOne("com.foo.bean.BlogMapper.selectByPrimaryKey",id);  
    blogInfo.setBlogId(blog.getBlogId());  
    blogInfo.setTitle(blog.getTitle());  
      
    //2.根據(jù)Blog中的authorId，進(jìn)入數(shù)據(jù)庫查詢Author信息，將結(jié)果設(shè)置到blogInfo對象中  
    Author author = (Author)session.selectOne("com.foo.bean.AuthorMapper.selectByPrimaryKey",blog.getAuthorId());  
    blogInfo.setAuthor(author);  
      
    //3.查詢posts對象，設(shè)置進(jìn)blogInfo中  
    List posts = session.selectList("com.foo.bean.PostMapper.selectByBlogId",blog.getBlogId());  
    blogInfo.setPosts(posts);  
    //以JSON字符串的形式將對象打印出來  
    JSONObject object = new JSONObject(blogInfo);  
    System.out.println(object.toString());  
    return blogInfo;  
}

從上面的代碼可以看出，想獲取一個BlogInfo對象比較麻煩，總共要調(diào)用三次數(shù)據(jù)庫查詢，得到需要的信息，然后再組裝BlogInfo對象。

10.1 嵌套語句查詢##

mybatis提供了一種機(jī)制，叫做嵌套語句查詢，可以大大簡化上述的操作，加入配置及代碼如下：

<resultMap type="com.foo.bean.BlogInfo" id="BlogInfo">  
    <id column="blog_id" property="blogId" />  
    <result column="title" property="title" />  
    <association property="author" column="blog_author_id"  
        javaType="com.foo.bean.Author" select="com.foo.bean.AuthorMapper.selectByPrimaryKey">  
    </association>  
    <collection property="posts" column="blog_id" ofType="com.foo.bean.Post"  
        select="com.foo.bean.PostMapper.selectByBlogId">  
    </collection>  
</resultMap>  
  
<select id="queryBlogInfoById" resultMap="BlogInfo" parameterType="java.math.BigDecimal">  
    SELECT  
    B.BLOG_ID,  
    B.TITLE,  
    B.AUTHOR_ID AS BLOG_AUTHOR_ID  
    FROM LOULUAN.BLOG B  
    where B.BLOG_ID = #{blogId,jdbcType=DECIMAL}  
</select>  

/* 
 * 通過blogId獲取BlogInfo對象 
 */  
public static BlogInfo nestedQueryOnTest(String blogId)  
{  
    BigDecimal id = new BigDecimal(blogId);  
    SqlSession session = sqlSessionFactory.openSession();  
    BlogInfo blogInfo = new BlogInfo();  
    blogInfo = (BlogInfo)session.selectOne("com.foo.bean.BlogMapper.queryBlogInfoById",id);  
    JSONObject object = new JSONObject(blogInfo);  
    System.out.println(object.toString());  
    return blogInfo;  
}

通過上述的代碼完全可以實(shí)現(xiàn)前面的那個查詢。這里我們在代碼里只需要 blogInfo = (BlogInfo)session.selectOne("com.foo.bean.BlogMapper.queryBlogInfoById",id);一句即可獲取到復(fù)雜的blogInfo對象。

嵌套語句查詢的原理：

在上面的代碼中，Mybatis會執(zhí)行以下流程：

  1. 先執(zhí)行 queryBlogInfoById 對應(yīng)的語句從Blog表里獲取到ResultSet結(jié)果集；

  2. 取出ResultSet下一條有效記錄，然后根據(jù)resultMap定義的映射規(guī)格，通過這條記錄的數(shù)據(jù)來構(gòu)建對應(yīng)的一個BlogInfo 對象。

  3. 當(dāng)要對BlogInfo中的author屬性進(jìn)行賦值的時候，發(fā)現(xiàn)有一個關(guān)聯(lián)的查詢，此時Mybatis會先執(zhí)行這個select查詢語句，得到返回的結(jié)果，將結(jié)果設(shè)置到BlogInfo的author屬性上；

  4. 對BlogInfo的posts進(jìn)行賦值時，也有上述類似的過程。

  5. 重復(fù)2步驟，直至ResultSet. next () == false；

以下是blogInfo對象構(gòu)造賦值過程示意圖：

blogInfo對象構(gòu)造賦值過程示意圖

這種關(guān)聯(lián)的嵌套查詢，有一個非常好的作用就是：可以重用select語句，通過簡單的select語句之間的組合來構(gòu)造復(fù)雜的對象。上面嵌套的兩個select語句com.foo.bean.AuthorMapper.selectByPrimaryKey和com.foo.bean.PostMapper.selectByBlogId完全可以獨(dú)立使用。

N+1問題：

它的弊端也比較明顯：即所謂的N+1問題。關(guān)聯(lián)的嵌套查詢顯示得到一個結(jié)果集，然后根據(jù)這個結(jié)果集的每一條記錄進(jìn)行關(guān)聯(lián)查詢。

現(xiàn)在假設(shè)嵌套查詢就一個（即resultMap 內(nèi)部就一個association標(biāo)簽），現(xiàn)查詢的結(jié)果集返回條數(shù)為N，那么關(guān)聯(lián)查詢語句將會被執(zhí)行N次，加上自身返回結(jié)果集查詢1次，共需要訪問數(shù)據(jù)庫N+1次。如果N比較大的話，這樣的數(shù)據(jù)庫訪問消耗是非常大的！所以使用這種嵌套語句查詢的使用者一定要考慮慎重考慮，確保N值不會很大。

以上面的例子為例，select 語句本身會返回com.foo.bean.BlogMapper.queryBlogInfoById 條數(shù)為1 的結(jié)果集，由于它有兩條關(guān)聯(lián)的語句查詢，它需要共訪問數(shù)據(jù)庫 1*（1+1）=3次數(shù)據(jù)庫。

10.2 嵌套結(jié)果查詢##

嵌套語句的查詢會導(dǎo)致數(shù)據(jù)庫訪問次數(shù)不定，進(jìn)而有可能影響到性能。Mybatis還支持一種嵌套結(jié)果的查詢：即對于一對多，多對多，多對一的情況的查詢，Mybatis通過聯(lián)合查詢，將結(jié)果從數(shù)據(jù)庫內(nèi)一次性查出來，然后根據(jù)其一對多，多對一，多對多的關(guān)系和ResultMap中的配置，進(jìn)行結(jié)果的轉(zhuǎn)換，構(gòu)建需要的對象。

重新定義BlogInfo的結(jié)果映射 resultMap：

<resultMap type="com.foo.bean.BlogInfo" id="BlogInfo">  
    <id column="blog_id" property="blogId"/>  
    <result column="title" property="title"/>  
    <association property="author" column="blog_author_id" javaType="com.foo.bean.Author">  
        <id column="author_id" property="authorId"/>  
        <result column="user_name" property="userName"/>  
        <result column="password" property="password"/>  
        <result column="email" property="email"/>  
        <result column="biography" property="biography"/>  
    </association>  
    <collection property="posts" column="blog_post_id" ofType="com.foo.bean.Post">  
        <id column="post_id" property="postId"/>  
        <result column="blog_id" property="blogId"/>  
        <result column="create_time" property="createTime"/>  
        <result column="subject" property="subject"/>  
        <result column="body" property="body"/>  
        <result column="draft" property="draft"/>  
    </collection>    
</resultMap>

對應(yīng)的sql語句如下：

<select id="queryAllBlogInfo" resultMap="BlogInfo">  
    SELECT   
     B.BLOG_ID,  
     B.TITLE,  
     B.AUTHOR_ID AS BLOG_AUTHOR_ID,  
     A.AUTHOR_ID,  
     A.USER_NAME,  
     A.PASSWORD,  
     A.EMAIL,  
     A.BIOGRAPHY,  
     P.POST_ID,  
     P.BLOG_ID   AS BLOG_POST_ID ,  
  P.CREATE_TIME,  
     P.SUBJECT,  
     P.BODY,  
     P.DRAFT  
FROM BLOG B  
LEFT OUTER JOIN AUTHOR A  
  ON B.AUTHOR_ID = A.AUTHOR_ID  
LEFT OUTER JOIN POST P  
  ON P.BLOG_ID = B.BLOG_ID  
</select>  

/* 
 * 獲取所有Blog的所有信息 
 */  
public static BlogInfo nestedResultOnTest()  
{  
    SqlSession session = sqlSessionFactory.openSession();  
    BlogInfo blogInfo = new BlogInfo();  
    blogInfo = (BlogInfo)session.selectOne("com.foo.bean.BlogMapper.queryAllBlogInfo");  
    JSONObject object = new JSONObject(blogInfo);  
    System.out.println(object.toString());  
    return blogInfo;  
}

嵌套結(jié)果查詢的執(zhí)行步驟：

  1. 根據(jù)表的對應(yīng)關(guān)系，進(jìn)行join操作，獲取到結(jié)果集；

  2. 根據(jù)結(jié)果集的信息和BlogInfo 的resultMap定義信息，對返回的結(jié)果集在內(nèi)存中進(jìn)行組裝、賦值，構(gòu)造BlogInfo；

  3. 返回構(gòu)造出來的結(jié)果List<BlogInfo> 結(jié)果。

對于關(guān)聯(lián)的結(jié)果查詢，如果是多對一的關(guān)系，則通過形如 <association property="author" column="blog_author_id" javaType="com.foo.bean.Author"> 進(jìn)行配置，Mybatis會通過column屬性對應(yīng)的author_id 值去從內(nèi)存中取數(shù)據(jù)，并且封裝成Author對象；

如果是一對多的關(guān)系，就如Blog和Post之間的關(guān)系，通過形如 <collection property="posts" column="blog_post_id" ofType="com.foo.bean.Post">進(jìn)行配置，MyBatis通過 blog_Id去內(nèi)存中取Post對象，封裝成List<Post>；

對于關(guān)聯(lián)結(jié)果的查詢，只需要查詢數(shù)據(jù)庫一次，然后對結(jié)果的整合和組裝全部放在了內(nèi)存中。

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容