MyBatis整体预览（二）（关于自己开发插件与mybatis 的整合）

2024-06-21 12:08
文章标签 mybatis 插件 预览 整合 开发 整体

本文主要是介绍MyBatis整体预览（二）（关于自己开发插件与mybatis 的整合），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

   感谢原文作者分享，原文地址是：http://blog.csdn.net/jdream314/article/details/7473001

MyBatis整体预览（二）

       本文将介绍MyBatis的插件实现原理

         一、MyBatis为开发者提供了非常丰富的接口，以满足开发者扩充自己的功能。将扩展的插件配置到configuration的plugins的标签中，那么mybatis自动将插件插入到你想执行的地方。在《MyBatis整体预览（一）》中，曾介绍MyBatis允许开发者在StatementHandler、ResultSetHandler、ParameterHandler以及Executor插入自己想执行的代码。下面将详细介绍从我们定制自己的插件到插件是如何被调用的来进行分析。

      首先，要开发MyBatis的插件需要实现org.apache.ibatis.plugin.Interceptor接口，这个接口将会要求实现几个方法：intercept（）、plugin（）及setProperties（），intercept方法是开发人员所要执行的操作，plugin是将你插件放入到MyBatis的插件集合中去，而setProperties这是在你配置你插件的时候将plugins/plugin/properties的值设置到该插件中。这是实现自己插件的几个步骤，注意：一般在plugin方法中只写Plugin.wrap(target,this)，target一般是你要拦截的对象，this这是当前的插件，在plugin方法参数中有个plugin(Object target)，这个target类型就是StatementHandler、ResultSetHandler、ParameterHandler以及Executor中的一个。这里就插件的基本结构和方法进行了介绍。下面将对MyBatis如何获得开发人员开发的插件，以及具体执行的过程进行分析。

      在《MyBatis整体预览（一）》中，对MyBatis的整个执行过程进行了一个介绍，主要是对Configuration对象的初始化过程进行了比较详细的介绍。当然，在Configuration初始化的过程中当然也包括对开发人员自己的插件进行初始化，并进行保存插件对象。

在XMLConfigBuilder的parsetConfiguration里面调用了pluginElement方法，这个方法将会解析开发人员配置在configuration中的plugin标签下面的元素。执行代码如下：

[java] view plain copy
  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.   }  

    这个方法里面调用了configuration类中的addInterceptor方法，将插件实例添加到configuration对象中，那么让我们看看configuration里面对插件对象做了什么：

[java] view plain copy
  1. public void addInterceptor(Interceptor interceptor) {  
  2.    interceptorChain.addInterceptor(interceptor);  
  3.   }  

    这就是在configuration类中的这个addInterceptor方法，他将这个插件添加到一个链中，那么这个拦截器链是怎样的呢？

[java] view plain copy
  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.     }  

    这个类很简单，直接将这个插件添加到了一个List对象集合中。你可能会发现上面还有一个pluginAll方法，并且在该方法里面调用了插件的plugin方法。大家是否明白了，这个plugin方法里面上面已经介绍，只是执行了Plugin.wrap(target,this)段代码。那么现在就有个几个问题：第一、这个pluginAll方法什么时候调用，还有就是Plugin.wrap(target,this)，这段代码是干什么用的。理解清楚这两个问题，那么MyBatis的插件开发过程就完全理解了。

    首先让我们开看看如何调用pluginAll方法的。在Configuration类中会发现一下几个方法：

[java] view plain copy
  1. public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {  
  2.     ParameterHandler parameterHandler = new DefaultParameterHandler(mappedStatement, parameterObject, boundSql);  
  3.     parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);  
  4.     return parameterHandler;  
  5.   }  
  6.   
  7.   public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler,  
  8.       ResultHandler resultHandler, BoundSql boundSql) {  
  9.     ResultSetHandler resultSetHandler = mappedStatement.hasNestedResultMaps() ? new NestedResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql,  
  10.         rowBounds) : new FastResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);  
  11.     resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);  
  12.     return resultSetHandler;  
  13.   }  
  14.   
  15.   public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {  
  16.     StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);  
  17.     statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);  
  18.     return statementHandler;  
  19.       }  
  20.   public Executor newExecutor(Transaction transaction, ExecutorType executorType, boolean autoCommit) {  
  21.     executorType = executorType == null ? defaultExecutorType : executorType;  
  22.     executorType = executorType == null ? ExecutorType.SIMPLE : executorType;  
  23.     Executor executor;  
  24.     if (ExecutorType.BATCH == executorType) {  
  25.       executor = new BatchExecutor(this, transaction);  
  26.     } else if (ExecutorType.REUSE == executorType) {  
  27.       executor = new ReuseExecutor(this, transaction);  
  28.     } else {  
  29.       executor = new SimpleExecutor(this, transaction);  
  30.     }  
  31.     if (cacheEnabled) {  
  32.       executor = new CachingExecutor(executor, autoCommit);  
  33.     }  
  34.     executor = (Executor) interceptorChain.pluginAll(executor);  
  35.     return executor;  
  36.       }  

    可以很清楚看到这几个方法里面都调用了pluginAll方法。看了这几个方法名不用我解释这些方法是做什么的了吧？这就是我为什么说：MyBatis允许开发者在StatementHandler、ResultSetHandler、ParameterHandler以及Executor插入自己想执行的代码。pluginAll都是将new出来的对象传递过去，这就是target。这里就对pluginAll方法进行了介绍。那么接下来就对插件的核心部分进行介绍。

    Plugin.wrap(target,this)这段代码是做了什么事？在这里我将为大家解开这神秘的面纱。首先看看wrap方法是做了什么：

