Mybatis中的拦截器

先看一下mybatis拦截器的用法和用途，先用为ibatis3提供基于方言(Dialect)的分页查询的例子来看一下吧！源码：
@Intercepts({@Signature(
        type= Executor.class,
        method = "query",
        args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})})
public class OffsetLimitInterceptor implements Interceptor{
    private static int    MAPPED_STATEMENT_INDEX    = 0;
    private static int    PARAMETER_INDEX            = 1;
    private static int    ROWBOUNDS_INDEX            = 2;
    private Dialect        dialect;
   
    public Object intercept(Invocation invocation) throws Throwable {
        processIntercept(invocation.getArgs());
        return invocation.proceed();
    }

    private void processIntercept(final Object[] queryArgs) {
        //queryArgs = query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler)
        MappedStatement ms = (MappedStatement)queryArgs[MAPPED_STATEMENT_INDEX];
        Object parameter = queryArgs[PARAMETER_INDEX];
        final RowBounds rowBounds = (RowBounds)queryArgs[ROWBOUNDS_INDEX];
        int offset = rowBounds.getOffset();
        int limit = rowBounds.getLimit();
       
        if(dialect.supportsLimit() && (offset != RowBounds.NO_ROW_OFFSET || limit != RowBounds.NO_ROW_LIMIT)) {
            BoundSql boundSql = ms.getBoundSql(parameter);
            String sql = boundSql.getSql().trim();
            if (dialect.supportsLimitOffset()) {
                sql = dialect.getLimitString(sql, offset, limit);
                offset = RowBounds.NO_ROW_OFFSET;
            } else {
                sql = dialect.getLimitString(sql, 0, limit);
            }
            limit = RowBounds.NO_ROW_LIMIT;
           
            queryArgs[ROWBOUNDS_INDEX] = new RowBounds(offset,limit);
            BoundSql newBoundSql = new BoundSql(ms.getConfiguration(),sql, boundSql.getParameterMappings(), boundSql.getParameterObject());
            MappedStatement newMs = copyFromMappedStatement(ms, new BoundSqlSqlSource(newBoundSql));
            queryArgs[MAPPED_STATEMENT_INDEX] = newMs;
        }
    }
   
    //see: MapperBuilderAssistant
    private MappedStatement copyFromMappedStatement(MappedStatement ms,SqlSource newSqlSource) {
        Builder builder = new MappedStatement.Builder(ms.getConfiguration(),ms.getId(),newSqlSource,ms.getSqlCommandType());
       
        builder.resource(ms.getResource());
        builder.fetchSize(ms.getFetchSize());
        builder.statementType(ms.getStatementType());
        builder.keyGenerator(ms.getKeyGenerator());
        builder.keyProperty(ms.getKeyProperty());
       
        //setStatementTimeout()
        builder.timeout(ms.getTimeout());
       
        //setStatementResultMap()
        builder.parameterMap(ms.getParameterMap());
       
        //setStatementResultMap()
        builder.resultMaps(ms.getResultMaps());
        builder.resultSetType(ms.getResultSetType());
       
        //setStatementCache()
        builder.cache(ms.getCache());
        builder.flushCacheRequired(ms.isFlushCacheRequired());
        builder.useCache(ms.isUseCache());
       
        return builder.build();
    }

    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    public void setProperties(Properties properties) {
        String dialectClass = properties.getProperty("dialectClass");
        try {
            dialect = (Dialect)Class.forName(dialectClass).newInstance();
        } catch (Exception e) {
            throw new IllegalArgumentException(
                    "cannot create dialect instance by dialectClass:"
                            + dialectClass, e);
        }
    }
   
    public static class BoundSqlSqlSource implements SqlSource {

        private BoundSql    boundSql;

        public BoundSqlSqlSource(BoundSql boundSql) {
            this.boundSql = boundSql;
        }

        public BoundSql getBoundSql(Object parameterObject) {
            return boundSql;
        }
    }
}
      注解Intercepts表示该类被用作拦截器，@Signature(type= Executor.class,       method = "query",
        args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})用来表示拦截那个类得那个方法，拦截器可用于Executor,ParameterHandler,ResultSetHandler和StatementHandler这些类上。
       我们看看这个拦截器是怎么拦截Executor的qurey方法的。先看生成Executor对象的过程：
       我们从这个序列图中可以清晰的看出，我们最后得到的Executor是一个代理对象。返回的这个Executor的代理对象是将Plugin作为调用处理器的，我们看一下Plugin的invoke方法：
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)) {
        return interceptor.intercept(new Invocation(target, method, args));
      }
      return method.invoke(target, args);
    } catch (Exception e) {
      throw ExceptionUtil.unwrapThrowable(e);
    }
  }
        这个方法中需要提的就是signatureMap，我们看看这个signatureMap是怎么取得的，我们看到是从wrap方法中通过getSignatureMap(interceptor)得到的，getSignatureMap方法源码：
private static Map<Class<?>, Set<Method>> getSignatureMap(Interceptor interceptor) {
    Signature[] sigs = interceptor.getClass().getAnnotation(Intercepts.class).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;
  }
       这个方法就是解析各个迭代器的标注，得到一个以被拦截的对象为key，以被拦截的方法集为值得value的Map。从上面这些源码我们可以了解，mybatis是将plugin已经做方法调用处理器，将目标对象一层层的做代理，在执行的时候判断方法是否在signatureMap中注册（也就是@Signature( type= Executor.class,        method = "query",
        args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})）标注了没有）,如果注册了就执行拦截器中的intercept方法。