关于mybatis-plus:假装是小白之重学MyBatis二

前言

本篇咱们来介绍MyBatis插件的开发，这个也是来源于我之前的一个面试经验，面试官为我如何统计Dao层的慢SQL，我过后的答复是借助于Spring的AOP机制，拦挡Dao层所有的办法，但面试官又问，这事实上不齐全是SQL的执行工夫，这其中还有其余代码的工夫，问我还有其余思路吗？我想了想说没有，面试官接着问，有接触过MyBatis插件的开发吗？我说没接触过。但前面也给我过了，我认为这个问题是有价值的问题，所以也放在了我的学习打算中。

看本篇之前倡议先看:

《代理模式-AOP绪论》
《伪装是小白之重学MyBatis(一)》

如果有人问下面两篇文章在哪里能够找的到，能够去掘金或者思否翻翻，目前公众号还没有，预计年中会将三个平台的文章对立一下。

概述

翻阅官网文档的话，MyBatis并没有给处插件的具体定义，但基本上还是拦截器，MyBatis的插件就是一些可能拦挡某些MyBats外围组件办法，加强性能的拦截器。官网文档中列出了四种可供加强的切入点:

Executor

执行SQL的外围组件。拦挡Executor 意味着要烦扰或加强底层执行的CRUD操作

ParameterHandler

拦挡该ParameterHandler，意味着要烦扰SQL参数注入、读取的动作。

ResultSetHandler

拦挡该ParameterHandler, 要烦扰/加强封装后果集的动作

StatementHandler

拦挡StatementHandler ，则意味着要烦扰/加强Statement的创立和执行的动作

当然还是从HelloWorld开始

要做MyBatis的插件，首先要实现MyBatis的Interceptor 接口 , 留神类不要导错了，Interceptor很热门，该类位于org.apache.ibatis.plugin.Interceptor下。实现该接口，MyBatis会将该实现类当作MyBatis的拦截器，那拦挡哪些办法，该怎么指定呢? 通过@Intercepts注解来实现，上面是应用示例:

@Intercepts(@Signature(type = Executor.class, method = "query",
        args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}))
public class MyBatisPluginDemo implements Interceptor {
    
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        System.out.println("into invocation ..........");
        System.out.println(invocation.getTarget());
        System.out.println(invocation.getMethod().getName());
        System.out.println(Arrays.toString(invocation.getArgs()));
        return invocation.proceed();
    }
}

@Intercepts能够填多个@Signature,@Signature是办法签名,type用于定位类，method定位办法名，args用于指定办法的参数类型。三者加在一起就能够定位到具体的办法。留神写完还须要将此插件注册到MyBatis的配置文件中,让MyBatis加载该插件。

留神这个标签肯定要放在environments下面，MyBatis严格限制住了标签的程序。

<plugins>
    <plugin interceptor="org.example.mybatis.MyBatisPluginDemo"></plugin>
</plugins>

咱们来看下执行后果:

性能剖析插件走起

那拦挡谁呢？目前也只有Executor 和StatementHandler 供咱们抉择，咱们自身是要看SQL耗时，Executor 离SQL执行还有些远，一层套一层才走到SQL执行，MyBatis中标签的执行过程在《MyBatis源码学习笔记(一) 初遇篇》曾经讲述过了，这里不再赘述，目前来看StatementHandler 是离SQL最近的, 它的实现类就间接走到JDBC了，所以咱们拦挡StatementHandler ，那有的插入插了很多值，咱们要不要拦挡，当然也要拦挡, 咱们的插件办法如下:

@Intercepts({@Signature(type = StatementHandler.class, method = "query",
        args = {Statement.class, ResultHandler.class}), @Signature(type = StatementHandler.class,method =  "update" ,args = Statement.class )})
public class MyBatisSlowSqlPlugin implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        System.out.println("-----开始进入性能剖析插件中----");
        long startTime = System.currentTimeMillis();
        Object result = invocation.proceed();
        long endTime = System.currentTimeMillis();
       // query办法入参是statement,所以咱们能够将其转为Statement
        if (endTime - startTime > 1000){

        }
        return result;
    }
}

那对应的SQL该怎么拿？咱们还是到StatementHandler去看下:

咱们还是得通过Statement这个入参来拿, 咱们试试看, 你会发现在日志级别为DEBUG之上，会输入SQL，像上面这样:

如果日志级别为DEBUG输入会是上面这样:

这是为什么呢？如果看过《MyBatis源码学习笔记(一) 初遇篇》这篇的可能会想到，MyBatis架构中的日志模块，为了接入日志框架，就会用到代理，那么这个必定就是代理类，咱们打断点来验证一下咱们的想法:

代理剖析

