MyBatis 分页插件 PageHelper:是如何拦截SQL进行分页

电玩女神 2022-10-11 15:53 288阅读 0赞

**目录**

Springboot项目集成

分页插件参数介绍

如何选择配置这些参数

场景一

场景二

场景三

场景四

场景五

PageHelper的使用

PageHelper实现原理1: interceptor

1. springboot 中接入interceptor

2. interceptor的初始化

3. interceptor的调用过程

4. 是否跳过分页判定

5. PageHelper的 count 操作

6. select list 的改装

思考

ThreadLocal在PageHelper中的应用

PageHelper通过ThreadLocal来共享分页信息，那么它是何时进行清除的呢？

什么时候会导致不安全的分页？

--------------------

# `Springboot项目集成` #

**pom.xml中引入依赖**

<dependency>
 	<groupId>com.github.pagehelper</groupId>
 	<artifactId>pagehelper-spring-boot-starter</artifactId>
 	<version>1.3.0</version>
 </dependency>

**application.yml中引入配置**

pagehelper:
      helperDialect: mysql
      reasonable: true
      supportMethodsArguments: true
      params: count=countSql

## 分页插件参数介绍 ##

1. `helperDialect`：分页插件会自动检测当前的数据库链接，自动选择合适的分页方式。 你可以配置`helperDialect`属性来指定分页插件使用哪种方言。配置时，可以使用下面的缩写值： 
 `oracle`,`mysql`,`mariadb`,`sqlite`,`hsqldb`,`postgresql`,`db2`,`sqlserver`,`informix`,`h2`,`sqlserver2012`,`derby` 
 **特别注意：**使用 SqlServer2012 数据库时，需要手动指定为 `sqlserver2012`，否则会使用 SqlServer2005 的方式进行分页。 
 你也可以实现 `AbstractHelperDialect`，然后配置该属性为实现类的全限定名称即可使用自定义的实现方法。
2. `offsetAsPageNum`：默认值为 `false`，该参数对使用 `RowBounds` 作为分页参数时有效。 当该参数设置为 `true` 时，会将 `RowBounds` 中的 `offset` 参数当成 `pageNum` 使用，可以用页码和页面大小两个参数进行分页。
3. `rowBoundsWithCount`：默认值为`false`，该参数对使用 `RowBounds` 作为分页参数时有效。 当该参数设置为`true`时，使用 `RowBounds` 分页会进行 count 查询。
4. `pageSizeZero`：默认值为 `false`，当该参数设置为 `true` 时，如果 `pageSize=0` 或者 `RowBounds.limit = 0` 就会查询出全部的结果（相当于没有执行分页查询，但是返回结果仍然是 `Page` 类型）。
5. `reasonable`：分页合理化参数，默认值为`false`。当该参数设置为 `true` 时，`pageNum<=0` 时会查询第一页， `pageNum>pages`（超过总数时），会查询最后一页。默认`false` 时，直接根据参数进行查询。
6. `params`：为了支持`startPage(Object params)`方法，增加了该参数来配置参数映射，用于从对象中根据属性名取值， 可以配置 `pageNum,pageSize,count,pageSizeZero,reasonable`，不配置映射的用默认值， 默认值为`pageNum=pageNum;pageSize=pageSize;count=countSql;reasonable=reasonable;pageSizeZero=pageSizeZero`。
7. `supportMethodsArguments`：支持通过 Mapper 接口参数来传递分页参数，默认值`false`，分页插件会从查询方法的参数值中，自动根据上面 `params` 配置的字段中取值，查找到合适的值时就会自动分页。 使用方法可以参考测试代码中的 `com.github.pagehelper.test.basic` 包下的 `ArgumentsMapTest` 和 `ArgumentsObjTest`。
8. `autoRuntimeDialect`：默认值为 `false`。设置为 `true` 时，允许在运行时根据多数据源自动识别对应方言的分页 （不支持自动选择`sqlserver2012`，只能使用`sqlserver`），用法和注意事项参考下面的**场景五**。
9. `closeConn`：默认值为 `true`。当使用运行时动态数据源或没有设置 `helperDialect` 属性自动获取数据库类型时，会自动获取一个数据库连接， 通过该属性来设置是否关闭获取的这个连接，默认`true`关闭，设置为 `false` 后，不会关闭获取的连接，这个参数的设置要根据自己选择的数据源来决定。

**重要提示：**

当 `offsetAsPageNum=false` 的时候，由于 `PageNum` 问题，`RowBounds`查询的时候 `reasonable` 会强制为 `false`。使用 `PageHelper.startPage` 方法不受影响。

## 如何选择配置这些参数 ##

单独看每个参数的说明可能是一件让人不爽的事情，这里列举一些可能会用到某些参数的情况。

### 场景一 ###

如果你仍然在用类似ibatis式的命名空间调用方式，你也许会用到`rowBoundsWithCount`， 分页插件对`RowBounds`支持和 MyBatis 默认的方式是一致，默认情况下不会进行 count 查询，如果你想在分页查询时进行 count 查询， 以及使用更强大的 `PageInfo` 类，你需要设置该参数为 `true`。

**注：** `PageRowBounds` 想要查询总数也需要配置该属性为 `true`。

### 场景二 ###

如果你仍然在用类似ibatis式的命名空间调用方式，你觉得 `RowBounds` 中的两个参数 `offset,limit` 不如 `pageNum,pageSize` 容易理解， 你可以使用 `offsetAsPageNum` 参数，将该参数设置为 `true` 后，`offset`会当成 `pageNum` 使用，`limit` 和 `pageSize` 含义相同。

