MyBatis 學習筆記（七）---源碼分析篇---SQL的執行過程（一）

前言

接上一篇，今天我們接着來分析MyBatis的源碼。今天的分析的核心是SQL的執行過程。主要分為如下章節進行分析

代理類的生成
SQL的執行過程
處理查詢結果

mapper 接口的代理類的生成過程分析

首先我們來看看mapper 接口的代理類的生成過程，如下是一個MyBatis查詢的調用執行個體。

StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
 List<Student> studentList = mapper.selectByName("點點");

上述方法

sqlSession.getMapper(StudentMapper.class)

傳回的其實是

StudentMapper

的代理類。

接着我們來看看調用的時序圖。

如上時序圖我們可知，接口的代理類（MapperProxy）最終由MapperProxyFactory通過JDK動态代理生成。接着我們一步步分析下。

//DefaultSqlSession
  @Override
  public <T> T getMapper(Class<T> type) {
    //最後會去調用MapperRegistry.getMapper
    return configuration.<T>getMapper(type, this);
  }

如上，DefaultSqlSession直接請求抛給Configuration。

//Configuration
 public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    return mapperRegistry.getMapper(type, sqlSession);
  }

同樣，Configuration也是一個甩手掌櫃，将請求直接抛給了MapperRegistry 這個接盤俠。

接下來我們來看看接盤俠MapperRegistry。

//*MapperRegistry
  public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
    if (mapperProxyFactory == null) {
      throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
    }
    try {
      return mapperProxyFactory.newInstance(sqlSession);
    } catch (Exception e) {
      throw new BindingException("Error getting mapper instance. Cause: " + e, e);
    }
  }

如上，在MapperRegistry的getMapper的方法中，首先根據配置的Mapper 擷取其對應的MapperProxyFactory。接着調用newInstance方法傳回MapperProxy。最後我們來看看MapperProxyFactory

//*MapperProxyFactory
  protected T newInstance(MapperProxy<T> mapperProxy) {
    //用JDK自帶的動态代理生成映射器
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }

  public T newInstance(SqlSession sqlSession) {
    final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }

如上，通過JDK自帶的動态代理生成映射器，PS： JDK 動态代理需要接口。

分析完了MapperProxy的生成過程，接下來我們來分析下SQL的執行過程。

SQL的執行過程

SQL 的執行過程是從MapperProxy的invoke方法開始。按照慣例我們還是先看看相關的時序圖。

如上圖，在MapperProxy的invoke方法裡調用了MapperMethod的execute方法，該方法是真正執行SQL，傳回結果的方法。接下來我們來看看。

//*MapperProxy
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    //代理以後，所有Mapper的方法調用時，都會調用這個invoke方法
    //并不是任何一個方法都需要執行調用代理對象進行執行，如果這個方法是Object中通用的方法（toString、hashCode等）無需執行
    if (Object.class.equals(method.getDeclaringClass())) {
      try {
        return method.invoke(this, args);
      } catch (Throwable t) {
        throw ExceptionUtil.unwrapThrowable(t);
      }
    }
    //這裡優化了，去緩存中找MapperMethod
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    //執行
    return mapperMethod.execute(sqlSession, args);
  }

如上，這裡MyBatis做了個優化，如果緩存中有MapperMethod，則取緩存中的，如果沒有則new一個MapperMethod執行個體。

//*MapperProxy
  //去緩存中找MapperMethod
  private MapperMethod cachedMapperMethod(Method method) {
    MapperMethod mapperMethod = methodCache.get(method);
    if (mapperMethod == null) {
      //找不到才去new
      mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());
      methodCache.put(method, mapperMethod);
    }
    return mapperMethod;
  }

我們接着來看看MapperMethod 中的execute方法，該方法主要是通過區分各種CURD操作（insert|update|delete|select），分别調用sqlSession中的4大類方法。源碼如下：

