分页的逻辑

最新推荐文章于 2023-11-21 23:04:20 发布

木风wowind

最新推荐文章于 2023-11-21 23:04:20 发布

阅读量77

点赞数

分类专栏：技术总结分享

本文链接：https://blog.csdn.net/cattcatt1987/article/details/7568806

版权

技术总结分享专栏收录该内容

0 篇文章 0 订阅

订阅专栏

分页最后要的效果是在某个具体页面上显示第M条记录到第N条记录。

怎么去达到这个效果呢，有物理分页和逻辑分页，具体区别我先不说，我想说的是其中的分页逻辑。

1,、确定初始条件

我觉得初始条件就是我要知道需要显示的是从M条记录到N条记录，但通常我们不会直接得到这个条件，而是通过三个参数来确定这个条件，

先姑且称这三个参数为初始参数，分别是当前页currentPage，一页需要显示的记录数pageSize（页面大小），总记录数rowsCount。

2、计算初始条件及页面需要显示的内容。

（1）计算总页数allSize

总页数=总记录数rowsCount/页面大小pageSize向上取整，若总记录数为0，则得到总页数也应为0，但在页面显示时应把总页数显示为1。参考代码

public static int computePageCount(int rowsCount, int pageSize) {
		int result = rowsCount / pageSize;
		if (rowsCount % pageSize != 0) {
			result++;
		}

		return result;
	}

（2）计算要显示的页面是从第M条记录开始即开始记录位置startRow

先判断当前页若为非法参数0或null，直接定义当前页为1。然后根据当前页和页面大小计算startRow，即startRow=（currentPage-1）*pageSize+1。

（3）计算结束记录位置endRow

endRow=startRow+pageSize-1。这里有个地方我开始有疑问，就是如果显示最后一页的记录时，一般实际结束记录位置通常会小于理论结束记录位置，简单的说，一个53条记录的表，一页显示10条，那最后一页只显示3条记录，但最后一页计算出的结束记录位置=51+10-1=60条，那不是会出问题吗？但后来我一想，在数据库中你查到53条是最后记录的时候，就不可能还有53以后的记录了，所以这个担忧是不存在的。

在这顺便说下我对物理分页和逻辑分页的一些理解。

共同点：我感觉都是将数据库中的数据进行分页逻辑处理。

不同点：不同就在于逻辑分页是将所有的记录先查出来，然后进行分页逻辑处理，逻辑上分出首行记录和末行记录，只需要访问一次数据库。

而物理分页需要先查出数据的总记录数，根据3个初始参数先进行逻辑处理，然后将首行记录参数和末行记录参数代入数据持久层，查出需要的分页数据，要访问两次数据库。

下面是逻辑分页的参考代码：

import java.util.ArrayList;
import java.util.List;
import java.util.ResourceBundle;

/**
 * 翻页类
 * @author Administrator
 *
 */
public class Paper
{

	private static ResourceBundle properties = null;

	private static String bundleName = "paper";

	private int PAGE_SIZE = 10;// 每个页面默认的记录数

	private int currentpage = 1;// 记录当前页号
	
	private int allSize=1;//共多少页
	private int curNum=0;//开始行号
	private int maxNum=0;//结束行号
	private List resultList=null;//结果集
	public Paper()
	{
		
		
		this.getPAGE_SIZE();
	}

	public Paper(int pageSize)
	{
		
		PAGE_SIZE=pageSize;
		
	}

	/**
	 * 获取当前页号
	 * 
	 * @param allList
	 * @param pageDirection 翻页操作下一页，上一页，第一页，最后一页
	 * @param _currentpage
	 */
	private void getCurrentPageNum(String pageDirection,String _currentpage)
	{

		if ("next".equals(pageDirection))
		{
			if ((Integer.parseInt(_currentpage) + 1) <=allSize)
			{
				currentpage = Integer.parseInt(_currentpage) + 1;
			}
			else
			{
				currentpage = Integer.parseInt(_currentpage);
			}

		}
		else if ("previous".equals(pageDirection))
		{

				if ((Integer.parseInt(_currentpage) - 1) <= 0)
				{
					currentpage = 0;
				}
				else
				{
					currentpage = Integer.parseInt(_currentpage) - 1;
				}

		}
		else if ("first".equals(pageDirection))
		{
			currentpage = 1;
		}
		else if ("last".equals(pageDirection))
		{
			if (allSize == 0)
			{
				currentpage = 0;
			}
			else
			{

				currentpage = allSize ;
	
			}
		}
		else
		{
			currentpage=Integer.parseInt(_currentpage);
		}
		if(currentpage==0)
		{
			currentpage=1;
		}
	}
	
