mybatis定义了一个接口 org.apache.ibatis.plugin.Interceptor，任何自定义插件都需要实现这个接口。原理类似于拦截器。
拦截范围
自定义插件可以拦截mybatis的4大对象ParameterHandler、ResultSetHandler、StatementHandler、Executor，但并不是所有的方法都可以拦截。
Interceptor 接口
package org.apache.ibatis.plugin;
import java.util.Properties;
public interface Interceptor {
Object intercept(Invocation invocation) throws Throwable;
default Object plugin(Object target) {
return Plugin.wrap(target, this);
}
default void setProperties(Properties properties) {
// NOP
}
}
Interceptor接口提供了三个方法。
1：intercept
拦截方法，里面是具体的拦截逻辑。通过参数Invocation 可获得拦截的对象、方法、参数。
2：plugin
接口提供默认实现，为拦截对象创建代理
3：setProperties
为拦截器设置属性
PageHelper实现原理
PageHelper 实现了Interceptor 接口，拦截Executor对象的query(MappedStatement mappedStatement, Object obj, RowBounds rowBounds, ResultHandler resultHandler) 方法
@Intercepts(@Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}))
public class PageHelper implements Interceptor {
……
}
测试代码
@Test
public void testPageHelper () throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
PageHelper.startPage(2,3);
List<User> list = mapper.findAll();
for (User user : list) {
System.out.println(user);
}
sqlSession.close();
}
1.读取配置文件，解析plugins标签。为拦截器创建实例，添加到interceptorChain中
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
执行上面代码时，会解析配置文件，每个标签都进行解析，这里看解析plugins标签
配置文件里，plugins标签要解析的内容
<plugins>
<plugin interceptor="com.github.pagehelper.PageHelper">
<property name="dialect" value="mysql"/>
</plugin>
</plugins>
private void pluginElement(XNode parent) throws Exception {
if (parent != null) {
for (XNode child : parent.getChildren()) {
//取出配置文件里plugin标签里的interceptor属性值，这里为com.github.pagehelper.PageHelper
String interceptor = child.getStringAttribute("interceptor");
//取出该interceptor的property
Properties properties = child.getChildrenAsProperties();
//通过反射创建拦截器实例，强转为Interceptor 类型
Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).getDeclaredConstructor().newInstance();
//为该拦截器实例设置属性
interceptorInstance.setProperties(properties);
//将拦截器实例添加到configuration中的interceptorChain中（ArrayList）
configuration.addInterceptor(interceptorInstance);
}
}
}
2.SqlSession实例化时，创建executor对象，然后在遍历plugins的时候，代理嵌套增强executor
SqlSession sqlSession = sqlSessionFactory.openSession();
Configuration中创建Executor,StatementHandler,parameterHandler,ResultSetHandler时调用对应的newXXX方法，方法中都会调用Configuration中的属性interceptorChains的pluginAll方法
创建executor时，调用pluginAll方法对其进行增强（JDK动态代理）
public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
executorType = executorType == null ? defaultExecutorType : executorType;
executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
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;
}
循环对目标对象进行层层代理，生成最终的代理对象。
public Object pluginAll(Object target) {
for (Interceptor interceptor : interceptors) {
target = interceptor.plugin(target);
}
return target;
}
PageHelper重写了plugin方法，只拦截Executor
public Object plugin(Object target) {
if (target instanceof Executor) {
return Plugin.wrap(target, this);
} else {
return target;
}
}
Plugin的wrap方法，通过动态代理增强
public static Object wrap(Object target, Interceptor interceptor) {
Map<Class<?>, Set<Method>> 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));
}
return target;
}
Plugin类实现了 InvocationHandler 接口，覆盖了invoke方法。
当动态代理对象调用一个方法时，这个方法的调用就会被转发到实现InvocationHandler 接口类的 invoke 方法来调用。
Plugin类的invoke方法的执行逻辑为：
如果是定义的拦截的方法 就执行拦截器的intercept方法；
不是需要拦截的方法 直接执行
3.PageHelper.startPage(2,3);
public static <E> Page<E> startPage(int pageNum, int pageSize, boolean count, Boolean reasonable, Boolean pageSizeZero) {
Page<E> page = new Page<E>(pageNum, pageSize, count);
page.setReasonable(reasonable);
page.setPageSizeZero(pageSizeZero);
//当已经执行过orderBy的时候
Page<E> oldPage = SqlUtil.getLocalPage();
if (oldPage != null && oldPage.isOrderByOnly()) {
page.setOrderBy(oldPage.getOrderBy());
}
SqlUtil.setLocalPage(page);
return page;
}
新建Page对象并初始化，并保存到ThreadLoacl中
public class SqlUtil implements Constant {
private static final ThreadLocal<Page> LOCAL_PAGE = new ThreadLocal<Page>();
……
}
ThreadLocal可以在指定线程内存取数据。每个线程都互不干扰。
4.List<User> list = mapper.findAll();
执行查询方法时，先动态创建mapper的代理类，然后底层会执行Executor的query方法，正是PageHelper要拦截的方法。所以此时程序会走到PageHelper的intercept方法中。
public Object intercept(Invocation invocation) throws Throwable {
if (autoRuntimeDialect) {
SqlUtil sqlUtil = getSqlUtil(invocation);
return sqlUtil.processPage(invocation);
} else {
if (autoDialect) {
initSqlUtil(invocation);
}
return sqlUtil.processPage(invocation);
}
}
关键代码
sqlUtil.processPage(invocation);
在出现异常时也可以清空Threadlocal。这也是为什么调用PageHelper.startPage()方法后的第一个查询语句会分页而再次执行的查询语句不会分页。
public Object processPage(Invocation invocation) throws Throwable {
try {
Object result = _processPage(invocation);
return result;
} finally {
clearLocalPage();
}
}
从本地线程中获取page
private Object _processPage(Invocation invocation) throws Throwable {
final Object[] args = invocation.getArgs();
Page page = null;
//支持方法参数时，会先尝试获取Page
if (supportMethodsArguments) {
page = getPage(args);
}
//分页信息
RowBounds rowBounds = (RowBounds) args[2];
//支持方法参数时，如果page == null就说明没有分页条件，不需要分页查询
if ((supportMethodsArguments && page == null)
//当不支持分页参数时，判断LocalPage和RowBounds判断是否需要分页
|| (!supportMethodsArguments && SqlUtil.getLocalPage() == null && rowBounds == RowBounds.DEFAULT)) {
return invocation.proceed();
} else {
//不支持分页参数时，page==null，这里需要获取
if (!supportMethodsArguments && page == null) {
page = getPage(args);
}
return doProcessPage(invocation, page, args);
}
}
在doProcessPage(invocation, page, args) 方法中
1.新建查询数据总记录数的MappedStatement，放到缓存中
取出缓存中的ms，放行，获取到数据总记录数
2.还原ms，获取boundSql，设置参数后放行
放行后，执行Excutor的query方法
最终执行了MysqlParser 里的getPageSql方法，拼接了sql语句，然后去执行
public class MysqlParser extends AbstractParser {
@Override
public String getPageSql(String sql) {
StringBuilder sqlBuilder = new StringBuilder(sql.length() + 14);
sqlBuilder.append(sql);
sqlBuilder.append(" limit ?,?");
return sqlBuilder.toString();
}
自定义分页插件
1.自定义一个类，实现Interceptor 接口，覆盖三个方法
2.在配置文件中配置插件
如下代码，实现以 "ByPager"结尾的方法，sql语句后拼接limit语句实现分页
package com.myown.interceptor;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.executor.parameter.ParameterHandler;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.SystemMetaObject;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import java.sql.Connection;
import java.util.Map;
import java.util.Properties;
@Intercepts({@Signature(type= StatementHandler.class,method="prepare",args={Connection.class,Integer.class})})
public class MyPageInterceptor implements Interceptor {
private int page;
private int size;
@Override
public Object intercept(Invocation invocation) throws Throwable {
//获取拦截对象
StatementHandler statementHandler = (StatementHandler)invocation.getTarget();
MetaObject metaObject = SystemMetaObject.forObject(statementHandler);
MappedStatement mappedStatement = (MappedStatement)metaObject.getValue("delegate.mappedStatement");
String mapId = mappedStatement.getId();
if(mapId.matches(".+ByPager$")){
ParameterHandler parameterHandler = (ParameterHandler)metaObject.getValue("delegate.parameterHandler");
Map<String, Object> params = (Map<String, Object>)parameterHandler.getParameterObject();
page = (int)params.get("page");
size = (int)params.get("size");
String sql = (String) metaObject.getValue("delegate.boundSql.sql");
sql += " limit "+(page-1)*size +","+size;
metaObject.setValue("delegate.boundSql.sql", sql);
}
return invocation.proceed();
}
@Override
public Object plugin(Object target) {
return Plugin.wrap(target, this);
}
@Override
public void setProperties(Properties properties) {
}
}