public Object execute(SqlSession sqlSession, Object[] args) {
    Object result;
    //可以看到執行時就是4種情況，insert|update|delete|select，分别調用SqlSession的4大類方法
    if (SqlCommandType.INSERT == command.getType()) {
//      對使用者傳入的參數進行轉換，下同
      Object param = method.convertArgsToSqlCommandParam(args);
// 執行插入操作，rowCountResult方法用于處理傳回值
      result = rowCountResult(sqlSession.insert(command.getName(), param));
    } else if (SqlCommandType.UPDATE == command.getType()) {
      Object param = method.convertArgsToSqlCommandParam(args);
      result = rowCountResult(sqlSession.update(command.getName(), param));
    } else if (SqlCommandType.DELETE == command.getType()) {
      Object param = method.convertArgsToSqlCommandParam(args);
      result = rowCountResult(sqlSession.delete(command.getName(), param));
    }
//    根據目标傳回方法的傳回類型進行相應的查詢操作。
    else if (SqlCommandType.SELECT == command.getType()) {
      if (method.returnsVoid() && method.hasResultHandler()) {
        /*
          如果方法傳回值為void，但參數清單中包含ResultHandler,
          想通過ResultHandler的方式擷取查詢結果，而非通過傳回值擷取結果
        * */
        executeWithResultHandler(sqlSession, args);
        result = null;
      } else if (method.returnsMany()) {
        //如果結果有多條記錄
        result = executeForMany(sqlSession, args);
      } else if (method.returnsMap()) {
        //如果結果是map
        result = executeForMap(sqlSession, args);
      } else {
        //否則就是一條記錄
        Object param = method.convertArgsToSqlCommandParam(args);
        result = sqlSession.selectOne(command.getName(), param);
      }
    } else {
      throw new BindingException("Unknown execution method for: " + command.getName());
    }
//    如果方法的傳回值是基本類型，而傳回值卻為null，此種情況下應抛出異常
    if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
      throw new BindingException("Mapper method '" + command.getName() 
          + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
    }
    return result;
  }

如上，代碼注釋比較詳細。前面也說過了，不同的操作調用sqlSession中不同的方法。這裡我重點分析下查詢操作。查詢的情況分為四種：

傳回值為空
傳回多條記錄
傳回map
傳回單條記錄。

傳回值為空的情況下，直接傳回 result 為null。其餘幾種情況内部都調用了sqlSession 中的selectList 方法。下面我就以傳回單條記錄為例進行分析。

//DefaultSqlSession
  public <T> T selectOne(String statement, Object parameter) {
    // Popular vote was to return null on 0 results and throw exception on too many.
    //轉而去調用selectList,很簡單的，如果得到0條則傳回null，得到1條則傳回1條，得到多條報TooManyResultsException錯
    // 特别需要主要的是當沒有查詢到結果的時候就會傳回null。是以一般建議在mapper中編寫resultType的時候使用包裝類型
    //而不是基本類型，比如推薦使用Integer而不是int。這樣就可以避免NPE
    List<T> list = this.<T>selectList(statement, parameter);
    if (list.size() == 1) {
      return list.get(0);
    } else if (list.size() > 1) {
      throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
    } else {
      return null;
    }
  }

如果所示，如果selectList查詢傳回1條，則直接傳回，如果傳回多條則抛出異常，否則直接傳回null。我們接着往下看.

//DefaultSqlSession
  public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
      //根據statement id找到對應的MappedStatement
      MappedStatement ms = configuration.getMappedStatement(statement);
      //轉而用執行器來查詢結果,注意這裡傳入的ResultHandler是null
      return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

如上，在selectList 内部最終調用的是SimpleExecutor (執行器)的query方法來執行查詢結果。我們接着往下找

根據類圖我們不難發現SimpleExecutor是BaseExecutor類的子類。在BaseExecutor 類中我們找到了query 方法。

public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    //得到綁定sql
    BoundSql boundSql = ms.getBoundSql(parameter);
    //建立緩存Key
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    //查詢
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
 }

