springboot学习----使⽤pageHelper实现分页功能
⽬录
  1.介绍pageHelper
  2.pageHelper的基本配置
  3.使⽤pageHelper实现分页功能
  pageHelper是⼀款分页插件，它能很好的集成在spring boot中在它是⼀个基于mybatis的⼀款插件。它是的底层实现技术则是使⽤动态代理实现的。所以我们在使⽤它时，我们需要使⽤mybatis作为持久层框架。如果有需要请参照《spring boot 集成 mybatis》
  如果我们需要使⽤pageHelper的话，我们需要在spring boot项⽬中引⼊pageHelper的依赖。以下是PageHelper的GitHub地址
  在这⾥我们导⼊以下依赖：
<!-- pagehelper -->
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper-spring-boot-starter</artifactId>
<version>1.2.5</version>
</dependency>
  同样，我们在spring boot的application.properties中可以配置pageHelper的基本信息，
# 指定数据库，不指定的话会默认⾃动检测数据库类型
pagehelper.helperDialect=mysql
# 是否启⽤分页合理化。
# 如果启⽤，当pagenum<1时，会⾃动查询第⼀页的数据，当pagenum>pages时，⾃动查询最后⼀页数据；
# 不启⽤的，以上两种情况都会返回空数据
# 默认值false，分页插件会从查询⽅法的参数值中，⾃动根据上⾯ params 配置的字段中取值，查到合适的值时就会⾃动分页。
pagehelper.supportMethodsArguments=true
# ⽤于从对象中根据属性名取值，
# 可以配置 pageNum,pageSize,count,pageSizeZero,reasonable，不配置映射的⽤默认值，
# 默认值为pageNum=pageNum;pageSize=pageSize;count=countSql;reasonable=reasonable;pageSizeZero=pageSizeZero
pagehelper.params=count=countSql
  在1.2.5这个版本中我们可以不⽤配置，使⽤默认的就够⽤了。
  在上⼀步中，我们已近知道pageHelper的基本配置了。在这，我们使⽤pageHelper实现分页功能。
我们使⽤《mysql必知必会》中给出的数据库进⾏分页查询。
package com.springboot.pagehelper;
public class City {
//    id
private int id;
//    国家名
private String name;
//    国家代码
private String countryCode;
//    地区
private String district;
//    ⼈⼝
private int population;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCountryCode() {
return countryCode;
}
public void setCountryCode(String countryCode) {
}
public String getDistrict() {
return district;
}
public void setDistrict(String district) {
this.district = district;
}
public int getPopulation() {
return population;
}
public void setPopulation(int population) {
this.population = population;
}
}
package com.springboot.pagehelper.mapper;
import com.springboot.pagehelper.City;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Repository;
import java.util.List;
@Mapper
@Repository
public interface CityMapper {
/
/    获取所有城市
@Select("select * from city")
@Results({
@Result(property = "id",column = "ID"),
@Result(property = "name",column = "Name"),
@Result(property = "countryCode",column = "CountryCode"),            @Result(property = "district",column = "District"),
@Result(property = "population",column = "Population")
})
List<City> selectCity();
}
CityMapper
  这⾥我们使⽤两种实现
