[[285992]]

概述

Mybatis插件又稱攔截器，本篇文章中出現(xiàn)的攔截器都表示插件。

Mybatis采用責(zé)任鏈模式，通過動態(tài)代理組織多個插件(攔截器)，通過這些插件可以改變Mybatis的默認(rèn)行為(諸如SQL重寫之類的)，由于插件會深入到Mybatis的核心，因此在編寫自己的插件前最好了解下它的原理，以便寫出安全高效的插件。

MyBatis 允許你在已映射語句執(zhí)行過程中的某一點進(jìn)行攔截調(diào)用。默認(rèn)情況下，MyBatis 允許使用插件來攔截的方法調(diào)用包括：

• Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)
• ParameterHandler (getParameterObject, setParameters)
• ResultSetHandler (handleResultSets, handleOutputParameters)
• StatementHandler (prepare, parameterize, batch, update, query)

總體概括為：

• 攔截執(zhí)行器的方法
• 攔截參數(shù)的處理
• 攔截結(jié)果集的處理
• 攔截Sql語法構(gòu)建的處理

Mybatis是通過動態(tài)代理的方式實現(xiàn)攔截的，閱讀此篇文章需要先對Java的動態(tài)代理機(jī)制有所了解。

Mybatis四大接口

既然Mybatis是對四大接口進(jìn)行攔截的，那我們先要知道Mybatis的四大接口是哪些： Executor, StatementHandler, ResultSetHandler, ParameterHandler。

上圖Mybatis框架的整個執(zhí)行過程。Mybatis插件能夠?qū)@四大對象進(jìn)行攔截，可以說包含到了Mybatis一次SQL執(zhí)行的所有操作。可見Mybatis的的插件很強(qiáng)大。

1. Executor是 Mybatis的內(nèi)部執(zhí)行器，它負(fù)責(zé)調(diào)用StatementHandler操作數(shù)據(jù)庫，并把結(jié)果集通過 ResultSetHandler進(jìn)行自動映射，另外，他還處理了二級緩存的操作。從這里可以看出，我們也是可以通過插件來實現(xiàn)自定義的二級緩存的。
2. StatementHandler是Mybatis直接和數(shù)據(jù)庫執(zhí)行sql腳本的對象。另外它也實現(xiàn)了Mybatis的一級緩存。這里，我們可以使用插件來實現(xiàn)對一級緩存的操作(禁用等等)。
3. ParameterHandler是Mybatis實現(xiàn)Sql入?yún)⒃O(shè)置的對象。插件可以改變我們Sql的參數(shù)默認(rèn)設(shè)置。
4. ResultSetHandler是Mybatis把ResultSet集合映射成POJO的接口對象。我們可以定義插件對Mybatis的結(jié)果集自動映射進(jìn)行修改。

插件Interceptor

Mybatis的插件實現(xiàn)要實現(xiàn)Interceptor接口，我們看下這個接口定義的方法。

public interface Interceptor {   
  Object intercept(Invocation invocation) throws Throwable;     
  Object plugin(Object target);   
  void setProperties(Properties properties); 
} 

這個接口只聲明了三個方法：

• setProperties方法是在Mybatis進(jìn)行配置插件的時候可以配置自定義相關(guān)屬性，即：接口實現(xiàn)對象的參數(shù)配置。
• plugin方法是插件用于封裝目標(biāo)對象的，通過該方法我們可以返回目標(biāo)對象本身，也可以返回一個它的代理，可以決定是否要進(jìn)行攔截進(jìn)而決定要返回一個什么樣的目標(biāo)對象，官方提供了示例：return Plugin.wrap(target, this)。
• intercept方法就是要進(jìn)行攔截的時候要執(zhí)行的方法。

理解這個接口的定義，先要知道java動態(tài)代理機(jī)制。plugin接口即返回參數(shù)target對象(Executor/ParameterHandler/ResultSetHander/StatementHandler)的代理對象。在調(diào)用對應(yīng)對象的接口的時候，可以進(jìn)行攔截并處理。

Mybatis四大接口對象創(chuàng)建方法

Mybatis的插件是采用對四大接口的對象生成動態(tài)代理對象的方法來實現(xiàn)的。那么現(xiàn)在我們看下Mybatis是怎么創(chuàng)建這四大接口對象的。

public Executor newExecutor(Transaction transaction, ExecutorType executorType) { 
  //確保ExecutorType不為空(defaultExecutorType有可能為空) 
  executorType = executorType == null ? defaultExecutorType : executorType; 
  executorType = executorType == null ? ExecutorType.SIMPLE : executorType; 
  Executor executor;  if (ExecutorType.BATCH == executorType) { 
   executor = new BatchExecutor(this, transaction); 
  } else if (ExecutorType.REUSE == executorType) { 
   executor = new ReuseExecutor(this, transaction); 
  } else { 
   executor = new SimpleExecutor(this, transaction); 
  }  if (cacheEnabled) { 
   executor = new CachingExecutor(executor); 
  } 
  executor = (Executor) interceptorChain.pluginAll(executor); 
  return executor; 
} 
 
