PageHelper分页原理解析

开心一刻

说实话，作为一个宅男，每次被淘宝上的雄性店主追着喊“亲，亲，亲”，这感觉真的很恶心，仿佛被强吻一样。更让人烦的是为了省钱，我不得不用个女号跟那些店主沟通：“哥哥包邮吗？”“哥哥再便宜点呗，我钱不够了嘛，5555555。”这些日子真是充满了不堪的苦难。

问题背景

用过PageHelper的都知道（没用过的赶紧去百度下），实现分页非常简单。服务实现层调用DAO层之前进行Page设置，Mapper.xml中不处理分页，这样就够了，就能实现分页了。以下是具体实现代码：

@Override
public PageInfo listUser(int pageNum, int pageSize) {
    PageHelper.startPage(pageNum, pageSize);
    List
   
     users = userMapper.listUser();
    PageInfo pageInfo = new PageInfo(users);
    return pageInfo;
}

哎我去，这样就实现分页了？这是什么意思？这是怎么做到的？凡事有果必有因，我们一起来看看这个因到底是什么。

JDK的动态代理

在进入正题之前，我们先做下准备。如果对动态代理很熟悉，可以略过，但建议还是看看，权且当做热身。

我们来看看JDK下的动态代理的具体实现：

public class PageHelperAutoConfiguration {
    @Autowired
    private List
   
     sqlSessionFactoryList;
    @Autowired
    private PageHelperProperties properties;
    @Bean
    @ConfigurationProperties(prefix = PageHelperProperties.PAGEHELPER_PREFIX)
    public Properties pageHelperProperties() {
        return new Properties();
    }
    @PostConstruct
    public void addPageInterceptor() {
        PageInterceptor interceptor = new PageInterceptor();
        Properties properties = new Properties();
        properties.putAll(pageHelperProperties());
        properties.putAll(this.properties.getProperties());
        interceptor.setProperties(properties);
        for (SqlSessionFactory sqlSessionFactory : sqlSessionFactoryList) {
            sqlSessionFactory.getConfiguration().addInterceptor(interceptor);
        }
    }
}

从Mybatis的SQL执行流程图中可以看到，Mybatis的四大对象Executor、ParameterHandler、ResultSetHandler、StatementHandler，由他们一起合作完成SQL的执行，这四大对象是由谁创建的呢？没错，就是Mybatis的配置中心：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;
}

pluginAll方法的实现如下：

public static Object wrap(Object target, Interceptor interceptor) {
    Map
   
     signatureMap = getSignatureMap(interceptor);
    Class
     type = target.getClass();
    Class
    [] interfaces = getAllInterfaces(type, signatureMap);
    if (interfaces.length > 0) {
        return Proxy.newProxyInstance(
            type.getClassLoader(),
            interfaces,
            new Plugin(target, interceptor, signatureMap)
        );
    }
    return target;
}

pluginAll其实就是给四大对象创建代理，而我们的PageInterceptor只是其中一层代理。我们接着往下看，Plugin继承了InvocationHandler，相当于上述：JDK的动态代理示例中的MyInvocationHandler，它的invoke方法肯定会被调用：

@Override
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);
    }
}

拦截器：PageInterceptor

在解读intercept方法之前，我们先来看看PageInterceptor类上的注解：

@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})
})

这就标明了PageInterceptor拦截的是Executor的query方法；还记上述wrap方法的：

Map
   
     signatureMap = getSignatureMap(interceptor);

吗？读取的就是@Intercepts下@Signature中的内容。我们接着看intercept方法：

@Override
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) {
            boundSql = ms.getBoundSql(parameter);
            cacheKey = executor.createCacheKey(ms, parameter, rowBounds, boundSql);
        } else {
            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
   
     additionalParameters = (Map
    
     ) additionalParametersField.get(boundSql);
            if (dialect.beforeCount(ms, parameter, rowBounds)) {
                String countMsId = msId + countSuffix;
                Long count;
                MappedStatement countMs = getExistedMappedStatement(configuration, countMsId);
                if (countMs != null) {
                    count = executeManualCount(executor, countMs, parameter, boundSql, resultHandler);
                } else {
                    countMs = msCountMap.get(countMsId);
                    if (countMs == null) {
                        countMs = MSUtils.newCountMappedStatement(ms, countMsId);
                        msCountMap.put(countMsId, countMs);
                    }
                    count = executeAutoCount(executor, countMs, parameter, boundSql, rowBounds, resultHandler);
                }
                if (!dialect.afterCount(count, parameter, rowBounds)) {
                    return dialect.afterPage(new ArrayList(), parameter, rowBounds);
                }
            }
            if (dialect.beforePage(ms, parameter, rowBounds)) {
                parameter = dialect.processParameterObject(ms, parameter, boundSql, cacheKey);
                String pageSql = dialect.getPageSql(ms, boundSql, parameter, rowBounds, cacheKey);
                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, cacheKey, pageBoundSql);
            } else {
                resultList = executor.query(ms, parameter, rowBounds, resultHandler, cacheKey, boundSql);
            }
        } else {
            resultList = executor.query(ms, parameter, rowBounds, resultHandler, cacheKey, boundSql);
        }
        return dialect.afterPage(resultList, parameter, rowBounds);
    } finally {
        dialect.afterAll();
    }
}

其中会读取当前线程中的Page信息，根据Page信息来断定是否需要分页；而Page信息就是从我们的业务代码中存放到当前线程的。PageHelper的作者已经将intercept方法中的注释写得非常清楚了，相信大家都能看懂。

总结

1、PageHelper属于Mybatis插件拓展，也可称拦截器拓展，是基于Mybatis的Interceptor实现；

2、Page信息是在我们的业务代码中放到当前线程的，作为后续是否需要分页的条件；

3、Mybatis创建mapper代理的过程（详情请看：）中，也会创建四大对象的代理(有必要的话)，而PageInterceptor对应的四大对象的代理会拦截Executor的query方法，将分页参数添加到目标SQL中；

4、不管我们是否需要分页，只要我们集成了PageHelper，那么四大对象的代理实现中肯定包含了一层PageHelper的代理（可能是多层代理，包括其他第三方的Mybatis插件，或者我们自定义的Mybatis插件），如果当前线程中设置了Page，那么就表示需要分页，PageHelper就会读取当前线程中的Page信息，将分页条件添加到目标SQL中（Mysql是后面添加LIMIT，而Oracle则不一样），那么此时发送到数据库的SQL是有分页条件的，也就完成了分页处理；

5、@Intercepts、@Signature以及Plugin类，三者配合起来，完成了分页逻辑的植入，Mybatis这么做便于拓展，使用起来更灵活，包容性更强；我们自定义插件的话，可以基于此，也可以抛弃这3个类，直接在plugin方法内部根据target实例的类型做相应的操作；个人推荐基于这3个来实现；

6、Mybatis的Interceptor是基于JDK的动态代理，只能针对接口进行处理；另外，当我们进行Mybatis插件开发的时候，需要注意顺序问题，可能会与其他的Mybatis插件有冲突。

转载地址：http://dilbz.baihongyu.com/

你可能感兴趣的文章