[Analyse du code source MyBatis] Principe de mise en œuvre du plug-in

Principe du plug-in MyBatis ----Commencer à partir de l'analyse des

Cet article analyse le principe de mise en œuvre du plug-in de MyBatis. Avant cela, si vous n'êtes pas très familier avec le plug-in MyBatis, vous pouvez vous référer à cet article MyBatis7 : Plug-in MyBatis et exemples ---- imprimer chaque instruction SQL et son temps d'exécution. J'utilise un exemple pour expliquer ce qu'est le plug-in MyBatis et comment l'implémenter. Puisque le plug-in MyBatis a pénétré dans le code sous-jacent de MyBatis, pour mieux utiliser le plug-in, vous devez être familier avec le principe d'implémentation du plug-in et le code sous-jacent de MyBatis. Cet article analyse le principe d'implémentation du plug-in. de MyBatis.

Tout d'abord, nous commençons par l'analyse du plug-in . Le code source se trouve dans la méthode pluginElement de XMLConfigBuilder :

 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 }

.

Voici l'attribut de l'intercepteur dans la balise . Il s'agit du chemin complet de l'intercepteur personnalisé. Le code de la ligne 6 génère une instance d'intercepteur par réflexion.

Prenez toutes les balises sous la balise , analysez les attributs name et value dans une propriété et définissez les propriétés sur l'intercepteur.

Enfin, définissez l'intercepteur sur Configuration via le code de la ligne 8. Le code source est implémenté comme :

<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 est une chaîne d'intercepteurs qui stocke tous les intercepteurs définis et plusieurs méthodes de fonctionnement associées :

 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 }

sont ajoutés respectivement aux intercepteurs, ajoutez tous les intercepteurs à l'objet cible et obtenez tous les intercepteurs actuels.

Principe du plug-in MyBatis ----méthode pluginAll pour ajouter des plug-ins

Ce que nous avons fait ci-dessus, j'ai vu une méthode pluginAll dans InterceptorChain. La méthode pluginAll génère un proxy pour l'objet cible. Ensuite, lorsque l'objet cible appelle la méthode, il n'utilise pas la méthode d'origine mais la méthode. méthode proxy Cela sera expliqué plus tard .

La documentation du site officiel de MyBatis indique que les plug-ins sont autorisés aux quatre points d'exécution de code suivants :

Le timing de génération du plug-in (En d'autres termes, le timing d'appel de la méthode pluginAll ) est Executor, ParameterHandler, ResultSetHandler, StatementHandler Lorsque les quatre classes d'implémentation d'interface sont générées, le moment où chaque classe d'implémentation d'interface est générée dans MyBatis est différent du moment où elles ont été générées. Je pense que chaque outil de développement dispose d'une touche de raccourci à afficher. À l'endroit où la méthode pluginAll est appelée, l'Eclipse que j'utilise est Ctrl+Alt+H.

Regardez à nouveau la méthode pluginAll :

1 public Object pluginAll(Object target) {2     for (Interceptor interceptor : interceptors) {3       target = interceptor.plugin(target);4     }5     return target;6 }

这里值得注意的是：

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)))，不断嵌套下去，这就得到一个重要的结论：...中后定义的实际其拦截器方法先被执行，因为根据这段代码来看，后定义的代理实际后生成，包装了先生成的代理，自然其代理方法也先执行

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，添加到signatureMap中，构建出一个方法签名映射。举个例子来说，就是我定义的@Intercepts注解，Executor下我要拦截的所有Method、StatementHandler下我要拦截的所有Method。

回过头继续看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 }

Ici, supprimez la classe correspondant à la méthode et obtenez les signatures de méthode dans la classe. En d'autres termes, il s'agit de Executor, ParameterHandler, ResultSetHandler et StatementHandler. L'annotation @Intercepts définit quelles signatures de méthode doivent être utilisées. être intercepté.

Si la signature de méthode de la méthode actuellement appelée est dans l'ensemble de signatures de méthode, c'est-à-dire qu'elle répond au jugement de la ligne 4, alors la méthode d'interception de l'intercepteur est appelée. , la méthode est appelée telle quelle et ne sera pas exécutée par Interceptor.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!