我本来的想法是PreparedStatementLogger的代理类，认真一想，感觉不对，感觉本人还是对代理模式理解不大透，于是我就又把之前的文章《代理模式-AOP绪论》看了一下，动静代理模式的指标:

咱们有一批类，而后咱们想在不扭转它们的根底之上，加强它们, 咱们还心愿只着眼于编写加强指标对象代码的编写。
咱们还心愿由程序来编写这些类，而不是由程序员来编写，因为太多了。

在《代理模式-AOP绪论》中咱们做的是很简略的代理:

public interface IRentHouse {
    void rentHouse();
    void study();
}
public class RentHouse implements IRentHouse{
    @Override
    public void rentHouse() {
        System.out.println("sayHello.....");
    }
    @Override
    public void study() {
        System.out.println("say Study");
    }
}

咱们当初的需要是加强IRentHouse中的办法，用动态代理就是为IRentHouse再做一个实现类，相当于在RentHouse上再包装一层。但如果我有很多想加强的类呢，这样去包装，事实上对代码的侵入性是很大的。对于这种情况，咱们最终的抉择是动静代理，在运行时产生接口实现类的代理类，咱们最终产生代理对象的办法是:

/**
   * @param target 为须要加强的类
   * @return 返回的对象在调用接口中的任意办法都会走到Lambda回调中。
*/
private static  Object getProxy(Object  target){
        Object proxy = Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), (proxy1, method, args) -> {
            System.out.println("办法开始执行..........");
            Object obj = method.invoke(target, args);
            System.out.println("办法执行完结..........");
            return obj;
        });
        return proxy;
  }

接下来咱们来看下MyBatis是怎么包装的，咱们还是从PreparedStatementLogger开始看：

InvocationHandler是动静代理的接口，BaseJdbcLogger这个先不关注。值得关注的是:

public static PreparedStatement newInstance(PreparedStatement stmt, Log statementLog, int queryStack) {
  InvocationHandler handler = new PreparedStatementLogger(stmt, statementLog, queryStack);
  ClassLoader cl = PreparedStatement.class.getClassLoader();
  return (PreparedStatement) Proxy.newProxyInstance(cl, new Class[]{PreparedStatement.class, CallableStatement.class}, handler);
}

可能有同学会问newProxyInstance为什么给了两个参数, 因为CallableStatement继承了PreparedStatement。这里是一层，事实上还能点进去另外一层，在ConnectionLogger的回调中(ConnectionLogger也实现了InvocationHandler，所以这个也是个代理回调类)，ConnectionLogger的实例化在BaseExecutor这个类外面实现，如果你还能回顾JDBC产生SQL的话，过后的流程事实上是这样的：

    public static boolean execute(String sql, Object... param) throws Exception {
        boolean result = true;
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            //获取数据库连贯
            connection = getConnection();
            connection.setAutoCommit(false);
            preparedStatement = connection.prepareStatement(sql);
            // 设置参数 
            for (int i = 0; i < param.length; i++) {
                preparedStatement.setObject(i, param[i]);
                preparedStatement.addBatch();
            }
            preparedStatement.executeBatch();
            //提交事务
            connection.commit();
        } catch (SQLException e) {
            e.printStackTrace();
            if (connection != null) {
                try {
                    connection.rollback();
                } catch (SQLException ex) {
                    ex.printStackTrace();
                    // 日志记录事务回滚失败
                    result = false;
                    return result;
                }
            }
            result = false;
        } finally {
            close(preparedStatement, connection);
        }
        return result;
    }

咱们来捋一下，ConnectionLogger是读Connection的代理，然而Connection接口中有许多办法, 所以ConnectionLogger在回调的时候做了判断:

@Override
public Object invoke(Object proxy, Method method, Object[] params)
    throws Throwable {
  try {
    if (Object.class.equals(method.getDeclaringClass())) {
      return method.invoke(this, params);
    }
    if ("prepareStatement".equals(method.getName()) || "prepareCall".equals(method.getName())) {
      if (isDebugEnabled()) {
        debug(" Preparing: " + removeExtraWhitespace((String) params[0]), true);
      }
      // Connection 的prepareStatement办法、prepareCall会产生PreparedStatement
      PreparedStatement stmt = (PreparedStatement) method.invoke(connection, params);
      // 而后PreparedStatementLogger产生的还是stmt的代理类
      // 咱们在plugin中拿到的就是  
      stmt = PreparedStatementLogger.newInstance(stmt, statementLog, queryStack);
      return stmt;
    } else if ("createStatement".equals(method.getName())) {
      Statement stmt = (Statement) method.invoke(connection, params);
      stmt = StatementLogger.newInstance(stmt, statementLog, queryStack);
      return stmt;
    } else {
      return method.invoke(connection, params);
    }
  } catch (Throwable t) {
    throw ExceptionUtil.unwrapThrowable(t);
  }
}