	/**
	 * 获取总页数
	 * @param ListSize
	 */
	private void getPageAllSizeNum(int ListSize)
	{

		try {
			if (ListSize > PAGE_SIZE) {
				if ((ListSize / PAGE_SIZE) * PAGE_SIZE < ListSize) {
					allSize = (ListSize / PAGE_SIZE) + 1;
				} else {
					allSize = (ListSize / PAGE_SIZE);
				}
			} else if (ListSize / PAGE_SIZE == 1) {
				allSize = 1;
			} else {
				allSize = 1;
			}
		} catch (Exception e) {
			allSize = 0;
		}
	}

	/**
	 * 取得分页的List
	 * 
	 * @param allList
	 * @param pageDirection
	 * @param _currentpage
	 * @return
	 */

	public List getPaperList(List allList, String pageDirection,
			String _currentpage)
	{
		this.getPageAllSizeNum(allList.size());
//		 设置当前页号
		this.getCurrentPageNum(pageDirection, _currentpage);
		List rsList = new ArrayList();
		for (int i = currentpage * PAGE_SIZE; i < (currentpage + 1) * PAGE_SIZE; i++)
		{
			if (i == allList.size())
			{
				break;
			}
			rsList.add(allList.get(i));
		}
		return rsList;

	}

	/**
	 * 读取配置文件每页多少条信息
	 *
	 */
	private void getPAGE_SIZE()
	{
		try
		{
			if (properties == null)
			{
				loadProperties();
			}

			this.PAGE_SIZE = Integer
					.parseInt(properties.getString("PAGE_SIZE"));
			// System.out.println("系统分页:"+properties.getString("PAGE_SIZE")+"条/页");
		}
		catch (Exception ex)
		{
			ex.printStackTrace();
		}

	}
	
	/**
	 * 取得分页的List，自定义条／页
	 * 
	 * @param allList
	 * @param pageDirection
	 * @param _currentpage
	 * @param pageSize
	 * @return
	 */

	public List getPaperList(List allList, String pageDirection,
			String _currentpage, int pageSize)
	{
		// 设置当前页号
		PAGE_SIZE=pageSize;
		List rsList=this.getPaperList(allList, pageDirection, _currentpage);
		return rsList;
	}
	
	/**
	 * 计算总页数和启示游标
	 * @param count 总记录条数
	 * @param currentpage 页号
	 * @param pageSize 每页多少条数据
	 */
	public void FillSeat(String pageDirection,int count,int currentpage,int pageSize)
	{
		PAGE_SIZE=pageSize;
		this.FillSeat(pageDirection, count, currentpage);
		
	}
	
	/**
	 * 计算总页数和启示游标
	 * @param count 总记录条数
	 * @param currentpage 页号
	 */
	public void FillSeat(String pageDirection,int count,int currentpage)
	{
		this.getPageAllSizeNum(count);//总页数
		this.getCurrentPageNum(pageDirection, String.valueOf(currentpage));//下一页的页码
//		curNum = (this.getCurrentpage() - 1) * PAGE_SIZE + 1; // 当前页的数据开始号
		curNum = (this.getCurrentpage() - 1) * PAGE_SIZE ; // 当前页的数据开始号
		maxNum = this.getCurrentpage() * PAGE_SIZE; // 当前页的结束时的数据号
		if (maxNum > count) {
			maxNum = count;
		}
		if (maxNum < 1) {
//			curNum = 1;
			curNum = 0;
		} 
	}
	
