关于mybatis:从零开始手写-mybatis二mybatis-interceptor-插件机制详解

3次阅读

共计 11525 个字符，预计需要花费 29 分钟才能阅读完成。

第一节从零开始手写 mybatis（一）MVP 版本中咱们实现了一个最根本的能够运行的 mybatis。

常言道，万事开头难，而后两头难。

mybatis 的插件机制是 mybatis 除却动静代理之外的第二大灵魂。

上面咱们一起来体验一下这乏味的灵魂带来的苦楚与高兴~

在理论开发过程中, 咱们常常应用的 Mybaits 插件就是分页插件了，通过分页插件咱们能够在不必写 count 语句和 limit 的状况下就能够获取分页后的数据, 给咱们开发带来很大

的便当。除了分页，插件应用场景次要还有更新数据库的通用字段，分库分表，加解密等的解决。

这篇博客次要讲 Mybatis 插件原理, 下一篇博客会设计一个 Mybatis 插件实现的性能就是每当新增数据的时候不必数据库自增 ID 而是通过该插件生成雪花 ID, 作为每条数据的主键。

Mybatis 的插件其实就是个拦截器性能。它利用 JDK 动静代理和责任链设计模式的综合使用。采纳责任链模式，通过动静代理组织多个拦截器, 通过这些拦截器你能够做一些你想做的事。

所以在讲 Mybatis 拦截器之前咱们先说说 JDK 动静代理 + 责任链设计模式。

package com.github.houbb.mybatis.plugin;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class JdkDynamicProxy {

    /**
     * 一个接口
     */
    public interface HelloService{void sayHello();
    }

    /**
     * 指标类实现接口
     */
    static class HelloServiceImpl implements HelloService{

        @Override
        public void sayHello() {System.out.println("sayHello......");
        }

    }

    /**
     * 自定义代理类须要实现 InvocationHandler 接口
     */
    static  class HelloInvocationHandler implements InvocationHandler {

        private Object target;

        public HelloInvocationHandler(Object target){this.target = target;}

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("------ 插入前置告诉代码 -------------");
            // 执行相应的指标办法
            Object rs = method.invoke(target,args);
            System.out.println("------ 插入后置解决代码 -------------");
            return rs;
        }

        public static Object wrap(Object target) {return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                    target.getClass().getInterfaces(),new HelloInvocationHandler(target));
        }
    }

    public static void main(String[] args)  {HelloService proxyService = (HelloService) HelloInvocationHandler.wrap(new HelloServiceImpl());
        proxyService.sayHello();}

}

输入

------ 插入前置告诉代码 -------------
sayHello......
------ 插入后置解决代码 -------------

下面代理的性能是实现了, 然而有个很显著的缺点，就是 HelloInvocationHandler 是动静代理类，也能够了解成是个工具类，咱们不可能会把业务代码写到写到到 invoke 办法里，

不合乎面向对象的思维，能够形象一下解决。

能够设计一个 Interceptor 接口，须要做什么拦挡解决实现接口就行了。

public interface Interceptor {

    /**
     * 具体拦挡解决
     */
    void intercept();}

public class LogInterceptor implements Interceptor{

    @Override
    public void intercept() {System.out.println("------ 插入前置告诉代码 -------------");
    }

}

和

public class TransactionInterceptor implements Interceptor{

    @Override
    public void intercept() {System.out.println("------ 插入后置解决代码 -------------");
    }

}

public class InterfaceProxy implements InvocationHandler {

    private Object target;

    private List<Interceptor> interceptorList = new ArrayList<>();

    public InterfaceProxy(Object target, List<Interceptor> interceptorList) {
        this.target = target;
        this.interceptorList = interceptorList;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 解决多个拦截器
        for (Interceptor interceptor : interceptorList) {interceptor.intercept();
        }
        return method.invoke(target, args);
    }

    public static Object wrap(Object target, List<Interceptor> interceptorList) {InterfaceProxy targetProxy = new InterfaceProxy(target, interceptorList);
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), targetProxy);
    }

    

}