PreparedStatementLogger是回调类，这个PreparedStatementLogger有对应的Statement，咱们通过Statement就能够拿到对应的SQL。那回调类和代理类是什么关系呢，咱们来看下Proxy类的大抵结构:

所以我最后的想法是JDK为咱们产生的类外面有回调类实例这个对象会有InvocationHandler成员变量，然而如果你用getClass().getDeclaredField(“h”)去获取发现获取不到，那么代理类就没有这个回调类实例，那咱们钻研一下getProxyClass0这个办法:

private static Class<?> getProxyClass0(ClassLoader loader,
                                       Class<?>... interfaces) {
    if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }

    // If the proxy class defined by the given loader implementing
    // the given interfaces exists, this will simply return the cached copy;
    // otherwise, it will create the proxy class via the ProxyClassFactory
    // proxyClassCache 是 new WeakCache<>(new KeyFactory(), new ProxyClassFactory()) 的实例
    // 最终会调用ProxyClassFactory的apply办法。
    // 在ProxyClassFactory的apply办法中有 ProxyGenerator.generateProxyClass() 
    // 答案就在其中,最初调用的是ProxyGenerator的generateClassFile办法
    // 中产生代理类时,让代理类继承Proxy类。
    return proxyClassCache.get(loader, interfaces);
}

所以破案了，在Proxy里的InvocationHandler是protected，所以咱们取变量该当这么取:

@Intercepts({@Signature(type = StatementHandler.class, method = "query",
        args = {Statement.class, ResultHandler.class}), @Signature(type = StatementHandler.class,method =  "update" ,args = Statement.class )})
public class MyBatisSlowSqlPlugin implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        System.out.println("-----开始进入性能剖析插件中----");
        long startTime = System.currentTimeMillis();
        Object result = invocation.proceed();
        long endTime = System.currentTimeMillis();
       // query办法入参是statement,所以咱们能够将其转为Statement
        Statement statement = (Statement)invocation.getArgs()[0];
        if (Proxy.isProxyClass(statement.getClass())){
            Class<?> statementClass = statement.getClass().getSuperclass();
            Field targetField = statementClass.getDeclaredField("h");
            targetField.setAccessible(true);
            PreparedStatementLogger  loggerStatement  = (PreparedStatementLogger) targetField.get(statement);
            PreparedStatement preparedStatement = loggerStatement.getPreparedStatement();
            if (endTime - startTime > 1){
                System.out.println(preparedStatement.toString());
            }
        }else {
            if (endTime - startTime > 1){
                System.out.println(statement.toString());
            }
        }
        return result;
    }
}

最初输入如下:

然而这个插件还不是那么完满，就是这个慢SQL查问工夫了，咱们当初是写死的

这两个问题在MyBatis 外面都能够失去解决，咱们能够看Interceptor这个接口:

public interface Interceptor {
    
  Object intercept(Invocation invocation) throws Throwable;
 
  default Object plugin(Object target) {
    return Plugin.wrap(target, this);
  }

  default void setProperties(Properties properties) {
    // NOP
  }
}

setProperties用于从配置文件中取值, plugin将以后插件退出，intercept是真正加强办法。那下面的两个问题曾经被解决了:

硬编码

首先在配置文件外面配置

 <plugins>
        <plugin interceptor="org.example.mybatis.MyBatisSlowSqlPlugin">
            <property name = "maxTolerate" value = "10"/>
        </plugin>
 </plugins>

而后重写:

@Override
public void setProperties(Properties properties) {
    //maxTolerate 是MyBatisSlowSqlPlugin的成员变量
    this.maxTolerate = Long.parseLong(properties.getProperty("maxTolerate"));
}

回顾一下JDBC咱们执行SQl事实上有两种形式:

Connection中的prepareStatement办法
Connection中的createStatement

在MyBatis中这两种办法对应不同的StatementType, 下面的PreparedStatementLogger对应 Connection中的prepareStatement办法，如果说你在MyBatis中将语句申明为Statement，则咱们的SQL监控语句就会出错，所以这里咱们还须要在独自适配一下Statement语句类型。

@Intercepts({@Signature(type = StatementHandler.class, method = "query",
        args = {Statement.class, ResultHandler.class}), @Signature(type = StatementHandler.class,method =  "update" ,args = Statement.class )})
public class MyBatisSlowSqlPlugin implements Interceptor {

