java-mybaits-011-mybatis-拦截器计算耗时

一、概述　

　　Mybatis采用责任链模式，通过动态代理组织多个插件（拦截器），通过这些插件可以改变Mybatis的默认行为（诸如SQL重写之类的）

　　Mybatis是通过动态代理的方式实现拦截的

　　拦截器（Interceptor）在 Mybatis 中被当做插件（plugin）对待，官方文档提供了 Executor（拦截执行器的方法），ParameterHandler（拦截参数的处理），ResultSetHandler（拦截结果集的处理），StatementHandler（拦截Sql语法构建的处理） 共4种，并且提示“这些类中方法的细节可以通过查看每个方法的签名来发现，或者直接查看 MyBatis 发行包中的源代码”。

　　拦截器的使用场景主要是更新数据库的通用字段，分库分表，加解密等的处理。

　　MyBatis提供了一种插件(plugin)的功能，虽然叫做插件，但其实这是拦截器功能。

　　MyBatis 允许你在已映射语句执行过程中的某一点进行拦截调用。默认情况下，MyBatis 允许使用插件来拦截的方法调用包括：

　　　　Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)：拦截执行器的方法

　　　　　　Mybatis的内部执行器，它负责调用StatementHandler操作数据库，并把结果集通过 ResultSetHandler进行自动映射，另外，他还处理了二级缓存的操作。从这里可以看出，我们也是可以通过插件来实现自定义的二级缓存的。

　　　　ParameterHandler (getParameterObject, setParameters)：拦截参数的处理

　　　　　　是Mybatis实现Sql入参设置的对象。插件可以改变我们Sql的参数默认设置。

　　　　ResultSetHandler (handleResultSets, handleOutputParameters)：拦截结果集的处理

　　　　　　是Mybatis把ResultSet集合映射成POJO的接口对象。我们可以定义插件对Mybatis的结果集自动映射进行修改。

　　　　StatementHandler (prepare, parameterize, batch, update, query)：拦截Sql语法构建的处理

　　　　　　是Mybatis直接和数据库执行sql脚本的对象。另外它也实现了Mybatis的一级缓存。这里，我们可以使用插件来实现对一级缓存的操作(禁用等等)。

　　

　　Mybatis插件能够对这四大对象进行拦截，可以说包含到了Mybatis一次SQL执行的所有操作

二、 原理

　　

　　Mybatis的拦截器实现机制,使用的是JDK的InvocationHandler.

　　当我们调用ParameterHandler,ResultSetHandler,StatementHandler,Executor的对象的时候，实际上使用的是Plugin这个代理类的对象,这个类实现了InvocationHandler接口

　　接下来我们就知道了,在调用上述被代理类的方法的时候,就会执行Plugin的invoke方法.

　　Plugin在invoke方法中根据@Intercepts的配置信息(方法名,参数等)动态判断是否需要拦截该方法.

　　再然后使用需要拦截的方法Method封装成Invocation,并调用Interceptor的proceed方法.

　　这样我们就达到了拦截目标方法的结果.

　　例如Executor的执行大概是这样的流程:

　　拦截器代理类对象->拦截器->目标方法

　　　　Executor->Plugin->Interceptor->Invocation

　　　　Executor.Method->Plugin.invoke->Interceptor.intercept->Invocation.proceed->method.invoke

2.1、拦截器接口

　　拦截器均需要实现该 org.apache.ibatis.plugin.Interceptor 接口

public interface Interceptor {
  Object intercept(Invocation invocation) throws Throwable;
  Object plugin(Object target);
  void setProperties(Properties properties);
}

　　有3个方法。 MyBatis默认没有一个拦截器接口的实现类

　　setProperties方法是在Mybatis进行配置插件的时候可以配置自定义相关属性，即：接口实现对象的参数配置。

　　plugin方法是插件用于封装目标对象的，通过该方法我们可以返回目标对象本身，也可以返回一个它的代理，可以决定是否要进行拦截进而决定要返回一个什么样的目标对象，官方提供了示例：return Plugin.wrap(target, this)。

　　　　理解这个接口的定义，先要知道java动态代理机制。plugin接口即返回参数target对象(Executor/ParameterHandler/ResultSetHander/StatementHandler)的代理对象。在调用对应对象的接口的时候，可以进行拦截并处理。