[java] view plain copy
  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.       }  

    这个方法有来两个参数，第一个是target，第二个是interceptor。target就是我们要拦截的对象，及就是我们插件要放入到那个对象的代码中去，而interceptor就是开发人员开发的插件对象，此处貌似叫插件不是很合里，叫做拦截器更为合理，因为他是拦截MyBatis的执行过程，从而插入开发人员自己想执行的代码。此处就不就此问题纠结太久。发现在wrap方法里面第一行就调用了getSignatureMap方法，看到Signature这个单词不知是否很熟悉，这个在我们定义自己插件的时候貌似用到了：

[java] view plain copy
  1. @Intercepts( {@Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class})})  
  2. public class StatementHandlerInterceptor implements Interceptor {  
  3.     private String DIALECT ;  
  4.     public String getDIALECT() {  
  5.         return DIALECT;  
  6.     }  
  7.   
  8.     public void setDIALECT(String dIALECT) {  
  9.         DIALECT = dIALECT;  
  10.     }  
  11.   
  12.     @Override  
  13.     public Object intercept(Invocation invocation) throws Throwable {  
  14.   
  15.         RoutingStatementHandler statement = (RoutingStatementHandler)invocation.getTarget();  
  16.         PreparedStatementHandler handler = (PreparedStatementHandler)ReflectUtil.getFieldValue(statement,  
  17.                 "delegate");  
  18.         RowBounds rowBounds = (RowBounds)ReflectUtil.getFieldValue(handler,  
  19.                 "rowBounds");  
  20.         if(rowBounds!=null)  
  21.         {  
  22.         if (rowBounds.getLimit() > 0  
  23.                 && rowBounds.getLimit() < RowBounds.NO_ROW_LIMIT)  
  24.         {  
  25.             BoundSql boundSql = statement.getBoundSql();  
  26.             String sql = boundSql.getSql();  
  27.             Dialect dialect = (Dialect)Class.forName(DIALECT).newInstance();  
  28.             sql = dialect.getLimitString(sql,  
  29.                     rowBounds.getOffset(),  
  30.                     rowBounds.getLimit());  
  31.             ReflectUtil.setFieldValue(boundSql, "sql", sql);  
  32.         }  
  33.         }  
  34.         return invocation.proceed();  
  35.     }  
  36.   
  37.     @Override  
  38.     public Object plugin(Object target) {  
  39.         return Plugin.wrap(target, this);  
  40.     }  
  41.   
  42.     @Override  
  43.     public void setProperties(Properties arg0) {  
  44.   
  45.     }  
  46.   
  47.     }  

    上面那段代码是我实现的一个拦截StatementHandler的prepare方法的插件。看到我在配置拦截目标的时候用到了这样一个注解：

@Intercepts( {@Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class})})

这里面有个@Signature注解，这个单词是否和我上面讲到的一个方法名中包含这个单词。对，就是getSignatureMap这个方法。可以很容易想到这个方法就是处理这个注解的。接下来展开看一下getSignatureMap方法所要执行的操作。