該方法主要有兩步，

得到綁定的SQL，
調用其重載query方法。

綁定SQL的過程，我們稍後分析。我們接着來看看其重載的query方法。

public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
   ····· 省略部分代碼
    try {
      //加一,這樣遞歸調用到上面的時候就不會再清局部緩存了
      queryStack++;
      //先根據cachekey從localCache去查
      list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
      if (list != null) {
        //若查到localCache緩存，處理localOutputParameterCache
        handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
      } else {
        //從資料庫查
        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
      }
    ···· 省略部分代碼
    }
    return list;
  }

該方法核心的步驟是，首先根據cacheKey 從localCache 中去查，如果不為空的話則直接取緩存的，否則查詢資料庫。我們主要看看查詢資料庫的queryFromDatabase方法。

//BaseExecutor
  //從資料庫查
  private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    List<E> list;
    //先向緩存中放入占位符
    localCache.putObject(key, EXECUTION_PLACEHOLDER);
    try {
//      調用doQuery進行查詢
      list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
    } finally {
      //最後删除占位符
      localCache.removeObject(key);
    }
    //加入緩存
    localCache.putObject(key, list);
    //如果是存儲過程，OUT參數也加入緩存
    if (ms.getStatementType() == StatementType.CALLABLE) {
      localOutputParameterCache.putObject(key, parameter);
    }
    return list;
  }
    //query-->queryFromDatabase-->doQuery
  protected abstract <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql)
      throws SQLException;

此處doQuery方法是抽象方法，定義了模闆供子類實作。此處用到了模闆模式。

首先，此方法首先調用doQuery方法執行查詢，然後将查詢的結果放入緩存中。

接着我們再來看看SimpleExcutor中的doQuery方法。

//*SimpleExcutor
  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
      //這裡看到ResultHandler傳入了
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      //準備語句
      stmt = prepareStatement(handler, ms.getStatementLog());
      //StatementHandler.query（實際調用的是PreparedStatementHandler）
      return handler.<E>query(stmt, resultHandler);
    } finally {
//      關閉statement
      closeStatement(stmt);
    }
  }

如上，該方法主要有三步：

建立一個StatementHandler
擷取Statement
StatementHandler.query（實際調用的是PreparedStatementHandler）擷取查詢結果。

第一步比較簡單，我們首先來看看第二步

//*SimpleExcutor
  private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
//   擷取資料庫連接配接
    Connection connection = getConnection(statementLog);
    //建立Statement
    stmt = handler.prepare(connection);
    //為Statement設定IN參數
    handler.parameterize(stmt);
    return stmt;
  }

對于prepareStatement方法裡的相關步驟，相信大家都不會陌生。擷取資料庫連接配接，建立Statement; 為Statement設定IN參數。都是我們非常熟悉的。我們接着看看第三步。

public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
    PreparedStatement ps = (PreparedStatement) statement;
//    執行SQL
    ps.execute();
//    處理執行結果
    return resultSetHandler.<E> handleResultSets(ps);
  }

MyBatis 學習筆記（七）---源碼分析篇---SQL的執行過程（一）

前言

mapper 接口的代理類的生成過程分析

SQL的執行過程

總結

繼續閱讀

ASP程式設計經典例子

ASP程式設計中20個非常有用的例子

龍珠訓練營task04

阿裡雲天池龍珠計劃SQL訓練營打卡

阿裡雲天池龍珠計劃SQL訓練營day1

實驗樓sql進階之成績管理系統的資料操作(window)

Oracle的基本操作

SQL優化SQL語句優化的目的

JAVA高效程式設計指南

MyBatis學習筆記Mybatis學習筆記（maven、Idea版）

關于SQL語言

SQL語言基礎：常用的資料查詢語句

neo4j之cypher使用文檔

用mybatis的generator插件在項目中自動生成dao及entity

sqlServer根據經緯查距離

從mybatis到mybatis plus(mp)