### 场景三 ###

如果觉得某个地方使用分页后，你仍然想通过控制参数查询全部的结果，你可以配置 `pageSizeZero` 为 `true`， 配置后，当 `pageSize=0` 或者 `RowBounds.limit = 0` 就会查询出全部的结果。

### 场景四 ###

如果你分页插件使用于类似分页查看列表式的数据，如新闻列表，软件列表， 你希望用户输入的页数不在合法范围（第一页到最后一页之外）时能够正确的响应到正确的结果页面， 那么你可以配置 `reasonable` 为 `true`，这时如果 `pageNum<=0` 会查询第一页，如果 `pageNum>总页数` 会查询最后一页。

### 场景五 ###

如果你在 Spring 中配置了动态数据源，并且连接不同类型的数据库，这时你可以配置 `autoRuntimeDialect` 为 `true`，这样在使用不同数据源时，会使用匹配的分页进行查询。 这种情况下，你还需要特别注意 `closeConn` 参数，由于获取数据源类型会获取一个数据库连接，所以需要通过这个参数来控制获取连接后，是否关闭该连接。 默认为 `true`，有些数据库连接关闭后就没法进行后续的数据库操作。而有些数据库连接不关闭就会很快由于连接数用完而导致数据库无响应。所以在使用该功能时，特别需要注意你使用的数据源是否需要关闭数据库连接。

当不使用动态数据源而只是自动获取 `helperDialect` 时，数据库连接只会获取一次，所以不需要担心占用的这一个连接是否会导致数据库出错，但是最好也根据数据源的特性选择是否关闭连接。