[python] view plain copy
  1. private static Map<Class<?>, Set<Method>> getSignatureMap(Interceptor interceptor) {  
  2.   
  3.     Intercepts interceptsAnnotation = interceptor.getClass().getAnnotation(Intercepts.class);  
  4.   
  5.     if (interceptsAnnotation == null) { // issue #251  
  6.   
  7.       throw new PluginException("No @Intercepts annotation was found in interceptor " + interceptor.getClass().getName());        
  8.   
  9.     }  
  10.   
  11.     Signature[] sigs = interceptsAnnotation.value();  
  12.   
  13.     Map<Class<?>, Set<Method>> signatureMap = new HashMap<Class<?>, Set<Method>>();  
  14.   
  15.     for (Signature sig : sigs) {  
  16.   
  17.       Set<Method> methods = signatureMap.get(sig.type());  
  18.   
  19.       if (methods == null) {  
  20.   
  21.         methods = new HashSet<Method>();  
  22.   
  23.         signatureMap.put(sig.type(), methods);  
  24.   
  25.       }  
  26.   
  27.       try {  
  28.   
  29.         Method method = sig.type().getMethod(sig.method(), sig.args());  
  30.   
  31.         methods.add(method);  
  32.   
  33.       } catch (NoSuchMethodException e) {  
  34.   
  35.         throw new PluginException("Could not find method on " + sig.type() + " named " + sig.method() + ". Cause: " + e, e);  
  36.   
  37.       }  
  38.   
  39.     }  
  40.   
  41.     return signatureMap;  
  42.   
  43.   }  

    该方法的第一句话就是获得Intercepts注解，这种方法应该很容易理解。那么接下来将获得在Intercepts里面的参数@Signature注解内容，在该注解中包含三个参数，分别是type，method，args。Type指定要拦截的类对象，method是指明要拦截该类的哪个方法，第三个是指明要拦截的方法参数集合。在Intercepts中可以配置多个@Signature。那么便对这写值进行遍历，已获得对应的type、method以及args。最终是获得一个HashMap对象，这些对象里面的键是类对象，而值是指定的类中方法对象。执行该端程序之后，更具target的classLoader和接口，来创建一个代理，并且，InvocationHandler是创建一个新的Plugin对象，同时将target，interceptor以及signatureMap传递给Plugin对象，当然，这里的Plugin也实现了Invocation接口。那么target对象所有的方法调用都会触发Plugin中的invoke方法，那么这里将执行开发者所有插入的操作。

[java] view plain copy
  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.   }  

    发现，此处将判断，复合拦截要求的将执行插件的intercept方法，而在intercept方法里面放入了开发者所要执行的操作。那么此时，就成功的调用了开发者开发的MyBatis的插件了。现在来梳理一下执行的过程。

    首先，开发者需要实现MyBatis的Interceptor接口，并主要要实现interceptor和plugin方法，而setProperties()当你配置了property就需要实现，没有，那么可以不用实现。实现接口后，那么就要将插件配置到MyBatis中去，然后通过XMLConfigBuilder来实例化插件对象，并将他们放到Configuration对象的InterceptChain对象的List集合中，然后在Configuration各种new的方法中调用InterceptChain的pluginAll方法，这里面将调用各个插件的plugin方法，这个方法里面则就调用Plugin的wrap方法，这个方法将要传入target和this(也就是插件自身对象)。那么在Plugin对象里面将创建一个代理对象，并且为这个代理对象创建一个InvocationHandler对象，这里将拦截代理对象的所有方法执行过程，及触发invoke方法，这里将执行实现的插件行为。这就是MyBatis的插件实现以及执行的过程。可能其中存在很多疑惑，但大致的流程应该都有，希望能够给大家带来帮助。

    本文到此已结束！后期有时间也会发布关于MyBatis的相关内容！如有不对还望大家指出！大家相互学习，相互进步！


这篇关于MyBatis整体预览（二）（关于自己开发插件与mybatis 的整合）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1081181。

相关文章

持久层 技术选型如何决策？JPA，Hibernate，ibatis(mybatis)

持久层 技术选型如何决策？JPA，Hibernate，ibatis(mybatis)

转自：http://t.51jdy.cn/thread-259-1-1.html 持久层 是一个项目 后台 最重要的部分。他直接 决定了 数据读写的性能，业务编写的复杂度，数据结构(对象结构)等问题。 因此 架构师在考虑 使用那个持久层框架的时候 要考虑清楚。 选择的 标准： 1，项目的场景。 2，团队的技能掌握情况。 3，开发周期(开发效率)。 传统的 业务系统，通常业
阅读更多...
Eclipse+ADT与Android Studio开发的区别

Eclipse+ADT与Android Studio开发的区别

下文的EA指Eclipse+ADT,AS就是指Android Studio。 就编写界面布局来说AS可以边开发边预览（所见即所得,以及多个屏幕预览），这个优势比较大。AS运行时占的内存比EA的要小。AS创建项目时要创建gradle项目框架，so,创建项目时AS比较慢。android studio基于gradle构建项目，你无法同时集中管理和维护多个项目的源码，而eclipse ADT可以同时打开
阅读更多...
Python应用开发——30天学习Streamlit Python包进行APP的构建（9）

