Mybatis3.3.x技術內幕（四）：五鼠鬧東京之執行器Executor設計本來

在上一篇博文中，已經分析了Mybatis事務相關的內容，而今天的這篇博文，不少內容都是在方法method內部，與事務無關，因此，建議暫時忘記事務概念，避免攪擾。

Mybatis對數據庫的操做，都將委託給執行器Executor來完成，因此，在Mybatis這部電影當中，Executor是絕對的領銜主演。

在Mybatis中，SqlSession對數據庫的操做，將委託給執行器Executor來完成，而Executor由五鼠組成，分別是：簡單鼠SimpleExecutor、重用鼠ReuseExecutor、批量鼠BatchExecutor、緩存鼠CachingExecutor、無用鼠ClosedExecutor。

‍1. Executor接口設計與類結構圖‍

public interface Executor {
  ResultHandler NO_RESULT_HANDLER = null;
  int update(MappedStatement ms, Object parameter) throws SQLException;
  <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey cacheKey, BoundSql boundSql) throws SQLException;
  <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException;
  List<BatchResult> flushStatements() throws SQLException;
  void commit(boolean required) throws SQLException;
  void rollback(boolean required) throws SQLException;
  CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql);
  boolean isCached(MappedStatement ms, CacheKey key);
  void clearLocalCache();
  void deferLoad(MappedStatement ms, MetaObject resultObject, String property, CacheKey key, Class<?> targetType);
  Transaction getTransaction();
  void close(boolean forceRollback);
  boolean isClosed();
  void setExecutorWrapper(Executor executor);
}

這些接口方法相對都比較見名知意，但其中的flushStatements()方法，給人不少疑惑，它是咱們關注的重點方法。

類結構圖：

(Made In Intellij Idea IDE)

不是說有五鼠嗎？怎麼就看見四鼠？其實，還有一個無用鼠ClosedExecutor是靜態內部類：private static final class ClosedExecutor extends BaseExecutor。

接下來，咱們看看這五鼠都有哪些本領，能鬧得起東京。

簡單鼠SimpleExecutor：每執行一次update或select，就開啓一個Statement對象，用完馬上關閉Statement對象。（能夠是Statement或PrepareStatement對象）

重用鼠ReuseExecutor：執行update或select，以sql做爲key查找Statement對象，存在就使用，不存在就建立，用完後，不關閉Statement對象，而是放置於Map<String, Statement>內，供下一次使用。（能夠是Statement或PrepareStatement對象）

批量鼠BatchExecutor：執行update（沒有select，JDBC批處理不支持select），將全部sql都添加到批處理中（addBatch()），等待統一執行（executeBatch()），它緩存了多個Statement對象，每一個Statement對象都是addBatch()完畢後，等待逐一執行executeBatch()批處理的；BatchExecutor至關於維護了多個桶，每一個桶裏都裝了不少屬於本身的SQL，就像蘋果藍裏裝了不少蘋果，番茄藍裏裝了不少番茄，最後，再統一倒進倉庫。（能夠是Statement或PrepareStatement對象）

緩存鼠CachingExecutor：裝飾設計模式典範，先從緩存中獲取查詢結果，存在就返回，不存在，再委託給Executor delegate去數據庫取，delegate能夠是上面任一的SimpleExecutor、ReuseExecutor、BatchExecutor。

無用鼠ClosedExecutor：毫無用處，讀者可自行查看其源碼，僅做爲一種標識，和Serializable標記接口做用至關。

做用範圍：以上這五鼠的做用範圍，都嚴格限制在SqlSession生命週期範圍內。

‍2. 基類BaseExecutor源碼解析

org.apache.ibatis.executor.BaseExecutor.java部分源碼。

  @Override
  public int update(MappedStatement ms, Object parameter) throws SQLException {
    ErrorContext.instance().resource(ms.getResource()).activity("executing an update").object(ms.getId());
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    clearLocalCache();
    return doUpdate(ms, parameter);
  }
    protected abstract int doUpdate(MappedStatement ms, Object parameter)
      throws SQLException;

  protected abstract List<BatchResult> doFlushStatements(boolean isRollback)
      throws SQLException;

  protected abstract <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql)
      throws SQLException;