　　intercept方法就是要进行拦截的时候要执行的方法。

2.2、拦截器四大接口实例

　　上述的Executor、ParameterHandler、ResultSetHandler、StatementHandler具体实现

2.2.1、实例创建

public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
   //确保ExecutorType不为空(defaultExecutorType有可能为空)
   executorType = executorType == null ? defaultExecutorType : executorType;
   executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
   Executor executor;   if (ExecutorType.BATCH == executorType) {
      executor = new BatchExecutor(this, transaction);
   } else if (ExecutorType.REUSE == executorType) {
      executor = new ReuseExecutor(this, transaction);
   } else {
      executor = new SimpleExecutor(this, transaction);
   }   if (cacheEnabled) {
      executor = new CachingExecutor(executor);
   }
   executor = (Executor) interceptorChain.pluginAll(executor);
   return executor;
}

public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
   StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
   statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
   return statementHandler;
}

public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
   ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
   parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
   return parameterHandler;
}

public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler, ResultHandler resultHandler, BoundSql boundSql) {
   ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);
   resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
   return resultSetHandler;
}

　　查看源码可以发现， Mybatis框架在创建好这四大接口对象的实例后，都会调用InterceptorChain.pluginAll()方法。InterceptorChain对象是插件执行链对象，看源码就知道里面维护了Mybatis配置的所有插件(Interceptor)对象。

2.2.2、插件加载执行过程

1、plugin

　　target --> Executor/ParameterHandler/ResultSetHander/StatementHandler

public Object pluginAll(Object target) {
    for (Interceptor interceptor : interceptors) {
       target = interceptor.plugin(target);
    }
    return target;
}

　　其实就是按顺序执行我们插件的plugin方法，一层一层返回我们原对象(Executor/ParameterHandler/ResultSetHander/StatementHandler)的代理对象。当我们调用四大接口的方法的时候，实际上是调用代理对象的相应方法，代理对象又会调用四大接口的实例。

　　Plugin对象

　　我们知道，官方推荐插件实现plugin方法为：Plugin.wrap(target, this);

2、wrap

public static Object wrap(Object target, Interceptor interceptor) {
　　// 获取插件的Intercepts注解
　　Map, Set> signatureMap = getSignatureMap(interceptor);
　　Class<?> type = target.getClass();
　　Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
　　if (interfaces.length > 0) {
  　　return Proxy.newProxyInstance(type.getClassLoader(), interfaces, new Plugin(target, interceptor, signatureMap));
　　}
　　return target;
}

　　这个方法其实是Mybatis简化我们插件实现的工具方法。其实就是根据当前拦截的对象创建了一个动态代理对象。代理对象的InvocationHandler处理器为新建的Plugin对象。

3、插件配置注解@Intercepts

　　Mybatis的插件都要有Intercepts注解来指定要拦截哪个对象的哪个方法。我们知道，Plugin.warp方法会返回四大接口对象的代理对象(通过new Plugin()创建的IvocationHandler处理器)，会拦截所有的执行方法。在代理对象执行对应方法的时候，会调用InvocationHandler处理器的invoke方法。Mybatis中利用了注解的方式配置指定拦截哪些方法。具体如下：

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
　　try {
　　　　Set<Method> methods = signatureMap.get(method.getDeclaringClass());
　　　　if (methods != null && methods.contains(method)) {
　　　　　　return interceptor.intercept(new Invocation(target, method, args));
　　　　}
　　return method.invoke(target, args);
　　} catch (Exception e) {
　　　　throw ExceptionUtil.unwrapThrowable(e);
　　}
}

　　可以看到，只有通过Intercepts注解指定的方法才会执行我们自定义插件的intercept方法。未通过Intercepts注解指定的将不会执行我们的intercept方法。

4、官方插件开发方式

@Intercepts({@Signature(type = Executor.class, method = "query",args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})})
public class TestInterceptor implements Interceptor {
　　public Object intercept(Invocation invocation) throws Throwable {
　　　　Object target = invocation.getTarget(); //被代理对象
 　　　 Method method = invocation.getMethod(); //代理方法
　　　　Object[] args = invocation.getArgs(); //方法参数
　　　　// do something ...... 方法拦截前执行代码块
　　　　Object result = invocation.proceed();
　　　　// do something .......方法拦截后执行代码块
　　　　return result;
　　}
　　public Object plugin(Object target) {
 　　return Plugin.wrap(target, this);
　　}
}

