Mybatis Interceptor 拦截器原理源码分析

不念不忘少年蓝@ 2023-06-18 05:52 109阅读 0赞

Mybatis采用责任链模式，通过动态代理组织多个拦截器（插件），通过这些拦截器可以改变Mybatis的默认行为（诸如SQL重写之类的），由于插件会深入到Mybatis的核心，因此在编写自己的插件前最好了解下它的原理，以便写出安全高效的插件。

**代理链的生成**

Mybatis支持对Executor、StatementHandler、PameterHandler和ResultSetHandler进行拦截，也就是说会对这4种对象进行代理。

通过查看Configuration类的源代码我们可以看到，每次都对目标对象进行代理链的生成。

>     public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
>         ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
>         parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
>         return parameterHandler;
>       }

>     public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler,
>           ResultHandler resultHandler, BoundSql boundSql) {
>         ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);
>         resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
>         return resultSetHandler;
>       }

>     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;
>       }

>     public Executor newExecutor(Transaction transaction, ExecutorType executorType, boolean autoCommit) {
>         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, autoCommit);
>         }
>         executor = (Executor) interceptorChain.pluginAll(executor);
>         return executor;
>       }

接下来让我们通过分析源代码的方式来解读Mybatis的拦截器实现原理

对于拦截器Mybatis为我们提供了一个Interceptor接口，通过实现该接口就可以定义我们自己的拦截器。

package org.apache.ibatis.plugin;
    
    import java.util.Properties;
    
    public interface Interceptor {
        Object intercept(Invocation var1) throws Throwable;
    
        Object plugin(Object var1);
    
        void setProperties(Properties var1);
    }

我们可以看到在该接口中一共定义有三个方法，***intercept、plugin和setProperties***。

**plugin方法：**是拦截器用于封装目标对象的，通过该方法我们可以返回目标对象本身，也可以返回一个它的代理。当返回的是代理的时候我们可以对其中的方法进行拦截来调用intercept方法，当然也可以调用其他方法，这点将在后文讲解。setProperties方法是用于在Mybatis配置文件中指定一些属性的。

定义自己的Interceptor最重要的是要实现plugin方法和intercept方法，在plugin方法中我们可以决定是否要进行拦截进而决定要返回一个什么样的目标对象。而intercept方法就是要进行拦截的时候要执行的方法。

对于plugin方法而言，其实Mybatis已经为我们提供了一个实现。Mybatis中有一个叫做Plugin的类，里面有一个静态方法wrap(Object target,Interceptor interceptor)，通过该方法可以决定要返回的对象是目标对象还是对应的代理。这里我们先来看一下Plugin的源码：

package org.apache.ibatis.plugin;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Map;
    import java.util.Set;
    
    import org.apache.ibatis.reflection.ExceptionUtil;
    
    //这个类是Mybatis拦截器的核心,大家可以看到该类继承了InvocationHandler
    //又是JDK动态代理机制
    public class Plugin implements InvocationHandler {
    
        //目标对象
        private Object target;
        //拦截器
        private Interceptor interceptor;
        //记录需要被拦截的类与方法
        private 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) {
            //首先根据interceptor上面定义的注解 获取需要拦截的信息
            Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
            //目标对象的Class
            Class<?> type = target.getClass();
            //返回需要拦截的接口信息
            Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
            //如果长度为>0 则返回代理类 否则不做处理
            if (interfaces.length > 0) {
                return Proxy.newProxyInstance(
                        type.getClassLoader(),
                        interfaces,
                        new Plugin(target, interceptor, signatureMap));
            }
            return target;
        }
    
        //代理对象每次调用的方法
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            try {
                //通过method参数定义的类 去signatureMap当中查询需要拦截的方法集合
                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);
            }
        }
    
        //根据拦截器接口（Interceptor）实现类上面的注解获取相关信息
        private static Map<Class<?>, Set<Method>> getSignatureMap(Interceptor interceptor) {
            //获取注解信息
            Intercepts interceptsAnnotation = interceptor.getClass().getAnnotation(Intercepts.class);
            //为空则抛出异常
            if (interceptsAnnotation == null) { // issue #251
                throw new PluginException("No @Intercepts annotation was found in interceptor " + interceptor.getClass().getName());
            }
            //获得Signature注解信息
            Signature[] sigs = interceptsAnnotation.value();
            Map<Class<?>, Set<Method>> signatureMap = new HashMap<Class<?>, Set<Method>>();
            //循环注解信息
            for (Signature sig : sigs) {
                //根据Signature注解定义的type信息去signatureMap当中查询需要拦截方法的集合
                Set<Method> methods = signatureMap.get(sig.type());
                //第一次肯定为null 就创建一个并放入signatureMap
                if (methods == null) {
                    methods = new HashSet<Method>();
                    signatureMap.put(sig.type(), methods);
                }
                try {
                    //找到sig.type当中定义的方法 并加入到集合
                    Method method = sig.type().getMethod(sig.method(), sig.args());
                    methods.add(method);
                } catch (NoSuchMethodException e) {
                    throw new PluginException("Could not find method on " + sig.type() + " named " + sig.method() + ". Cause: " + e, e);
                }
            }
            return signatureMap;
        }
    
        //根据对象类型与signatureMap获取接口信息
        private static Class<?>[] getAllInterfaces(Class<?> type, Map<Class<?>, Set<Method>> signatureMap) {
            Set<Class<?>> interfaces = new HashSet<Class<?>>();
            //循环type类型的接口信息 如果该类型存在与signatureMap当中则加入到set当中去
            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()]);
        }
    }

下面是俩个注解类的定义源码

package org.apache.ibatis.plugin;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.TYPE})
    public @interface Intercepts {
        Signature[] value();
    }