细品mybatis源码系列（四）：Mybatis的插件分析

前言

本文将介绍一下mybatis的插件思想

插件介绍

如果读者熟练使用mybatis的话，应该都会接触过mybatis不少插件，比如最常见的pagehelper分页插件，插件就是开源框架提供的拓展点，方便开发者根据自己的需求进行功能拓展。

mybatis的四大组件Executor，StatementHandler，ParameterHandler，ResultSetHandler都提供了插件拓展功能

mybatis支持插件对四大对象进行拦截和增强，相当于拦截器，其实现借助于底层的动态代理。

mybatis允许插件拦截的方法

• 执行器Executor的update，query， commit，rollback方法
• sql语法构建器StatementHandler的prepare，parameterize，batch，update，query等方法
• 参数处理器ParameterHandler的getParameterObject，setParameters方法
• 结果集处理器ResultSetHandler的handleResultSets，handleOutputParameters等方法

插件实现原理

在四大对象创建的时候：

• 每个创建出来的对象不是直接返回的，而是interceptorChain.pluginAll(parameterHandler)处理后
• 获取到所有Interceptor拦截器，即插件需要实现的接口，调用interceptor.plugin(target)返回一个target对象
• 插件机制，为每一个目标对象都生成代理对象。即aop，创建出来的代理对象可以拦截到四大对象的每个执行

插件的拦截代码，举例如ParameterHandler讲

    // 创建 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;
    }

追进拦截器链中interceptorChain.pluginAll方法

   /**
     * 拦截器数组
     */
    private final List<Interceptor> interceptors = new ArrayList<>();

    /**
     * 应用所有插件
     *
     * @param target 目标对象
     * @return 应用结果
     */
    public Object pluginAll(Object target) {
        for (Interceptor interceptor : interceptors) {
            target = interceptor.plugin(target);
        }
        return target;
    }

interceptorChain保存了所有的拦截器，而拦截器是在mybatis初始化的时候就已创建好了。interceptor.plugin(target) 中的target即四大对象，循环执行拦截器链中的增强方法，返回一个新的已增强的target代理对象。
深追interceptor.plugin(target) 最终就是jdk动态代理

 @Override
        public Object plugin(Object target) {
            return Plugin.wrap(target, this);
        }
  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;
    }

熟悉jdk动态代理的读者知道Plugin实现了InvocationHandler接口，因此它的invoker方法会对拦截的方法进行检查，判断是否需要进行插件增强

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

可知，invoke会检测被拦截方法是否在配置插件中的@Signature 注解中，是的话执行插件逻辑，否则就执行源方法。插件的逻辑都封装在intercept中，方法入参为Invocation，这个类主要存储目标类，方法及方法参列表。

public class Invocation {

    /**
     * 目标对象
     */
    private final Object target;
    /**
     * 方法对象
     */
    private final Method method;
    /**
     * 方法参数数组
     */
    private final Object[] args;

    public Invocation(Object target, Method method, Object[] args) {
        this.target = target;
        this.method = method;
        this.args = args;
    }

    public Object getTarget() {
        return target;
    }

    public Method getMethod() {
        return method;
    }

    public Object[] getArgs() {
        return args;
    }

    /**
     * 调用方法
     *
     * @return 调用结果
     */
    public Object proceed() throws InvocationTargetException, IllegalAccessException {
        return method.invoke(target, args);
    }

}

自定义插件

上文讲到了插件的执原理，就稍微提下如何自定义插件

step1 新建自定义插件类

@Intercepts({//可以定义多个@Signature对多个地方拦截，都用这个拦截器
@Signature(type = StatementHandler.class,//拦截哪个接口
method = "prepare",//接口内的方法名
args = { Connection.class, Integer.class}),//拦截方法的入参，遵循源方法顺序
})
public class MyPlugin implements Interceptor {
private final Logger logger = LoggerFactory.getLogger(this.getClass());
// 每次被拦截到的方法都会进入到这个增强方法
@Override
public Object intercept(Invocation invocation) throws Throwable {
//增强逻辑
System.out.println("对方法进行增强....");
return invocation.proceed(); //执行源方法
}
/**
* // 把拦截器生成一个代理放入到拦截器链中
* @Description 包装目标对象，为目标对象创建代理对象
* @Param target为要拦截的对象
* @Return 代理对象
*/
@Override
public Object plugin(Object target) {
System.out.println("将要包装的对象"+target);
return Plugin.wrap(target,this);
}
/** 获取配置文件的属性 **/
// 插件初始化的时候调用，只调用一次，插件配置的属性从这里设置进来
@Override
public void setProperties(Properties properties) {
System.out.println("插件配置的初始化参数"+properties);
}
}

step2 修改全局配置文件

修改全局配置文件sqlMapConfig.xml，显示声明自定义的插件

<plugins>
<plugin interceptor="com.plugin.MySqlPagingPlugin">
<!--配置参数-->
<property name="name" value="Bob"/>
</plugin>
</plugins>

至此自定义插件就到此结束了

总结

本文从代码层面介绍了mybatis的插件思想和实现原理