public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) { 
  StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql); 
  statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler); 
  return statementHandler; 
} 
 
public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) { 
  ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql); 
  parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler); 
  return parameterHandler; 
} 
 
public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler, ResultHandler resultHandler, BoundSql boundSql) { 
  ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds); 
  resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler); 
  return resultSetHandler; 
} 

查看源碼可以發(fā)現(xiàn)， Mybatis框架在創(chuàng)建好這四大接口對象的實例后，都會調(diào)用InterceptorChain.pluginAll()方法。InterceptorChain對象是插件執(zhí)行鏈對象，看源碼就知道里面維護(hù)了Mybatis配置的所有插件(Interceptor)對象。

// target --> Executor/ParameterHandler/ResultSetHander/StatementHandler 
public Object pluginAll(Object target) { 
  for (Interceptor interceptor : interceptors) { 
   target = interceptor.plugin(target); 
  } 
  return target; 
} 

其實就是按順序執(zhí)行我們插件的plugin方法，一層一層返回我們原對象(Executor/ParameterHandler/ResultSetHander/StatementHandler)的代理對象。當(dāng)我們調(diào)用四大接口的方法的時候，實際上是調(diào)用代理對象的相應(yīng)方法，代理對象又會調(diào)用四大接口的實例。

Plugin對象

我們知道，官方推薦插件實現(xiàn)plugin方法為：Plugin.wrap(target, this);

public static Object wrap(Object target, Interceptor interceptor) { 
  // 獲取插件的Intercepts注解 
  Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor); 
  Class<?> type = target.getClass(); 
  Class<?>[] interfaces = getAllInterfaces(type, signatureMap); 
  if (interfaces.length > 0) { 
   return Proxy.newProxyInstance(type.getClassLoader(), interfaces, new Plugin(target, interceptor, signatureMap)); 
  } 
  return target; 
} 

這個方法其實是Mybatis簡化我們插件實現(xiàn)的工具方法。其實就是根據(jù)當(dāng)前攔截的對象創(chuàng)建了一個動態(tài)代理對象。代理對象的InvocationHandler處理器為新建的Plugin對象。

插件配置注解@Intercepts

Mybatis的插件都要有Intercepts注解來指定要攔截哪個對象的哪個方法。我們知道，Plugin.warp方法會返回四大接口對象的代理對象(通過new Plugin()創(chuàng)建的IvocationHandler處理器)，會攔截所有的執(zhí)行方法。在代理對象執(zhí)行對應(yīng)方法的時候，會調(diào)用InvocationHandler處理器的invoke方法。Mybatis中利用了注解的方式配置指定攔截哪些方法。具體如下：

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
  try { 
   Set<Method> methods = signatureMap.get(method.getDeclaringClass()); 
   if (methods != null && methods.contains(method)) { 
     return interceptor.intercept(new Invocation(target, method, args)); 
   } 
   return method.invoke(target, args); 
  } catch (Exception e) { 
   throw ExceptionUtil.unwrapThrowable(e); 
  } 
} 

可以看到，只有通過Intercepts注解指定的方法才會執(zhí)行我們自定義插件的intercept方法。未通過Intercepts注解指定的將不會執(zhí)行我們的intercept方法。

官方插件開發(fā)方式

@Intercepts({@Signature(type = Executor.class, method = "query", 
    args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})}) 
public class TestInterceptor implements Interceptor { 
  public Object intercept(Invocation invocation) throws Throwable { 
   Object target = invocation.getTarget(); //被代理對象 
   Method method = invocation.getMethod(); //代理方法 
   Object[] args = invocation.getArgs(); //方法參數(shù) 
   // do something ...... 方法攔截前執(zhí)行代碼塊 
   Object result = invocation.proceed(); 
   // do something .......方法攔截后執(zhí)行代碼塊 
   return result; 
  } 
  public Object plugin(Object target) { 
   return Plugin.wrap(target, this); 
  } 
} 

以上就是Mybatis官方推薦的插件實現(xiàn)的方法，通過Plugin對象創(chuàng)建被代理對象的動態(tài)代理對象。可以發(fā)現(xiàn)，Mybatis的插件開發(fā)還是很簡單的。

自定義開發(fā)方式

Mybatis的插件開發(fā)通過內(nèi)部提供的Plugin對象可以很簡單的開發(fā)。只有理解了插件實現(xiàn)原理，對應(yīng)不采用Plugin對象我們一樣可以自己實現(xiàn)插件的開發(fā)。下面是我個人理解之后的自己實現(xiàn)的一種方式。

