mybatis官方定义：MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。
mybatis的拦截器，一般用于针对数据库的一些通用操作处理，比如慢查耗时打印，压测场景影子表写入。用户需要使用拦截器的时候，通过实现Interceptor接口即可。拦截器的功能，不仅带来了切面编程的优势，还使用起来也很方便。那么mybatis具体是如何实现拦截器的呢？下面我们来一探究竟。以下所有分析均基于3.4.5版本。
1.拦截器初始化
通过查看源码，我们可以发现，关于拦截器的代码，都放在了plugin包目录下，该目录下包含七个类：
- Intercepts：注解类，其value为Signature类数值，注解在Interceptor实现类上，表示实现类对哪些sql执行类（实现Executor）的哪些方法切入
- Signature：注解类，表示一个唯一的Interceptor实现类的一个方法，以及入参
- InterceptorChain：拦截器链表，用于初始化一个拦截器链
- Interceptor：拦截器接口
- Invocation：拦截衔接类，用于指向下一个拦截器或者sql执行类
- Plugin：拦截器实现辅助类
- PluginException：异常
Intercepts和Signature，对于熟悉mybatis切面编程的同学都知道，是用户的Interceptor实现类注解。
Intercepts的内部结构很简单就是Signature数组：
@Documented @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.TYPE}) public @interface Intercepts { Signature[] value(); }
Signature注解也比较简单，包含目标类，方法，入参类型数组，标识唯一一个方法
@Documented @Retention(RetentionPolicy.RUNTIME) @Target({}) public @interface Signature {
// 目标类 Class<?> type(); // 方法 String method(); // 入参类型数组 Class<?>[] args(); }
InterceptorChain类的pluginAll方法是mybatis初始化的时候，初始化拦截器功能的入口方法
private final List<Interceptor> interceptors = new ArrayList();
// target是Executor实现类之一，所有sql语句执行都需要通过这些实现类生效 public Object pluginAll(Object target) { Interceptor interceptor;
// 遍历数组，调用每一个interceptor的plugin方法 for(Iterator var2 = this.interceptors.iterator(); var2.hasNext(); target = interceptor.plugin(target)) { interceptor = (Interceptor)var2.next(); } return target; }
interceptor实现类（需要使用者编写）的plugin方法一个标准的实现如下：
@Override public Object plugin(Object target) {
// 直接调用 return Plugin.wrap(target, this); }
Plugin类wrap方法，Plugin实现InvocationHandler，用于JDK动态代理
public class Plugin implements InvocationHandler { private final Object target; private final Interceptor interceptor; private final Map<Class<?>, Set<Method>> signatureMap; private Plugin(Object target, Interceptor interceptor, Map<Class<?>, Set<Method>> signatureMap) { this.target = target; this.interceptor = interceptor; this.signatureMap = signatureMap; } public static Object wrap(Object target, Interceptor interceptor) {
// 根据Intercepor实现类的注解，获取Executor实现类各个需要拦截的方法，Map中的key是Executor实现类，value是类中需要拦截的方法集合 Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor); Class<?> type = target.getClass();
// 遍历target类型的接口数值，因为target同一实现Executor接口，所以该数组长度为1，值类型为Executor.class Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
// 根据是否需要代理，返回target代理类或者target return interfaces.length > 0 ? Proxy.newProxyInstance(type.getClassLoader(), interfaces, new Plugin(target, interceptor, signatureMap)) : target; }private static Map<Class<?>, Set<Method>> getSignatureMap(Interceptor interceptor) { Intercepts interceptsAnnotation = (Intercepts)interceptor.getClass().getAnnotation(Intercepts.class); if (interceptsAnnotation == null) { throw new PluginException("No @Intercepts annotation was found in interceptor " + interceptor.getClass().getName()); } else { Signature[] sigs = interceptsAnnotation.value(); Map<Class<?>, Set<Method>> signatureMap = new HashMap(); Signature[] var4 = sigs; int var5 = sigs.length; for(int var6 = 0; var6 < var5; ++var6) { Signature sig = var4[var6]; Set<Method> methods = (Set)signatureMap.get(sig.type()); if (methods == null) { methods = new HashSet(); signatureMap.put(sig.type(), methods); } try { Method method = sig.type().getMethod(sig.method(), sig.args()); ((Set)methods).add(method); } catch (NoSuchMethodException var10) { throw new PluginException("Could not find method on " + sig.type() + " named " + sig.method() + ". Cause: " + var10, var10); } } return signatureMap; } } private static Class<?>[] getAllInterfaces(Class<?> type, Map<Class<?>, Set<Method>> signatureMap) { HashSet interfaces; for(interfaces = new HashSet(); type != null; type = type.getSuperclass()) { Class[] var3 = type.getInterfaces(); int var4 = var3.length; for(int var5 = 0; var5 < var4; ++var5) { Class<?> c = var3[var5]; if (signatureMap.containsKey(c)) { interfaces.add(c); } } } return (Class[])interfaces.toArray(new Class[interfaces.size()]); }
因此，我们可以看到，调用路径为：InterceptorChain.pulginAll --> Interceptor.plugin --> Pulgin.wrap，InterceptorChain.pulginAll的入参target和返回值经历了这样的一个过程：target --> 根据Intercepor实现类的注解是否包含本target，通过JDK动态代理返回Proxy或者target --> target --> 下一个Intercepor，这样一直遍历InterceptorChain，不断返回当前target的代理类或者直接返回target，在target包了一层又一层：
最后返回的target就是就是不断代理的结果，而相邻代理之间通过Pulgin.wrap方法实现，wrap方法实现上调用了Proxy，也就是通过JDK的动态代理实现
2.sql执行
以上是从初始化时，已pulginAll方法为切入点，看拦截器各个模块间的关系以及实现方式，下面从sql执行的角度看看。
通过调试发现，执行的入口方法的Pulgin.invoke方法，当代理对象执行方法调用的时候，就会进入
public class Plugin implements InvocationHandler { private final Object target; private final Interceptor interceptor; private final Map<Class<?>, Set<Method>> signatureMap; private Plugin(Object target, Interceptor interceptor, Map<Class<?>, Set<Method>> signatureMap) { this.target = target; this.interceptor = interceptor; this.signatureMap = signatureMap; }
...
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { try {
// 获取所有需要拦截的方法，这里method.getDeclaringClass()的值为Executor.class Set<Method> methods = (Set)this.signatureMap.get(method.getDeclaringClass());
// 判断当前方法是否需要拦截，需要拦截则调用interceptor实现类的intercept方法并将被代理对象，接口方法，入参传入，否则直接调用被代理对象方法 return methods != null && methods.contains(method) ? this.interceptor.intercept(new Invocation(this.target, method, args)) : method.invoke(this.target, args); } catch (Exception var5) { throw ExceptionUtil.unwrapThrowable(var5); } }
... }
Interceptor实现类一般会处理一下业务上需求，最后调用被代理类
@Intercepts({ @Signature(type = Executor.class, method = "update", args = { MappedStatement.class, Object.class }),
@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 }) })
@Component
public class SqlMonitorManager implements Interceptor {
private boolean showSql = true;
@Override
public Object intercept(Invocation invocation) throws Throwable {
// 这里是业务处理
/****/
// 调用proceed方法
try {
return invocation.proceed();
} catch (Throwable e) {
throw e;
}
}
// 初始化时，可以指定属性值，这里配置了showSql
@Override
public void setProperties(Properties properties) {
if (properties == null) {
return;
}
if (properties.containsKey("show_sql")) {
String value = properties.getProperty("show_sql");
if (Boolean.TRUE.toString().equals(value)) {
this.showSql = true;
}
}
}
}
intercept方法最后调用了invocation的proceed方法：
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 this.method.invoke(this.target, this.args); } }
其实从执行的调度就是从最外层的proxy，层层进入，最后调用target的方法执行sql，这与动态代理的使用也是类似的，存在调用路径为：
Proxy2.method --> Pulgin.invoke --> 是否方法拦截，如果是，掉用interceptor.intercept方法，最后调用被代理类方法，如果否，调用直接调用代理类方法啊 -->Proxy1.method，这样一直调用下去。调用流程图如下：
3.总结
总的来说，mybatis拦截器提供了相对方便并且可控的切面编程支持，也是一种动态代理的一种最佳实践。通过嵌套代理，实现多个拦截器，通过传递被代理类方法以及入参，推迟并由用户决定被代理类的调用，从而实现拦截。