　　以上就是Mybatis官方推荐的插件实现的方法，通过Plugin对象创建被代理对象的动态代理对象。可以发现，Mybatis的插件开发还是很简单的。

　　自定义开发方式

　　Mybatis的插件开发通过内部提供的Plugin对象可以很简单的开发。只有理解了插件实现原理，对应不采用Plugin对象我们一样可以自己实现插件的开发。下面是我个人理解之后的自己实现的一种方式。

5、实例；

public class TestInterceptor implements Interceptor {

public Object intercept(Invocation invocation) throws Throwable {
    Object target = invocation.getTarget(); //被代理对象
    Method method = invocation.getMethod(); //代理方法
    Object[] args = invocation.getArgs(); //方法参数
    // do something ...... 方法拦截前执行代码块
    Object result = invocation.proceed();
    // do something .......方法拦截后执行代码块
    return result;
}
public Object plugin(final Object target) {
    return Proxy.newProxyInstance(Interceptor.class.getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            return intercept(new Invocation(target, method, args));
        }
    });
}
public void setProperties(Properties properties) {
}
}

　　当然，Mybatis插件的那这个时候Intercepts的注解起不到作用了。

6、小结

　　如果有N个插件，就有N个代理，每个代理都要执行上面的逻辑。这里面的层层代理要多次生成动态代理，是比较影响性能的。虽然能指定插件拦截的位置，但这个是在执行方法时动态判断，初始化的时候就是简单的把插件包装到了所有可以拦截的地方。

　　因此，在编写插件时需注意以下几个原则：

　　　　不编写不必要的插件；

　　　　实现plugin方法时判断一下目标类型，是本插件要拦截的对象才执行Plugin.wrap方法，否者直接返回目标本身，这样可以减少目标被代理的次数。

　　　　// 假如我们只要拦截Executor对象，那么我们应该这么做，默认是【return Plugin.wrap(target, this);】

    @Override
    public Object plugin(Object target) {
        if (target instanceof Executor) {
            return Plugin.wrap(target, this);
        } else {
            return target;
        }
    }

　　Mybatis插件很强大，可以对Mybatis框架进行很大的扩展。当然，如果你不理解Mybatis插件的原理，开发起来只能是模拟两可。在实际开发过程中，我们可以参考别人写的插件。下面是一个Mybatis分页的插件，可以为以后开发做参考。

　　每一个拦截器对目标类都进行一次代理，原对象如果是X，那么第一个拦截器代理后为P(X)，第二个代理后P(P(X))......最后返回这样的多重代理对象并执行。所以先配置的拦截器会后执行，因为先配置的先被包装成代理对象。

　　最后在调用真实对象方法的时候，实际上是调用多重代理的invoke方法，当符合拦截条件的时候执行我们编写的interceptor.intercept，intercept方法最后必定是调用invocation.proceed，proceed也是一个method.invoke，促使拦截链往下进行，不符合拦截条件的时候直接调用method.invoke，即不执行我们的拦截方法，继续拦截链。

2.3、对象方法说明

2.3.1、Executor类说明

1、拦截器注解

@Intercepts({
        @Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class})
})

　　拦截器的使用需要查看每一个type所提供的方法参数。

　　Signature 对应 Invocation 构造器，type 为 Invocation.Object，method 为 Invocation.Method，args 为 Invocation.Object[]。

　　method 对应的 update 包括了最常用的 insert/update/delete 三种操作，因此 update 本身无法直接判断sql为何种执行过程。

　　args 包含了其余所有的操作信息, 按数组进行存储, 不同的拦截方式有不同的参数顺序, 具体看type接口的方法签名, 然后根据签名解析。

2、Object 对象类型

　　args 参数列表中，Object.class 是特殊的对象类型。如果有数据库统一的实体 Entity 类，即包含表公共字段，比如创建、更新操作对象和时间的基类等，在编写代码时尽量依据该对象来操作，会简单很多。该对象的判断使用

