互联网轻量级框架SSM-查缺补漏第八天（MyBatis插件plugin使用及原理）

　　简言：今天进行第八天的记录（只是写了八天）。有的时候看的多，有的时候看的少，看的少的时候就攒几天一起写了。而今天这个插件我昨天写了一下午，下班没写完就回去了，今天把尾收了，再加上一个过程图方便下面原理的理解。我这个特别不爱看书的人都看半个多月了，希望我一个月真能养成个戒不掉的习惯~

第八章 插件

　　在前一篇介绍了四个对象，是sqlsession执行过程中通过他们来完成数据库操作和结果返回的。（executor、statementhandler、parameterhandler、resultsethandler）。我昨天的查缺补漏有记载，要是想深入了解就可以去查资料了，或者看我这本书的第七章（书名《javaee 互联网轻量级框架整合开发》）

　　插件的原理就是在四大对象调度时插入我们的代码去执行一些特殊的要求以满足特殊的场景需求。

　　斜体字是部分原理。我先在这插入一张流程图，如果有疑问可以看到最后再返回来琢磨一下这个图。

 

　　使用方法：（举例：要想在预编译之前在控制台上打印一些东西，就需要拦截执行sql的statementhandler对象的预编译方法，也就是prepare方法）

　　在mybatis中使用插件，就必须实现interceptor接口，实现它的三个方法（代码中有注释，应该能知道啥意思）：

package com.ssm.chapter8.plugin;
import java.sql.connection;
import java.util.properties;

import org.apache.ibatis.executor.statement.statementhandler;
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 org.apache.ibatis.reflection.metaobject;
import org.apache.ibatis.reflection.systemmetaobject;
import org.apache.log4j.logger;

@intercepts({
    @signature(
            type=statementhandler.class,
            method="prepare",
            args = {connection.class,integer.class}
            )
})
public class myplugin implements interceptor {
    private logger log = logger.getlogger(myplugin.class);
    private properties props = null;
    /**
     * 插件方法，它代替statementhandler的prepare方法
     * 
     * @param invocation 入参
     * @return 返回预编译后的preparedstatement
     * @throws throwable 异常
     * */
    @override
    public object intercept(invocation invocation) throws throwable {
        statementhandler statementhandler = (statementhandler)invocation.gettarget();
        //进行绑定
        metaobject metastatementhandler = systemmetaobject.forobject(statementhandler);
        object object = null;
        /*分离代理对象链(由于目标类可能被多个拦截器[插件]拦截，从而形成多次代理，通过循环可以分离出最原始的目标类)*/
        while(metastatementhandler.hasgetter("h")){
            object = metastatementhandler.getvalue("h");
            metastatementhandler = systemmetaobject.forobject(object);
        }
        statementhandler = (statementhandler)object;
        string sql = (string)metastatementhandler.getvalue("delegate.boundsql.sql");
        long parameterobject = (long)metastatementhandler.getvalue("delegate.boundsql.parameterobject");
        
        log.info("执行的sql：【"+sql+"】");
        log.info("参数：【"+parameterobject+"】");
        log.info("before......");
        //如果当前代理的事一个非代理对象，那么它就会回调用真实拦截对象的方法
        //如果不是，那么它就会调度下一个插件代理对象的invoke方法
        object obj = invocation.proceed();
        log.info("after......");
        return obj;
    }
    /**
     * 生成代理对象
     * 
     * @param target 被拦截对象
     * @return 代理对象
     * */
    public object plugin(object target) {
        // 采用系统默认的plugin.wrap方法生成
        return plugin.wrap(target, this);
    }
    /**
     * 设置参数，mybatis初始化时，就会生成插件实例，并调用这个方法
     * 
     * @param props 配置参数
     * */
    public void setproperties(properties props) {
        this.props = props;
        log.info("dbtype = "+this.props.getproperty("dbtype"));
        
    }
}

　　标黄的三个就是要去实现的方法：

• intercept：英译：拦截。简单说就是拦截签名（指类名上面的注解@signature）中对应类中对应方法。参数invocation就是被拦截内容的整合。
• plugin：英译：插件（计算机名词）。target是被拦截的对象
• setproperties：设置参数。这个参数是要在xml配置中配置的。

　　注解@intercepts说明它是一个拦截器。@singnature是注册拦截器签名的地方，只有签名满足要求才能拦截，type可以是四大对象中的一个，这里是statementhandler。method代表要拦截四大对象的某一接口方法，而args则表示该方法的参数（要根据拦截对象的方法进行拦截。）下面贴一段statementhandler中prepare方法的定义代码。

public abstract statement prepare(connection connection, integer integer) throws sqlexception;

　　所以args中是一个connection.class和 integer.class。拦截后，通过 invocation对象可以反射调度原来对象的方法。贴一段 invocation的源代码。

public class invocation {

    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;
    }
    public object proceed() throws invocationtargetexception, illegalaccessexception {
        return method.invoke(target, args);
    }
    private final object target;
    private final method method;
    private final object args[];
}

　　一看就知道 target是被拦截的目标对象，method是被拦截的方法，args就是注解中的参数，这里的proceed方法是通过反射调用原对象中的方法。

　　配置xml：注意mybatis配置xml中标签的顺序。

