Mybatis拦截器分页

最新推荐文章于 2024-05-15 23:12:02 发布

啊哈哈4

最新推荐文章于 2024-05-15 23:12:02 发布

阅读量294

点赞数

文章标签： Mybatis拦截器

Mybatis 拦截器介绍

1.1 目录

1.2 前言

1.3 Interceptor接口

1.4 注册拦截器

1.5 Mybatis可拦截的方法

1.6 利用拦截器进行分页

   拦截器的一个作用就是我们可以拦截某些方法的调用，我们可以选择在这些被拦截的方法执行前后加上某些逻辑，也可以在执行这些被拦截的方法时执行自己的逻辑而不再执行被拦截的方法。Mybatis拦截器设计的一个初衷就是为了供用户在某些时候可以实现自己的逻辑而不必去动Mybatis固有的逻辑。打个比方，对于Executor，Mybatis中有几种实现：BatchExecutor、ReuseExecutor、SimpleExecutor和CachingExecutor。这个时候如果你觉得这几种实现对于Executor接口的query方法都不能满足你的要求，那怎么办呢？是要去改源码吗？当然不。我们可以建立一个Mybatis拦截器用于拦截Executor接口的query方法，在拦截之后实现自己的query方法逻辑，之后可以选择是否继续执行原来的query方法。


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

package org.apache.ibatis.plugin;

import java.util.Properties;

public interface Interceptor {

Object intercept(Invocation invocation) throws Throwable;

Object plugin(Object target);

void setProperties(Properties properties);

}

   我们可以看到在该接口中一共定义有三个方法，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;

public class Plugin implements InvocationHandler {

private Object target;
private Interceptor interceptor;
private Map

}

先看一下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 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