JavaWeb分页显示内容之分页查询的三种思路(数据库分页查询)

感谢原文作者：有梦就能实现
原文链接：https://www.cnblogs.com/firstdream/p/7732672.html

简介

在开发过程中，经常做的一件事，也是最基本的事，就是从数据库中查询数据，然后在客户端显示出来。当数据少时，可以在一个页面内显示完成。然而，如果查询记录是几百条、上千条呢？直接一个页面显示完全的话，表格得多长啊。。。。。。这时，我们可以用分页技术。

何为分页？效果图如下：

这里总共查询了100条记录，如果一次性显示的话表格会很多行，用户体验不佳。而我们采用分页显示的话，一页显示10条记录，共十页。用户可以自行翻阅，记录少，清晰显示。

实现方式

下面谈谈分页效果的实现，思路简单的有三种：

1. 伪分页(前端JS实现)

一次性查询记录并加载到html的table中。然后通过选择性地显示某些行来达到分页显示的目的。这是一种伪分页，障眼法而已。只能用于数据少的情况下。一旦数据多了，十几万条数据加载到html中会变得很慢。而且不实时，一次加载完后数据就写死在页面了，若数据库中有变化，浏览器端显示的仍是上次加载过来的数据。

2. 逻辑分页(结果集游标移动)

就是说，我们可以执行一个数据库查询操作，得到结果集rs。然后，通过指针的移动来显示当前页面的记录。这样，就可以以 rs.absolute(当前页面号*每页记录数)定位到当前页的第一条记录，然后通过while循环显示n条记录（n为每页显示记录数）。在跳页时，只需修改currentPage，即可在重定位到下一页时把当前页面号改掉，重新定位记录指针，通过while遍历显示n条记录。与JS选择性显示不同，这里是选择性遍历。与JS分页不同的是，这里分页每次跳页修改的是遍历的指针，每次跳页都要进行一次全面查询。同样地，不适合大数据量查询。这里比JS分页优化的地方在于——实时性。每次跳页都会查询一次数据库，保证数据的实时性。

3. 物理分页(通过SQL语句)

跳到第n页才查询、显示第n页内容。要点就是根据客户端表格的“页面”计算出数据库要查询的当前页面的第一条记录的位置。优点：实时性：跳页才查询。数据量小：只加载当前页的记录进行显示。只查询本页需要的数据。
注意：如果通过该方式实现，不同的数据库，实现语句可能不同。
比如MySQL：

//查询得到记录总条数
select count(*) from table
//查询从第pageNo条开始的rowsCount条数据
 select * from .. limit pageNo,rowsCount

其他数据库的物理分页方式语句：

1.oracle数据库分页
    select * from (select a.*,rownum rc from 表名 where rownum<=endrow) a where a.rc>=startrow

2.DB2数据库分页
    Select * from (select rownumber() over() as rc,a.* from (select * from 表名 order by列名) as a) where rc between startrow and endrow

3.SQL Server 2000数据库分页
    Select top pagesize * from 表名 where 列名 not in(select top pagesize*page 列名 from 表名 order by列名) order by列名

4.SQL Server 2005数据库分页
    Select * from (select 列名,row_number() over(order by 列名1) as 别名from 表名) as t where t.列名1>=startrow and t.列名1<=endrow

5.MySQL数据库分页
    Select * from 表名 limit startrow,pagesize
    (Pagesize为每页显示的记录条数)

6.PostgreSQL数据库分页
    Select * from 表名 limit pagesize,offset startrow
    (Pagesize为每页显示的记录条数)

分页实现注意点

以上所说的2、3方式，其2方式为所有数据库通用，毕竟仅靠结果集游标移动，需要注意的地方也就是在Java中创建Statement对象时，需要指定结果集游标是可以移动的。如：connection.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_READ_ONLY)
ResultSet.TYPE_SCROLL_INSENSITIVE:表示结果集可滚动。
ResultSet.CONCUR_READ_ONLY：表示以只读方式打开结果集。
参数具体怎么用，看具体情况。

以上所说的2、3方式，其3方式，每个数据库实现的语句不太一样，毕竟是在数据库里面筛选结果的。上面已经给出了几种常用的数据库语句。

以上所说的2、3方式，都需要获取两点：

1. 数据总数：计算总页码，以及定位。
2. 数据：数据显示

具体实现

1. 伪分页(前端JS实现)

首先：用table来显示查询出来的记录们，全部显示。

