一、mybatis +generator 原生的分页

今天在做查询优化的时候，遇到mybatis查询性能问题，由于给出的查询条件比较多（多达十几个），并且需要做查询总数的count计算，返回给前端需要分页；如果使用原生的查询分页及计数需要查询两次：

• 查询计数： countByExample
• 查询分页：rowBounds + selectByExampleWithRowbounds

由于数据量比较大，这样两次查询耗时就超过1000ms，如果网络有延迟，会让使用的人感受很糟糕。

调研了一下selectByExampleWithRowbounds方法：

// 对应的xxxMapper.xml内的方法
<select resultMap="BaseResultMap" parameterType="xxxxx.com.xxxxx" id="selectByExampleWithRowbounds" >
    select
    <if test="distinct" >
      distinct
    </if>
    <include refid="Base_Column_List" />
    from xxx_xxxx_record
    <if test="_parameter != null" >
      <include refid="Example_Where_Clause" />
    </if>
    <if test="orderByClause != null" >
      order by ${orderByClause}
    </if>
  </select>

// 上述select中引用的方法如下：
<sql id="Example_Where_Clause" >
    <where >
      <foreach collection="oredCriteria" item="criteria" separator="or" >
        <if test="criteria.valid" >
          <trim prefix="(" suffix=")" prefixOverrides="and" >
            <foreach collection="criteria.criteria" item="criterion" >
              <choose >
                <when test="criterion.noValue" >
                  and ${criterion.condition}
                </when>
                <when test="criterion.singleValue" >
                  and ${criterion.condition} #{criterion.value}
                </when>
                <when test="criterion.betweenValue" >
                  and ${criterion.condition} #{criterion.value} and #{criterion.secondValue}
                </when>
                <when test="criterion.listValue" >
                  and ${criterion.condition}
                  <foreach collection="criterion.value" item="listItem" open="(" close=")" separator="," >
                    #{listItem}
                  </foreach>
                </when>
              </choose>
            </foreach>
          </trim>
        </if>
      </foreach>
    </where>
  </sql>

从上述代码中，虽然代码比较长，但是粗略扫一下发现并没有sql中使用分页查询会用到的limit字段，因此推断它的查询不是真正意义上的分页查询，这样的话当查询数据量很大一定会存在性能问题，继续往下探索，对rowbounds源码进行分析：

// rowbounds 定义
public class RowBounds {

  public static final int NO_ROW_OFFSET = 0;
  public static final int NO_ROW_LIMIT = Integer.MAX_VALUE;
  public static final RowBounds DEFAULT = new RowBounds();

  private final int offset;
  private final int limit;

  public RowBounds() {
    this.offset = NO_ROW_OFFSET;
    this.limit = NO_ROW_LIMIT;
  }

  public RowBounds(int offset, int limit) {
    this.offset = offset;
    this.limit = limit;
  }

  public int getOffset() {
    return offset;
  }

  public int getLimit() {
    return limit;
  }

}

当我们在查询的时候传入rowBounds这个对象的时候,会调用org.apache.ibatis.session中的DefaultResultSetHandler方法实行分页，具体代码如下：

private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping)
      throws SQLException {
    DefaultResultContext<Object> resultContext = new DefaultResultContext<Object>();
    //跳过RowBounds设置的offset值
    skipRows(rsw.getResultSet(), rowBounds);
    //判断数据是否小于limit，如果小于limit的话就不断的循环取值
    while (shouldProcessMoreRows(resultContext, rowBounds) && rsw.getResultSet().next()) {
      ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(rsw.getResultSet(), resultMap, null);
      Object rowValue = getRowValue(rsw, discriminatedResultMap);
      storeObject(resultHandler, resultContext, rowValue, parentMapping, rsw.getResultSet());
    }
  }
private boolean shouldProcessMoreRows(ResultContext<?> context, RowBounds rowBounds) throws SQLException {
    //判断数据是否小于limit，小于返回true
    return !context.isStopped() && context.getResultCount() < rowBounds.getLimit();
  }
  //跳过不需要的行,应该就是rowbounds设置的limit和offset
  private void skipRows(ResultSet rs, RowBounds rowBounds) throws SQLException {
    if (rs.getType() != ResultSet.TYPE_FORWARD_ONLY) {
      if (rowBounds.getOffset() != RowBounds.NO_ROW_OFFSET) {
        rs.absolute(rowBounds.getOffset());
      }
    } else {
      //跳过RowBounds中设置的offset条数据
      for (int i = 0; i < rowBounds.getOffset(); i++) {
        rs.next();
      }
    }

所以并没有在查库的时候就进行分页，这样一旦数据量很大就会有性能问题，借助谷歌查询了一下，现在springBoot下比较流行的物理分页方法借助插件gitHub传送门。文档非常简单，这里给出简单配置使用示例：

1. 首先导入pageHelper包，我的项目依赖管理是gradle，所以在dependencies中加入：

    // pagehelper 物理分页查询
    compile group: 'com.github.pagehelper', name: 'pagehelper-spring-boot-starter', version: '1.2.9'

注意！！！
记住组名一定要是pagehelper-spring-boot-starter，适用于springBoot项目，如果是pageHelper组名字话，你会发现在springBoot项目使用这个插件查询会失效。

2. 接着按照自己的需求写一个配置文件（springBoot中都是配置代码化，不需要再xml中配置，这是springBoot优势，不要本末倒置了），或者在application启动项中加入Bean如下：

    @Bean
    public PageHelper pageHelper() {
        PageHelper pageHelper = new PageHelper();
        Properties p = new Properties();
//       如果直接使用原来的rowBounds方式可以设置这两项
//        p.setProperty("offsetAsPageNum","true");    
//        p.setProperty("rowBoundsWithCount","true");
        p.setProperty("reasonable","true");
        p.setProperty("dialect","mysql");
        pageHelper.setProperties(p);
        return pageHelper;
    }

3. 使用示例：

// 定义一个查询返回类
@Data
@Builder
public class UserResponse {

    private List<User>  users;

    private long total;
}

// 查询实现类
@Service
public class UserServiceImpl implements UserService {

    @Autowired
    UserMapper userMapper;

    @Override
    public UserResponse findUser( Integer pageNum,Integer pageSize) {
        
        // example可以加入查询条件
        UserExample example = new UserExample();
        PageInfo pageInfo = PageHelper.startPage(pageNum,pageSize).doSelectPageInfo(() -> userMapper.selectByExample(example));
        return UserResponse.builder().users(pageInfo.getList()).total(pageInfo.getTotal()).build();
    }

个人比较喜欢这种流式写法，可以，里面参数不懂的可以感觉上面的github链接查看，不足之处欢迎指出。

以上就是springBoot+mybatis+gradle+pageHelper实现分页查询一个示例。