自己写分页的代码
package com.asam.buz.common.core.dao.primitive;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.lang3.StringUtils;
/**
* 分页工具
*/
//这个<T>就是一个不确定的泛型，T相当于一个泛型变量
public class Page<T> {
/**
* 升序
*/
public static final String ASC = "asc";
/**
* 降序
*/
public static final String DESC = "desc";
/**
* 页大小
*/
//每页的数据条数，默认为-1
protected int pageSize = -1;
/**
* 当前页
*/
protected int currentPage = 1;
/**
* 总记录数
*/
protected long countRecord = -1;
/**
* 总页数
*/
protected long totalPages;
/**
* 排序字段
*/
protected String order = null;
/**
* 升降序
*/
protected String orderBy = null;
/**
* 是否先执行统计总条数
*/
protected boolean autoCount = true;
/**
* 分页结果
*/
//分页结果就是直接调用page的类的时候，就直接将查询的结果（list类型）放入到page类当中，然后返回给前端，同时返回的数据还有跟多，如总记录条数，当前页，每页的数据条数，等等
protected List<T> list = new ArrayList<T>();
/**
* 构造
*/
//空的构造函数
public Page() {
}
/**
* 构造
*
* @param pageSize
* 页大小
*/
//当为首页时，没有当前页数时的构造函数
public Page(int pageSize) {
this.pageSize = pageSize;
}
/**
* 构造
*
* @param pageSize
* 页大小
* @param currentPage
* 当前页
*/
//同时传入参数当前页和每页数据数的构造函数
public Page(int pageSize, int currentPage) {
this.pageSize = pageSize;
this.currentPage = currentPage;
}
/**
* 获得当前页的页号,序号从1开始,默认为1
*
* @return int 当前页
*/
public int getCurrentPage() {
return currentPage;
}
/**
* 设置当前页的页号,序号从1开始,低于1时自动调整为1
*
* @param currentPage
* int 当前页
*/
//当前页如果为-1（默认），则说明是没有传入currentPage的参数，所以是首页，将值设置成1
public void setCurrentPage(final int currentPage) {
this.currentPage = currentPage;
if (currentPage < 1) {
this.currentPage = 1;
}
}
/**
* 返回Page对象自身的setCurrentPage函数,可用于连续设置
*
* @param currentPage
* int 当前页
* @param Page
* <T> 分页自身
*/
//搞不清楚
public Page<T> currentPage(final int currentPage) {
setCurrentPage(currentPage);
return this;
}
/**
* 获得每页的记录数量, 默认为-1
*
* @return int 页大小
*/
public int getPageSize() {
return pageSize;
}
/**
* 设置每页的记录数量
*
* @param pageSize
* int 页大小
*/
public void setPageSize(final int pageSize) {
this.pageSize = pageSize;
}
/**
* 返回Page对象自身的setPageSize函数,可用于连续设置
*
* @param thePageSize
* int 页大小
* @return Page<T> 分页自身
*/
public Page<T> pageSize(final int thePageSize) {
setPageSize(thePageSize);
return this;
}
/**
* 根据pageNo和pageSize计算当前页第一条记录在总结果集中的位置,序号从1开始
*
* @return int 开始记录
*/
public int getFirst() {
int minRecord = ((getCurrentPage() - 1) * getPageSize()) + 1;
return minRecord;
}
/**
* 获得排序字段,无默认值. 多个排序字段时用','分隔
*
* @return String 排序字段
*/
public String getOrderBy() {
return orderBy;
}
/**
* 设置排序字段,多个排序字段时用','分隔
*
* @param orderBy
* String 排序字段
*/
public void setOrderBy(final String orderBy) {
this.orderBy = orderBy;
}
/**
* 返回Page对象自身的setOrderBy函数,可用于连续设置
*
* @param theOrderBy
* String 排序字段,多个排序字段时用','分隔
* @return Page<T> 分页自身
*/
public Page<T> orderBy(final String theOrderBy) {
setOrderBy(theOrderBy);
return this;
}
/**
* 获得排序方向, 无默认值
*
* @return String 排序方向
*/
public String getOrder() {
return order;
}
/**
* 设置排序方式方向
*
* @param order
* String 可选值为desc或asc,多个排序字段时用','分隔
*/
public void setOrder(final String order) {
String lowcaseOrder = StringUtils.lowerCase(order);
// 检查order字符串的合法值
String[] orders = StringUtils.split(lowcaseOrder, ',');
for (String orderStr : orders) {
if (!StringUtils.equals(DESC, orderStr)
&& !StringUtils.equals(ASC, orderStr)) {
throw new IllegalArgumentException("排序方向" + orderStr + "不是合法值");
}
}
this.order = lowcaseOrder;
}
/**
* 返回Page对象自身的setOrder函数,可用于连续设置
*
* @param theOrder
* String 可选值为desc或asc,多个排序字段时用','分隔
* @return Page<T> 分页自身
*/
public Page<T> order(final String theOrder) {
setOrder(theOrder);
return this;
}
/**
* 是否已设置排序字段,无默认值
*
* @return boolean 是否已设置排序字段
*/
public boolean isOrderBySetted() {
return (StringUtils.isNotBlank(orderBy) && StringUtils
.isNotBlank(order));
}
/**
* 获得查询对象时是否先自动执行count查询获取总记录数, 默认为true
*
* @return boolean 是否先自动执行count查询获取总记录数
*/
public boolean isAutoCount() {
return autoCount;
}
/**
* 设置查询对象时是否自动先执行count查询获取总记录数
*
* @param autoCount
* boolean 是否先执行count查询
*/
public void setAutoCount(final boolean autoCount) {
this.autoCount = autoCount;
}
/**
* 返回Page对象自身的setAutoCount函数,可用于连续设置
*
* @param theAutoCount
* boolean 是否先执行count查询
* @return Page<T> 分页自身
*/
public Page<T> autoCount(final boolean theAutoCount) {
setAutoCount(theAutoCount);
return this;
}
/**
* 获得总记录数, 默认值为-1
*
* @return long 总记录数
*/
public long getCountRecord() {
return this.countRecord;
}
/**
* 获得总记录数, 默认值为-1(为EcTable设计,EcTable要求总记录数为Int类型)
*
* @return int 总记录数
*/
public int getCountRecordToEcTable() {
return new Long(this.countRecord).intValue();
}
/**
* 设置总记录数.
*
* @param countRecord
* long 总记录数
*/
public void setCountRecord(final long countRecord) {
this.countRecord = countRecord;
this.totalPages = (countRecord - 1) / this.pageSize + 1;// 设置总页数
}
/**
* 根据页大小与总记录数计算总页数, 默认值为-1
*
* @return long 总页数
*/
public long getCountPage() {
if (getCountRecord() < 0) {
return -1;
}
return getCountRecord() / getPageSize()
+ (getCountRecord() % getPageSize() == 0 ? 0 : 1);
}
/**
* 是否还有下一页
*
* @return boolean 是否有下页
*/
public boolean isHasNext() {
return (getCurrentPage() + 1 <= getCountPage());
}
/**
* 取得下页的页号, 序号从1开始 当前页为尾页时仍返回尾页序号
*
* @return int 下页序号
*/
public int getNextPage() {
if (isHasNext()) {
return getCurrentPage() + 1;
} else {
return getCurrentPage();
}
}
/**
* 是否还有上一页
*
* @return boolean 是否有上页
*/
public boolean isHasPre() {
return (getCurrentPage() - 1 >= 1);
}
/**
* 取得上页的页号, 序号从1开始 当前页为首页时返回首页序号
*
* @return int 得到上页序号
*/
public int getPrePage() {
if (isHasPre()) {
return getCurrentPage() - 1;
} else {
return getCurrentPage();
}
}
/**
* 是否是首页,第一页页码为1
*
* @return boolean 是否是首页
*/
public boolean isFirstPage() {
return getCurrentPage() <= 1;
}
/**
* 是否为末页
*
* @return boolean 是否为末页
*/
public boolean isLastPage() {
return currentPage >= getCountPage();
}
/**
* 获得页内的记录列表.
*
* @return List<T> 记录对象
*/
public List<T> getList() {
return list;
}
/**
* 设置页内的记录列表.
*
* @param resultList
* List<T> 记录列表
*/
public void setList(List<T> list) {
this.list = list;
}
/**
* 获取总页数
*
* @return
*/
public long getTotalPages() {
return totalPages;
}
/**
* 设置总页数
*
* @param totalPages
*/
public void setTotalPages(long totalPages) {
this.totalPages = totalPages;
}
}