經典的模板設計模式，不一樣的實現類，分別實現本身的三個抽象方法便可：doUpdate()、doQuery()、doFlushStatement()。五鼠鬧東京的本領，就看各自對這三個方法的江湖修煉狀況了。

2.1. 簡單鼠SimpleExecutor源碼解析

簡單鼠SimpleExecutor，真的很是簡單，幾乎沒啥可說的。

  @Override
  public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    Statement stmt = null;
    try {
      Configuration configuration = ms.getConfiguration();
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      stmt = prepareStatement(handler, ms.getStatementLog());
      return handler.<E>query(stmt, resultHandler);
    } finally {
      closeStatement(stmt);
    }
  }

隨建隨關Statement。

2.2. 重用鼠ReuseExecutor源碼解析

public class ReuseExecutor extends BaseExecutor {
  // key=sql, value=Statement，不一樣的sql，對應不一樣的Statement
  private final Map<String, Statement> statementMap = new HashMap<String, Statement>();
  
    @Override
  public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
    Configuration configuration = ms.getConfiguration();
    StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);
    Statement stmt = prepareStatement(handler, ms.getStatementLog());
    return handler.update(stmt);
  }
    private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    BoundSql boundSql = handler.getBoundSql();
    String sql = boundSql.getSql();
    // sql是key，不一樣的sql，將產生不一樣的Statement
    if (hasStatementFor(sql)) {
    // 從statementMap中獲取Statement
      stmt = getStatement(sql);
    } else {
      Connection connection = getConnection(statementLog);
      stmt = handler.prepare(connection);
      // 將Statement放到statementMap中
      putStatement(sql, stmt);
    }
    handler.parameterize(stmt);
    return stmt;
  }
  // ...
    @Override
  public List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException {
    for (Statement stmt : statementMap.values()) {
      closeStatement(stmt);
    }
    statementMap.clear();
    return Collections.emptyList();
  }

重用鼠ReuseExecutor就是依賴Map<String, Statement>來完成對Statement的重用的（用完不關）。

總不能一直不關吧？到底何時關閉這些Statement對象的？問的很是好。

方法flushStatements()就是用來處理這些Statement對象的。

在執行commit、rollback等動做前，將會執行flushStatements()方法，將Statement對象逐一關閉。讀者可參看BaseExecutor源碼。

2.3. 批量鼠BatchExecutor原理及源碼解析（重點難點）

批量鼠BatchExecutor是咱們重點分析的對象，也是咱們重點學習的對象，由於它略微難一點點，不過，我會使出個人九陽神功，將它描述的簡單易懂。

// 緩存多個Statement對象，每一個Statement都是addBatch()後，等待執行
private final List<Statement> statementList = new ArrayList<Statement>();
// 對應的結果集（主要保存了update結果的count數量）
private final List<BatchResult> batchResultList = new ArrayList<BatchResult>();
// 當前保存的sql，即上次執行的sql
private String currentSql;

  @Override
  public int doUpdate(MappedStatement ms, Object parameterObject) throws SQLException {
    final Configuration configuration = ms.getConfiguration();
    final StatementHandler handler = configuration.newStatementHandler(this, ms, parameterObject, RowBounds.DEFAULT, null, null);
    final BoundSql boundSql = handler.getBoundSql();
    // 本次執行的sql
    final String sql = boundSql.getSql();
    final Statement stmt;
    // 要求當前的sql和上一次的currentSql相同，同時MappedStatement也必須相同
    if (sql.equals(currentSql) && ms.equals(currentStatement)) {
     // 已經存在Statement，取出最後一個Statement，有序
      int last = statementList.size() - 1;
      stmt = statementList.get(last);
     handler.parameterize(stmt);//fix Issues 322
      BatchResult batchResult = batchResultList.get(last);
      batchResult.addParameterObject(parameterObject);
    } else {
    // 尚不存在，新建Statement
      Connection connection = getConnection(ms.getStatementLog());
      stmt = handler.prepare(connection);
      handler.parameterize(stmt);    //fix Issues 322
      currentSql = sql;
      currentStatement = ms;
      // 放到Statement緩存
      statementList.add(stmt);
      batchResultList.add(new BatchResult(ms, sql, parameterObject));
    }
  // 將sql以addBatch()的方式，添加到Statement中（該步驟由StatementHandler內部完成）
    handler.batch(stmt);
    return BATCH_UPDATE_RETURN_VALUE;
  }