> 更多参考: [https://pagehelper.github.io/docs/howtouse/][https_pagehelper.github.io_docs_howtouse]

# PageHelper的使用 #

使用的时候，只需在查询list前，调用 startPage 设置分页信息，即可使用分页功能。

public Object getUsers(int pageNum, int pageSize) {
        PageHelper.startPage(pageNum, pageSize);
        // 不带分页的查询
        List<UserEntity> list = userMapper.selectAllWithPage(null);
        // 可以将结果转换为 Page , 然后获取 count 和其他结果值
        com.github.pagehelper.Page listWithPage = (com.github.pagehelper.Page) list;
        System.out.println("listCnt:" + listWithPage.getTotal());
        return list;
   }

>  *  即使用时, 只需提前声明要分页的信息, 得到的结果就是有分页信息的了.
>  *  如果不想进行count, 只要查分页数据, 则调用: PageHelper.startPage(pageNum, pageSize, false); 即可, 避免了不必要的count消耗.

# PageHelper实现原理1: interceptor #

mybatis 有个插件机制，可以支持外部应用进行任意扩展。它在启动的时候会将 interceptor 添加到mybatis的上下文中。然后在进行查询时再触发实例化动作.

Mybatis拦截器可以对下面4种对象进行拦截：

<table style="width:500px;"> 
 <tbody> 
 <tr> 
 <td>拦截对象</td> 
 <td>拦截方法</td> 
 <td>方法作用</td> 
 </tr> 
 <tr> 
 <td style="text-align:center;">Executor</td> 
 <td>update&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</td> 
 <td>对应insert,delete,update语句</td> 
 </tr> 
 <tr> 
 <td>query</td> 
 <td>对应select语句</td> 
 </tr> 
 <tr> 
 <td>flushStatements</td> 
 <td>刷新Statement</td> 
 </tr> 
 <tr> 
 <td>commit</td> 
 <td>提交事务</td> 
 </tr> 
 <tr> 
 <td>rollback</td> 
 <td>回滚事务</td> 
 </tr> 
 <tr> 
 <td>getTransaction</td> 
 <td>获取事务</td> 
 </tr> 
 <tr> 
 <td>close</td> 
 <td>关闭事务</td> 
 </tr> 
 <tr> 
 <td>isClosed</td> 
 <td>判断事务是否关闭</td> 
 </tr> 
 <tr> 
 <td>StatementHandler</td> 
 <td>prepare</td> 
 <td> 预编译SQL </td> 
 </tr> 
 <tr> 
 <td>parameterize</td> 
 <td>设置参数</td> 
 </tr> 
 <tr> 
 <td> batch </td> 
 <td>批处理</td> 
 </tr> 
 <tr> 
 <td>update&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</td> 
 <td>对应insert,delete,update语句</td> 
 </tr> 
 <tr> 
 <td>query</td> 
 <td>对应select语句</td> 
 </tr> 
 <tr> 
 <td style="text-align:center;">ParameterHandler</td> 
 <td>getParameterObject</td> 
 <td>获取参数</td> 
 </tr> 
 <tr> 
 <td>setParameters</td> 
 <td>设置参数</td> 
 </tr> 
 <tr> 
 <td>ResultSetHandler</td> 
 <td>handleResultSets</td> 
 <td>处理结果集</td> 
 </tr> 
 <tr> 
 <td>handleOutputParameters</td> 
 <td>处理存储过程出参</td> 
 </tr> 
 </tbody> 
</table>

*  Executor：mybatis的内部执行器，作为调度核心负责调用StatementHandler操作数据库，并把结果集通过ResultSetHandler进行自动映射
 *  StatementHandler： 封装了JDBC Statement操作，是sql语法的构建器，负责和数据库进行交互执行sql语句
 *  ParameterHandler：作为处理sql参数设置的对象，主要实现读取参数和对PreparedStatement的参数进行赋值
 *  ResultSetHandler：处理Statement执行完成后返回结果集的接口对象，mybatis通过它把ResultSet集合映射成实体对象

> 估计你也猜到了，PageHelper也是用的mybatis的拦截器进行分页的

## 1. springboot 中接入interceptor ##

springboot 中接入pagehelper非常简单, 主要受益于初始化的方式, 它会自动加载配置.

// com.github.pagehelper.autoconfigure.PageHelperAutoConfiguration#addPageInterceptor
        @PostConstruct
        public void addPageInterceptor() {
            // 初始化 com.github.pagehelper.PageInterceptor
            PageInterceptor interceptor = new PageInterceptor();
            Properties properties = new Properties();
            //先把一般方式配置的属性放进去
            properties.putAll(pageHelperProperties());
            //在把特殊配置放进去，由于close-conn 利用上面方式时，属性名就是 close-conn 而不是 closeConn，所以需要额外的一步
            properties.putAll(this.properties.getProperties());
            interceptor.setProperties(properties);
            for (SqlSessionFactory sqlSessionFactory : sqlSessionFactoryList) {
                // 添加inteceptor到 mybatis 中
                sqlSessionFactory.getConfiguration().addInterceptor(interceptor);
            }
        }
      // org.apache.ibatis.session.Configuration#addInterceptor
      public void addInterceptor(Interceptor interceptor) {
        interceptorChain.addInterceptor(interceptor);
      }
      
      // org.apache.ibatis.plugin.InterceptorChain#addInterceptor
      public void addInterceptor(Interceptor interceptor) {
        // 使用 ArrayList 保存intceptor
        interceptors.add(interceptor);
      }

借助springboot的自动配置， 获取mybatis的sqlSessionFactoryList, 依次将 PageHelper接入其中。

## 2. interceptor的初始化 ##

将 interceptor 添加到mybatis上下文后, 会在每次调用查询时进行拦截请求, 它的初始化也会在这时候触发.

> 我们知道，Sqlsession对象是通过openSession()方法返回的，
> 
> 而Executor又是属于SqlSession内部对象，所以让我们跟随openSession方法去看一下Executor对象的初始化过程。

// org.apache.ibatis.session.Configuration#newExecutor
 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);
   }
   // 以interceptorChain包装 executor, 以便inteceptor发挥作用
 // 可以看到，当初始化完成Executor之后，会调用interceptorChain的pluginAll方法，
 // pluginAll方法本身非常简单，就是把我们存到list中的插件进行循环，并调用Interceptor对象的plugin方法：
   executor = (Executor) interceptorChain.pluginAll(executor);
   return executor;
 }
  
 // org.apache.ibatis.plugin.InterceptorChain#pluginAll
 public Object pluginAll(Object target) {
   for (Interceptor interceptor : interceptors) {
     // 使用plugin一层层包装 target, 具体实现为使用代理包装 target
     // 所以, interceptor 的使用顺序是按照添加的顺序来的, 并不能自行设置
     target = interceptor.plugin(target);
   }
   return target;
 }
  
   // com.github.pagehelper.PageInterceptor#plugin
   @Override
   public Object plugin(Object target) {
       return Plugin.wrap(target, this);
   }
 // org.apache.ibatis.plugin.Plugin#wrap
 public static Object wrap(Object target, Interceptor interceptor) {
   // 获取注解中说明的方式列表 @Intercepts -> @Signature, 下面我们看 pageInterceptor的注解
   Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
   Class<?> type = target.getClass();
   // 过滤需要进行代理的接口, 而非全部代理
   Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
   if (interfaces.length > 0) {
     // 使用jdk方式生成动态代理
     return Proxy.newProxyInstance(
         type.getClassLoader(),
         interfaces,
         // 使用 Plugin 包装代理实现
         new Plugin(target, interceptor, signatureMap));
   }
   return target;
 }
 // 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}),
       }
 )
 // 过滤代理的接口
 private static Class<?>[] getAllInterfaces(Class<?> type, Map<Class<?>, Set<Method>> signatureMap) {
   Set<Class<?>> interfaces = new HashSet<>();
   while (type != null) {
     for (Class<?> c : type.getInterfaces()) {
       // 只有设置了的接口才会被添加
       if (signatureMap.containsKey(c)) {
         interfaces.add(c);
       }
     }
     type = type.getSuperclass();
   }
   return interfaces.toArray(new Class<?>[interfaces.size()]);
 }

这样, interceptor 就和executor绑定了, 后续的查询将会看到interceptor 的作用.

> 看到InterceptorChain我们是不是可以联想到，**MyBatis的插件就是通过责任链模式实现的**。
> 
> 要注意的是MyBatis插件是通过JDK动态代理来实现的，而JDK动态代理的条件就是被代理对象必须要有接口，这一点和Spring中不太一样，Spring中是如果有接口就采用JDK动态代理，没有接口就是用CGLIB动态代理。

## 3. interceptor的调用过程 ##

在executor被代理后, 会继续执行查询动作, 这时就会被interceptor拦截了.

> 正因为MyBatis的插件只使用了JDK动态代理，所以我们上面才强调了一定要实现Interceptor接口。  
> 而代理之后会执行Plugin的invoke方法，我们最后再来看看invoke方法：