public class TestInterceptor implements Interceptor { 
  public Object intercept(Invocation invocation) throws Throwable { 
    Object target = invocation.getTarget(); //被代理對象 
    Method method = invocation.getMethod(); //代理方法 
    Object[] args = invocation.getArgs(); //方法參數(shù) 
    // do something ...... 方法攔截前執(zhí)行代碼塊 
    Object result = invocation.proceed(); 
    // do something .......方法攔截后執(zhí)行代碼塊 
    return result; 
  } 
  public Object plugin(final Object target) { 
    return Proxy.newProxyInstance(Interceptor.class.getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() { 
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
        return intercept(new Invocation(target, method, args)); 
      } 
    }); 
  } 
  public void setProperties(Properties properties) { 
  } 
} 

當(dāng)然，Mybatis插件的那這個時候Intercepts的注解起不到作用了。

小結(jié)

我們在MyBatis配置了一個插件，在運行發(fā)生了什么

1. 所有可能被攔截的處理類都會生成一個代理
2. 處理類代理在執(zhí)行對應(yīng)方法時，判斷要不要執(zhí)行插件中的攔截方法
3. 執(zhí)行插接中的攔截方法后，推進(jìn)目標(biāo)的執(zhí)行

如果有N個插件，就有N個代理，每個代理都要執(zhí)行上面的邏輯。這里面的層層代理要多次生成動態(tài)代理，是比較影響性能的。雖然能指定插件攔截的位置，但這個是在執(zhí)行方法時動態(tài)判斷，初始化的時候就是簡單的把插件包裝到了所有可以攔截的地方。

因此，在編寫插件時需注意以下幾個原則：

• 不編寫不必要的插件;
• 實現(xiàn)plugin方法時判斷一下目標(biāo)類型，是本插件要攔截的對象才執(zhí)行Plugin.wrap方法，否者直接返回目標(biāo)本身，這樣可以減少目標(biāo)被代理的次數(shù)。

// 假如我們只要攔截Executor對象，那么我們應(yīng)該這么做 
public Object plugin(final Object target) { 
  if (target instanceof Executor) { 
   return Plugin.wrap(target, this); 
  } else { 
   return target; 
  } 
} 

Mybatis插件很強(qiáng)大，可以對Mybatis框架進(jìn)行很大的擴(kuò)展。當(dāng)然，如果你不理解Mybatis插件的原理，開發(fā)起來只能是模擬兩可。在實際開發(fā)過程中，我們可以參考別人寫的插件。下面是一個Mybatis分頁的插件，可以為以后開發(fā)做參考。

/** 
 * Mybatis - 通用分頁插件（如果開啟二級緩存需要注意） 
 */ 
@Intercepts({@Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class}), 
    @Signature(type = ResultSetHandler.class, method = "handleResultSets", args = {Statement.class})}) 
@Log4j 
public class PageHelper implements Interceptor { 
 
  public static final ThreadLocal<Page> localPage = new ThreadLocal<Page>(); 
 
  /** 
   * 開始分頁 
   * 
   * @param pageNum 
   * @param pageSize 
   */ 
  public static void startPage(int pageNum, int pageSize) { 
    localPage.set(new Page(pageNum, pageSize)); 
  } 
 
  /** 
   * 結(jié)束分頁并返回結(jié)果，該方法必須被調(diào)用，否則localPage會一直保存下去，直到下一次startPage 
   * 
   * @return 
   */ 
  public static Page endPage() { 
    Page page = localPage.get(); 
    localPage.remove(); 
    return page; 
  } 
 