Python应用开发——30天学习Streamlit Python包进行APP的构建（9）

st.area_chart 显示区域图。 这是围绕 st.altair_chart 的语法糖。主要区别在于该命令使用数据自身的列和指数来计算图表的 Altair 规格。因此，在许多 "只需绘制此图 "的情况下，该命令更易于使用，但可定制性较差。 如果 st.area_chart 无法正确猜测数据规格，请尝试使用 st.altair_chart 指定所需的图表。 Function signa
阅读更多...
WordPress网创自动采集并发布插件

WordPress网创自动采集并发布插件

网创教程：WordPress插件网创自动采集并发布 阅读更新：随机添加文章的阅读数量，购买数量，喜欢数量。 使用插件注意事项 如果遇到404错误，请先检查并调整网站的伪静态设置，这是最常见的问题。需要定制化服务，请随时联系我。 本次更新内容 我们进行了多项更新和优化，主要包括： 界面设置：用户现在可以更便捷地设置文章分类和发布金额。代码优化：改进了采集和发布代码，提高了插件的稳定
阅读更多...
WDF驱动开发-WDF总线枚举(一)

WDF驱动开发-WDF总线枚举(一)

支持在总线驱动程序中进行 PnP 和电源管理 某些设备永久插入系统，而其他设备可以在系统运行时插入和拔出电源。 总线驱动 必须识别并报告连接到其总线的设备，并且他们必须发现并报告系统中设备的到达和离开情况。 总线驱动程序标识和报告的设备称为总线的 子设备。 标识和报告子设备的过程称为 总线枚举。 在总线枚举期间，总线驱动程序会为其子 设备创建设备对象 。  总线驱动程序本质上是同时处理总线枚
阅读更多...
vscode-创建vue3项目-修改暗黑主题-常见错误-element插件标签-用法涉及问题

vscode-创建vue3项目-修改暗黑主题-常见错误-element插件标签-用法涉及问题

文章目录 1.vscode创建运行编译vue3项目2.添加项目资源3.添加element-plus元素4.修改为暗黑主题4.1.在main.js主文件中引入暗黑样式4.2.添加自定义样式文件4.3.html页面html标签添加样式 5.常见错误5.1.未使用变量5.2.关闭typescript检查5.3.调试器支持5.4.允许未到达代码和未定义代码 6.element常用标签6.1.下拉列表
阅读更多...
JavaWeb系列六: 动态WEB开发核心(Servlet) 上

JavaWeb系列六: 动态WEB开发核心(Servlet) 上

韩老师学生 官网文档为什么会出现Servlet什么是ServletServlet在JavaWeb项目位置Servlet基本使用Servlet开发方式说明快速入门- 手动开发 servlet浏览器请求Servlet UML分析Servlet生命周期GET和POST请求分发处理通过继承HttpServlet开发ServletIDEA配置ServletServlet注意事项和细节 Servlet注
阅读更多...
手把手教你入门vue+springboot开发（五）--docker部署

手把手教你入门vue+springboot开发（五）--docker部署

文章目录 前言一、前端打包二、后端打包三、docker运行总结 前言 前面我们重点介绍了vue+springboot前后端分离开发的过程，本篇我们结合docker容器来研究一下打包部署过程。 一、前端打包 在VSCode的命令行中输入npm run build可以打包前端代码，出现下图提示表示打包完成。 打包成功后会在前端工程目录生成dist目录，如下图所示： 把
阅读更多...
Sapphire开发日志 (十) 关于页面

Sapphire开发日志 (十) 关于页面

关于页面 任务介绍 关于页面用户对我组工作量的展示。 实现效果 代码解释 首先封装一个子组件用于展示用户头像和名称。 const UserGrid = ({src,name,size,link,}: {src: any;name: any;size?: any;link?: any;}) => (<Box sx={{ display: "flex", flexDirecti
阅读更多...
ROS2从入门到精通4-4：局部控制插件开发案例(以PID算法为例)

ROS2从入门到精通4-4：局部控制插件开发案例(以PID算法为例)

目录 0 专栏介绍1 控制插件编写模板1.1 构造控制插件类1.2 注册并导出插件1.3 编译与使用插件 2 基于PID的路径跟踪原理3 控制插件开发案例(PID算法)常见问题 0 专栏介绍 本专栏旨在通过对ROS2的系统学习，掌握ROS2底层基本分布式原理，并具有机器人建模和应用ROS2进行实际项目的开发和调试的工程能力。 🚀详情：《ROS2从入门到精通》 1 控制插
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2