假装是小白之重学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(二)

前言

概述

当然还是从HelloWorld开始

性能分析插件走起

代理分析

写在最后

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

假装是小白之重学MyBatis(二)

前言

概述

当然还是从HelloWorld开始

性能分析插件走起

代理分析

写在最后

热门文章

最新文章

相关课程

相关电子书