<table width="500" id="idData">
            <%
                    String user_id, user_name, user_sex, user_phone, user_age;
                    while (sqlRst.next()) {
                        user_id = sqlRst.getString(1);
                        user_name = sqlRst.getString(2);
                        user_sex = sqlRst.getString(3);
                        user_phone = sqlRst.getString(4);
                        user_age = sqlRst.getString(5);
            %>
            <tr>
                <td><%=user_id%></td>
                <td><%=user_name%></td>
                <td><%=user_sex%></td>
                <td><%=user_phone%></td>
                <td><%=user_age%></td>
            </tr>
            <%
                }
            %>            
        </table>        
        <br/>
        
    <table width="60%" align="right">
        <tr><td><div id="changePages" name="changePages"></div></td></tr>
    </table>

然后，在JS中修改table中某些行显示，某些行隐藏。

<script type="text/javascript">
    function goPage(pno,psize){
    var itable = document.getElementById("idData");//获取table
    var num = itable.rows.length;//得到记录总数
    var totalPage = 0;
    var pageSize = psize;//一页显示pageSize条记录
    //计算总页数
    if(num/pageSize > parseInt(num/pageSize)){   
            totalPage=parseInt(num/pageSize)+1;   
       }else{   
           totalPage=parseInt(num/pageSize);   
       }   
     //当前页数
    var currentPage = pno;
    //获取当前页第一条、最后一条记录的行号
    var startRow = (currentPage - 1) * pageSize+1;
       var endRow = currentPage * pageSize;
       endRow = (endRow > num)? num : endRow;
    //修改table中当前页对应的行的属性为显示，非本页的记录为隐藏
    for(var i=1;i<(num+1);i++){    
        var irow = itable.rows[i-1];
        if(i>=startRow && i<=endRow){
            irow.style.display = "block";    
        }else{
            irow.style.display = "none";
        }
    }
    
    //分页页码列表
    var tempStr = "共"+num+"条记录 分"+totalPage+"页 当前第"+currentPage+"页";
    if(currentPage>1){
        tempStr += "<a href="#" onClick="goPage("+(1)+","+psize+")">首页</a>";
        tempStr += "<a href="#" onClick="goPage("+(currentPage-1)+","+psize+")"><上一页</a>"
    }else{
        tempStr += "首页";
        tempStr += "<上一页";    
    }

    if(currentPage<totalPage){
        tempStr += "<a href="#" onClick="goPage("+(currentPage+1)+","+psize+")">下一页></a>";
        tempStr += "<a href="#" onClick="goPage("+(totalPage)+","+psize+")">尾页</a>";
    }else{
        tempStr += "下一页>";
        tempStr += "尾页";    
    }
    document.getElementById("changePages").innerHTML = tempStr;   
}
    </script>

2. 逻辑分页(结果集游标移动)

参考代码：

<%    
　　　　　　　　　　 　int intPageSize = 10;             //一页显示的记录数 
                    int intRowCount;                 //记录总数 
                    int intPageCount;                 //总页数 
                    String strPage;                    //从表单或URL传送的待显示页码
                    int intPage;                     //待显示页码 ，由strPage转换成的整数


　　　　　　　　　　　
　　　　　　　　//---计算记录总数的第一种方法：查询出所有记录，移动结果集指针到最后一条，获取最后一条记录的行号
　　　　　　　　　　//查询所有数据
    　　　　　　　　ResultSet sqlRst = sqlStmt.executeQuery("select * from user");
  　　　　　　　　  //获取记录总数 
   　　　　　　　　　sqlRst.last();                    //光标在最后一行
    　　　　　　　　intRowCount = sqlRst.getRow();    //获得当前行号，即总记录数
  　　　　　　　　  //记算总页数 
   　　　　　　　　 intPageCount = (int)Math.ceil(intRowCount/(intPageSize*1.0));



 
//将记录指针定位到待显示页的第一条记录上 
                    sqlRst.absolute((intPage - 1) * intPageSize + 1);
                    //显示数据 
                    int i=0;
                    String user_id, user_name, user_sex, user_phone, user_age;
                    while (i < intPageSize && !sqlRst.isAfterLast()) {
                        user_id = sqlRst.getString(1);
                        user_name = sqlRst.getString(2);
                        user_sex = sqlRst.getString(3);
                        user_phone = sqlRst.getString(4);
                        user_age = sqlRst.getString(5);
            %>
            <tr>
                <td><%=user_id%></td>
                <td><%=user_name%></td>
                <td><%=user_sex%></td>
                <td><%=user_phone%></td>
                <td><%=user_age%></td>
            </tr>
            <%
                        sqlRst.next();//移动记录指针指向下一条记录
                        i++;//统计当前页已显示多少条记录
                    }
            %>

