MyBatis | MyBatis中使用插件、使用PageInterceptor插件、自定义类型处理器

一、插件原理

在四大对象创建的时候，有以下几个特性：

• 每个创建出来的对象不是直接返回的，而是interceptorChain.pluginAll(parameterHandler);
• 该方法获取到所有的Interceptor（插件需要实现的接口），调用interceptor.plugin(target);返回target包装后的对象。

    public Object pluginAll(Object target) {
        Interceptor interceptor;
        for(Iterator var2 = this.interceptors.iterator(); var2.hasNext(); target = interceptor.plugin(target)) {
            interceptor = (Interceptor)var2.next();
        }

        return target;
    }

因此，我们可以使用插件为目标对象创建一个代理对象，类似于AOP（面向切面编程）。我们的插件可以为四大对象创建出代理对象，代理对象就可以拦截到四大对象中每一个的执行。

---

二、插件编写（单个插件）

1、编写Interceptor的实现类

package com.cerr.dao;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.plugin.*;
import java.util.Properties;
public class MyFirstPlugin implements Interceptor {

    //拦截目标对象的目标方法的执行
    public Object intercept(Invocation invocation) throws Throwable {
        System.out.println("intercept..."+invocation);
        //执行目标方法
        Object proceed = invocation.proceed();
        //返回执行后的返回值
        return proceed;
    }

    //包装目标对象，为目标对象创建一个代理对象
    public Object plugin(Object target) {
        System.out.println("plugin..."+target);
        //借助这个方法来使用当前Interceptor包装我们目标对象
        Object wrap = Plugin.wrap(target,this);
        //返回当前target创建的动态代理对象
        return wrap;
    }

    //将插件注册时的property属性设置进去
    public void setProperties(Properties properties) {
        System.out.println("插件配置的信息"+properties);

    }
}

2、使用@Intercepts注解完成插件的签名

在编写的插件类上标注@Intercepts，标注后的插件类如下：

package com.cerr.dao;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.plugin.*;
import java.util.Properties;

//完成插件签名：告诉MyBatis当前插件来用拦截哪个对象的哪个方法
@Intercepts({
        @Signature(type = StatementHandler.class,method = "parameterize",
            args = java.sql.Statement.class)
})
public class MyFirstPlugin implements Interceptor {

    //拦截目标对象的目标方法的执行
    public Object intercept(Invocation invocation) throws Throwable {
        System.out.println("intercept..."+invocation);
        //执行目标方法
        Object proceed = invocation.proceed();
        //返回执行后的返回值
        return proceed;
    }

    //包装目标对象，为目标对象创建一个代理对象
    public Object plugin(Object target) {
        System.out.println("plugin..."+target);
        //借助这个方法来使用当前Interceptor包装我们目标对象
        Object wrap = Plugin.wrap(target,this);
        //返回当前target创建的动态代理对象
        return wrap;
    }

    //将插件注册时的property属性设置进去
    public void setProperties(Properties properties) {
        System.out.println("插件配置的信息"+properties);

    }
}

3、将写好的插件注册到全局配置文件中

在全局配置文件中使用标签来注册：

此时我们就定义了一个拦截StatementHandler对象的parameterize方法的拦截器。

---

三、多个插件时的执行顺序

我们再编写一个插件类MySecondPlugin，也是和上面的插件类一样拦截的同一个对象的同一个方法。代码如下：

package com.cerr.dao;

import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.plugin.*;

import java.util.Properties;
@Intercepts({
        @Signature(type = StatementHandler.class,method = "parameterize",
                args = java.sql.Statement.class)
})
public class MySecondPlugin implements Interceptor {
    public Object intercept(Invocation invocation) throws Throwable {
        System.out.println("MySecondPlugin..intercept:"+invocation);
        return invocation.proceed();
    }

    public Object plugin(Object target) {
        System.out.println("MySecondPlugin...plugin:"+target);
        return Plugin.wrap(target,this);
    }

    public void setProperties(Properties properties) {
    }
}

在全局配置文件中配置：

配置后我们随便找一个测试方法运行，例如：

    @Test
    public void testSimple() throws IOException {
        SqlSessionFactory factory = getSqlSessionFactory();
        SqlSession session = factory.openSession();
        try{
            EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
            List< Employee > list = mapper.selectByExample(null);
        }finally {
            session.close();
        }
    }

结果如图1所示：

图1：控制台结果

从上图可以看出，在生成代理对象时，是先创建第一个插件类的代理对象，再创建第二个插件类的代理对象；但是在拦截目标方法的时候，则是先执行第二个插件类，再执行第一个插件类。

因此我们可以得出以下结论：创建动态代理的时候，是按照插件配置的顺序层层创建代理对象的。执行目标方法的时候，按照逆序顺序执行。

我们可以将该过程类比为如下的模型，首先创建的StatementHandler，然后再创建MyFirstPlugin代理对象，然后再创建了MySecondPlugin代理对象，其三者的关系是晚创建的包含早创建的，在执行目标方法的时候自然而然是从外向里执行。

图2：动态代理模型

---

四、使用PageInterceptor插件

1、导包

需要两个包，可以在GitHub上面下载：点此下载

图3：下载这两个jar包

2、在全局配置文件中注册PageInterceptor插件

3、编码

可以使用Page对象：

    @Test
    public void test() throws IOException {
        SqlSessionFactory factory = getSqlSessionFactory();
        SqlSession session = factory.openSession();
        try{
            EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
            //第一个参数是页码，第二个是每页的记录数
            Page