【MyBatis原始碼分析】外掛實現原理

MyBatis外掛原理----從<plugins>解析開始

本文分析一下MyBatis的外掛實現原理，在此之前，如果對MyBatis外掛不是很熟悉的朋友，可參看此文MyBatis7：MyBatis外掛及示例----列印每條SQL語句及其執行時間，本文我以一個例子說明了MyBatis外掛是什麼以及如何實現。由於MyBatis的外掛已經深入到了MyBatis底層程式碼，因此要更好地使用外掛，必須對外掛實現原理及MyBatis底層程式碼有所熟悉才行，本文分析一下MyBatis的外掛實現原理。

首先，我們從外掛<plugins>解析開始，原始碼位於XMLConfigBuilder的pluginElement方法中：

private void pluginElement(XNode parent) throws Exception {
    if (parent != null) {
      for (XNode child : parent.getChildren()) {
        String interceptor = child.getStringAttribute("interceptor");
        Properties properties = child.getChildrenAsProperties();
        Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).newInstance();
        interceptorInstance.setProperties(properties);
        configuration.addInterceptor(interceptorInstance);
      }
    }
}

這裡拿<plugin>標籤中的interceptor屬性，這是自定義的攔截器的全路徑，第6行的程式碼通過反射生成攔截器例項。

再拿<plugin>標籤下的所有<property>標籤，解析name和value屬性成為一個Properties，將Properties設定到攔截器中。

最後，通過第8行的程式碼將攔截器設定到Configuration中，原始碼實現為：

public void addInterceptor(Interceptor interceptor) {
    interceptorChain.addInterceptor(interceptor);
}

InterceptorChain是一個攔截器鏈，儲存了所有定義的攔截器以及相關的幾個操作的方法：

public class InterceptorChain {

  private final List<Interceptor> interceptors = new ArrayList<Interceptor>();

  public Object pluginAll(Object target) {
    for (Interceptor interceptor : interceptors) {
      target = interceptor.plugin(target);
    }
    return target;
  }

  public void addInterceptor(Interceptor interceptor) {
    interceptors.add(interceptor);
  }
  
  public List<Interceptor> getInterceptors() {
    return Collections.unmodifiableList(interceptors);
  }

}

分別有新增攔截器、為目標物件新增所有攔截器、獲取當前所有攔截器三個方法。

 

MyBatis外掛原理----pluginAll方法新增外掛

上面我們在InterceptorChain中看到了一個pluginAll方法，pluginAll方法為目標物件生成代理，之後目標物件呼叫方法的時候走的不是原方法而是代理方法，這個在後面會說明。

MyBatis官網文件有說明，在以下四個程式碼執行點上允許使用外掛：

 

為之生成外掛的時機（換句話說就是pluginAll方法呼叫的時機）是Executor、ParameterHandler、ResultSetHandler、StatementHandler四個介面實現類生成的時候，每個介面實現類在MyBatis中生成的時機是不一樣的，這個就不看它們是在什麼時候生成的了，每個開發工具我相信都有快捷鍵可以看到pluginAll方法呼叫的地方，我使用的Eclipse就是Ctrl+Alt+H。

再看pluginAll方法：

public Object pluginAll(Object target) {
    for (Interceptor interceptor : interceptors) {
      target = interceptor.plugin(target);
    }
    return target;
}

這裡值得注意的是：

1. 形參Object target，這個是Executor、ParameterHandler、ResultSetHandler、StatementHandler介面的實現類，換句話說，plugin方法是要為Executor、ParameterHandler、ResultSetHandler、StatementHandler的實現類生成代理，從而在呼叫這幾個類的方法的時候，其實呼叫的是InvocationHandler的invoke方法
2. 這裡的target是通過for迴圈不斷賦值的，也就是說如果有多個攔截器，那麼如果我用P表示代理，生成第一次代理為P(target)，生成第二次代理為P(P(target))，生成第三次代理為P(P(P(target)))，不斷巢狀下去，這就得到一個重要的結論：<plugins>...</plugins>中後定義的<plugin>實際其攔截器方法先被執行，因為根據這段程式碼來看，後定義的<plugin>代理實際後生成，包裝了先生成的代理，自然其代理方法也先執行

plugin方法中呼叫MyBatis提供的現成的生成代理的方法Plugin.wrap(Object target, Interceptor interceptor)，接著我們看下wrap方法的原始碼實現。

 

MyBatis外掛原理----Plugin的wrap方法的實現

Plugin的wrap方法實現為：

public static Object wrap(Object target, Interceptor interceptor) {
    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;
}

首先看一下第2行的程式碼，獲取Interceptor上定義的所有方法簽名：