package com.springboot.pagehelper.service;
import com.github.pagehelper.Page;
import com.springboot.pagehelper.City;
import java.util.List;
public interface CityService {
List<City> getcity();
Page<City> pageCity();
}
CityService
package com.springboot.pagehelper.service;
import com.github.pagehelper.Page;
import com.springboot.pagehelper.City;
import com.springboot.pagehelper.mapper.CityMapper;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class CityServiceImpl implements  CityService {
@Autowired
private CityMapper mapper;
@Override
public List<City> getcity() {
return mapper.selectCity();
}
@Override
public Page<City> pageCity() {
return (Page<City>)mapper.selectCity();
}
}
CityServiceImpl
package com.ller;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.springboot.pagehelper.City;
import com.springboot.pagehelper.service.CityService;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RestController;
import java.util.List;
@RestController
public class DataController {
@Autowired
private CityService service;
@GetMapping("/citys/{page}")
public PageInfo<City> lists(@PathVariable int page){
//        设置分页规则
PageHelper.startPage(page,10);
//        返回所有分页信息参数为查询所有记录的信息
PageInfo<City> pageInfo = new PageInfo<>(service.pageCity());
return pageInfo;
@GetMapping("/city")
public List<City> paraList(@RequestParam(defaultValue = "1") int p,
@RequestParam(defaultValue = "10") int size){
//        设置分页规则
PageHelper.startPage(p,size);
//        取数据，插件会⾃动按照规则分页显⽰数据
ity();
}
}
DataController
  实现分页功能在使⽤时，PageInfo源码如下：
/*
* The MIT License (MIT)
*
* Copyright (c) 2014-2017 abel533@gmail
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package com.github.pagehelper;
import java.io.Serializable;
import java.util.Collection;
import java.util.List;
/**
* 对Page<E>结果进⾏包装
* <p/>
* 新增分页的多项属性，主要参考:bbs.csdn/topics/360010907
*
* @author liuzh/abel533/isea533
* @version 3.3.0
* @since 3.2.2
* 项⽬地址 : git.oschina/free/Mybatis_PageHelper
*/
@SuppressWarnings({"rawtypes", "unchecked"})
public class PageInfo<T> extends PageSerializable<T> {
/
/当前页
private int pageNum;
//每页的数量
private int pageSize;
//当前页的数量
private int size;
//由于startRow和endRow不常⽤，这⾥说个具体的⽤法
//可以在页⾯中"显⽰startRow到endRow 共size条数据"
//当前页⾯第⼀个元素在数据库中的⾏号
private int startRow;
//当前页⾯最后⼀个元素在数据库中的⾏号
private int endRow;
//总页数
private int pages;
//前⼀页
private int prePage;
//下⼀页
private int nextPage;
//是否为第⼀页
private boolean isFirstPage = false;
//是否为最后⼀页
private boolean isLastPage = false;
/
/是否有前⼀页
private boolean hasPreviousPage = false;
//是否有下⼀页
private boolean hasNextPage = false;
//导航页码数
private int navigatePages;
//所有导航页号
private int[] navigatepageNums;
//导航条上的第⼀页
private int navigateFirstPage;
//导航条上的最后⼀页
private int navigateLastPage;
public PageInfo() {
}
/**
* 包装Page对象
*
* @param list
*/
public PageInfo(List<T> list) {
this(list, 8);
}
/
**
* 包装Page对象
*
* @param list          page结果
* @param navigatePages 页码数量
*/
public PageInfo(List<T> list, int navigatePages) {
super(list);
if (list instanceof Page) {
Page page = (Page) list;
this.pageNum = PageNum();
this.pageSize = PageSize();
this.pages = Pages();
this.size = page.size();
//由于结果是>startRow的，所以实际的需要+1
if (this.size == 0) {
this.startRow = 0;
} else {
this.startRow = StartRow() + 1;
//计算实际的endRow（最后⼀页的时候特殊）
}
} else if (list instanceof Collection) {
this.pageNum = 1;
this.pageSize = list.size();
this.pages = this.pageSize > 0 ? 1 : 0;
this.size = list.size();
this.startRow = 0;
}
if (list instanceof Collection) {
this.navigatePages = navigatePages;
/
/计算导航页
calcNavigatepageNums();
//计算前后页，第⼀页，最后⼀页
calcPage();
//判断页⾯边界
judgePageBoudary();
}
}
public static <T> PageInfo<T> of(List<T> list){
return new PageInfo<T>(list);
}
public static <T> PageInfo<T> of(List<T> list, int navigatePages){
return new PageInfo<T>(list, navigatePages);
}
/**
* 计算导航页
*/
private void calcNavigatepageNums() {
//当总页数⼩于或等于导航页码数时
if (pages <= navigatePages) {
navigatepageNums = new int[pages];
for (int i = 0; i < pages; i++) {
navigatepageNums[i] = i + 1;
}
} else { //当总页数⼤于导航页码数时
navigatepageNums = new int[navigatePages];
int startNum = pageNum - navigatePages / 2;
int endNum = pageNum + navigatePages / 2;
if (startNum < 1) {
startNum = 1;
//(最前navigatePages页
for (int i = 0; i < navigatePages; i++) {
navigatepageNums[i] = startNum++;
}
} else if (endNum > pages) {
endNum = pages;
//最后navigatePages页
for (int i = navigatePages - 1; i >= 0; i--) {
navigatepageNums[i] = endNum--;
}
} else {
//所有中间页
for (int i = 0; i < navigatePages; i++) {
navigatepageNums[i] = startNum++;
}
}
}
}
/**
* 计算前后页，第⼀页，最后⼀页
*/
private void calcPage() {
if (navigatepageNums != null && navigatepageNums.length > 0) {
navigateFirstPage = navigatepageNums[0];
navigateLastPage = navigatepageNums[navigatepageNums.length - 1];
if (pageNum > 1) {
prePage = pageNum - 1;
}
if (pageNum < pages) {
nextPage = pageNum + 1;
}
}
}
/**
* 判定页⾯边界
*/
private void judgePageBoudary() {
isFirstPage = pageNum == 1;
isLastPage = pageNum == pages || pages == 0;;
hasPreviousPage = pageNum > 1;
hasNextPage = pageNum < pages;
}
public int getPageNum() {
return pageNum;
}
public void setPageNum(int pageNum) {
this.pageNum = pageNum;
}
public int getPageSize() {
return pageSize;
}
public void setPageSize(int pageSize) {
this.pageSize = pageSize;
}
public int getSize() {
return size;
}
springboot框架的作用public void setSize(int size) {
this.size = size;
}
public int getStartRow() {
return startRow;
}
public void setStartRow(int startRow) {
this.startRow = startRow;
}
public int getEndRow() {
return endRow;
}
public void setEndRow(int endRow) {
}
public int getPages() {
return pages;
}
public void setPages(int pages) {
this.pages = pages;
}
@Deprecated
// firstPage就是1, 此函数获取的是导航条上的第⼀页, 容易产⽣歧义
public int getFirstPage() {
return navigateFirstPage;
}
@Deprecated
public void setFirstPage(int firstPage) {
this.navigateFirstPage = firstPage;
}
public int getPrePage() {
return prePage;
}
public void setPrePage(int prePage) {
this.prePage = prePage;
}
public int getNextPage() {
return nextPage;
}
public void setNextPage(int nextPage) {
}
@Deprecated
// 请⽤getPages()来获取最后⼀页, 此函数获取的是导航条上的最后⼀页, 容易产⽣歧义. public int getLastPage() {
return navigateLastPage;
}
@Deprecated
public void setLastPage(int lastPage) {
this.navigateLastPage = lastPage;
}
public boolean isIsFirstPage() {
return isFirstPage;
}
public void setIsFirstPage(boolean isFirstPage) {
this.isFirstPage = isFirstPage;
}
public boolean isIsLastPage() {
return isLastPage;
}
public void setIsLastPage(boolean isLastPage) {
this.isLastPage = isLastPage;
}
public boolean isHasPreviousPage() {
return hasPreviousPage;
}
public void setHasPreviousPage(boolean hasPreviousPage) {
this.hasPreviousPage = hasPreviousPage;
}
public boolean isHasNextPage() {
return hasNextPage;
}
public void setHasNextPage(boolean hasNextPage) {
this.hasNextPage = hasNextPage;
}
public int getNavigatePages() {
return navigatePages;
}
public void setNavigatePages(int navigatePages) {
this.navigatePages = navigatePages;
}
public int[] getNavigatepageNums() {
return navigatepageNums;
}
public void setNavigatepageNums(int[] navigatepageNums) {
this.navigatepageNums = navigatepageNums;
}
public int getNavigateFirstPage() {
return navigateFirstPage;
}
public int getNavigateLastPage() {

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。