  public Object intercept(Invocation invocation) throws Throwable { 
    if (localPage.get() == null) { 
      return invocation.proceed(); 
    } 
    if (invocation.getTarget() instanceof StatementHandler) { 
      StatementHandler statementHandler = (StatementHandler) invocation.getTarget(); 
      MetaObject metaStatementHandler = SystemMetaObject.forObject(statementHandler); 
      // 分離代理對象鏈(由于目標(biāo)類可能被多個插件攔截，從而形成多次代理，通過下面的兩次循環(huán) 
      // 可以分離出最原始的的目標(biāo)類) 
      while (metaStatementHandler.hasGetter("h")) { 
        Object object = metaStatementHandler.getValue("h"); 
        metaStatementHandler = SystemMetaObject.forObject(object); 
      } 
      // 分離最后一個代理對象的目標(biāo)類 
      while (metaStatementHandler.hasGetter("target")) { 
        Object object = metaStatementHandler.getValue("target"); 
        metaStatementHandler = SystemMetaObject.forObject(object); 
      } 
      MappedStatement mappedStatement = (MappedStatement) metaStatementHandler.getValue("delegate.mappedStatement"); 
      //分頁信息if (localPage.get() != null) { 
      Page page = localPage.get(); 
      BoundSql boundSql = (BoundSql) metaStatementHandler.getValue("delegate.boundSql"); 
      // 分頁參數(shù)作為參數(shù)對象parameterObject的一個屬性 
      String sql = boundSql.getSql(); 
      // 重寫sql 
      String pageSql = buildPageSql(sql, page); 
      //重寫分頁sql 
      metaStatementHandler.setValue("delegate.boundSql.sql", pageSql); 
      Connection connection = (Connection) invocation.getArgs()[0]; 
      // 重設(shè)分頁參數(shù)里的總頁數(shù)等 
      setPageParameter(sql, connection, mappedStatement, boundSql, page); 
      // 將執(zhí)行權(quán)交給下一個插件 
      return invocation.proceed(); 
    } else if (invocation.getTarget() instanceof ResultSetHandler) { 
      Object result = invocation.proceed(); 
      Page page = localPage.get(); 
      page.setResult((List) result); 
      return result; 
    } 
    return null; 
  } 
 
  /** 
   * 只攔截這兩種類型的 
   * <br>StatementHandler 
   * <br>ResultSetHandler 
   * 
   * @param target 
   * @return 
   */ 
  public Object plugin(Object target) { 
    if (target instanceof StatementHandler || target instanceof ResultSetHandler) { 
      return Plugin.wrap(target, this); 
    } else { 
      return target; 
    } 
  } 
 
  public void setProperties(Properties properties) { 
 
  } 
 
  /** 
   * 修改原SQL為分頁SQL 
   * 
   * @param sql 
   * @param page 
   * @return 
   */ 
  private String buildPageSql(String sql, Page page) { 
    StringBuilder pageSql = new StringBuilder(200); 
    pageSql.append("select * from ("); 
    pageSql.append(sql); 
    pageSql.append(" ) temp limit ").append(page.getStartRow()); 
    pageSql.append(" , ").append(page.getPageSize()); 
    return pageSql.toString(); 
  } 
 
  /** 
   * 獲取總記錄數(shù) 
   * 
   * @param sql 
   * @param connection 
   * @param mappedStatement 
   * @param boundSql 
   * @param page 
   */ 
  private void setPageParameter(String sql, Connection connection, MappedStatement mappedStatement, 
                 BoundSql boundSql, Page page) { 
    // 記錄總記錄數(shù) 
    String countSql = "select count(0) from (" + sql + ") temp"; 
    PreparedStatement countStmt = null; 
    ResultSet rs = null; 
    try { 
      countStmt = connection.prepareStatement(countSql); 
      BoundSql countBS = new BoundSql(mappedStatement.getConfiguration(), countSql, 
          boundSql.getParameterMappings(), boundSql.getParameterObject()); 
      setParameters(countStmt, mappedStatement, countBS, boundSql.getParameterObject()); 
      rs = countStmt.executeQuery(); 
      int totalCount = 0; 
      if (rs.next()) { 
        totalCount = rs.getInt(1); 
      } 
      page.setTotal(totalCount); 
      int totalPage = totalCount / page.getPageSize() + ((totalCount % page.getPageSize() == 0) ? 0 : 1); 
      page.setPages(totalPage); 
    } catch (SQLException e) { 
      log.error("Ignore this exception", e); 
    } finally { 
      try { 
        rs.close(); 
      } catch (SQLException e) { 
        log.error("Ignore this exception", e); 
      } 
      try { 
        countStmt.close(); 
      } catch (SQLException e) { 
        log.error("Ignore this exception", e); 
      } 
    } 
  } 
 
  /** 
   * 代入?yún)?shù)值 
   * 
   * @param ps 
   * @param mappedStatement 
   * @param boundSql 
   * @param parameterObject 
   * @throws SQLException 
   */ 
  private void setParameters(PreparedStatement ps, MappedStatement mappedStatement, BoundSql boundSql, 
                Object parameterObject) throws SQLException { 
    ParameterHandler parameterHandler = new DefaultParameterHandler(mappedStatement, parameterObject, boundSql); 
    parameterHandler.setParameters(ps); 
  } 
 
  @Data //采用lombok插件編譯 
  public static class Page<E> { 
    private int pageNum; 
    private int pageSize; 
    private int startRow; 
    private int endRow; 
    private long total; 
    private int pages; 
    private List<E> result; 
 
    public Page(int pageNum, int pageSize) { 
      this.pageNum = pageNum; 
      this.pageSize = pageSize; 
      this.startRow = pageNum > 0 ? (pageNum - 1) * pageSize : 0; 
      this.endRow = pageNum * pageSize; 
    } 
 
  } 
}