mybatis源码分析：插件是什么
在上篇文章中，《mybatis源码配置文件解析之四：解析plugins标签 》分析了mybatis中的plugin标签的解析过程，plugin指的是插件，或者说拦截器更为形象，因为它的作用就是拦截特定的方法，根据拦截到的方法进行特定的处理。
一、概述
在mybatis中插件我认为叫拦截器更贴切，下面的统一称为拦截器，在上篇文章中说到了拦截器的使用方式及作用，现在来分析下其实现原理，是如何进行方法拦截的。在上篇最后提到在mybatis核心配置文件中配置的拦截器经过解析后，最终都保存在了InterceptorChai类中的interceptors属性中，如下图，
最终所有的拦截器均保存在了ArrayList中。回过头来看InterceptorChain类，在该类中有pluginAll方法，从该方法的定义分析知道，此方法在遍历所有的拦截器，并调用其plugin方法，既然是遍历拦截器，那就说明在使用拦截器，可以大胆判断pluginAll方法和拦截器的使用有关。搜索mybatis的源码，plugin方法被调用的地方如下，
从上面可以看出在整个源码中仅有四处调用，都是在Configuration类中，这四处调用分别和ParameterHandler、ReslutSetHandler、StatementHandler、Executor有关，从上篇文件可以知道，拦截器拦截的就是这四个接口中的方法，现在可以肯定这里便是拦截器起作用的地方，从这四处中选择statementHandler=(StatementHandler)interceptorChain.pluginAll(statementHandler);来分析其实现原理。
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; }
二、详述
根据上面的分析，在newStatementHandler方法中调用了pluginAll方法，我们便从newStatementHandler方法开始分析，改方法中首先生成了一个RoutingStatementHandler的实例，此行代码就是单纯的new，暂时不必关注，紧接着下面一句interceptorChain.pluginAll，调用了pluginAll方法，在开篇就提到该方法在InterceptorChain类中。
1、pluginAll方法
下面是pluginAll方法的定义，
public Object pluginAll(Object target) { for (Interceptor interceptor : interceptors) { target = interceptor.plugin(target); } return target; }
此方法在遍历interceptors即遍历所有的拦截器，调用每个拦截器的plugin方法，plugin方法会返回一个对象，我们看默认的拦截器接口的plugin方法，
public interface Interceptor { Object intercept(Invocation invocation) throws Throwable; Object plugin(Object target); void setProperties(Properties properties); }
也就是所有实现该接口的方法需要实现上面的三个方法，如果对plugin方法，不进行重写，那么默认会返回null。回到下面这行代码看下能否返回null，
target = interceptor.plugin(target);
如果plugin方法返回null，那么最后pluginAll方法会返回null，该方法返回null，那么下面这行代码便为null，
statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
最后newStatementHandler便会为null，我们知道newStatementHandler方法不能为null，为null了mybatis就无法往下处理。所以对于实现了Interceptor接口的类必须重新plugin方法，怎么重新那，该方法如何返回一个对象那，返回一个什么样的对象那，我们知道在newStatementHandler方法中已经new了一个StatementHandler对象，然后调用了pluginAll方法，为什么不直接返回statementHandler对象，而是把statementHandler作为参数调用pluginAll之后返回statementHandler那，因为要进行代理。这就说明plugin方法必须要返回一个JDK代理对象。
2、plugin方法
由于plugin方法定义在Interceptor接口中，并且上面已经看到了其在接口中的定义，下面看我自定义的接口中plugin的实现，
package cn.com.mybatis.plugins; import java.util.Properties; import org.apache.ibatis.executor.Executor; import org.apache.ibatis.mapping.MappedStatement; 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.session.ResultHandler; import org.apache.ibatis.session.RowBounds; @Intercepts({@Signature(type=Executor.class,method="query",args= {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})}) public class MyInterceptor implements Interceptor{ private Properties properties; /** * incation 封装了拦截的类，方法，方法参数 */ @Override public Object intercept(Invocation invocation) throws Throwable { // TODO Auto-generated method stub //执行被拦截的类中的方法 Object o=invocation.proceed(); return o; } /** * 返回一个JDK代理对象 */ @Override public Object plugin(Object target) { // TODO Auto-generated method stub return Plugin.wrap(target, this); } /** * 允许在配置文件中配置一些属性即 * <plugin interceptor=""> * <property name ="" value =""/> * </plugin> */ @Override public void setProperties(Properties properties) { // TODO Auto-generated method stub this.properties = properties; } }
从上面的代码中，看到调用了Plugin.wrap方法，wrap的意思是包装，这里返回的是一个JDK代理对象。且改方法的入参有一个target，这里指的就是statementHandler对象。
2.1、Plugin.wrap方法
我们现在看Plugin类的wrap方法，如下
public static Object wrap(Object target, Interceptor interceptor) { //1、获得自定义拦截器上的注解信息key为要拦截的接口的Class对象，value为该接口中的Method Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor); Class<?> type = target.getClass(); //2、获得目标类中所有接口中被拦截的接口信息 Class<?>[] interfaces = getAllInterfaces(type, signatureMap); //3、如果存在接口，则使用JDK动态代理，否则返回被代理对象 if (interfaces.length > 0) { return Proxy.newProxyInstance( type.getClassLoader(), interfaces, new Plugin(target, interceptor, signatureMap)); } return target; }
上面已经写上了注释，第一步会获得自定义拦截器上的注解，即下面的内容，
@Intercepts({@Signature(type=Executor.class,method="query",args= {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})})
public class MyInterceptor implements Interceptor{}
获得@Intercepts注解的内容，该注解中的值是@Signature注解的一个数组，看下@Intercepts注解的定义，
/** * Copyright 2009-2016 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.ibatis.plugin; import java.lang.annotation.Documented; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** * @author Clinton Begin */ @Documented @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) public @interface Intercepts { Signature[] value();
很明显必须是一个Signature类型的数组，和配置的注解的内容是一样的，在看@Signature注解的定义，
/** * Copyright 2009-2016 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.ibatis.plugin; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** * @author Clinton Begin */ @Documented @Retention(RetentionPolicy.RUNTIME) @Target({}) public @interface Signature { Class<?> type(); String method(); Class<?>[] args(); }
根据注解中的定义，再对比配置，发现一样，不一样就惨了。
回到wrap方法中，第二步就是要找到被代理对象statementHandler（这里是RoutingStatementHandler）所实现的接口和拦截器中配置的接口，返回被代理对象所实现的接口且配置在拦截器中的接口。
private static Class<?>[] getAllInterfaces(Class<?> type, Map<Class<?>, Set<Method>> signatureMap) { Set<Class<?>> interfaces = new HashSet<Class<?>>(); while (type != null) { for (Class<?> c : type.getInterfaces()) { if (signatureMap.containsKey(c)) { interfaces.add(c); } } type = type.getSuperclass(); } return interfaces.toArray(new Class<?>[interfaces.size()]); }
第三步就是大名鼎鼎的JDK动态代理了，
//3、如果存在接口，则使用JDK动态代理，否则返回被代理对象 if (interfaces.length > 0) { return Proxy.newProxyInstance( type.getClassLoader(), interfaces, new Plugin(target, interceptor, signatureMap)); } return target;
如果第二步存在接口则生成一个JDK动态代理，也就是RoutingStatementHandler的代理对象并返回；如果没有则直接返回原对象，也就是RoutingStatementHandler。看第三个参数new Plugin(target,interceptor,signatureMap)，下面看Plugin类，
构造方法给target、interceptor、signatureMap进行了赋值。看该类实现了InvocationHandler接口，这类和代理有关系，肯定实现了invoke方法。
2.2、Plugin的invoke方法
从上面的分析知道使用Plugin生成了代理类，那么在执行方法时肯定会调用该类的invoke方法，
@Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { try { Set<Method> methods = signatureMap.get(method.getDeclaringClass()); if (methods != null && methods.contains(method)) {
//1、拦截器的interceptor方法 return interceptor.intercept(new Invocation(target, method, args)); } return method.invoke(target, args);//2、直接调用方法 } catch (Exception e) { throw ExceptionUtil.unwrapThrowable(e); } }
从上面可以看到invoke方法主要完成了两项工作，一个就是调用拦截器的intercept方法，第二个就方法的正常调用。主要看intercept函数，由于intercept方法是Interceptor接口中的，下面看我的拦截器中的intercept方法，
/** * invocation 封装了拦截的类，方法，方法参数 */ @Override public Object intercept(Invocation invocation) throws Throwable { // TODO Auto-generated method stub //写自己的逻辑，改变参数、监控SQL执行等 //最后一定要执行下面的代码，对原方法的调用 Object o=invocation.proceed(); return o; }
看intercept方法的参数Invocation，在调用intercept方法时传入了一个Invocation的实例，
return interceptor.intercept(new Invocation(target, method, args));
target表示的是被代理的对象，这里就是RoutingStatementHandler对象，method就是要执行的方法，args是方法的参数。在自定义的拦截器中重写intercept方法时除了加入自己的逻辑处理外，要调用invocation.proceed()方法，此方法是做什么的那，
public Object proceed() throws InvocationTargetException, IllegalAccessException { return method.invoke(target, args); }
可以看到此方法是对被代理对象的方法的调用，也就是在执行完自定义逻辑外肯定要执行目标方法，也就是被代理对象的方法。
三、总结
上面就分析完了mybatis拦截器的实现原理，综合拦截器标签<plugin>的解析，以及Interceptor接口中的三个方法，
/** * Copyright 2009-2015 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.ibatis.plugin; import java.util.Properties; /** * @author Clinton Begin */ public interface Interceptor { Object intercept(Invocation invocation) throws Throwable; Object plugin(Object target); void setProperties(Properties properties); }
- 在解析<plugin>标签时如果有<property>标签，则解析为Proerties对象，并调用setProperties方法设置到拦截器中；
- mybatis拦截器可以拦截的Executor、StatementHandler、ParameterHandler、ResultSetHandler中的方法，在生成这些接口的实例时如果有拦截，则调用plugin方法，生成一个JDK动态代理对象；
- 在执行Executor、StatementHandler、ParameterHandler、ResultSetHandler中的方法时，如果自定义拦截器拦截了相应的方法，则调用intercept方法，执行自定义拦截器中的逻辑；
有不正之处，欢迎指正，感谢！