<plugins><!-- 插件 -->
    <plugin interceptor="com.ssm.chapter8.plugin.myplugin">
        <property name="dbtype" value="mysql"/>
    </plugin>
</plugins>

　　我使用的查询配置：

<select id="getrole" parametertype="long" resulttype="role">
    select id,role_name as rolename,note from t_role where id = #{id}
</select>

　　执行结果：

debug - reader entry: <?xml version="1.0" encoding="utf-8"?>
debug - checking to see if class com.learn.ssm.chapter3.mapper.rolemapper matches criteria [is assignable to object]
debug - cache hit ratio [com.learn.ssm.chapter3.mapper.rolemapper]: 0.0
debug - opening jdbc connection
debug - created connection 407858146.
debug - setting autocommit to false on jdbc connection [com.mysql.jdbc.jdbc4connection@184f6be2]
 info - 执行的sql：【select id,role_name as rolename,note from t_role where id = ?】
 info - 参数：【1】
 info - before......
debug - ==>  preparing: select id,role_name as rolename,note from t_role where id = ? 
 info - after......
debug - ==> parameters: 1(long)
debug - <==      total: 1
debug - resetting autocommit to true on jdbc connection [com.mysql.jdbc.jdbc4connection@184f6be2]
debug - closing jdbc connection [com.mysql.jdbc.jdbc4connection@184f6be2]
debug - returned connection 407858146 to pool.

　　标红为intercept方法中log.info打印的东西。在before和after中间可以清晰看出，进行了预编译，也就是调用了原有的prepare。

　　总结：

　　梳理一下思路，在介绍一下没提到的部分原理：

　　按照程序的进行，在构建configuration的时候，插件对象被创建。下面是xmlconfigbuilder部分代码。

private void parseconfiguration(xnode root) {
     try {
            /*省略*/
            pluginelement(root.evalnode("plugins"));
            /*省略*/
        } catch (exception e) {
            throw new builderexception((new stringbuilder()).append("error parsing sql mapper configuration. cause: ")
                    .append(e).tostring(), e);
        }
}
private void pluginelement(xnode parent) throws exception {
    if (parent != null) {
        interceptor interceptorinstance;
        for (iterator iterator = parent.getchildren().iterator(); iterator.hasnext(); configuration
                    .addinterceptor(interceptorinstance)) {
            xnode child = (xnode) iterator.next();
            string interceptor = child.getstringattribute("interceptor");
            properties properties = child.getchildrenasproperties();
            interceptorinstance = (interceptor) resolveclass(interceptor).newinstance();
            interceptorinstance.setproperties(properties);
　　　　　　　
        }
    }
}

　　在初始化插件的时候，调用pluginelement方法。在pluginelement方法中使用反射技术生成插件对应的插件实力，然后调用插件方法中的setproperties方法，设置我们配置的参数，将插件实例保存到配置对象中，以便读取和使用它。所以插件的实力对象是一开始就被初始化的，而不是用的时候才初始化。

　　其实反射得来的插件实例被存储到interceptorchain中（chain是链的意思），贴段流程。

 

 

　　插件准备好了，接下来就是利用插件拦截了。在configuration类中。四大对象的初始化方法代码，这里用到了interceptorchain的另一个方法：

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

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 executor newexecutor(transaction transaction, executortype executortype) {
    executortype = executortype != null ? executortype : defaultexecutortype;
    executortype = executortype != null ? executortype : executortype.simple;
    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;
}

　　注意观察标红的代码，interceptorchain.pluginall方法就是就是用来便利所有的插件，校验是否拦截该对象。

public object pluginall(object target) {
    for (iterator iterator = interceptors.iterator(); iterator.hasnext();) {
        interceptor interceptor = (interceptor) iterator.next();
        target = interceptor.plugin(target);
    }
    return target;
}

　　plugin方法，也就是最上面例子中我写的方法。

　　现在就差拦截prepare方法并用intercept方法覆盖了。

　　我上面写了intercept方法拦截了statementhandler的prepare方法，四大对象传递给plugin方法后就会返回一个代理对象，在使用代理对象的方法（例子中就是statementhandler的prepare方法）时候就会进入invoke方法进行逻辑处理，这是代理模式的关键，通过逻辑判断就可以不适用prepare方法而返回intercept方法这就是拦截的地方。自己编写代理类的工作量很大，mybatis提供了一个常用的工具类plugin，用来生成代理对象。plugin类实现了invocationhandler接口，采用的是jdk的动态代理技术。代码如下：

public class plugin implements invocationhandler {
    public static object wrap(object target, interceptor interceptor) {
    map 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));
    else
        return target;
    }
    public object invoke(object proxy, method method, object args[]) throws throwable {
    try {
        set methods = (set) signaturemap.get(method.getdeclaringclass());
        if (methods != null && methods.contains(method))
            return interceptor.intercept(new invocation(target, method, args));
    } catch (exception e) {
        throw exceptionutil.unwrapthrowable(e);
    }
    return method.invoke(target, args);
    }
}

　　在例子中，myplugin的plugin方法里就是调用plugin.wrap方法来返回一个代理对象。当代理对象调用prepare方法就会进入invoke方法。signature就是上面提到的签名，如果存在签名的拦截方法，就会调用intercept方法并返回结果。这样我们想要做的事就做好了~