public static void main(String[] args) {List<Interceptor> interceptorList = new ArrayList<>();
    interceptorList.add(new LogInterceptor());
    interceptorList.add(new TransactionInterceptor());

    HelloService target = new HelloServiceImpl();
    HelloService targetProxy = (HelloService) InterfaceProxy.wrap(target, interceptorList);
    targetProxy.sayHello();}

日志

------ 插入前置告诉代码 -------------
------ 插入后置解决代码 -------------
sayHello......

这里有一个很显著的问题，所有的拦挡都在办法执行前被解决了。

下面的动静代理的确能够把代理类中的业务逻辑抽离进去，然而咱们留神到，只有前置代理，无奈做到前后代理，所以还须要在优化下。

所以须要做更一步的形象，

把拦挡对象信息进行封装，作为拦截器拦挡办法的参数，把拦挡指标对象真正的执行办法放到 Interceptor 中实现，这样就能够实现前后拦挡，并且还能对拦挡对象的参数等做批改。

设计一个 Invocation 对象。

public class Invocation {

    /**
     * 指标对象
     */
    private Object target;
    /**
     * 执行的办法
     */
    private Method method;
    /**
     * 办法的参数
     */
    private Object[] args;

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

    /**
     * 执行指标对象的办法
     */
    public Object process() throws Exception{return method.invoke(target,args);
    }

    // 省略 Getter/Setter

}

Interceptor.java

public interface Interceptor {

    /**
     * 具体拦挡解决
     */
    Object intercept(Invocation invocation) throws Exception;

}

日志实现

public class MyLogInterceptor implements Interceptor {

    @Override
    public Object intercept(Invocation invocation) throws Exception {System.out.println("------ 插入前置告诉代码 -------------");
        Object result = invocation.process();
        System.out.println("------ 插入后置解决代码 -------------");
        return result;
    }

}

public class MyInvocationHandler implements InvocationHandler {

    private Object target;

    private Interceptor interceptor;

    public MyInvocationHandler(Object target, Interceptor interceptor) {
        this.target = target;
        this.interceptor = interceptor;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {Invocation invocation = new Invocation(target, method, args);
        // 返回的仍然是代理类的后果
        return interceptor.intercept(invocation);
    }

    public static Object wrap(Object target, Interceptor interceptor) {MyInvocationHandler targetProxy = new MyInvocationHandler(target, interceptor);
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                targetProxy);
    }

}

最外围的就在于构建了 invocation，而后执行对应的办法。

代码

public static void main(String[] args) {HelloService target = new HelloServiceImpl();
    Interceptor interceptor = new MyLogInterceptor();
    HelloService targetProxy = (HelloService) MyInvocationHandler.wrap(target, interceptor);
    targetProxy.sayHello();}

日志

------ 插入前置告诉代码 -------------
sayHello......
------ 插入后置解决代码 -------------

下面这样就能实现前后拦挡，并且拦截器能获取拦挡对象信息。

然而测试代码的这样调用看着很顺当，对应指标类来说，只须要理解对他插入了什么拦挡就好。

再批改一下，在拦截器减少一个插入指标类的办法。

public interface Interceptor {

    /**
     * 具体拦挡解决
     *
     * @return 办法执行的后果
     * @since 0.0.2
     */
    Object intercept(Invocation invocation) throws Exception;

    /**
     * 插入指标类
     *
     * @return 代理
     * @since 0.0.2
     */
    Object plugin(Object target);

}

能够了解为把静态方法调整为对象办法。

public class MyLogInterceptor implements Interceptor {

    @Override
    public Object intercept(Invocation invocation) throws Exception {System.out.println("------ 插入前置告诉代码 -------------");
        Object result = invocation.process();
        System.out.println("------ 插入后置解决代码 -------------");
        return result;
    }

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

}

代码

public static void main(String[] args) {HelloService target = new HelloServiceImpl();
    Interceptor interceptor = new MyLogInterceptor();
    HelloService targetProxy = (HelloService) interceptor.plugin(target);
    targetProxy.sayHello();}

日志

------ 插入前置告诉代码 -------------
sayHello......
------ 插入后置解决代码 -------------

