关于mybatis:建议收藏mybatis插件原理详解

关注“Java 后端技术全栈”

回复“面试”获取全套面试材料

上次发文说到了如何集成分页插件 MyBatis 插件原理剖析，看完感觉本人 better 了，明天咱们接着来聊 mybatis 插件的原理。

mybatis 插件波及到的几个类：

我将以 Executor 为例，剖析 MyBatis 是如何为 Executor 实例植入插件的。Executor 实例是在开启 SqlSession 时被创立的，因而，咱们从源头进行剖析。先来看一下 SqlSession 开启的过程。

public SqlSession openSession() {return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
}
private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;
    try {
        // 省略局部逻辑
        
        // 创立 Executor
        final Executor executor = configuration.newExecutor(tx, execType);
        return new DefaultSqlSession(configuration, executor, autoCommit);
    } 
    catch (Exception e) {...} 
    finally {...}
}

Executor 的创立过程封装在 Configuration 中，咱们跟进去看看看。

// Configuration 类中
public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
    executorType = executorType == null ? defaultExecutorType : executorType;
    executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
    Executor executor;
    
    // 依据 executorType 创立相应的 Executor 实例
    if (ExecutorType.BATCH == executorType) {...} 
    else if (ExecutorType.REUSE == executorType) {...} 
    else {executor = new SimpleExecutor(this, transaction);
    }
    if (cacheEnabled) {executor = new CachingExecutor(executor);
    }
    
    // 植入插件
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
}

如上，newExecutor 办法在创立好 Executor 实例后，紧接着通过拦截器链 interceptorChain 为 Executor 实例植入代理逻辑。那上面咱们看一下 InterceptorChain 的代码是怎么的。

public class InterceptorChain {private final List<Interceptor> interceptors = new ArrayList<Interceptor>();
    public Object pluginAll(Object target) {
        // 遍历拦截器汇合
        for (Interceptor interceptor : interceptors) {
            // 调用拦截器的 plugin 办法植入相应的插件逻辑
            target = interceptor.plugin(target);
        }
        return target;
    }
    /** 增加插件实例到 interceptors 汇合中 */
    public void addInterceptor(Interceptor interceptor) {interceptors.add(interceptor);
    }
    /** 获取插件列表 */
    public List<Interceptor> getInterceptors() {return Collections.unmodifiableList(interceptors);
    }
}

下面的 for 循环代表了只有是插件，都会以 责任链 的形式逐个执行（别指望它能跳过某个节点），所谓插件，其实就相似于拦截器。

这里就用到了责任链设计模式，责任链设计模式就相当于咱们在 OA 零碎里发动审批，领导们一层一层进行审批。

以上是 InterceptorChain 的全副代码，比较简单。它的 pluginAll 办法会调用具体插件的 plugin 办法植入相应的插件逻辑。如果有多个插件，则会屡次调用 plugin 办法，最终生成一个层层嵌套的代理类。形如上面：

当 Executor 的某个办法被调用的时候，插件逻辑会后行执行。执行程序由外而内，比方上图的执行程序为 plugin3 → plugin2 → Plugin1 → Executor。

plugin 办法是由具体的插件类实现，不过该办法代码个别比拟固定，所以上面找个示例剖析一下。

// TianPlugin 类
public Object plugin(Object target) {return Plugin.wrap(target, this);
}
//Plugin
public static Object wrap(Object target, Interceptor interceptor) {
    /*
     * 获取插件类 @Signature 注解内容，并生成相应的映射构造。形如上面：* {*     Executor.class : [query, update, commit],
     *     ParameterHandler.class : [getParameterObject, setParameters]
     * }
     */
    Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
    Class<?> type = target.getClass();
    // 获取指标类实现的接口
    Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
    if (interfaces.length > 0) {
        // 通过 JDK 动静代理为指标类生成代理类
        return Proxy.newProxyInstance(type.getClassLoader(),
            interfaces,
            new Plugin(target, interceptor, signatureMap));
    }
    return target;
}

如上，plugin 办法在外部调用了 Plugin 类的 wrap 办法，用于为指标对象生成代理。Plugin 类实现了 InvocationHandler 接口，因而它能够作为参数传给 Proxy 的 newProxyInstance 办法。

到这里，对于插件植入的逻辑就剖析完了。接下来，咱们来看看插件逻辑是怎么执行的。

Plugin 实现了 InvocationHandler 接口，因而它的 invoke 办法会拦挡所有的办法调用。invoke 办法会对所拦挡的办法进行检测，以决定是否执行插件逻辑。该办法的逻辑如下：

// 在 Plugin 类中
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
        /*
         * 获取被拦挡办法列表，比方：*    signatureMap.get(Executor.class)，可能返回 [query, update, commit]
         */
        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 办法的代码比拟少，逻辑不难理解。首先，invoke 办法会检测被拦挡办法是否配置在插件的 @Signature 注解中，若是，则执行插件逻辑，否则执行被拦挡办法。插件逻辑封装在 intercept 中，该办法的参数类型为 Invocation。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 proceed() throws InvocationTargetException, IllegalAccessException {
        // 反射调用被拦挡的办法
        return method.invoke(target, args);
    }
}

对于插件的执行逻辑就剖析到这，整个过程不难理解，大家简略看看即可。

上面为了让大家更好的了解 Mybatis 的插件机制，咱们来模仿一个慢 sql 监控的插件。