Object parameter = invocation.getArgs()[1];
if (parameter instanceof BaseEntity) {
    BaseEntity entity = (BaseEntity) parameter;
}

　　即可，根据语句执行类型选择对应字段的赋值。

　　如果参数不是实体，而且具体的参数，那么 Mybatis 也做了一些处理，比如 @Param("name") String name 类型的参数，会被包装成 Map 接口的实现来处理，即使是原始的 Map 也是如此。使用

Object parameter = invocation.getArgs()[1];
if (parameter instanceof Map) {
    Map map = (Map) parameter;
}

　　即可，对具体统一的参数进行赋值。

3、SqlCommandType 命令类型

Executor 提供的方法中，update 包含了 新增，修改和删除类型，无法直接区分，需要借助 MappedStatement 类的属性 SqlCommandType 来进行判断，该类包含了所有的操作类型

public enum SqlCommandType {
  UNKNOWN, INSERT, UPDATE, DELETE, SELECT, FLUSH;
}

毕竟新增和修改的场景，有些参数是有区别的，比如创建时间和更新时间，update 时是无需兼顾创建时间字段的

MappedStatement ms = (MappedStatement) invocation.getArgs()[0];
SqlCommandType commandType = ms.getSqlCommandType(); 

三、示例

3.1、基础使用示例

增加拦截器类

@Intercepts({@Signature(type= Executor.class,method = "update",args = {MappedStatement.class,Object.class})})
public class ExamplePlugin implements Interceptor {
  public Object intercept(Invocation invocation) throws Throwable {
    return invocation.proceed();
  }
  public Object plugin(Object target) {
    return Plugin.wrap(target, this);
  }
  public void setProperties(Properties properties) {
  }
}

全局xml配置

<plugins>
    <plugin interceptor="com.github.bjlhx15.mybatis.interceptor.ExamplePlugin"></plugin>
</plugins>

　　说明：这个拦截器拦截Executor接口的update方法（其实也就是SqlSession的新增，删除，修改操作），所有执行executor的update方法都会被该拦截器拦截到。

2.2、统一给数据库字段属性赋值

1、普通实体类

public class BaseEntity {
    private int id;
    private int creator;
    private int updater;
    private Long createTime;
    private Long updateTime;
}

2、dao 操作使用了实体和参数的方式，

方式一、使用实体

int add(BaseEntity entity);

方式二、使用参数

int update(@Param("id") int id,@Param("creator") int creator, @Param("updateTime") long updateTime); 

3、拦截器开发

import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Plugin;
import org.apache.ibatis.plugin.Signature;import java.util.Map;
import java.util.Properties;

/**
 * 全局拦截数据库创建和更新
 * <p>
 * Signature 对应 Invocation 构造器, type 为 Invocation.Object, method 为 Invocation.Method, args 为 Invocation.Object[]
 * method 对应的 update 包括了最常用的 insert/update/delete 三种操作, 因此 update 本身无法直接判断sql为何种执行过程
 * args 包含了其余多有的操作信息, 按数组进行存储, 不同的拦截方式有不同的参数顺序, 具体看type接口的方法签名, 然后根据签名解析, 参见官网
 *
 * @link http://www.mybatis.org/mybatis-3/zh/configuration.html#plugins 插件
 * <p>
 * MappedStatement 包括了SQL具体操作类型, 需要通过该类型判断当前sql执行过程
 */
@Intercepts({
        @Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class})
})
@Slf4j
public class NormalPlugin implements Interceptor {