public static void main(String[] args) {HelloService target = new HelloServiceImpl();
    //1. 拦截器 1
    Interceptor interceptor = new MyLogInterceptor();
    target = (HelloService) interceptor.plugin(target);
    //2. 拦截器 2
    Interceptor interceptor2 = new MyTransactionInterceptor();
    target = (HelloService) interceptor2.plugin(target);
    // 调用
    target.sayHello();}

其中 MyTransactionInterceptor 实现如下：

public class MyTransactionInterceptor implements Interceptor {

    @Override
    public Object intercept(Invocation invocation) throws Exception {System.out.println("------tx start-------------");
        Object result = invocation.process();
        System.out.println("------tx end-------------");
        return result;
    }

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

}

日志如下：

------tx start-------------
------ 插入前置告诉代码 -------------
sayHello......
------ 插入后置解决代码 -------------
------tx end-------------

当然很多小伙伴看到这里其实曾经想到应用责任链模式，上面咱们一起来看一下责任链模式。

public class InterceptorChain {private List<Interceptor> interceptorList = new ArrayList<>();

    /**
     * 插入所有拦截器
     */
    public Object pluginAll(Object target) {for (Interceptor interceptor : interceptorList) {target = interceptor.plugin(target);
        }
        return target;
    }

    public void addInterceptor(Interceptor interceptor) {interceptorList.add(interceptor);
    }
    /**
     * 返回一个不可批改汇合，只能通过 addInterceptor 办法增加
     * 这样控制权就在本人手里
     */
    public List<Interceptor> getInterceptorList() {return Collections.unmodifiableList(interceptorList);
    }
}

public static void main(String[] args) {HelloService target = new HelloServiceImpl();

    Interceptor interceptor = new MyLogInterceptor();
    Interceptor interceptor2 = new MyTransactionInterceptor();
    InterceptorChain chain = new InterceptorChain();
    chain.addInterceptor(interceptor);
    chain.addInterceptor(interceptor2);

    target = (HelloService) chain.pluginAll(target);
    // 调用
    target.sayHello();}

日志

------tx start-------------
------ 插入前置告诉代码 -------------
sayHello......
------ 插入后置解决代码 -------------
------tx end-------------

实际上个人感觉这里能够换一种角度，比方定义拦截器接口时，改为：

这样能够代码中能够不必写执行的局部，实现起来更加简略，也不会遗记。

public interface Interceptor {

    /**
     * 具体拦挡解决
     */
    void before(Invocation invacation);

    /**
     * 具体拦挡解决
     */
    void after(Invocation invacation);

}

不过这样也有一个毛病，那就是对于 process 执行的局部不可见，丢失了一部分灵活性。

对于 plugin() 这个办法，实际上实现十分固定。

应该对于接口不可见，间接放在 chain 中对立解决即可。

说了这么多，如果你了解之后，那么接下来的插件实现局部就是小菜一碟。

只是将下面的思维做一个简略的实现而已。

引入插件，其余局部省略。

<plugins>
    <plugin interceptor="com.github.houbb.mybatis.plugin.SimpleLogInterceptor"/>
</plugins>

咱们就是简略的输入一下入参和出参。

public class SimpleLogInterceptor implements Interceptor{
    @Override
    public void before(Invocation invocation) {System.out.println("----param:" + Arrays.toString(invocation.getArgs()));
    }

    @Override
    public void after(Invocation invocation, Object result) {System.out.println("----result:" + result);
    }

}

输入日志如下。