	/**
	 * 获取开始行号
	 * @return
	 */
	public int getCurNum() {
		return curNum;
	}
	/**
	 * 获取结束行号
	 * @return
	 */
	public int getMaxNum() {
		return maxNum;
	}

	/**
	 * 获取总页数
	 * @return
	 */
	public int  getAllSize()
	{
		return allSize;
	}
	
	/**
	 * 获取下一次操作的页码
	 * @return
	 */
	public int getCurrentpage()
	{
		return currentpage;
	}
	/**
	 * 获取结果集
	 * @return
	 */
	public List getResultList() {
		return resultList;
	}
	
	/**
	 * 给结果集赋值
	 * @param resultList
	 */
	public void setResultList(List resultList) {
		this.resultList = resultList;
	}
	
	/**
	 * 获取每页的数据条数
	 * @return
	 */
	public int getPageSize() {
		return PAGE_SIZE;
	}
	
	private synchronized static void loadProperties()
	{
		properties = ResourceBundle.getBundle(bundleName);
	}

}

下面是物理分页

分页bean

import java.io.Serializable;

/**
 * 分页Bean
 * 
 * @author 
 * @version 
 */
public class Page implements Serializable {

	private static final long serialVersionUID = 6532040187801295203L;

	/** 页码 */
	private Integer page = 1;

	/** 页面大小 */
	private Integer pageSize = 10;

	/** 总页数 */
	private Integer pageCount;

	/** 首行记录 */
	private Integer firstRow = 1;

	/** 末行记录 */
	private Integer lastRow = 2147483647;

	/** 总记录数 */
	private Integer rowsCount;

	public Integer getPage() {
		return page;
	}

	public void setPage(Integer page) {
		this.page = page;
	}

	public Integer getPageSize() {
		return pageSize;
	}

	public void setPageSize(Integer pageSize) {
		this.pageSize = pageSize;
	}

	public Integer getPageCount() {
		return pageCount;
	}

	public void setPageCount(Integer pageCount) {
		this.pageCount = pageCount;
	}

	public Integer getFirstRow() {
		return firstRow;
	}

	public void setFirstRow(Integer firstRow) {
		this.firstRow = firstRow;
	}

	public Integer getLastRow() {
		return lastRow;
	}

	public void setLastRow(Integer lastRow) {
		this.lastRow = lastRow;
	}

	public Integer getRowsCount() {
		return rowsCount;
	}

	public void setRowsCount(Integer rowsCount) {
		this.rowsCount = rowsCount;
	}
}

分页逻辑

import com.tjhq.common.bean.Page;

/**
 * iBatis分页计算器
 * 
 * @author 
 * @version 
 */
public class Pagination {

	/**
	 * 计算分页
	 * 
	 * @param page
	 *            page
	 */
	public static void compute(Page page) {
		if (page.getPage() == null || page.getPage() < 1) {
			page.setPage(1);
		}
		int pageCount = computePageCount(page.getRowsCount(), page.getPageSize());
		if (page.getPage() > pageCount) {
			page.setPage(pageCount);
		}
		if(pageCount==0){
			pageCount=1;
		}
		page.setPageCount(pageCount);
		int firstRow = computeFirstRow(page.getPage(), page.getPageSize());
		int lastRow = firstRow + page.getPageSize() - 1;
		page.setFirstRow(firstRow);
		page.setLastRow(lastRow);
	}

	/**
	 * 计算总页数
	 * 
	 * @param rowsCount
	 *            记录数
	 * @param pageSize
	 *            页面大小
	 * @return 总页数
	 */
	public static int computePageCount(int rowsCount, int pageSize) {
		int result = rowsCount / pageSize;
		if (rowsCount % pageSize != 0) {
			result++;
		}

		return result;
	}

	/**
	 * 计算首条记录定位
	 * 
	 * @param curPage
	 *            当前页
	 * @param pageSize
	 *            页面大小
	 * @return 首条记录位置
	 */
	public static int computeFirstRow(int curPage, int pageSize) {
		return (curPage - 1) * pageSize + 1;
	}
}