    @Override
    @SuppressWarnings("unchecked")
    public Object intercept(Invocation invocation) throws Throwable {
        // 根据签名指定的args顺序获取具体的实现类
        // 1. 获取MappedStatement实例, 并获取当前SQL命令类型
        MappedStatement ms = (MappedStatement) invocation.getArgs()[0];
        SqlCommandType commandType = ms.getSqlCommandType();

        // 2. 获取当前正在被操作的类, 有可能是Java Bean, 也可能是普通的操作对象, 比如普通的参数传递
        // 普通参数, 即是 @Param 包装或者原始 Map 对象, 普通参数会被 Mybatis 包装成 Map 对象
        // 即是 org.apache.ibatis.binding.MapperMethod$ParamMap
        Object parameter = invocation.getArgs()[1];
        // 获取拦截器指定的方法类型, 通常需要拦截 update
        String methodName = invocation.getMethod().getName();
        log.info("NormalPlugin, methodName; {}, commandType: {}", methodName, commandType);

        // 3. 获取当前用户信息
        UserEntity userEntity = UserUtil.getCurrentUser();

        if (parameter instanceof BaseEntity) {
            // 4. 实体类
            BaseEntity entity = (BaseEntity) parameter;

            if (methodName.equals("update")) {
                if (commandType.equals(SqlCommandType.INSERT)) {
                    entity.setCreator(userEntity.getUserName());
                    entity.setCreateTime(new Date());
                } else if (commandType.equals(SqlCommandType.UPDATE)) {
                    entity.setUpdater(userEntity.getUserName());
                    entity.setUpdateTime(new Date());
                }
            }
        } else if (parameter instanceof Map) {
            // 5. @Param 等包装类
            // 更新时指定某些字段的最新数据值
            if (commandType.equals(SqlCommandType.UPDATE)) {
                // 遍历参数类型, 检查目标参数值是否存在对象中, 该方式需要应用编写有一些统一的规范
                // 否则均统一为实体对象, 就免去该重复操作
                Map map = (Map) parameter;
                if (map.containsKey("creator")) {
                    map.put("creator", creator);
                }
                if (map.containsKey("updateTime")) {
                    map.put("updateTime", DateUtil.getTimeStamp());
                }
            }
        }
        // 6. 均不是需要被拦截的类型, 不做操作
        return invocation.proceed();
    }

    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {
    }
}

xml配置

2.3、实现Mybatis官方提供的拦截器，用于记录SQL语句的执行时间

package com.github.bjlhx15.mybatis;

/**
 * @author lihongxu
 * @since 2018/11/15 下午4:02
 */

import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.session.ResultHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.sql.Statement;
import java.util.Properties;

/**
 * Sql执行时间记录拦截器
 */
@Intercepts({@Signature(type = StatementHandler.class, method = "query", args = {Statement.class, ResultHandler.class}),
        @Signature(type = StatementHandler.class, method = "update", args = {Statement.class}),
        @Signature(type = StatementHandler.class, method = "batch", args = { Statement.class })})
public class SqlCostInterceptor implements Interceptor {
    Logger logger = LoggerFactory.getLogger(SqlCostInterceptor.class);

    @Override
    public Object intercept(Invocation invocation) throws Throwable {

        long startTime = System.currentTimeMillis();
        StatementHandler statementHandler = (StatementHandler) invocation.getTarget();
        final BoundSql boundSql = statementHandler.getBoundSql();
        try {
            return invocation.proceed();
        } finally {

            final StringBuilder build = new StringBuilder(7);
            build.append("\n");
            build.append("------------sql执行耗时计算开始---------------");
            build.append("\n");
            build.append("SQL:");
            build.append(boundSql.getSql());
            build.append("\n");
            build.append("MYBATIS-SQL执行耗时:[");
            build.append((System.currentTimeMillis() - startTime));
            build.append("ms]");
            build.append("\n");
            build.append("------------sql执行耗时计算结束---------------");
            logger.warn(build.toString());
        }
    }

    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {

    }
}

注：Interceptor接口是Mybatis官方提供的拦截接口，创建一个类实现该接口并重写其三个方法并将该类配置在Mybatis的配置文件中，即可拦截SQL语句的执行过程

手动编写执行的配置文件

<?xml version="1.0"  encoding="UTF-8"  ?>
<!DOCTYPE configuration PUBLIC  "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>

    <settings>
        <setting name="cacheEnabled" value="false" />
        <setting name="lazyLoadingEnabled" value="false" />
        <setting name="multipleResultSetsEnabled" value="true" />
        <setting name="useColumnLabel" value="true" />
        <setting name="useGeneratedKeys" value="false" />
        <setting name="defaultExecutorType" value="SIMPLE" />
        <setting name="defaultStatementTimeout" value="30" />
        <!--<setting name="logImpl" value="LOG4J2" />-->
    </settings>
    <plugins>
        <!-- 拦截器配置 -->
        <plugin interceptor="com.github.bjlhx15.mybatis.SqlCostInterceptor" />
    </plugins>

</configuration>