----param: [com.github.houbb.mybatis.config.impl.XmlConfig@3b76982e, MapperMethod{type='select', sql='select * from user where id = ?', methodName='selectById', resultType=class com.github.houbb.mybatis.domain.User, paramType=class java.lang.Long}, [Ljava.lang.Object;@67011281]
----result: User{id=1, name='luna', password='123456'}
User{id=1, name='luna', password='123456'}

是不是灰常的简略，那么是怎么实现的呢？

public interface Interceptor {

    /**
     * 前置拦挡
     * @param invocation 上下文
     * @since 0.0.2
     */
    void before(Invocation invocation);

    /**
     * 后置拦挡
     * @param invocation 上下文
     * @param result 执行后果
     * @since 0.0.2
     */
    void after(Invocation invocation, Object result);

}

在 openSession() 的时候，咱们启动插件：

public SqlSession openSession() {Executor executor = new SimpleExecutor();
    //1. 插件
    InterceptorChain interceptorChain = new InterceptorChain();
    List<Interceptor> interceptors = config.getInterceptorList();
    interceptorChain.add(interceptors);
    executor = (Executor) interceptorChain.pluginAll(executor);

    //2. 创立
    return new DefaultSqlSession(config, executor);
}

这里咱们就看到了一个责任链，实现如下。

public class InterceptorChain {

    /**
     * 拦截器列表
     * @since 0.0.2
     */
    private final List<Interceptor> interceptorList = new ArrayList<>();

    /**
     * 增加拦截器
     * @param interceptor 拦截器
     * @return this
     * @since 0.0.2
     */
    public synchronized InterceptorChain add(Interceptor interceptor) {interceptorList.add(interceptor);

        return this;
    }

    /**
     * 增加拦截器
     * @param interceptorList 拦截器列表
     * @return this
     * @since 0.0.2
     */
    public synchronized InterceptorChain add(List<Interceptor> interceptorList) {for(Interceptor interceptor : interceptorList) {this.add(interceptor);
        }

        return this;
    }

    /**
     * 代理所有
     * @param target 指标类
     * @return 后果
     * @since 0.0.2
     */
    public Object pluginAll(Object target) {for(Interceptor interceptor : interceptorList) {target = DefaultInvocationHandler.proxy(target, interceptor);
        }

        return target;
    }

}

其中的 DefaultInvocationHandler 实现如下：

/**
 * 默认的代理实现
 * @since 0.0.2
 */
public class DefaultInvocationHandler implements InvocationHandler {

    /**
     * 代理类
     * @since 0.0.2
     */
    private final Object target;

    /**
     * 拦截器
     * @since 0.0.2
     */
    private final Interceptor interceptor;

    public DefaultInvocationHandler(Object target, Interceptor interceptor) {
        this.target = target;
        this.interceptor = interceptor;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {Invocation invocation = new Invocation(target, method, args);

        interceptor.before(invocation);

        // invoke
        Object result = method.invoke(target, args);

        interceptor.after(invocation, result);

        return result;
    }

    /**
     * 构建代理
     * @param target 指标对象
     * @param interceptor 拦截器
     * @return 代理
     * @since 0.0.2
     */
    public static Object proxy(Object target, Interceptor interceptor) {DefaultInvocationHandler targetProxy = new DefaultInvocationHandler(target, interceptor);
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                targetProxy);
    }

}

本节的实现并不难，难在要了解 mybatis 整体对于插件的设计理念，技术层面还是动静代理，联合了责任链的设计模式。

这种套路学会之后，其实很多相似的框架，咱们本人在实现的时候都能够借鉴这种思维。

从零开始手写 mybatis（一）MVP 版本

Mybatis 框架 (8)—Mybatis 插件原理 (代理 + 责任链)

正文完

mybatis

发表至： mybatis

2020-07-18

0

关于mybatis:聊聊mybatis的ParamNameResolver

关于mybatis:Mybits环境搭建

关于mybatis:mybatis之脚本解析器

关于mybatis:从零开始实现一个MyBatis加解密插件

关于java:JavaSE第05篇Java基础语法之数组方法

关于mybatis:从零开始手写-mybatis二mybatis-interceptor-插件机制详解

前景回顾

插件的作用

JDK 动静代理 + 责任链设计模式

JDK 动静代理案例

优化 1：面向对象

定义接口

实现接口

实现代理

测试验证

优化 2：灵便指定前后

实现思路

代理类上下文

调整接口

从新实现代理类

测试

优化 3：划清界限

实现

接口调整

实现调整

测试

责任链模式

多个拦截器如何解决?

测试代码

责任链模式

责任链模式

测试

集体的思考

拦截器是否能够改良？

形象实现

手写 mybatis 引入插件

疾速体验

config.xml

SimpleLogInterceptor.java

执行测试方法

外围实现

接口定义

启动插件

责任链

小结

拓展浏览

参考资料

站内搜索