【Mybatis源码分析】12-插件PageHelper机制

PageInterceptor是Mybatis的插件，用于拦截Executor的query方法，增强这个方法用于分页查询。

@Intercepts(
    {
        @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}),
        @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class}),
    }
)
public class PageInterceptor implements Interceptor {
    //缓存count查询的ms
    protected Cache<String, MappedStatement> msCountMap = null;
    private Dialect dialect;
    private String default_dialect_class = "com.github.pagehelper.PageHelper";
    private Field additionalParametersField;
    private String countSuffix = "_COUNT";

对于Mybatis配置了插件后，实例化插件后就会调用Interceper的setProperties方法。

public void setProperties(Properties properties) {
    //缓存 count ms
    msCountMap = CacheFactory.createCache(properties.getProperty("msCountCache"), "ms", properties);
    String dialectClass = properties.getProperty("dialect");
    if (StringUtil.isEmpty(dialectClass)) {
        dialectClass = default_dialect_class;
    }
    try {
        Class<?> aClass = Class.forName(dialectClass);
        dialect = (Dialect) aClass.newInstance();
    } catch (Exception e) {
        throw new PageException(e);
    }
    dialect.setProperties(properties);
    String countSuffix = properties.getProperty("countSuffix");
    if (StringUtil.isNotEmpty(countSuffix)) {
        this.countSuffix = countSuffix;
    }
    try {
        //反射获取 BoundSql 中的 additionalParameters 属性
        additionalParametersField = BoundSql.class.getDeclaredField("additionalParameters");
        additionalParametersField.setAccessible(true);
    } catch (NoSuchFieldException e) {
        throw new PageException(e);
    }
}
这个方法中首先会实例化一个Cache实例，用于缓存用于查询数据数量的MappedStatement，如果没有配置dialect就会使用PageHelper，然后调用dialect的setProperties()方法。



public void setProperties(Properties properties) {
    setStaticProperties(properties);
    pageParams = new PageParams();
    autoDialect = new PageAutoDialect();
    pageParams.setProperties(properties);
    autoDialect.setProperties(properties);
}

PageHelper中有一个PageParams对象和一个AutoDialect对象，都会调用自身的setProperties()方法。看一下autoDialect的:

public void setProperties(Properties properties) {
    //多数据源时，获取 jdbcurl 后是否关闭数据源
    String closeConn = properties.getProperty("closeConn");
    if (StringUtil.isNotEmpty(closeConn)) {
        this.closeConn = Boolean.parseBoolean(closeConn);
    }
    String dialectAlias = properties.getProperty("dialectAlias");
    if (StringUtil.isNotEmpty(dialectAlias)) {
        String[] alias = dialectAlias.split(";");
        for (int i = 0; i < alias.length; i++) {
            String[] kv = alias[i].split("=");
            if(kv.length != 2){
                throw new IllegalArgumentException("dialectAlias 参数配置错误，" +
                        "请按照 alias1=xx.dialectClass;alias2=dialectClass2 的形式进行配置!");
            }
            for (int j = 0; j < kv.length; j++) {
                try {
                    Class<? extends Dialect> diallectClass = (Class<? extends Dialect>) Class.forName(kv[1]);
                    //允许覆盖已有的实现
                    registerDialectAlias(kv[0], diallectClass);
                } catch (ClassNotFoundException e) {
                    throw new IllegalArgumentException("请确保 dialectAlias 配置的 Dialect 实现类存在!", e);
                }
            }
        }
    }
    //指定的 Helper 数据库方言，和  不同
    String dialect = properties.getProperty("helperDialect");
    //运行时获取数据源
    String runtimeDialect = properties.getProperty("autoRuntimeDialect");
    //1.动态多数据源
    if (StringUtil.isNotEmpty(runtimeDialect) && "TRUE".equalsIgnoreCase(runtimeDialect)) {
        this.autoDialect = false;
        this.properties = properties;
    }
    //2.动态获取方言
    else if (StringUtil.isEmpty(dialect)) {
        autoDialect = true;
        this.properties = properties;
    }
    //3.指定方言
    else {
        autoDialect = false;
        this.delegate = initDialect(dialect, properties);
    }
}

默认情况下的结果为autoDialect = true。此类还有个方法initDelegateDialect()会在PageHelper的skip方法中调用(马上会说到)。

initDelegateDialect方法会根据jdbcurl自动选取合适的Dialect实例赋值给一个委托变量delegate，PageHelper是一个委派模式，此后对PageHelper对象方法的调用都会委托delegate对象。

接下来就是看Intecepter的核心方法intercept()方法。

public Object intercept(Invocation invocation) throws Throwable {
    try {
        Object[] args = invocation.getArgs();
        MappedStatement ms = (MappedStatement) args[0];
        Object parameter = args[1];
        RowBounds rowBounds = (RowBounds) args[2];
        ResultHandler resultHandler = (ResultHandler) args[3];
        Executor executor = (Executor) invocation.getTarget();
        CacheKey cacheKey;
        BoundSql boundSql;
        //由于逻辑关系，只会进入一次
        if(args.length == 4){
            //4 个参数时
            boundSql = ms.getBoundSql(parameter);
            cacheKey = executor.createCacheKey(ms, parameter, rowBounds, boundSql);
        } else {
            //6 个参数时
            cacheKey = (CacheKey) args[4];
            boundSql = (BoundSql) args[5];
        }
        List resultList;
        //调用方法判断是否需要进行分页，如果不需要，直接返回结果
        if (!dialect.skip(ms, parameter, rowBounds)) {
            //反射获取动态参数
            String msId = ms.getId();
            Configuration configuration = ms.getConfiguration();
            Map<String, Object> additionalParameters = (Map<String, Object>) additionalParametersField.get(boundSql);
            //判断是否需要进行 count 查询
            if (dialect.beforeCount(ms, parameter, rowBounds)) {
                String countMsId = msId + countSuffix;
                Long count;
                //先判断是否存在手写的 count 查询
                MappedStatement countMs = getExistedMappedStatement(configuration, countMsId);
                if(countMs != null){
                    count = executeManualCount(executor, countMs, parameter, boundSql, resultHandler);
                } else {
                    countMs = msCountMap.get(countMsId);
                    //自动创建
                    if (countMs == null) {
                        //根据当前的 ms 创建一个返回值为 Long 类型的 ms
                        countMs = MSUtils.newCountMappedStatement(ms, countMsId);
                        msCountMap.put(countMsId, countMs);
                    }
                    count = executeAutoCount(executor, countMs, parameter, boundSql, rowBounds, resultHandler);
                }
                //处理查询总数
                //返回 true 时继续分页查询，false 时直接返回
                if (!dialect.afterCount(count, parameter, rowBounds)) {
                    //当查询总数为 0 时，直接返回空的结果
                    return dialect.afterPage(new ArrayList(), parameter, rowBounds);
                }
            }
            //判断是否需要进行分页查询
            if (dialect.beforePage(ms, parameter, rowBounds)) {
                //生成分页的缓存 key
                CacheKey pageKey = cacheKey;
                //处理参数对象
                parameter = dialect.processParameterObject(ms, parameter, boundSql, pageKey);
                //调用方言获取分页 sql
                String pageSql = dialect.getPageSql(ms, boundSql, parameter, rowBounds, pageKey);
                BoundSql pageBoundSql = new BoundSql(configuration, pageSql, boundSql.getParameterMappings(), parameter);
                //设置动态参数
                for (String key : additionalParameters.keySet()) {
                    pageBoundSql.setAdditionalParameter(key, additionalParameters.get(key));
                }
                //执行分页查询
                resultList = executor.query(ms, parameter, RowBounds.DEFAULT, resultHandler, pageKey, pageBoundSql);
            } else {
                //不执行分页的情况下，也不执行内存分页
                resultList = executor.query(ms, parameter, RowBounds.DEFAULT, resultHandler, cacheKey, boundSql);
            }
        } else {
            //rowBounds用参数值，不使用分页插件处理时，仍然支持默认的内存分页
            resultList = executor.query(ms, parameter, rowBounds, resultHandler, cacheKey, boundSql);
        }
        return dialect.afterPage(resultList, parameter, rowBounds);
    } finally {
        dialect.afterAll();
    }
}

dialect.skip()方法用于判断当前查询是否跳过分页，PageHelper的skip()方法。

public boolean skip(MappedStatement ms, Object parameterObject, RowBounds rowBounds) {
    if(ms.getId().endsWith(MSUtils.COUNT)){
        throw new RuntimeException("在系统中发现了多个分页插件，请检查系统配置!");
    }
    Page page = pageParams.getPage(parameterObject, rowBounds);
    if (page == null) {
        return true;
    } else {
        //设置默认的 count 列
        if(StringUtil.isEmpty(page.getCountColumn())){
            page.setCountColumn(pageParams.getCountColumn());
        }
        autoDialect.initDelegateDialect(ms);//注意这里哦
        return false;
    }
}

PageParams的getPage方法如果返回一个Page对象则不可以跳过分页，说明我们使用了查询分页。

public Page getPage(Object parameterObject, RowBounds rowBounds) {
    Page page = PageHelper.getLocalPage();
    if (page == null) {
        if (rowBounds != RowBounds.DEFAULT) {
            if (offsetAsPageNum) {
                page = new Page(rowBounds.getOffset(), rowBounds.getLimit(), rowBoundsWithCount);
            } else {
                page = new Page(new int[]{rowBounds.getOffset(), rowBounds.getLimit()}, rowBoundsWithCount);
                //offsetAsPageNum=false的时候，由于PageNum问题，不能使用reasonable，这里会强制为false
                page.setReasonable(false);
            }
            if(rowBounds instanceof PageRowBounds){
                PageRowBounds pageRowBounds = (PageRowBounds)rowBounds;
                page.setCount(pageRowBounds.getCount() == null || pageRowBounds.getCount());
            }
        } else if(supportMethodsArguments){
            try {
                page = PageObjectUtil.getPageFromObject(parameterObject, false);
            } catch (Exception e) {
                return null;
            }
        }
        if(page == null){
            return null;
        }
        PageHelper.setLocalPage(page);
    }
    //分页合理化
    if (page.getReasonable() == null) {
        page.setReasonable(reasonable);
    }
    //当设置为true的时候，如果pagesize设置为0（或RowBounds的limit=0），就不执行分页，返回全部结果
    if (page.getPageSizeZero() == null) {
        page.setPageSizeZero(pageSizeZero);
    }
    return page;
}

1.PageHelper的getLocalPage()方法是调用ThreadLocal的get()方法，如果返回一个Page对象，说明我们在调用查询接口之前使用了PageHelper的startPage等可以调用 ThreadLocal的set()方法。

2.如果page==null，在判断是否满足rowBounds != RowBounds.DEFAULT，因为该分页插件也支持RowBounds分页的这也是比较建议的一种方式，因为侵入性小。在判断该rowBounds instanceof PageRowBounds，因为PageRowBounds继承RowBounds，使用它可以支持对该分页查询的count查询，先做个标记page.setCount(pageRowBounds.getCount() == null || pageRowBounds.getCount());

3.如果上述条件不满足在判断是否supportMethodsArguments==true，这种条件下会使用参数对象的属性作为分页的关键字。这种用的方式较少暂不分析，默认值如下:

PARAMS.put("pageNum", "pageNum");
PARAMS.put("pageSize", "pageSize");
PARAMS.put("count", "countSql");
PARAMS.put("orderBy", "orderBy");
PARAMS.put("reasonable", "reasonable");
PARAMS.put("pageSizeZero", "pageSizeZero");

情况2和3是插件为我们自动创建的Page对象，调用PageHelper.setLocalPage(page)保存到当前线程。

下面就说一下满足分页查询的情况。

1、dialect.beforeCount()方法判断是否需要count()查询。

beforeCount()方法定义在AbstractHelperDialect，就是查看ThreadLocal中Page对象的count属性。

public boolean beforeCount(MappedStatement ms, Object parameterObject, RowBounds rowBounds) {
    Page page = getLocalPage();
    return !page.isOrderByOnly() && page.isCount();
}

需要count查询，接下来会根据当前查询的MappedStatement构建一个count查询的MappedStatement。除了id与返回类型不同其余都一样。

public static MappedStatement newCountMappedStatement(MappedStatement ms, String newMsId) {
    MappedStatement.Builder builder = new MappedStatement.Builder(ms.getConfiguration(), newMsId, ms.getSqlSource(), ms.getSqlCommandType());
    builder.resource(ms.getResource());
    builder.fetchSize(ms.getFetchSize());
    builder.statementType(ms.getStatementType());
    builder.keyGenerator(ms.getKeyGenerator());
    if (ms.getKeyProperties() != null && ms.getKeyProperties().length != 0) {
        StringBuilder keyProperties = new StringBuilder();
        for (String keyProperty : ms.getKeyProperties()) {
            keyProperties.append(keyProperty).append(",");
        }
        keyProperties.delete(keyProperties.length() - 1, keyProperties.length());
        builder.keyProperty(keyProperties.toString());
    }
    builder.timeout(ms.getTimeout());
    builder.parameterMap(ms.getParameterMap());
    //count查询返回值int
    List<ResultMap> resultMaps = new ArrayList<ResultMap>();
    ResultMap resultMap = new ResultMap.Builder(ms.getConfiguration(), ms.getId(), Long.class, EMPTY_RESULTMAPPING).build();
    resultMaps.add(resultMap);
    builder.resultMaps(resultMaps);
    builder.resultSetType(ms.getResultSetType());
    builder.cache(ms.getCache());
    builder.flushCacheRequired(ms.isFlushCacheRequired());
    builder.useCache(ms.isUseCache());
    return builder.build();
}

之后执行方法executeAutoCount(executor, countMs, parameter, boundSql, rowBounds, resultHandler)获取count插叙的结果。

private Long executeAutoCount(Executor executor, MappedStatement countMs,
                               Object parameter, BoundSql boundSql,
                               RowBounds rowBounds, ResultHandler resultHandler) throws IllegalAccessException, SQLException {
    Map<String, Object> additionalParameters = (Map<String, Object>) additionalParametersField.get(boundSql);
    //创建 count 查询的缓存 key
    CacheKey countKey = executor.createCacheKey(countMs, parameter, RowBounds.DEFAULT, boundSql);
    //调用方言获取 count sql
    String countSql = dialect.getCountSql(countMs, boundSql, parameter, rowBounds, countKey);
    //countKey.update(countSql);
    BoundSql countBoundSql = new BoundSql(countMs.getConfiguration(), countSql, boundSql.getParameterMappings(), parameter);
    //当使用动态 SQL 时，可能会产生临时的参数，这些参数需要手动设置到新的 BoundSql 中
    for (String key : additionalParameters.keySet()) {
        countBoundSql.setAdditionalParameter(key, additionalParameters.get(key));
    }
    //执行 count 查询
    Object countResultList = executor.query(countMs, parameter, RowBounds.DEFAULT, resultHandler, countKey, countBoundSql);
    Long count = (Long) ((List) countResultList).get(0);
    return count;
}

dialect.getCountSql根据当前查询sql语句返回一个select count(0)。。。形式的sql语句，因为AbstractHelperDialect内的countSqlParser提供了这样的能力(有兴趣的自己看下具体实现，这里不再展开)。构建好了新的BoundSql后传入executor的query方法返回数量。

2.dialect.beforePage(ms, parameter, rowBounds)) 判断是否需要进行分页查询

public boolean beforePage(MappedStatement ms, Object parameterObject, RowBounds rowBounds) {
    Page page = getLocalPage();
    if (page.isOrderByOnly() || page.getPageSize() > 0) {
        return true;
    }
    return false;
}

String pageSql = dialect.getPageSql(ms, boundSql, parameter, rowBounds, pageKey);这句是分页的核心方法，用于加入分页语句，对于mysql就是limit xx,yy。

 //执行分页查询

 resultList = executor.query(ms, parameter, RowBounds.DEFAULT, resultHandler, pageKey, pageBoundSql);

最后调用dialect.afterPage(resultList, parameter, rowBounds);填充resultList和count到ThreadLocal的Page中。

在intercept方法中最后的finally代码块中会调用 dialect.afterAll();内部会清除ThreadLocal的变量，所以每次调用分页方法都要重新设置Page到ThreadLocal中。