// org.apache.ibatis.plugin.Plugin#invoke
 @Override
 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)) {
       // 匹配的方法会被拦截, 即 query 方法
       return interceptor.intercept(new Invocation(target, method, args));
     }
     return method.invoke(target, args);
   } catch (Exception e) {
     throw ExceptionUtil.unwrapThrowable(e);
   }
 }
   // PageHelper正式起作用的入口
   // com.github.pagehelper.PageInterceptor#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) {
               //4 个参数时
               boundSql = ms.getBoundSql(parameter);
               cacheKey = executor.createCacheKey(ms, parameter, rowBounds, boundSql);
           } else {
               //6 个参数时
               cacheKey = (CacheKey) args[4];
               boundSql = (BoundSql) args[5];
           }
           checkDialectExists();
 
           List resultList;
           //调用方法判断是否需要进行分页，如果不需要，直接返回结果
           if (!dialect.skip(ms, parameter, rowBounds)) {
               //判断是否需要进行 count 查询
               if (dialect.beforeCount(ms, parameter, rowBounds)) {
                   //查询总数
                   Long count = count(executor, ms, parameter, rowBounds, resultHandler, boundSql);
                   //处理查询总数，返回 true 时继续分页查询，false 时直接返回
                   if (!dialect.afterCount(count, parameter, rowBounds)) {
                       //当查询总数为 0 时，直接返回空的结果
                       return dialect.afterPage(new ArrayList(), parameter, rowBounds);
                   }
               }
               resultList = ExecutorUtil.pageQuery(dialect, executor,
                       ms, parameter, rowBounds, resultHandler, boundSql, cacheKey);
           } else {
               //rowBounds用参数值，不使用分页插件处理时，仍然支持默认的内存分页
               resultList = executor.query(ms, parameter, rowBounds, resultHandler, cacheKey, boundSql);
           }
           return dialect.afterPage(resultList, parameter, rowBounds);
       } finally {
           if(dialect != null){
               dialect.afterAll();
           }
       }
   }

以上就是 PageHelper的大体执行框架了:

> 1. 先解析各位置参数; 　　　　
> 
> 2. 初始化 PageHelper实例, 即 dialect; 　　　　
> 
> 3. 调用方法判断是否需要进行分页，如果不需要，直接返回结果; 　　
> 
> 4. 判断是否要进行count, 如果需要则实现一次count, ; 　　　
> 
> 5. 查询分页结果; 　　　
> 
> 6. 封装带分页的结果返回;

下面我们就每个细节依次看看实现吧.

## 4. 是否跳过分页判定 ##

首先会进行是否需要跳过分页逻辑,如果跳过, 则直接执行mybatis的核心逻辑继续查询.

而是否要跳过分页, 则是通过直接获取page分页参数来决定的,没有分页参数设置,则跳过, 否则执行分页查询. 这算是分页的一个入口判定呢。

/**
         * 跳过 count 和 分页查询
         *
         * @param ms              MappedStatement
         * @param parameterObject 方法参数
         * @param rowBounds       分页参数
         * @return true 跳过，返回默认查询结果，false 执行分页查询
         */
         // com.github.pagehelper.PageHelper#skip
        @Override
        public boolean skip(MappedStatement ms, Object parameterObject, RowBounds rowBounds) {
            if (ms.getId().endsWith(MSUtils.COUNT)) {
                throw new RuntimeException("在系统中发现了多个分页插件，请检查系统配置!");
            }
            // 如果 page 返回null, 则不需要进行分页, 即是否调用  PageHelper.start(pageNo, pageSize) 方法
            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;
            }
        }
        // com.github.pagehelper.page.PageAutoDialect#initDelegateDialect
        //多数据动态获取时，每次需要初始化
        public void initDelegateDialect(MappedStatement ms) {
            if (delegate == null) {
                if (autoDialect) {
                    // 比如 MySqlDialect
                    this.delegate = getDialect(ms);
                } else {
                    dialectThreadLocal.set(getDialect(ms));
                }
            }
        }
    
        /**
         * 获取分页参数
         */
        // com.github.pagehelper.page.PageParams#getPage
        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(parameterObject instanceof IPage || 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;
        }

才上判定决定了后续的分页效果，主要是利用 ThreadLocal 来保存分页信息，从而与用户代码产生关联。

## 5. PageHelper的 count 操作 ##

判断是否是否需要count, 这些判定都会以 PageHelper作为门面类进行接入, 而特殊地方则由具体方言实现.

