MyBatis外掛程式原理----從
#本文分析MyBatis的外掛實作原理，在此之前，如果對MyBatis外掛不是很熟悉的朋友，可參考此文MyBatis7：MyBatis外掛及範例----印出每個SQL語句及其執行時間，本文我以一個例子說明了MyBatis外掛是什麼以及如何實作。由於MyBatis的插件已經深入了MyBatis底層程式碼，因此要更好地使用插件，必須對插件實作原理及MyBatis底層程式碼有所熟悉才行，本文分析一下MyBatis的插件實作原理。
首先，我們從外掛程式
1 private void pluginElement(XNode parent) throws Exception { 2 if (parent != null) { 3 for (XNode child : parent.getChildren()) { 4 String interceptor = child.getStringAttribute("interceptor"); 5 Properties properties = child.getChildrenAsProperties(); 6 Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).newInstance(); 7 interceptorInstance.setProperties(properties); 8 configuration.addInterceptor(interceptorInstance); 9 }10 }11 } #這裡拿
再拿
最後，透過第8行的程式碼將攔截器設定到Configuration中，原始碼實作為：
<span style="color: #008080"> 1</span> <span style="color: #0000ff">public</span> <span style="color: #0000ff">void</span><span style="color: #000000"> addInterceptor(Interceptor interceptor) {</span><span style="color: #008080"> 2</span> <span style="color: #000000"> interceptorChain.addInterceptor(interceptor);</span><span style="color: #008080"> 3</span> <span style="color: #000000">}</span><span style="color: #008080"><br></span>InterceptorChain是一個攔截器鏈，儲存了所有定義的攔截器以及相關的幾個操作的方法：
1 public class InterceptorChain { 2 3 private final List<Interceptor> interceptors = new ArrayList<Interceptor>(); 4 5 public Object pluginAll(Object target) { 6 for (Interceptor interceptor : interceptors) { 7 target = interceptor.plugin(target); 8 } 9 return target;10 }11 12 public void addInterceptor(Interceptor interceptor) {13 interceptors.add(interceptor);14 }15 16 public List<Interceptor> getInterceptors() {17 return Collections.unmodifiableList(interceptors);18 }19 20 }分別有新增攔截器、為目標物件新增所有攔截器、取得目前所有攔截器三個方法。
MyBatis外掛程式原理----pluginAll方法加入外掛程式
##上面我們在InterceptorChain中看到了一個pluginAll方法，pluginAll方法為目標物件產生代理，之後目標物件呼叫方法的時候走的不是原方法而是代理方法，這個在後面會說明。
MyBatis官網文件有說明，在以下四個程式碼執行點上允許使用外掛程式：
換句話說就是pluginAll方法呼叫的時機）是Executor、ParameterHandler、ResultSetHandler、StatementHandler四個介面實作類別產生的時候，每個介面實作類別在MyBatis中產生的時機是不一樣的，這個就不看它們是在什麼時候產生的了，每個開發工具我相信都有快捷鍵可以看到pluginAll方法呼叫的地方，我使用的Eclipse就是Ctrl+Alt+H。
再看pluginAll方法：
1 public Object pluginAll(Object target) {2 for (Interceptor interceptor : interceptors) {3 target = interceptor.plugin(target);4 }5 return target;6 }这里值得注意的是：
形参Object target，这个是Executor、ParameterHandler、ResultSetHandler、StatementHandler接口的实现类，换句话说，plugin方法是要为Executor、ParameterHandler、ResultSetHandler、StatementHandler的实现类生成代理，从而在调用这几个类的方法的时候，其实调用的是InvocationHandler的invoke方法
这里的target是通过for循环不断赋值的，也就是说如果有多个拦截器，那么如果我用P表示代理，生成第一次代理为P(target)，生成第二次代理为P(P(target))，生成第三次代理为P(P(P(target)))，不断嵌套下去，这就得到一个重要的结论：
plugin方法中调用MyBatis提供的现成的生成代理的方法Plugin.wrap(Object target, Interceptor interceptor)，接着我们看下wrap方法的源码实现。
MyBatis插件原理----Plugin的wrap方法的实现
Plugin的wrap方法实现为：
1 public static Object wrap(Object target, Interceptor interceptor) { 2 Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor); 3 Class<?> type = target.getClass(); 4 Class<?>[] interfaces = getAllInterfaces(type, signatureMap); 5 if (interfaces.length > 0) { 6 return Proxy.newProxyInstance( 7 type.getClassLoader(), 8 interfaces, 9 new Plugin(target, interceptor, signatureMap));10 }11 return target;12 }首先看一下第2行的代码，获取Interceptor上定义的所有方法签名：
1 private static Map<Class<?>, Set<Method>> getSignatureMap(Interceptor interceptor) { 2 Intercepts interceptsAnnotation = interceptor.getClass().getAnnotation(Intercepts.class); 3 // issue #251 4 if (interceptsAnnotation == null) { 5 throw new PluginException("No @Intercepts annotation was found in interceptor " + interceptor.getClass().getName());
6 } 7 Signature[] sigs = interceptsAnnotation.value(); 8 Map<Class<?>, Set<Method>> signatureMap = new HashMap<Class<?>, Set<Method>>(); 9 for (Signature sig : sigs) {10 Set<Method> methods = signatureMap.get(sig.type());11 if (methods == null) {12 methods = new HashSet<Method>();13 signatureMap.put(sig.type(), methods);14 }15 try {16 Method method = sig.type().getMethod(sig.method(), sig.args());17 methods.add(method);18 } catch (NoSuchMethodException e) {19 throw new PluginException("Could not find method on " + sig.type() + " named " + sig.method() + ". Cause: " + e, e);20 }21 }22 return signatureMap;23 }看到先拿@Intercepts注解，如果没有定义@Intercepts注解，抛出异常，这意味着使用MyBatis的插件，必须使用注解方式。
接着拿到@Intercepts注解下的所有@Signature注解，获取其type属性（表示具体某个接口），再根据method与args两个属性去type下找方法签名一致的方法Method（如果没有方法签名一致的就抛出异常，此签名的方法在该接口下找不到），能找到的话key=type，value=Set
回过头继续看wrap方法，在拿到方法签名映射后，调用getAllInterfaces方法，传入的是Target的Class对象以及之前获取到的方法签名映射：
1 private static Class<?>[] getAllInterfaces(Class<?> type, Map<Class<?>, Set<Method>> signatureMap) { 2 Set<Class<?>> interfaces = new HashSet<Class<?>>(); 3 while (type != null) { 4 for (Class<?> c : type.getInterfaces()) { 5 if (signatureMap.containsKey(c)) { 6 interfaces.add(c); 7 } 8 } 9 type = type.getSuperclass();10 }11 return interfaces.toArray(new Class<?>[interfaces.size()]);12 }这里获取Target的所有接口，如果方法签名映射中有这个接口，那么添加到interfaces中，这是一个Set，最终将Set转换为数组返回。
wrap方法的最后一步：
1 if (interfaces.length > 0) {2 return Proxy.newProxyInstance(3 type.getClassLoader(),4 interfaces,5 new Plugin(target, interceptor, signatureMap));6 }7 return target;如果当前传入的Target的接口中有@Intercepts注解中定义的接口，那么为之生成代理，否则原Target返回。
这段理论可能大家会看得有点云里雾里，我这里举个例子：
= StatementHandler., method = "query", args = {Statement., ResultHandler.= StatementHandler.,
method = "update", args = {Statement. org.apache.ibatis.executor.statement.StatementHandler=[ org.apache.ibatis.executor.statement.StatementHandler.update(java.sql.
Statement) java.sql.SQLException, java.util.List org.apache.ibatis.executor.statement.StatementHandler.query(java.sql.Statement,org.apache.
ibatis.session.ResultHandler) 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方法的方法定义：
1 public class Plugin implements InvocationHandler { 2 3 private Object target; 4 private Interceptor interceptor; 5 private Map<Class<?>, Set<Method>> signatureMap; 6 7 private Plugin(Object target, Interceptor interceptor, Map<Class<?>, Set<Method>> signatureMap) { 8 this.target = target; 9 this.interceptor = interceptor;10 this.signatureMap = signatureMap;11 }12 ...13 }看到Plugin是InvocationHandler接口的实现类，换句话说，为目标接口生成代理之后，最终执行的都是Plugin的invoke方法，看一下invoke方法的实现：
1 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 2 try { 3 Set<Method> methods = signatureMap.get(method.getDeclaringClass()); 4 if (methods != null && methods.contains(method)) { 5 return interceptor.intercept(new Invocation(target, method, args)); 6 } 7 return method.invoke(target, args); 8 } catch (Exception e) { 9 throw ExceptionUtil.unwrapThrowable(e);10 }11 }在這裡，將method對應的Class拿出來，取得該Class中有哪些方法簽名，換句話說就是Executor、ParameterHandler、ResultSetHandler、StatementHandler，在@Intercepts註解中定義了要攔截哪些方法簽名。
如果目前調用的方法的方法簽名在方法簽名集合中，即滿足第4行的判斷，那麼調用攔截器的intercept方法，否則方法原樣調用，不會執行攔截器。
以上是【MyBatis源碼分析】外掛實作原理的詳細內容。更多資訊請關注PHP中文網其他相關文章！
