共计 9079 个字符，预计需要花费 23 分钟才能阅读完成。
关注“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();}其余数据库分页操作相似。对于具体原理剖析，这里就没必要赘述了，因为分页插件源代码里正文基本上全是中文。
Mybatis 插件利用场景
- 程度分表
- 权限管制
- 数据的加解密
总结
Spring-Boot+Mybatis 继承了分页插件，以及应用案例、插件的原理剖析、源码剖析、如何自定义插件。
波及到技术点：JDK 动静代理、责任链设计模式、模板办法模式。
Mybatis 插件要害对象总结：
- Inteceptor 接口：自定义拦挡必须实现的类。
- InterceptorChain：寄存插件的容器。
- Plugin：h 对象，提供创立代理类的办法。
- Invocation：对被代理对象的封装。
举荐浏览
教小师妹疾速入门 Mybatis，看这篇就够了
《算法问题整顿》.pdf
图解 MyBatis