【Review】Mybatis-以PageHelper为例分析拦截器

一时失言乱红尘 2022-09-10 03:18 206阅读 0赞

### 1、背景 ###

大家都知道，Mybatis提供了接口绑定，实现了DAO与xml文件的绑定，无需编写实现类，更方便使用。  
但如果我们需要对某些语句进行额外的统一处理，且是在运行时动态修改，怎么办？  
比如分页，不希望每次都在sql中手动填充分页参数，能不能动态传递分页参数来实现？

### 2、PageHelper ###

以PageHelper为例，来看下他是如果使用拦截器对sql进行处理的。

//其中，type：上面提到的四种拦截对象的类型。method：拦截哪些方法，因为是分页查询，所以只需要query即可。args：对应方法的参数。
    @Intercepts(@Signature(type = Executor.class, method = "query", args = { MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}))
    public class PageHelper implements Interceptor { 
    
    //方法增强
     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);
            }
      }
    
       /** * 只拦截Executor * * @param target * @return */
        public Object plugin(Object target) { 
            if (target instanceof Executor) { 
                return Plugin.wrap(target, this);
            } else { 
                return target;
            }
        }
     }

其中intercept()主要处理逻辑在SqlUtil类中的doProcessPage()，主要逻辑是拦截boundSql，然后添加上分页的参数，最后将补充完整的sql语句进行执行。

private Page doProcessPage(Invocation invocation, Page page, Object[] args) throws Throwable { 
            //保存RowBounds状态
            RowBounds rowBounds = (RowBounds) args[2];
            //获取原始的ms
            MappedStatement ms = (MappedStatement) args[0];
            //判断并处理为PageSqlSource
            if (!isPageSqlSource(ms)) { 
                processMappedStatement(ms);
            }
            //设置当前的parser，后面每次使用前都会set，ThreadLocal的值不会产生不良影响
            ((PageSqlSource)ms.getSqlSource()).setParser(parser);
            try { 
                //忽略RowBounds-否则会进行Mybatis自带的内存分页
                args[2] = RowBounds.DEFAULT;
                //如果只进行排序 或 pageSizeZero的判断
                if (isQueryOnly(page)) { 
                    return doQueryOnly(page, invocation);
                }
    
                //简单的通过total的值来判断是否进行count查询
                if (page.isCount()) { 
                    page.setCountSignal(Boolean.TRUE);
                    //替换MS
                    args[0] = msCountMap.get(ms.getId());
                    //查询总数
                    Object result = invocation.proceed();
                    //还原ms
                    args[0] = ms;
                    //设置总数
                    page.setTotal((Integer) ((List) result).get(0));
                    if (page.getTotal() == 0) { 
                        return page;
                    }
                } else { 
                    page.setTotal(-1l);
                }
                //pageSize>0的时候执行分页查询，pageSize<=0的时候不执行相当于可能只返回了一个count
                if (page.getPageSize() > 0 &&
                        ((rowBounds == RowBounds.DEFAULT && page.getPageNum() > 0)
                                || rowBounds != RowBounds.DEFAULT)) { 
                    //将参数中的MappedStatement替换为新的qs
                    page.setCountSignal(null);
                    BoundSql boundSql = ms.getBoundSql(args[1]);
                    args[1] = parser.setPageParameter(ms, args[1], boundSql, page);
                    page.setCountSignal(Boolean.FALSE);
                    //执行分页查询
                    Object result = invocation.proceed();
                    //得到处理结果
                    page.addAll((List) result);
                }
            } finally { 
                ((PageSqlSource)ms.getSqlSource()).removeParser();
            }
    
            //返回结果
            return page;
        }

### 3、Plugin机制 ###

Mybatis提供了Plugin机制，也叫拦截器。可以在映射语句的过程中进行拦截处理，拦截的对象可以是Executor ParameterHandler ResultSetHandler StatementHandler（sql语法构建）。

#### （1）Interceptor ####

上面提到了PageHelper实现了Interceptor接口，有三个主要接口。

//拦截器接口定义
    public interface Interceptor { 
    
      Object intercept(Invocation invocation) throws Throwable;
    
      //生成代理类
      Object plugin(Object target);
    
      void setProperties(Properties properties);
    
    }

其中plugin()用来生成对目标target的代理，实际是通过Plugin.wrap(target,this)来完成的

#### （2）Plugin ####

Plugin.wrap()的源码如下：

public class Plugin implements InvocationHandler { 
    
      //目标对象
      private Object target;
      //拦截器
      private Interceptor interceptor;
      //要被拦截的类、方法
      private Map<Class<?>, Set<Method>> signatureMap;
    
      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
        try { 
          Set<Method> methods = signatureMap.get(method.getDeclaringClass());
          //如果是需要被拦截的方法，调用interceptor的拦截方法。（若是PageHelper，则是上面提到的对sql的分页处理）
          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);
        }
      }
      
     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) { 
          //动态代理生成目标类target的代理
          return Proxy.newProxyInstance(
              type.getClassLoader(),
              interfaces,
              new Plugin(target, interceptor, signatureMap));
        }
        return target;
      }
    
      //从拦截器中获取要拦截的类、方法
      private static Map<Class<?>, Set<Method>> getSignatureMap(Interceptor interceptor) { 
        Intercepts interceptsAnnotation = interceptor.getClass().getAnnotation(Intercepts.class);
        // issue #251
        if (interceptsAnnotation == null) { 
          throw new PluginException("No @Intercepts annotation was found in interceptor " + interceptor.getClass().getName());      
        }
        Signature[] sigs = interceptsAnnotation.value();
        Map<Class<?>, Set<Method>> signatureMap = new HashMap<Class<?>, Set<Method>>();
        for (Signature sig : sigs) { 
          Set<Method> methods = signatureMap.get(sig.type());
          if (methods == null) { 
            methods = new HashSet<Method>();
            signatureMap.put(sig.type(), methods);
          }
          try { 
            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;
      }
     }

#### （3）加载全局配置 ####

以XMLConfigBuilder为入口，pluginElement() 解析配置信息，将自定义拦截器添加Configuration的拦截器链中。

private void pluginElement(XNode parent) throws Exception { 
        if (parent != null) { 
          for (XNode child : parent.getChildren()) { 
            String interceptor = child.getStringAttribute("interceptor");
            Properties properties = child.getChildrenAsProperties();
            Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).newInstance();
            interceptorInstance.setProperties(properties);
            configuration.addInterceptor(interceptorInstance);
          }
        }
      }
      
      public void addInterceptor(Interceptor interceptor) { 
        interceptorChain.addInterceptor(interceptor);
      }

在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) { 
        return newExecutor(transaction, defaultExecutorType);
      }
    
      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;
      }

### 4、小结 ###

拦截器的使用，可以方便用户做一些统一的拦截处理，类似分页、记录等信息。但也要合理使用，过多使用反倒会拖累项目。