实现场景：首页中的商品展示列表
    实现效果：

    分页操作基本是大部分网站都实现的一个功能
    实现它的原因：我们在进行查询操作的时候，如果数据库中数据过多时，我们可能并不需要将所有的数据都展示到页面中，而且这样做会导致 页面信息过多，很多噪音数据会影响用户体验，并且一次性查询过多数据服务器也会承受很多压力。因此我们需要实现分页功能。
    分析分页功能过程：
    第一步：我们应该在传入后台查询数据的时候需要先计算一共要分为多少页（总页数）
    第二步：我们需要根据总行数和设定的每页应该显示的行数来计算总体需要分的页数
    第三步：我们需要通过前端页面获取到当前页
    总页数的计算：通过查询数据库总数据的行数/一页需要分多少数据。
    但是要注意如果无法取模等于0，总页数需要+1；
    第四步：控制前端界面传入需要查询的数值到查servlet询界面，servlet调用service层查询指定页数的数据。
    具体实现代码：
    jsp层：

    1. <center>
    2.         <h3 align="center">用户信息管理</h3>
    3.    <table border='2' align='center'>
    4.     <tr>
    5.        <td> 商品编号 </td>
    6.        <td> 商品名称 </td>
    7.        <td> 生产日期 </td>
    8.         <td> 生产厂家 </td>
    9.         <td> 操作 </td>
    10.         <td><a href='/myWeb/addProduct.jsp'>添加商品</a></td>
    11.         </tr>
    12.     <c:forEach items="${requestScope.products}" var="p">
    13.     <tr>
    14.         <td> ${p.pid} </td>
    15.         <td> ${p.pname} </td>
    16.         <td> ${p.pdate}</td>
    17.         <td> ${p.pfactory} </td>
    18.         <td><a href='/myWeb/product?action=delete&pid=${p.pid}'>删除商品</a></td>
    19.         <td><a href='/myWeb/product?action=select&pid=${p.pid}'>查看详情</a></td>
    20.        </tr>
    21.     </c:forEach>
    22.     </table>
    23.     <div class="page">
    24.         <%-- 当前页减1 --%>
    25.         当前是第${pageNows},总页数为${pages}<br>
    26.         <a href="show?pn=${pageNows-1}">&lt;</a>
    27.         <c:forEach begin="1" end="${pages}" var="i">
    28.             <a href="/myWeb/show?pn=${i}">${i}</a>
    29.         </c:forEach>
    30.         <a href="show?pn=${pageNows+1}">&gt;</a>
    31.     </div>
    32.     <a href='/myWeb/loginServlet?action=logout'>退出登录</a>
    33. </center>

    servlet层：

    1. @WebServlet("/show")
    2. public class ShowServlet extends HttpServlet {
    4.     @Override
    5.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    6.         this.doPost(req,resp);
    7.     }
    9.     @Override
    10.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    11.         ProductDao productDao=new ProductDaoImpl();
    12.         // 获取到的当前页
    13.         String pn = req.getParameter("pn");
    14.         // 当前页
    15.         int pageNow ;
    16.         // 每页的行数
    17.         int pageCount=3;
    18.         // 总行数
    19.         int pageRows;
    20.         // 判断当前页是否为null
    21.         pageNow=pn==null?0:Integer.valueOf(pn);
    22.         // 判断当前页页数是否小于 0
    23.         if (pageNow <=0){
    24.                pageNow=1;
    25.         }
    26.         System.out.println("------------当前页--------------");
    27.         System.out.println(pageNow);
    28.         System.out.println("------------当前页--------------");
    29.         pageRows = productDao.selectCount();
    30.         // 总页数(总行数/每页的行数)
    31.         int pages=pageRows%pageCount==1?pageRows/pageCount:pageRows/pageCount+1;
    32.         if (pageNow>=pages){
    33.             pageNow=pages;
    34.         }
    35.         System.out.println("----------总页数----------------");
    36.         System.out.println(pages);
    37.         System.out.println("--------------------------");
    38.         req.setAttribute("pages",pages);
    39.         List<Product> products = productDao.selectAllProduct(pageNow,pageCount);
    40.         // 查询到的所有商品
    41.         req.setAttribute("products",products);
    42.         // 当前页
    43.         req.setAttribute("pageNows",pageNow);
    44.         req.getRequestDispatcher("main.jsp").forward(req,resp);
    46.     }
    47. }

    dao层

    1. /*
    2.      * @Author liu-miss
    3.      * @Description 查询所有商品信息
    4.      * @Date 19:44 2021/7/12
    5.      * @Param []
    6.      * @return java.util.List<com.luzhikun.myshopping.domaim.Product>
    7.      **/
    9.     @Override
    10.     public List<Product> selectAllProduct(int pageNow,int pageCount) {
    11.         DBCPUtil dbcpUtil=new DBCPUtil();
    12.         String sql = "select * from product limit ?,?";
    13.         List<Product> query = dbcpUtil.query(sql, Product.class, pageNow,pageCount);
    14.         return query;
    15.     }

    封装的util查询方法

    1.  public <T> List<T> query(String sql,Class<T> c,Object...params){
    2.         Connection connection=null;
    3.         PreparedStatement pst=null;
    4.         ResultSet rs=null;
    5.         List<T> list=new ArrayList<>();
    7.         try {
    8.             connection=getConnection();
    9.             pst = connection.prepareStatement(sql);
    11.             if (params!=null && params.length>0){
    12.                 for (int i = 0; i < params.length; i++) {
    13.                     pst.setObject(i+1,params[i]);
    14.                 }
    15.             }
    16.            rs = pst.executeQuery();
    17.             // 通过反射封装结果集
    18.             // 获取列数
    19.             ResultSetMetaData metaData = rs.getMetaData();
    20.             int columnCount = metaData.getColumnCount();
    21.             System.out.println("列数====="+columnCount);
    22.            while (rs.next()){
    23.                try {
    24.                   // 创建泛型对象
    25.                   T t = c.getConstructor().newInstance();
    26.                    for (int i = 0; i < columnCount ; i++) {
    27.                        String columnName = metaData.getColumnLabel(i+1);
    28.                        System.out.println("columnName"+columnName);
    29.                        String methodName = "set" +                 columnName.substring(0,1).toUpperCase()+ columnName.substring(1);
    30.                        System.out.println("methodName"+methodName);
    31.                        Method method = c.getMethod(methodName,String.class);
    32.                        System.out.println("method"+method);
    33.                        method.invoke(t,rs.getObject(columnName));
    34.                    }
    35.                    list.add(t);
    36.                } catch (InstantiationException e) {
    37.                    e.printStackTrace();
    38.                } catch (IllegalAccessException e) {
    39.                    e.printStackTrace();
    40.                } catch (InvocationTargetException e) {
    41.                    e.printStackTrace();
    42.                } catch (NoSuchMethodException e) {
    43.                    e.printStackTrace();
    44.                }
    45.            }
    46.         } catch (SQLException throwables) {
    47.             throwables.printStackTrace();
    48.         }
    49.         return list;
    50.     }

    这些都完成后，还有一些小细节问题：
    添加上一页下一页功能，实现方式有两种：一种是服务端实现，一种是客户端实现
    服务端实现：
    在servlet中：获取到前端页面的前一页和下一页传来的参数信息，并且判断当前页是否比第一页的数值还小，是否比最大页数还大，如果是 就给默认值 

    1.          // 总页数(总行数/每页的行数)
    2.         int pages=pageRows%pageCount==1?pageRows/pageCount:pageRows/pageCount+1;
    4.         // 判断当前页页数是否小于 0
    5.         if (pageNow <=0){
    6.                pageNow=1;
    7.         }
    9.         if (pageNow>=pages){
    10.             pageNow=pages;
    11.         }

    客户端实现：
    使用JSTL标签库中的if标签判断当前页的值是否小于等于或者大于等于最小页或最大页时，让前一页或者后一页的连接失效就可以了。

    1. 当前是第${pageNows},总页数为${pages}<br>
    2.         <%-- 当前页减1 --%>
    3.             <c:if test="${pageNows}<=1">
    4.                 <
    5.             </c:if>
    6.             <c:if test="${pageNows > 1 }">
    7.              <a href="show?pn=${pageNows-1}">&lt;</a>
    8.             </c:if>
    9.         <c:forEach begin="1" end="${pages}" var="i">
    10.             <a href="/myWeb/show?pn=${i}">${i}</a>
    11.         </c:forEach>
    12.         <c:if test="${pageNows >= pages}">
    13.             >
    14.         </c:if>
    15.         <c:if test="${pageNows < pages}">
    16.             <a href="show?pn=${pageNows+1}">&gt;</a>
    17.         </c:if>