須要注意的是sql.equals(currentSql)和statementList.get(last)，充分說明了其有序邏輯：AABB，將生成2個Statement對象；AABBAA，將生成3個Statement對象，而不是2個。由於，只要sql有變化，將致使生成新的Statement對象。

緩存了這麼多Statement批處理對象，什麼時候執行它們？在doFlushStatements()方法中完成執行stmt.executeBatch()，隨即關閉這些Statement對象。讀者可自行查看。

這裏所說的Statement，能夠是Statement或Preparestatement。

注：對於批處理來講，JDBC只支持update操做（update、insert、delete等），不支持select查詢操做。

---

BatchExecutor和JDBC批處理的區別。

---

JDBC中Statement的批處理原理圖。

(Made In Windows 畫圖板)

對於Statement來講，只要SQL不一樣，就會產生新編譯動做，Statement不支持問號「?」參數佔位符。

---

JDBC中PrepareStatement的批處理原理圖。

(Made In Windows 畫圖板)

對於PrepareStatement，只要SQL相同，就只會編譯一次，若是SQL不一樣呢？此時和Statement同樣，會編譯屢次。PrepareStatement的優點在於支持問號「?」參數佔位符，SQL相同，參數不一樣時，能夠減小編譯次數至一次，大大提升效率；另外能夠防止SQL注入漏洞。

---

BatchExecutor的批處理原理圖。

(Made In Windows 畫圖板)

BatchExecutor的批處理，和JDBC的批處理，主要區別就是BatchExecutor維護了一組Statement批處理對象，它有自動路由功能，SQL一、SQL二、SQL3表明不一樣的SQL。（Statement或Preparestatement）

---

2.4. 緩存鼠CachingExecutor原理及源碼分析

緩存鼠CachingExecutor使用了經典的裝飾器設計模式，先從緩存中取查詢結果，有則返回，若是沒有，再委託給Executor delegate從數據庫中查詢。

private Executor delegate;

delegate能夠是上面任一的SimpleExecutor、ReuseExecutor、BatchExecutor。

比較簡單，沒什麼可說的，有關Mybatis的緩存原理，將單獨開啓一篇緩存原理的文章。

‍‍‍‍‍‍2.5. 無用鼠ClosedExecutor‍‍‍‍‍‍

無用鼠ClosedExecutor，無內容可介紹，它僅做爲一種標識，和Serializable標記接口做用至關。

3. Executor的建立時機和建立策略

Executor的建立時機是，建立DefaultSqlSession實例時，做爲構造參數傳遞進去。（見DefaultSqlSessionFactory.java內）

Executor executor = configuration.newExecutor(tx, execType);
return new DefaultSqlSession(configuration, executor, autoCommit);

Executor有三種建立策略。

public enum ExecutorType {
  SIMPLE, REUSE, BATCH
}

那麼，Mybatis怎麼知道，應該建立這三種策略中的哪種呢？依據是什麼？

有兩種手段來指定Executor建立策略。

第一種，configuration配置文件中，配置默認ExecutorType類型。（當不配置時，默認爲ExecutorType.SIMPLE）

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <setting name="defaultExecutorType" value="REUSE" />
    </settings>
</configuration>

第二種，手動給DefaultSqlSessionFactory.java的建立SqlSession的方法傳遞ExecutorType參數。

@Override
  public SqlSession openSession(ExecutorType execType, boolean autoCommit) {
    return openSessionFromDataSource(execType, null, autoCommit);
  }

至此，關於Executor從哪兒來，要到哪裏去，能幹什麼，都已經打聽清楚了。

這五鼠，義結金蘭，七俠和五義流傳在民間。

版權提示：文章出自開源中國社區，若對文章感興趣，可關注個人開源中國社區博客（http://my.oschina.net/zudajun）。（通過網絡爬蟲或轉載的文章，常常丟失流程圖、時序圖，格式錯亂等，仍是看原版的比較好）