// com.github.pagehelper.PageHelper#beforeCount
   @Override
   public boolean beforeCount(MappedStatement ms, Object parameterObject, RowBounds rowBounds) {
       return autoDialect.getDelegate().beforeCount(ms, parameterObject, rowBounds);
   }
 
   // com.github.pagehelper.dialect.AbstractHelperDialect#beforeCount
   @Override
   public boolean beforeCount(MappedStatement ms, Object parameterObject, RowBounds rowBounds) {
       // 获取page参数信息, 该参数设置在 ThreadLocal 中
       Page page = getLocalPage();
       return !page.isOrderByOnly() && page.isCount();
   }
   // 如果需要进行count, 则需要自行组装count逻辑进行查询.
   // com.github.pagehelper.PageInterceptor#count
   private Long count(Executor executor, MappedStatement ms, Object parameter,
                       RowBounds rowBounds, ResultHandler resultHandler,
                       BoundSql boundSql) throws SQLException {
       // 在原有list 查询后添加 _COUNT 代表count查询id
       String countMsId = ms.getId() + countSuffix;
       Long count;
       //先判断是否存在手写的 count 查询
       MappedStatement countMs = ExecutorUtil.getExistedMappedStatement(ms.getConfiguration(), countMsId);
       if (countMs != null) {
           count = ExecutorUtil.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 = ExecutorUtil.executeAutoCount(dialect, executor, countMs, parameter, boundSql, rowBounds, resultHandler);
       }
       return count;
   }
   // 创建count ms
   // com.github.pagehelper.util.MSUtils#newCountMappedStatement(org.apache.ibatis.mapping.MappedStatement, java.lang.String)
   public static MappedStatement newCountMappedStatement(MappedStatement ms, String newMsId) {
       // 直接基于原有 sql 构建新的 MappedStatement
       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();
   }
 
   /**
     * 执行自动生成的 count 查询
     */
     // com.github.pagehelper.util.ExecutorUtil#executeAutoCount
   public static Long executeAutoCount(Dialect dialect, Executor executor, MappedStatement countMs,
                                       Object parameter, BoundSql boundSql,
                                       RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
       Map<String, Object> additionalParameters = getAdditionalParameter(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;
   }
   // com.github.pagehelper.PageHelper#getCountSql
   @Override
   public String getCountSql(MappedStatement ms, BoundSql boundSql, Object parameterObject, RowBounds rowBounds, CacheKey countKey) {
       // 委托给各方言实现 sql 组装
       return autoDialect.getDelegate().getCountSql(ms, boundSql, parameterObject, rowBounds, countKey);
   }
 
   // com.github.pagehelper.dialect.AbstractHelperDialect#getCountSql
   @Override
   public String getCountSql(MappedStatement ms, BoundSql boundSql, Object parameterObject, RowBounds rowBounds, CacheKey countKey) {
       Page<Object> page = getLocalPage();
       String countColumn = page.getCountColumn();
       if (StringUtil.isNotEmpty(countColumn)) {
           return countSqlParser.getSmartCountSql(boundSql.getSql(), countColumn);
       }
       return countSqlParser.getSmartCountSql(boundSql.getSql());
   }
 
   /**
     * 获取智能的countSql
     *
     * @param sql
     * @param name 列名，默认 0
     * @return
     */
     // com.github.pagehelper.parser.CountSqlParser#getSmartCountSql(java.lang.String, java.lang.String)
   public String getSmartCountSql(String sql, String name) {
       //解析SQL
       Statement stmt = null;
       //特殊sql不需要去掉order by时，使用注释前缀
       if(sql.indexOf(KEEP_ORDERBY) >= 0){
           return getSimpleCountSql(sql, name);
       }
       try {
           stmt = CCJSqlParserUtil.parse(sql);
       } catch (Throwable e) {
           //无法解析的用一般方法返回count语句
           return getSimpleCountSql(sql, name);
       }
       Select select = (Select) stmt;
       SelectBody selectBody = select.getSelectBody();
       try {
           //处理body-去order by
           processSelectBody(selectBody);
       } catch (Exception e) {
           //当 sql 包含 group by 时，不去除 order by
           return getSimpleCountSql(sql, name);
       }
       //处理with-去order by
       processWithItemsList(select.getWithItemsList());
       //处理为count查询
       sqlToCount(select, name);
       String result = select.toString();
       return result;
   }
   /**
     * 将sql转换为count查询
     *
     * @param select
     */
     // com.github.pagehelper.parser.CountSqlParser#sqlToCount
   public void sqlToCount(Select select, String name) {
       SelectBody selectBody = select.getSelectBody();
       // 是否能简化count查询
       List<SelectItem> COUNT_ITEM = new ArrayList<SelectItem>();
       // 如 select * from user 将会被转化为 select count(0) from user
       COUNT_ITEM.add(new SelectExpressionItem(new Column("count(" + name +")")));
       if (selectBody instanceof PlainSelect && isSimpleCount((PlainSelect) selectBody)) {
           // 简单sql直接转换select字段为 count(0) 即可, 而这个sql是否支持这种方式则得仔细验证
           ((PlainSelect) selectBody).setSelectItems(COUNT_ITEM);
       } else {
           // 如果对于复杂的sql查询, 则只能在现有sql外围加一个 select count(0) from (xxxxx) as table_count
           PlainSelect plainSelect = new PlainSelect();
           SubSelect subSelect = new SubSelect();
           subSelect.setSelectBody(selectBody);
           subSelect.setAlias(TABLE_ALIAS);
           // 将原sql作为临时表放入 plainSelect 中
           plainSelect.setFromItem(subSelect);
           plainSelect.setSelectItems(COUNT_ITEM);
           // 替换原有 select
           select.setSelectBody(plainSelect);
       }
   }
   /**
     * 是否可以用简单的count查询方式
     */
     // net.sf.jsqlparser.statement.select.PlainSelect
   public boolean isSimpleCount(PlainSelect select) {
       //包含group by的时候不可以
       if (select.getGroupBy() != null) {
           return false;
       }
       //包含distinct的时候不可以
       if (select.getDistinct() != null) {
           return false;
       }
       for (SelectItem item : select.getSelectItems()) {
           //select列中包含参数的时候不可以，否则会引起参数个数错误
           if (item.toString().contains("?")) {
               return false;
           }
           //如果查询列中包含函数，也不可以，函数可能会聚合列
           if (item instanceof SelectExpressionItem) {
               Expression expression = ((SelectExpressionItem) item).getExpression();
               if (expression instanceof Function) {
                   String name = ((Function) expression).getName();
                   if (name != null) {
                       String NAME = name.toUpperCase();
                       if(skipFunctions.contains(NAME)){
                           //go on
                       } else if(falseFunctions.contains(NAME)){
                           return false;
                       } else {
                           for (String aggregateFunction : AGGREGATE_FUNCTIONS) {
                               if(NAME.startsWith(aggregateFunction)){
                                   falseFunctions.add(NAME);
                                   return false;
                               }
                           }
                           skipFunctions.add(NAME);
                       }
                   }
               }
           }
       }
       return true;
   }

大体上讲就是分析sql, 如果是简单查询, 则直接将字段内容转换为 count(0) 即可, 这和我们普通认为的在select外部简单包一层还不太一样哦.

但是对于复杂查询咱们还是只能使用外包一层的实现方式了. 当然了,以上实现是针对mysql的,其他语言可能会有不一样的实现.

## 6. select list 的改装 ##

在执行完count后, 分页的功能完成了一半, 我们可以给到用户这个计数值

另外,我们可以根据该值得到后续分页还有多少数据, 如果没有自然不用再查了, 如果有则组装limit语句.

> ExecutorUtil.pageQuery()来处理分页，但是怎么处理的呢？

// com.github.pagehelper.dialect.AbstractHelperDialect#afterCount
   @Override
   public boolean afterCount(long count, Object parameterObject, RowBounds rowBounds) {
       Page page = getLocalPage();
       page.setTotal(count);
       if (rowBounds instanceof PageRowBounds) {
           ((PageRowBounds) rowBounds).setTotal(count);
       }
       //pageSize < 0 的时候，不执行分页查询
       //pageSize = 0 的时候，还需要执行后续查询，但是不会分页
       if (page.getPageSize() < 0) {
           return false;
       }
       // 还没到最后一页, 则需要进行分页查询
       return count > ((page.getPageNum() - 1) * page.getPageSize());
   }
    
   /**
     * 分页查询
     */
   public static <E> List<E> pageQuery(Dialect dialect, Executor executor, MappedStatement ms, Object parameter,
                                 RowBounds rowBounds, ResultHandler resultHandler,
                                 BoundSql boundSql, CacheKey cacheKey) throws SQLException {
       //判断是否需要进行分页查询
       if (dialect.beforePage(ms, parameter, rowBounds)) {
           //生成分页的缓存 key
           CacheKey pageKey = cacheKey;
           //处理参数对象, 将会加入 pageStart, pageSize 等参数
           parameter = dialect.processParameterObject(ms, parameter, boundSql, pageKey);
           //调用方言获取分页 sql
           String pageSql = dialect.getPageSql(ms, boundSql, parameter, rowBounds, pageKey);
           BoundSql pageBoundSql = new BoundSql(ms.getConfiguration(), pageSql, boundSql.getParameterMappings(), parameter);
 
           Map<String, Object> additionalParameters = getAdditionalParameter(boundSql);
           //设置动态参数
           for (String key : additionalParameters.keySet()) {
               pageBoundSql.setAdditionalParameter(key, additionalParameters.get(key));
           }
           //执行分页查询
           return executor.query(ms, parameter, RowBounds.DEFAULT, resultHandler, pageKey, pageBoundSql);
       } else {
           //不执行分页的情况下，也不执行内存分页
           return executor.query(ms, parameter, RowBounds.DEFAULT, resultHandler, cacheKey, boundSql);
       }
   }
   // com.github.pagehelper.dialect.AbstractHelperDialect#processParameterObject
   @Override
   public Object processParameterObject(MappedStatement ms, Object parameterObject, BoundSql boundSql, CacheKey pageKey) {
       //处理参数
       Page page = getLocalPage();
       //如果只是 order by 就不必处理参数
       if (page.isOrderByOnly()) {
           return parameterObject;
       }
       Map<String, Object> paramMap = null;
       if (parameterObject == null) {
           paramMap = new HashMap<String, Object>();
       } else if (parameterObject instanceof Map) {
           //解决不可变Map的情况
           paramMap = new HashMap<String, Object>();
           paramMap.putAll((Map) parameterObject);
       } else {
           paramMap = new HashMap<String, Object>();
           //动态sql时的判断条件不会出现在ParameterMapping中，但是必须有，所以这里需要收集所有的getter属性
           //TypeHandlerRegistry可以直接处理的会作为一个直接使用的对象进行处理
           boolean hasTypeHandler = ms.getConfiguration().getTypeHandlerRegistry().hasTypeHandler(parameterObject.getClass());
           MetaObject metaObject = MetaObjectUtil.forObject(parameterObject);
           //需要针对注解形式的MyProviderSqlSource保存原值
           if (!hasTypeHandler) {
               for (String name : metaObject.getGetterNames()) {
                   paramMap.put(name, metaObject.getValue(name));
               }
           }
           //下面这段方法，主要解决一个常见类型的参数时的问题
           if (boundSql.getParameterMappings() != null && boundSql.getParameterMappings().size() > 0) {
               for (ParameterMapping parameterMapping : boundSql.getParameterMappings()) {
                   String name = parameterMapping.getProperty();
                   if (!name.equals(PAGEPARAMETER_FIRST)
                           && !name.equals(PAGEPARAMETER_SECOND)
                           && paramMap.get(name) == null) {
                       if (hasTypeHandler
                               || parameterMapping.getJavaType().equals(parameterObject.getClass())) {
                           paramMap.put(name, parameterObject);
                           break;
                       }
                   }
               }
           }
       }
       return processPageParameter(ms, paramMap, page, boundSql, pageKey);
   }
 
   // 加入 page 参数
   // com.github.pagehelper.dialect.helper.MySqlDialect#processPageParameter
   @Override
   public Object processPageParameter(MappedStatement ms, Map<String, Object> paramMap, Page page, BoundSql boundSql, CacheKey pageKey) {
       // First_PageHelper, Second_PageHelper
       paramMap.put(PAGEPARAMETER_FIRST, page.getStartRow());
       paramMap.put(PAGEPARAMETER_SECOND, page.getPageSize());
       //处理pageKey
       pageKey.update(page.getStartRow());
       pageKey.update(page.getPageSize());
       //处理参数配置
       if (boundSql.getParameterMappings() != null) {
           List<ParameterMapping> newParameterMappings = new ArrayList<ParameterMapping>(boundSql.getParameterMappings());
           if (page.getStartRow() == 0) {
               newParameterMappings.add(new ParameterMapping.Builder(ms.getConfiguration(), PAGEPARAMETER_SECOND, Integer.class).build());
           } else {
               newParameterMappings.add(new ParameterMapping.Builder(ms.getConfiguration(), PAGEPARAMETER_FIRST, Integer.class).build());
               newParameterMappings.add(new ParameterMapping.Builder(ms.getConfiguration(), PAGEPARAMETER_SECOND, Integer.class).build());
           }
           MetaObject metaObject = MetaObjectUtil.forObject(boundSql);
           metaObject.setValue("parameterMappings", newParameterMappings);
       }
       return paramMap;
   }
   // 组装分页sql
   // com.github.pagehelper.dialect.AbstractHelperDialect#getPageSql
   @Override
   public String getPageSql(MappedStatement ms, BoundSql boundSql, Object parameterObject, RowBounds rowBounds, CacheKey pageKey) {
       String sql = boundSql.getSql();
       Page page = getLocalPage();
       //支持 order by
       String orderBy = page.getOrderBy();
       if (StringUtil.isNotEmpty(orderBy)) {
           pageKey.update(orderBy);
           sql = OrderByParser.converToOrderBySql(sql, orderBy);
       }
       if (page.isOrderByOnly()) {
           return sql;
       }
       return getPageSql(sql, page, pageKey);
   }
   // com.github.pagehelper.dialect.helper.MySqlDialect#getPageSql
   @Override
   public String getPageSql(String sql, Page page, CacheKey pageKey) {
       StringBuilder sqlBuilder = new StringBuilder(sql.length() + 14);
       sqlBuilder.append(sql);
       // 分页sql拼接, limit xxx
       if (page.getStartRow() == 0) {
           sqlBuilder.append(" LIMIT ? ");
       } else {
           sqlBuilder.append(" LIMIT ?, ? ");
       }
       return sqlBuilder.toString();
   }

> PageHelper首先将前端传递的参数保存到page这个对象中，接着将page的副本存放入ThreadLoacl中，这样可以保证分页的时候，参数互不影响，接着利用了mybatis提供的拦截器，取得ThreadLocal的值，重新拼装分页SQL，完成分页

经过上面的sql重组之后,就可以得到具体分页的list数据了, 返回的也是list数据.

那么, 用户如何获取其他的分页信息呢? 比如count值去了哪里?

> 实际上, **在list 返回之后, 还有一个 afterPage 的动作要做, 而它的作用就是封装list 为带page信息的list.**

// com.github.pagehelper.PageHelper#afterPage
        @Override
        public Object afterPage(List pageList, Object parameterObject, RowBounds rowBounds) {
            //这个方法即使不分页也会被执行，所以要判断 null
            AbstractHelperDialect delegate = autoDialect.getDelegate();
            if (delegate != null) {
                return delegate.afterPage(pageList, parameterObject, rowBounds);
            }
            return pageList;
        }
        
        // com.github.pagehelper.dialect.AbstractHelperDialect#afterPage
        @Override
        public Object afterPage(List pageList, Object parameterObject, RowBounds rowBounds) {
            // 取出本线程的page变量, 放入list
            Page page = getLocalPage();
            if (page == null) {
                return pageList;
            }
            page.addAll(pageList);
            // count 值临时变换, 用于应对没有进行count的场景, 使外部表现一致
            if (!page.isCount()) {
                page.setTotal(-1);
            } else if ((page.getPageSizeZero() != null && page.getPageSizeZero()) && page.getPageSize() == 0) {
                page.setTotal(pageList.size());
            } else if(page.isOrderByOnly()){
                page.setTotal(pageList.size());
            }
            return page;
        }

至此, 一个完整的分页功能就完成了. 核心逻辑最开始也已看到, 就是判断是否需要分页, 是否需要count, 然后添加分页sql取数的这么个过程. 其本身并无太多银弹, 但却是能让我们节省不少时间. 另外就是, 在应对数据库可能发生切换的场景, 我们也可以无需更改此部分代码, 从而减轻了历史负担. 用用又何乐而不为呢?

# 思考 #

## `ThreadLocal`在`PageHelper`中的应用 ##

/**
 * 分页调用的最终方法
 **/
 public static <E> Page<E> startPage(int pageNum, int pageSize, boolean count,
 Boolean reasonable, Boolean pageSizeZero) {
 Page<E> page = new Page<E>(pageNum, pageSize, count);
 page.setReasonable(reasonable);
 page.setPageSizeZero(pageSizeZero);
 //当已经执行过orderBy的时候
 Page<E> oldPage = getLocalPage();
 if (oldPage != null && oldPage.isOrderByOnly()) {
 page.setOrderBy(oldPage.getOrderBy());
 }
 setLocalPage(page);
 return page;
 }
 
 //里边最重要的就是Page<E> oldPage = getLocalPage();和setLocalPage(page);方法，他俩是看当前线程中的
 //ThreadLocal.ThreadLocalMap中是否存在该page对象，若存在直接取出，若不存在则设置一个，我们以第一个为例继续深入
 
 
 protected static final ThreadLocal<Page> LOCAL_PAGE = new ThreadLocal<Page>();
 /**
 * 获取 Page 参数
 * @return
 */
 public static <T> Page<T> getLocalPage() {
 return LOCAL_PAGE.get();
 }
 
 public T get() {
 //获取当前线程
 Thread t = Thread.currentThread();
 //获取当前线程中的ThreadLocalMap
 ThreadLocalMap map = getMap(t);//ThreadLocal.ThreadLocalMap threadLocals = null;
 if (map != null) {
 //getEntry(ThreadLocal<?> key)源码在下边
 ThreadLocalMap.Entry e = map.getEntry(this);
 if (e != null) {
 @SuppressWarnings("unchecked")
 T result = (T)e.value;
 return result;
 }
 }
 return setInitialValue();//=> t.threadLocals = new ThreadLocalMap(this, firstValue);
 }
 
 private Entry getEntry(ThreadLocal<?> key) {
 //通过hashCode与length位运算确定出一个索引值i，这个i就是被存储在table数组中的位置
 int i = key.threadLocalHashCode & (table.length - 1);
 Entry e = table[i];
 if (e != null && e.get() == key)
 return e;
 else
 return getEntryAfterMiss(key, i, e);
 }
 
 static class Entry extends WeakReference<ThreadLocal<?>> {
 /** The value associated with this ThreadLocal. */
 Object value;
 
 Entry(ThreadLocal<?> k, Object v) {
 super(k);
 value = v;
 }
 }

>  我们发现在Thread中维护着类型为ThreadLocal.ThreadLocalMap的一个参数threadLocals，可以把它看作是一个特殊的map，它的key是threadLocal的threadLocalHashCode，value是我们设置的page信息，
> 
> 其实它底下维护了一个大小为16的环形的table数组，它的负载因子为2/3，我们的数据就存在这个table中的Entry对象中。

## PageHelper通过ThreadLocal来共享分页信息，那么它是何时进行清除的呢？ ##

// 实际上在每次运行完成pageInterceptor之后，都会在finnaly中进行一次清理工作
            try {
                // do page things
            } finally {
                // afterAll 即为清理任务
                if(dialect != null){
                    dialect.afterAll();
                }
            }
        // com.github.pagehelper.PageHelper#afterAll
        @Override
        public void afterAll() {
            //这个方法即使不分页也会被执行，所以要判断 null
            AbstractHelperDialect delegate = autoDialect.getDelegate();
            if (delegate != null) {
                // 默认为空
                delegate.afterAll();
                // delegate 移除，这里也是使用 ThreadLocal 实现，直接remove即可
                autoDialect.clearDelegate();
            }
            // 清理 page对象，下次不再有该设置，也就是说 page 设置是一次性的
            clearPage();
        }
        // com.github.pagehelper.page.PageMethod#clearPage
        public static void clearPage() {
            LOCAL_PAGE.remove();
        }
        // 下次再进行分页时，重新调用  PageHelper.startPage(x, x, x); 即可

> 通过这,也就明白了**为什么PageHelper只对startPage后的第一条select语句有效?**
> 
> 因为, 在finally内把ThreadLocal中的分页数据给清除掉了，所以只要执行一次查询语句就会清除分页信息，故而后面的select语句自然就无效了。

##  什么时候会导致不安全的分页？ ##

`PageHelper` 方法使用了静态的 `ThreadLocal` 参数，分页参数和线程是绑定的。

只要你可以保证在 `PageHelper` 方法调用后紧跟 MyBatis 查询方法，这就是安全的。因为 `PageHelper` 在 `finally` 代码段中自动清除了 `ThreadLocal` 存储的对象。

如果代码在进入 `Executor` 前发生异常，就会导致线程不可用，这属于人为的 Bug（例如接口方法和 XML 中的不匹配，导致找不到 `MappedStatement` 时）， 这种情况由于线程不可用，也不会导致 `ThreadLocal` 参数被错误的使用。

但是如果你写出下面这样的代码，就是不安全的用法：

PageHelper.startPage(1, 10);
 List<Country> list;
 if(param1 != null){
 list = countryMapper.selectIf(param1);
 } else {
 list = new ArrayList<Country>();
 }

这种情况下由于 param1 存在 null 的情况，就会导致 PageHelper 生产了一个分页参数，但是没有被消费，这个参数就会一直保留在这个线程上。当这个线程再次被使用时，就可能导致不该分页的方法去消费这个分页参数，这就产生了莫名其妙的分页。

上面这个代码，应该写成下面这个样子：

List<Country> list;
 if(param1 != null){
 PageHelper.startPage(1, 10);
 list = countryMapper.selectIf(param1);
 } else {
 list = new ArrayList<Country>();
 }

这种写法就能保证安全。

如果你对此不放心，你可以手动清理 `ThreadLocal` 存储的分页参数，可以像下面这样使用：

List<Country> list;
 if(param1 != null){
 PageHelper.startPage(1, 10);
 try{
 list = countryMapper.selectAll();
 } finally {
 PageHelper.clearPage();
 }
 } else {
 list = new ArrayList<Country>();
 }

这么写很不好看，而且没有必要。

参考链接:

[https://pagehelper.github.io/docs/howtouse/][https_pagehelper.github.io_docs_howtouse]

[https_pagehelper.github.io_docs_howtouse]: https://pagehelper.github.io/docs/howtouse/