/**
 * 慢查问 sql 插件
 */
@Intercepts({@Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class, Integer.class})})
public class SlowSqlPlugin implements Interceptor {
    private long slowTime;
    // 拦挡后须要解决的业务
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        // 通过 StatementHandler 获取执行的 sql
        StatementHandler statementHandler = (StatementHandler) invocation.getTarget();
        BoundSql boundSql = statementHandler.getBoundSql();
        String sql = boundSql.getSql();
        long start = System.currentTimeMillis();
        // 完结拦挡
        Object proceed = invocation.proceed();
        long end = System.currentTimeMillis();
        long f = end - start;
        System.out.println(sql);
        System.out.println("耗时 =" + f);
        if (f > slowTime) {System.out.println("本次数据库操作是慢查问，sql 是:");
            System.out.println(sql);
        }
        return proceed;
    }
    // 获取到拦挡的对象，底层也是通过代理实现的，实际上是拿到一个指标代理对象
    @Override
    public Object plugin(Object target) {
        // 触发 intercept 办法
        return Plugin.wrap(target, this);
    }
    // 设置属性
    @Override
    public void setProperties(Properties properties) {
        // 获取咱们定义的慢 sql 的工夫阈值 slowTime
        this.slowTime = Long.parseLong(properties.getProperty("slowTime"));
    }
}

而后把这个插件类注入到容器中。

而后咱们来执行查问的办法。

耗时 28 秒的，大于咱们定义的 10 毫秒，那这条 SQL 就是咱们认为的慢 SQL。

通过这个插件，咱们就能很轻松的了解 setProperties()办法是做什么的了。

也是实现 mybatis 接口 Interceptor。

@SuppressWarnings({"rawtypes", "unchecked"})
@Intercepts(
    {@Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}),
        @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class}),
    }
)
public class PageInterceptor implements Interceptor {
        @Override
    public Object intercept(Invocation invocation) throws Throwable {...}

intercept 办法中

//AbstractHelperDialect 类中
@Override
public String getPageSql(MappedStatement ms, BoundSql boundSql, Object parameterObject, RowBounds rowBounds, CacheKey pageKey) {String sql = boundSql.getSql();
        Page page = getLocalPage();
        // 反对 order by
        String orderBy = page.getOrderBy();
        if (StringUtil.isNotEmpty(orderBy)) {pageKey.update(orderBy);
            sql = OrderByParser.converToOrderBySql(sql, orderBy);
        }
        if (page.isOrderByOnly()) {return sql;}
        // 获取分页 sql
        return getPageSql(sql, page, pageKey);
 }
// 模板办法模式中的钩子办法
 public abstract String getPageSql(String sql, Page page, CacheKey pageKey);

AbstractHelperDialect 类的实现类有如下（也就是此分页插件反对的数据库就以下几种）：

咱们用的是 MySQL。这里也有与之对应的。

 @Override
    public String getPageSql(String sql, Page page, CacheKey pageKey) {StringBuilder sqlBuilder = new StringBuilder(sql.length() + 14);
        sqlBuilder.append(sql);
        if (page.getStartRow() == 0) {sqlBuilder.append("LIMIT ?");
        } else {sqlBuilder.append("LIMIT ?, ?");
        }
        pageKey.update(page.getPageSize());
        return sqlBuilder.toString();}

到这里咱们就晓得了，它无非就是在咱们执行的 SQL 上再拼接了 Limit 罢了。同理，Oracle 也就是应用 rownum 来解决分页了。上面是 Oracle 解决分页

 @Override
    public String getPageSql(String sql, Page page, CacheKey pageKey) {StringBuilder sqlBuilder = new StringBuilder(sql.length() + 120);
        if (page.getStartRow() > 0) {sqlBuilder.append("SELECT * FROM (");
        }
        if (page.getEndRow() > 0) {sqlBuilder.append("SELECT TMP_PAGE.*, ROWNUM ROW_ID FROM (");
        }
        sqlBuilder.append(sql);
        if (page.getEndRow() > 0) {sqlBuilder.append(") TMP_PAGE WHERE ROWNUM <= ?");
        }
        if (page.getStartRow() > 0) {sqlBuilder.append(") WHERE ROW_ID > ?");
        }
        return sqlBuilder.toString();}

其余数据库分页操作相似。对于具体原理剖析，这里就没必要赘述了，因为分页插件源代码里正文基本上全是中文。

程度分表
权限管制
数据的加解密

Spring-Boot+Mybatis 继承了分页插件，以及应用案例、插件的原理剖析、源码剖析、如何自定义插件。

波及到技术点：JDK 动静代理、责任链设计模式、模板办法模式。

Mybatis 插件要害对象总结：

Inteceptor 接口：自定义拦挡必须实现的类。
InterceptorChain：寄存插件的容器。
Plugin：h 对象，提供创立代理类的办法。
Invocation：对被代理对象的封装。

举荐浏览

教小师妹疾速入门 Mybatis，看这篇就够了

《算法问题整顿》.pdf

图解 MyBatis

关于mybatis:建议收藏mybatis插件原理详解

插件原理剖析

执行插件逻辑

自定义插件

回顾分页插件

Mybatis 插件利用场景

总结

Just My Socks（注册教程内含优惠码）

关于mybatis:建议收藏mybatis插件原理详解

插件原理剖析

执行插件逻辑

自定义插件

回顾分页插件

Mybatis 插件利用场景

总结

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）