    private  long  maxTolerate;

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        System.out.println("-----开始进入性能剖析插件中----");
        long startTime = System.currentTimeMillis();
        Object result = invocation.proceed();
        SystemMetaObject
        long endTime = System.currentTimeMillis();
       // query办法入参是statement,所以咱们能够将其转为Statement
        Statement statement = (Statement)invocation.getArgs()[0];
        if (Proxy.isProxyClass(statement.getClass())){
            Class<?> statementClass = statement.getClass().getSuperclass();
            Field targetField = statementClass.getDeclaredField("h");
            targetField.setAccessible(true);
            Object object = targetField.get(statement);
            if (object instanceof PreparedStatementLogger) {
                PreparedStatementLogger  loggerStatement  = (PreparedStatementLogger) targetField.get(statement);
                PreparedStatement preparedStatement = loggerStatement.getPreparedStatement();
                if (endTime - startTime > maxTolerate){
                    System.out.println(preparedStatement.toString());
                }
            }else {
                // target 是对应的语句处理器
                // 为什么不反射拿? Statement 对应的实现类未重写toString办法
                // 然而在RoutingStatementHandler 中提供了getBoundSql办法
                RoutingStatementHandler handler = (RoutingStatementHandler) invocation.getTarget();
                BoundSql boundSql = handler.getBoundSql();
                if (endTime - startTime > maxTolerate){
                    System.out.println(boundSql);
                }
            }
        }else {
            if (endTime - startTime > maxTolerate){
                System.out.println(statement.toString());
            }
        }
        return result;
    }

    @Override
    public void setProperties(Properties properties) {
        this.maxTolerate = Long.parseLong(properties.getProperty("maxTolerate"));
    }
}

事实上MyBatis外面写好了反射工具类，这个就是SystemMetaObject，用法示例如下:

@Intercepts({@Signature(type = StatementHandler.class, method = "query",
        args = {Statement.class, ResultHandler.class}), @Signature(type = StatementHandler.class,method =  "update" ,args = Statement.class )})
public class MyBatisSlowSqlPlugin implements Interceptor {

    private  long  maxTolerate;

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        System.out.println("-----开始进入性能剖析插件中----");
        long startTime = System.currentTimeMillis();
        Object result = invocation.proceed();
        long endTime = System.currentTimeMillis();
       // query办法入参是statement,所以咱们能够将其转为Statement
        Statement statement = (Statement)invocation.getArgs()[0];
        MetaObject metaObject = SystemMetaObject.forObject(statement);
        if (Proxy.isProxyClass(statement.getClass())){
            Object object = metaObject.getValue("h");
            if (object instanceof PreparedStatementLogger) {
                PreparedStatementLogger  loggerStatement  = (PreparedStatementLogger) object;
                PreparedStatement preparedStatement = loggerStatement.getPreparedStatement();
                if (endTime - startTime > maxTolerate){
                    System.out.println(preparedStatement.toString());
                }
            }else {
                // target 是对应的语句处理器
                // 为什么不反射拿? Statement 对应的实现类未重写toString办法
                // 然而在RoutingStatementHandler 中提供了getBoundSql办法
                RoutingStatementHandler handler = (RoutingStatementHandler) invocation.getTarget();
                BoundSql boundSql = handler.getBoundSql();
                if (endTime - startTime > maxTolerate){
                    System.out.println(boundSql);
                }
            }
        }else {
            if (endTime - startTime > maxTolerate){
                System.out.println(statement.toString());
            }
        }
        return result;
    }

    @Override
    public void setProperties(Properties properties) {
        this.maxTolerate = Long.parseLong(properties.getProperty("maxTolerate"));
    }
}

那我有多个插件，如何指定程序呢? 在配置文件中指定，从上往下顺次执行

 <plugins>
        <plugin interceptor="org.example.mybatis.MyBatisSlowSqlPlugin01">
            <property name = "maxTolerate" value = "10"/>
        </plugin> 
     <plugin interceptor="org.example.mybatis.MyBatisSlowSqlPlugin02">
            <property name = "maxTolerate" value = "10"/>
        </plugin> 
</plugins>

如下面所配置执行程序就是MyBatisSlowSqlPlugin01、MyBatisSlowSqlPlugin02。插件的几个办法执行程序呢

写在最初

感叹颇深，本来预计两个小时就能写完的，而后写了一下午，颇有种学海无涯的感觉。

参考资料

mybatis拦截器插件实例-获取不带占位符的可间接执行的sql B站教学视频 https://www.bilibili.com/vide…
MyBatis高级 https://www.bilibili.com/vide…

关于mybatis-plus:假装是小白之重学MyBatis二

前言

概述

当然还是从HelloWorld开始

性能剖析插件走起

代理剖析

写在最初

参考资料

评论

发表回复取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

关于mybatis-plus:假装是小白之重学MyBatis二

前言

概述

当然还是从HelloWorld开始

性能剖析插件走起

代理剖析

写在最初

参考资料

评论

发表回复 取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

发表回复取消回复