3. 物理分页(通过SQL语句)

int pages=0;            //待显示页面
    int count=0;            //总条数
    int totalpages=0;        //总页数
    int limit=10;            //每页显示记录条数    
    //计算记录总数的第二种办法：使用mysql的聚集函数count(*)
    ResultSet sqlRst = sqlStmt.executeQuery("select count(*) from user");
    if(sqlRst.next()){
        count = sqlRst.getInt(1);//结果为count(*)表，只有一列。这里通过列的下标索引（1）来获取值
    }    
    //由记录总数除以每页记录数得出总页数
    totalpages = (int)Math.ceil(count/(limit*1.0));
    //获取跳页时传进来的当前页面参数
    String strPage = request.getParameter("pages");
    //判断当前页面参数的合法性并处理非法页号（为空则显示第一页，小于0则显示第一页，大于总页数则显示最后一页）
    if (strPage == null) { 
        pages = 1;
    } else {
        try{
            pages = java.lang.Integer.parseInt(strPage);
        }catch(Exception e){
            pages = 1;
        }
        
        if (pages < 1){
            pages = 1;
        }
        
        if (pages > totalpages){
            pages = totalpages;
        }                            
    }
    //由(pages-1)*limit算出当前页面第一条记录，由limit查询limit条记录。则得出当前页面的记录
    sqlRst = sqlStmt.executeQuery("select * from user order by user_id limit " + (pages - 1) * limit + "," + limit);
    while (sqlRst.next()){//遍历显示}

跳页的实现：跳页是通过重定向来实现的，通过向当前网页传进待显示的pages，在跳转后根据pages重新算出页面显示的第一条，查limit条显示。

<form name="f1" method="POST" action="index.jsp" onSubmit="return checknum()">
            <table border="0" align="center" >
                <tr>
                    <td>第<%=pages%>页 共<%=totalpages%>页 <a href="index.jsp?pages=1">首页</a></td>
                    <td><a href="index.jsp?pages=<%=(pages<1)?pages:(pages-1) %>"> 上一页</a></td>
                    <td><a href="index.jsp?pages=<%=(pages>=totalpages)?totalpages:(pages+1)%>"> 下一页</a></td>
                    <td><a href="index.jsp?pages=<%=totalpages%>">最后一页</a></td>
                    <td>转到第:<input type="text" name="page" size="8">页<input type="submit" value="GO" name="cndok"></td>
                </tr>
            </table> 
 </form>

---

我的具体实现

看了上面大佬的3种分页方式，我决定采用第3中方式实现分页，我是用的数据库为MySQL。
演示站点：http://school.lking.top（后期可能会有所变动）

项目仓库地址：https://github.com/b84955189/TF-MIS
我的总结脑图：https://download.csdn.net/download/weixin_43670802/12364091

我将每次分页查询的数据包装成了一个对象，该对象包括：

package top.lking.bean;

import lombok.Data;

import java.util.List;

/**
 * 分页Bean
 * @author Jason
 * @version 1.0
 * @date 4/25/2020 3:16 PM
 */
@Data
public class Page {
    //起始页码
    private int startPageCount;
    //结束页码
    private int endPageCount;
    //当前页码
    private int currentPageCount;
    //数据总量
    private int totalData;
    //页面数据查询方式
    private String queryType;
    //查询片段
    private String snippet;

    //当前页数据
    private List<User> currentPageData;

}

每次跳转页面都会从Dao层（有点破坏MVC结构，不过是为了一并返回数据与数据量）返回一个含有数据与数据总量的初始page对象：

 @Override
    public Page queryAll(String snippet, int currentPageCount) throws SQLException {
        Page page=new Page();
        List<User> list=new ArrayList<User>();
        Connection connection=LoveQQDBUtils.getCon();
        //用来计算数据总量
        PreparedStatement totalCountPreparedStatement=connection.prepareStatement(R.LoveQQSQLConfig.PRE_LIMIT_QUERY_ALL_USER_COUNT_SQL);
        totalCountPreparedStatement.setString(1,"%"+snippet+"%");
        ResultSet totalResultSet=totalCountPreparedStatement.executeQuery();
        if(totalResultSet.next()){
            page.setTotalData(totalResultSet.getInt(1));
        }
        totalResultSet.close();
        totalCountPreparedStatement.close();
        //用来查询数据
        PreparedStatement preparedStatement=connection.prepareStatement(R.LoveQQSQLConfig.PRE_LIMIT_QUERY_ALL_USER_SQL);
        preparedStatement.setString(1,"%"+snippet+"%");
        preparedStatement.setInt(2,(currentPageCount-1)* LoveQQDBControlInterface.SHOW_PAGE_PAGINATION_COUNT);
        ResultSet resultSet = preparedStatement.executeQuery();
        while(resultSet.next()){

            User user=new User();
            user.setUser_id(resultSet.getInt(R.LoveQQSQLConfig.USER_ID));
            user.setUser_login(resultSet.getString(R.LoveQQSQLConfig.USER_LOGIN));
            user.setUser_pass(resultSet.getString(R.LoveQQSQLConfig.USER_PASS));
            user.setUser_register_time(resultSet.getTimestamp(R.LoveQQSQLConfig.USER_REGISTER_TIME).toString());
            list.add(user);
        }
        resultSet.close();
        preparedStatement.close();

        page.setCurrentPageData(list);
        return page;
    }

然后在Control层再判断加工一下page对象，返回一个完整的page对象：

    @Override
    public Page paginationQuery(int sign, String snippet,String currentPageCountString) {

        //如果没有输入搜索片段---转发完整数据
        if(snippet==null||snippet.trim().equals("")){
            snippet="";
        }

        //*******处理当前页参数***********
        int currentPageCount;
        if(currentPageCountString ==null)
            currentPageCount=1;
        else {
            try {
                currentPageCount=Integer.parseInt(currentPageCountString);
            }catch (Exception e){
                currentPageCount=1;
            }

        }
        //*************************

        //获取到当前页面的数据对象
        Page page=this.queryAll(sign,snippet, currentPageCount);

        //数据总量
        int totalCount=page.getTotalData();
        //设置起始页码
        page.setStartPageCount(1);
        //设置当前页码--并判断是否已有页码
        page.setCurrentPageCount(currentPageCount);
        //设置终止页码
        page.setEndPageCount(totalCount%LoveQQDBControlInterface.SHOW_PAGE_PAGINATION_COUNT==0?totalCount/LoveQQDBControlInterface.SHOW_PAGE_PAGINATION_COUNT:totalCount/LoveQQDBControlInterface.SHOW_PAGE_PAGINATION_COUNT+1);
        //标记页面数据查询方式-------------后期搜索类型增加，会有所变动
        page.setQueryType(R.RequestParamName.TYPE_USER_LOGIN);
        //标记查询片段
        page.setSnippet(snippet);
        //Test
        System.out.println("页面："+page);


        return page;
    }

最后绑定给request（之所以不绑定给其他域对象是为了防止数据过大影响用户体验），供显示页面调用：

@WebServlet("/search.do")
public class TestSearchServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        Page page=null;
        LoveQQDBControl loveQQDBControl = new LoveQQDBControl();
        String snippet=request.getParameter(R.RequestParamName.TYPE_USER_LOGIN);
        String currentCountString=request.getParameter(R.RequestParamName.PAGE_COUNT);
        page=loveQQDBControl.paginationQuery(LoveQQDBControlInterface.LOVE_QQ_USER_TABLE,snippet,currentCountString);



        //绑定数据
        request.setAttribute(R.RequestParamName.CURRENT_DATA,page);
        //转发至展示页---注意在服务器内部调用的路径与浏览器调用的路径问题--下面注释掉的，在服务器里是错误的，注意理解！！！之所以要加contextPath，是为了前端找资源的。
//        request.getRequestDispatcher(request.getContextPath()+R.FrontPageNames.SHOW_PAGE).forward(request,response);
          request.getRequestDispatcher(R.FrontPageNames.SHOW_PAGE).forward(request,response);

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       doGet(req,resp);
    }
}

参考
https://www.cnblogs.com/firstdream/p/7732672.html
https://blog.csdn.net/sinat_34612251/article/details/87620906
https://www.jb51.net/article/34728.htm
https://www.jb51.net/article/72380.htm
https://www.jb51.net/article/86326.htm
https://www.cnblogs.com/zhangyanran/p/10037537.html
https://www.jb51.net/article/86334.htm
https://www.jb51.net/article/86326.htm
https://blog.csdn.net/qq_38977097/article/details/81273814
https://www.iteye.com/blog/lixor-765255