private static Map<Class<?>, Set<Method>> getSignatureMap(Interceptor interceptor) {
    Intercepts interceptsAnnotation = interceptor.getClass().getAnnotation(Intercepts.class);
    // issue #251
    if (interceptsAnnotation == null) {
      throw new PluginException("No @Intercepts annotation was found in interceptor " + interceptor.getClass().getName());      
    }
    Signature[] sigs = interceptsAnnotation.value();
    Map<Class<?>, Set<Method>> signatureMap = new HashMap<Class<?>, Set<Method>>();
    for (Signature sig : sigs) {
      Set<Method> methods = signatureMap.get(sig.type());
      if (methods == null) {
        methods = new HashSet<Method>();
        signatureMap.put(sig.type(), methods);
      }
      try {
        Method method = sig.type().getMethod(sig.method(), sig.args());
        methods.add(method);
      } catch (NoSuchMethodException e) {
        throw new PluginException("Could not find method on " + sig.type() + " named " + sig.method() + ". Cause: " + e, e);
      }
    }
    return signatureMap;
}

看到先拿@Intercepts註解，如果沒有定義@Intercepts註解，丟擲異常，這意味著使用MyBatis的外掛，必須使用註解方式。

接著拿到@Intercepts註解下的所有@Signature註解，獲取其type屬性（表示具體某個介面），再根據method與args兩個屬性去type下找方法簽名一致的方法Method（如果沒有方法簽名一致的就丟擲異常，此簽名的方法在該介面下找不到），能找到的話key=type，value=Set<Method>，新增到signatureMap中，構建出一個方法簽名對映。舉個例子來說，就是我定義的@Intercepts註解，Executor下我要攔截的所有Method、StatementHandler下我要攔截的所有Method。

回過頭繼續看wrap方法，在拿到方法簽名對映後，呼叫getAllInterfaces方法，傳入的是Target的Class物件以及之前獲取到的方法簽名對映：

private static Class<?>[] getAllInterfaces(Class<?> type, Map<Class<?>, Set<Method>> signatureMap) {
    Set<Class<?>> interfaces = new HashSet<Class<?>>();
    while (type != null) {
      for (Class<?> c : type.getInterfaces()) {
        if (signatureMap.containsKey(c)) {
          interfaces.add(c);
        }
      }
      type = type.getSuperclass();
    }
    return interfaces.toArray(new Class<?>[interfaces.size()]);
}

這裡獲取Target的所有介面，如果方法簽名對映中有這個介面，那麼新增到interfaces中，這是一個Set，最終將Set轉換為陣列返回。

wrap方法的最後一步：

if (interfaces.length > 0) {
  return Proxy.newProxyInstance(
      type.getClassLoader(),
      interfaces,
      new Plugin(target, interceptor, signatureMap));
}
return target;

如果當前傳入的Target的介面中有@Intercepts註解中定義的介面，那麼為之生成代理，否則原Target返回。

這段理論可能大家會看得有點雲裡霧裡，我這裡舉個例子：

就以SqlCostPlugin為例，我的@Intercepts定義的是：
@Intercepts({@Signature(type = StatementHandler.class, method = "query", args = {Statement.class, ResultHandler.class}), @Signature(type = StatementHandler.class, 
method = "update", args = {Statement.class})})

此時，生成的方法簽名對映signatureMap應當是（我這裡把Map給toString()了）：
{interface org.apache.ibatis.executor.statement.StatementHandler=[public abstract int org.apache.ibatis.executor.statement.StatementHandler.update(java.sql.
Statement) throws java.sql.SQLException, public abstract java.util.List org.apache.ibatis.executor.statement.StatementHandler.query(java.sql.Statement,org.apache.
ibatis.session.ResultHandler) throws java.sql.SQLException]}
一個Class對應一個Set，Class為StatementHandler.class，Set為StataementHandler中的兩個方法

如果我new的是StatementHandler介面的實現類，那麼可以為之生成代理，因為signatureMap中的key有StatementHandler這個介面

如果我new的是Executor介面的實現類，那麼直接會把Executor介面的實現類原樣返回，因為signatureMap中的key並沒有Executor這個介面

相信這麼解釋大家應該會明白一點。注意這裡生不生成代理，只和介面在不在@Intercepts中定義過有關，和方法簽名無關，具體某個方法走攔截器，在invoke方法中，馬上來看一下。

 

MyBatis外掛原理----Plugin的invoke方法

首先看一下Plugin方法的方法定義：

public class Plugin implements InvocationHandler {

  private Object target;
  private Interceptor interceptor;
  private Map<Class<?>, Set<Method>> signatureMap;

  private Plugin(Object target, Interceptor interceptor, Map<Class<?>, Set<Method>> signatureMap) {
    this.target = target;
    this.interceptor = interceptor;
    this.signatureMap = signatureMap;
  }
  ...
}

看到Plugin是InvocationHandler介面的實現類，換句話說，為目標介面生成代理之後，最終執行的都是Plugin的invoke方法，看一下invoke方法的實現：

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

在這裡，將method對應的Class拿出來，獲取該Class中有哪些方法簽名，換句話說就是Executor、ParameterHandler、ResultSetHandler、StatementHandler，在@Intercepts註解中定義了要攔截哪些方法簽名。

如果當前呼叫的方法的方法簽名在方法簽名集合中，即滿足第4行的判斷，那麼呼叫攔截器的intercept方法，否則方法原樣呼叫，不會執行攔截器。