Mybatis插件

Mybatis工作流程：

Mybatis工作流程及其原理与解析_青元子的博客-CSDN博客_mybatis流程

Mybatis对持久层的操作主要借助于四大核心对象(Executor、 StatementHandler、ParameterHandler、 ResultSetHandler)。

Executor是sql执行器，insert、update、query、commit、rollback等方法，负责调用StatementHandler操作数据库；StatementHandler是直接和数据库执行sql脚本的对象，负责创建Statement的处理器，也实现了Mybatis的一级缓存；ParameterHandler是实现Sql入参设置的对象，PreparedStatemet接口的参数化处理；ResultSetHandler是把ResultSet集合映射成POJO的接口对象。

Mybatis插件又称为拦截器，通过对四大核心对象进行拦截，增强核心对象的功能。比如实现分页、分表，监控等功能。

插件实现原理

其中Configuration中维护了四大对象的创建方法：

    // 创建 Executor 对象
    public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
        // 获得执行器类型
        executorType = executorType == null ? defaultExecutorType : executorType; // 使用默认
        executorType = executorType == null ? ExecutorType.SIMPLE : executorType; // 使用 ExecutorType.SIMPLE
        // 创建对应实现的 Executor 对象
        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);
        }
        // 如果开启缓存，创建 CachingExecutor 对象，进行包装
        if (cacheEnabled) {
            executor = new CachingExecutor(executor);
        }
        // 应用插件
        executor = (Executor) interceptorChain.pluginAll(executor);
        return executor;
    }
    
    // 创建 StatementHandler 对象
    public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
        // 创建 RoutingStatementHandler 对象
        StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
        // 应用插件
        statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
        return statementHandler;
    }

    // 创建 ParameterHandler 对象
    public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
        // 创建 ParameterHandler 对象
        ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
        // 应用插件
        parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
        return parameterHandler;
    }


    // 创建 ResultSetHandler 对象
    public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler,
                                                ResultHandler resultHandler, BoundSql boundSql) {
        // 创建 DefaultResultSetHandler 对象
        ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);
        // 应用插件
        resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
        return resultSetHandler;
    }

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

可以看到在每个对象创建后，会调用InterceptorChain.pluginAll(Object target)，遍历拦截器应用Interceptor的plugin方法，返回封装后的代理对象，此处属于责任链模式。

 拦截器Interceptor接口

public interface Interceptor {
    Object intercept(Invocation var1) throws Throwable;

    Object plugin(Object var1);

    void setProperties(Properties var1);
}

--intercept方法 ：拦截器核心方法；

--plugin方法的官方实现：Plugin.wrap(target, this)；

--setProperties插件所需参数；

Plugin的wrap方法：获取拦截器的拦截的方法映射；获取目标类的接口集合，创建代理对象；

public static Object wrap(Object target, Interceptor interceptor) {
        // 获得拦截的方法映射
        Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
        // 获得目标类的类型
        Class<?> type = target.getClass();
        // 获得目标类的接口集合
        Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
        // 若有接口，则创建目标对象的 JDK Proxy 对象
        if (interfaces.length > 0) {
            return Proxy.newProxyInstance(
                    type.getClassLoader(),
                    interfaces,
                    new Plugin(target, interceptor, signatureMap)); // 因为 Plugin 实现了 InvocationHandler 接口，所以可以作为 JDK 动态代理的调用处理器
        }
        // 如果没有，则返回原始的目标对象
        return target;
    }

同时Plugin实现了InvocationHandler，

invoke方法：判断目标方法是否是拦截方法，是则调用拦截逻辑处理；

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);
        }
    }

总结：

插件的原理：对象创建的时候会遍历对应拦截器，生成包装了拦截器的代理对象；当执行目标对象的目标方法时，调用的是代理对象Plugin的invoke方法：调用拦截器的intercept核心方法处理。

自定义插件

实现Interceptor接口；并声明拦截对象和方法；注册拦截器；

@Intercepts({@Signature (type = StatementHandler .class , method = "prepare"， 
args = { Connection.class, Integer.class})})
public class ExamplePlugin implements Interceptor {
  private Properties properties;
  @Override
  public Object intercept(Invocation invocation) throws Throwable {
    // 拦截器逻辑
    return invocation.proceed();
  }

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

  @Override
  public void setProperties(Properties properties) {
    this.properties = properties;
  }

  public Properties getProperties() {
    return properties;
  }

}