如何实现通用分页（来看我这一篇就够了超级详细内含源码！！！）-阿里云开发者社区

好的今天我们来分享如何在浏览器显示分页效果。

一.页面显示分页效果

1.1分析页面展示所要展示的属性有哪些？

1.1.1模糊查询的关键字，第一页，上一页，下一页，尾页，总共页数，总共条数

1.2分析页面有哪些每次发送请求有哪些公共的参数

1.2.1我们每次点击不同的页码，会将关键字，当前页码，查询的URL地址传到后台，此时我们就可以使用某种方法保存公共的代码。

二.具体实现前端通用分页？

2.1分析思路：

1.我们在学会了通用分页基础后，对之前的pagebean类进行改进。（原来的文件中我只定义了页码，每一页显示的数量，默认调用的分页方法）这里我们需要给分页工具类添加几个属性：

1.1增加URL属性，用于保存上一次访问的页码地址（这个URL在我们下一次访问时，是可以利用的只不过我们每次访问的页码和关键字不同）

1.2增加初始pagebean类属性，用于获取servlet中传递来的值（修改页码和关键词）

1.3增加上一页方法，方便用户使用

1.4增加下一页方法，方便用户使用

1.5增加最大页方法，方便用户使用

1.6增加paramMap属性，用于接收多个关键词

2.以前我们使用servlet去保存我们从jsp页面传递来的值，是使用req.getParmeter,如果我们传递N个参数时，那么我们要写N便的req.getParmeter方法，所以我们要使用初始pagebean类去替代，从而简化了我们的代码量。

（getRequestDispatcher(转发的页面).forward（req,req））

3.初始pagebean类（作用：将当前选中的页码，所要展示内容的条数，是否要使用分页，上一次的URL地址，附带的关键字等进行内部修改。）

4.这里我们需要用到上篇分页基础中后台的使用(将后台查询的内容保存到req中)。

4.1通过创建自定义分页标签的方法循环显示展示内容（关于标如何创建自定义分页签我在上篇已经发布）

以下是创建自定义分页标签的过程：

2.2具体实现的过程

2.2.1标签助手类

属性：pageBean

方法： toHTML中拼接HTML代码

具体代码：

package com.lya.tag;
import java.io.IOException;
import java.util.Map;
import java.util.Set;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.tagext.BodyTagSupport;
import com.lya.util.PageBean;
/**
 * @author :JAVA-李永安
 * @date :2023年6月29日 上午9:22:31
 */
public class PageTag extends BodyTagSupport {
    private PageBean pageBean;
    public PageBean getPageBean() {
        return pageBean;
    }
    public void setPageBean(PageBean pageBean) {
        this.pageBean = pageBean;
    }
    @Override
    public int doStartTag() throws JspException {
        JspWriter out = pageContext.getOut();
        try {
            out.print(toHTML());
        } catch (IOException e) {
            e.printStackTrace();
        }
        return SKIP_BODY;
    }
    private String toHTML() {
        StringBuilder sb = new StringBuilder();
//        这里拼接的是一个上一次发送的请求以及携带的参数，唯一改变的就是页码
        sb.append("<form id='pageBeanForm' action='"+pageBean.getUrl()+"' method='post'>");
        sb.append("<input type='hidden' name='methodName' value='list'>");
        sb.append("<input type='hidden' name='page'>");
//        重要设置拼接操作，将上一次请求参数携带到下一次
        Map<String, String[]> paMap = pageBean.getParamMap();
        if(paMap !=null && paMap.size()>0){
            Set<Map.Entry<String, String[]>> entrySet = paMap.entrySet();
            for (Map.Entry<String, String[]> entry : entrySet) {
                for (String val : entry.getValue()) {
                    if(!"page".equals(entry.getKey())){
                        sb.append("<input type='hidden' name='"+entry.getKey()+"' value='"+val+"'>");
                    }
                }
            }
        }
        sb.append("</form>");
        int page = pageBean.getPage();
        int max = pageBean.maxpage();
        int before = page > 4 ? 4 : page-1;
        int after = 10 - 1 - before;
        after = page+after > max ? max-page : after;
//        disabled
        boolean startFlag = page == 1;
        boolean endFlag = max == page;
//        拼接分页条
        sb.append("<ul class='pagination'>");
        sb.append("<li class='page-item "+(startFlag ? "disabled" : "")+"'><a class='page-link' href='javascript:gotoPage(1)'>首页</a></li>");
        sb.append("<li class='page-item "+(startFlag ? "disabled" : "")+"'><a class='page-link' href='javascript:gotoPage("+pageBean.getPage()+")'>&lt;</a></li>");
//        代表了当前页的前4页
        for (int i = before; i > 0 ; i--) {
            sb.append("<li class='page-item'><a class='page-link' href='javascript:gotoPage("+(page-i)+")'>"+(page-i)+"</a></li>");
        }
        sb.append("<li class='page-item active'><a class='page-link' href='javascript:gotoPage("+pageBean.getPage()+")'>"+pageBean.getPage()+"</a></li>");
//        代表了当前页的后5页
        for (int i = 1; i <= after; i++) {
            sb.append("<li class='page-item'><a class='page-link' href='javascript:gotoPage("+(page+i)+")'>"+(page+i)+"</a></li>");
        }
        sb.append("<li class='page-item "+(endFlag ? "disabled" : "")+"'><a class='page-link' href='javascript:gotoPage("+pageBean.nextpage()+")'>&gt;</a></li>");
        sb.append("<li class='page-item "+(endFlag ? "disabled" : "")+"'><a class='page-link' href='javascript:gotoPage("+pageBean.maxpage()+")'>尾页</a></li>");
        sb.append("<li class='page-item go-input'><b>到第</b><input class='page-link' type='text' id='skipPage' name='' /><b>页</b></li>");
        sb.append("<li class='page-item go'><a class='page-link' href='javascript:skipPage()'>确定</a></li>");
        sb.append("<li class='page-item'><b>共"+pageBean.getTotal()+"条</b></li>");
        sb.append("</ul>");
//        拼接分页的js代码
        sb.append("<script type='text/javascript'>");
        sb.append("function gotoPage(page) {");
        sb.append("document.getElementById('pageBeanForm').page.value = page;");
        sb.append("document.getElementById('pageBeanForm').submit();");
        sb.append("}");
        sb.append("function skipPage() {");
        sb.append("var page = document.getElementById('skipPage').value;");
        sb.append("if (!page || isNaN(page) || parseInt(page) < 1 || parseInt(page) > "+max+") {");
        sb.append("alert('请输入1~N的数字');");
        sb.append("return;");
        sb.append("}");
        sb.append("gotoPage(page);");
        sb.append("}");
        sb.append("</script>");
        return sb.toString();
    }
}

注意我们在Tag类里面需要进行拼接，①页面能总是能显示前4页提供我们进行点击，逻辑是：我们得通过本页-1页，并且判断是否超过4页，超过了就每次-1页，不超过就显示小于4的页数。②同理页面能总是能显示后6页提供我们进行点击，逻辑是：我们得通过总共10页-本身1页-之前显示的页数，并且要判断我们当前页码+向后显示的页码是否超过了最大的页码，如果超过了就显示后面剩余的页数，没有超过就显示后面的5页。以上思路就是我们分页总是能够显示前4页后5页的逻辑

2.2.2创建标签库描述文件(tld)

<!DOCTYPE taglib
  PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
   "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
<!-- 标签库描述符 -->
<taglib xmlns="http://java.sun.com/JSP/TagLibraryDescriptor">
  <!-- 代表标签库的版本号 -->
  <tlib-version>1.0</tlib-version>
  <!-- 代表jsp的版本 -->
  <jsp-version>1.2</jsp-version>
  <!-- 你的标签库的简称 -->
  <short-name>test</short-name>
  <!-- 你标签库的引用uri -->
  <uri>/zking</uri><!-- 在jsp页面调用tld的路径 -->
  <tag>
    <!-- 标签名 -->
    <name>page</name>
    <!-- 标签工具类 -->
    <tag-class>com.lya.tag.PageTag</tag-class>
    <!-- 标签的内容类型：empty表示空标签，jsp表示可以为任何合法的JSP元素 -->
    <body-content>jsp</body-content>
    <!-- 自定义标签的属性定义,请注意一定要在标签类中提供对应的get/set方法 -->
    <attribute>
      <!-- 自定义标签的属性名称 -->
      <name>pageBean</name>
      <!-- true表示必填 -->
      <required>true</required>
      <!-- true支持动态值,可以向值里面填jsp表达式、EL表达式,false则不支持 -->
      <rtexprvalue>true</rtexprvalue>
      <description>通用的page</description>
    </attribute>
  </tag>
</taglib>

2.2.3创建jsp页面

（这里我们要用到c标签的foreach循环，和我们自定义的通用分页标签）

<%@ page language="java" contentType="text/html; charset=UTF-8"
  pageEncoding="UTF-8"%>
<%@taglib prefix="z" uri="/zking"%>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
<link
  href="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/4.5.0/css/bootstrap.css"
  rel="stylesheet">
<script
  src="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/4.5.0/js/bootstrap.js"></script>
<title>书籍列表</title>
<style type="text/css">
.page-item input {
  padding: 0;
  width: 40px;
  height: 100%;
  text-align: center;
  margin: 0 6px;
}
.page-item input, .page-item b {
  line-height: 38px;
  float: left;
  font-weight: 400;
}
.page-item.go-input {
  margin: 0 10px;
}
</style>
</head>
<body>
  <form class="form-inline"
    action="${pageContext.request.contextPath }/book.action" method="post">
    <div class="form-group mb-2">
      <input type="text" class="form-control-plaintext" name="bname"
        placeholder="请输入书籍名称">
    </div>
    <button type="submit" class="btn btn-primary mb-2">查询</button>
  </form>
  <table class="table table-striped ">
    <thead>
      <tr>
        <th scope="col">书籍ID</th>
        <th scope="col">书籍名</th>
        <th scope="col">价格</th>
      </tr>
    </thead>
    <tbody>
  <c:forEach items="${ckbook2 }" var="b">
    <tr>
      <td>${b.bid }</td>
      <td>${b.bname }</td>
      <td>${b.price }</td>
    </tr>
  </c:forEach>
    </tbody>
  </table>
  <form action="" id="pageBeanForm" method="post">
    <input type="hidden" name="page">
  </form>
  <script type='text/javascript'>
    function gotoPage(page) {
      document.getElementById('pageBeanForm').page.value = page;
      document.getElementById('pageBeanForm').submit();
    }
    function skipPage() {
      var page = document.getElementById('skipPage').value;
      if (!page || isNaN(page) || parseInt(page) < 1
          || parseInt(page) > 1122) {
        alert('请输入1~N的数字');
        return;
      }
      gotoPage(page);
    }
  </script>
  <z:page pageBean="${pagebean }"></z:page>
</body>
</html>

2.2.4创建servlet页面

（这里我们servlet的@WebServlet名称用.action结尾，应为方便我们下一步操作）

package com.lya.servlet;
import java.io.IOException;
import java.util.List;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.lya.dao.BookDaoS;
import com.lya.entity.Book;
import com.lya.util.PageBean;
/**
 * 实现书本页码展示的servlet
 * @author :JAVA-李永安
 * @date :2023年6月28日 下午9:12:06
 */
@WebServlet("/book.action")
public class BookListServlet extends HttpServlet{
  @Override
  protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    this.doPost(req, resp);
  }
  @Override
  protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    PageBean pagebean = new PageBean();
    pagebean.setRequest(req);
    Book book = new Book();
    book.setBname(req.getParameter("bname"));//从jsp页面传关键字
    BookDaoS bd = new  BookDaoS();//调用
    try {
      List<Book> ckbook2 = bd.ckbook2(book, pagebean);
      req.setAttribute("ckbook2", ckbook2);
    } catch (Exception e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    req.setAttribute("pagebean", pagebean);
    req.getRequestDispatcher("Book.jsp").forward(req, resp);
  }
}

2.2.5创建BaseDao类（用于通用分页）

package com.lya.dao;
import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import com.lya.entity.Book;
import com.lya.util.DBAccess;
import com.lya.util.PageBean;
import com.lya.util.StringUtils;
/**
 * 通用的增删改查(分页的显示)
 * 
 * @author :JAVA-李永安
 * @date :2023年6月27日 上午11:38:42
 */
public class BaseDao<T> {
  /**
   * @param sql
   *            sql语句
   * @param cla
   *            类对象
   * @param pagebeam
   *            分页工具类
   * @return
   * @throws Exception
   */
  public List<T> excuteQuery(String sql, Class cla, PageBean pagebeam) throws Exception {
    Connection conn = null;
    PreparedStatement stmt = null;
    ResultSet rs = null;
    List<T> list = new ArrayList<T>();
    // 这里我们考虑两种情况：
    // （一）需要使用分页，
    if (pagebeam != null && pagebeam.isPagination()) {
      // 这里定义分页的两个重要的属性：
      // countSQL（执行待条件sql后的记录数），sql参数在调用时拼写
      // pageSQl（执行待条件sql后返回的内容）,sql参数在调用时拼写,pagebeam参数是传递起始参数的
      String countSQL = getCountSQL(sql);
      conn = DBAccess.getConnection();
      stmt = conn.prepareStatement(countSQL);
      rs = stmt.executeQuery();
      // 当我们查询一次countSQL后就得到单个数据---我们用if不用while
      if (rs.next()) {
        pagebeam.setTotal(rs.getObject("n").toString());
      }
      String pageSQl = getPageSQl(sql, pagebeam);
      conn = DBAccess.getConnection();
      stmt = conn.prepareStatement(pageSQl);
      rs = stmt.executeQuery();
      System.out.println(countSQL+"  "+pageSQl);
    }
    // （二）不需要使用分页
    else {
      conn = DBAccess.getConnection();
      stmt = conn.prepareStatement(sql);
      rs = stmt.executeQuery();
    }
    while (rs.next()) {
      // 使用反射(拿到类的属性值)
      T t = (T) cla.newInstance();// 实例类类
      Field[] fd = cla.getDeclaredFields();// 获取属性
      for (Field f : fd) {// 遍历fd
        f.setAccessible(true);// 打开权限
        f.set(t, rs.getObject(f.getName()));// 为T设置属性值
      }
      list.add(t);
    }
    return list;
  }
  /**
   * 执行待条件sql后的记录数
   * 
   * @param sql
   * @return
   */
  private String getCountSQL(String sql) {
    // TODO Auto-generated method stub
    // SELECT count(*) as a FROM(SELECT * FROM`t_mvc_book` where Bname like '%圣%')t
    return "SELECT count(1) as n FROM(" + sql + ")t";
  }
  /**
   * 执行待条件sql后返回的内容
   * 
   * @param sql
   * @return
   */
  private String getPageSQl(String sql, PageBean pagebeam) {
    // TODO Auto-generated method stub
    // SELECT * FROM `t_mvc_book` where Bname like '%圣%' limit 0,10
//    return "'" + sql + "' limit '" + pagebeam.getStartIndex() + "' , '" + pagebeam.getRows() + "'  ";
    return sql + " limit " + pagebeam.getStartIndex() + "," + pagebeam.getRows();
  }
}

2.2.6创建实例化的BookDao类（用于实现当前书籍数据分页）

package com.lya.dao;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
import com.lya.entity.Book;
import com.lya.util.DBAccess;
import com.lya.util.PageBean;
import com.lya.util.StringUtils;
/**
 * S阶段写法与使用BaseDao之后的对比
 * 
 * @author :JAVA-李永安
 * @date :2023年6月27日 上午10:53:47
 */
public class BookDaoS extends BaseDao<Book> {
  /**
   * 未使用BaseDao
   * 
   * @param book
   * @param pagebeam
   * @return
   * @throws Exception
   */
  public List<Book> ckbook1(Book book, PageBean pagebeam) throws Exception {
    Connection conn = DBAccess.getConnection();
    String sql = "select * from t_mvc_book where 1=1";
    String bname = book.getBname();
    // StringUtils.isNotBlank(bname)------用于判断bname是否为空
    if (StringUtils.isNotBlank(bname)) {
      sql += " and bname like '%" + bname + "%'";
    }
    PreparedStatement stmt = conn.prepareStatement(sql);
    List<Book> list = new ArrayList<Book>();
    ResultSet rs = stmt.executeQuery();
    while (rs.next()) {
      Book b = new Book();
      b.setBid(rs.getInt("bid"));
      b.setBname(rs.getString("bname"));
      b.setPrice(rs.getFloat("price"));
      list.add(b);
    }
    return list;
  }
  /**
   * 使用BaseDao
   * 
   * @param book
   * @param pagebeam
   * @return
   * @throws Exception
   */
  public List<Book> ckbook2(Book book, PageBean pagebeam) throws Exception {
    String sql = "select * from t_mvc_book where 1=1";
    String bname = book.getBname();
    // StringUtils.isNotBlank(bname)------用于判断bname是否为空
    if (StringUtils.isNotBlank(bname)) {
      sql += " and bname like '%" + bname + "%'";
    }
    // super用法
    return super.excuteQuery(sql, Book.class, pagebeam);
  }
  public static void main(String[] args) {
    BookDaoS bookDaoS = new BookDaoS();
    Book book = new Book();
    book.setBname("斗");
    PageBean pagebeam = new PageBean();
    List<Book> ckbook = null;
    try {
      ckbook = new BookDaoS().ckbook2(book, pagebeam);
    } catch (Exception e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    for (Book book2 : ckbook) {
      System.out.println(book2);
    }
  }
  @Test
  public void test1() throws Exception {
    System.out.println("test1======");
    BookDaoS bookDaoS = new BookDaoS();
    Book book = new Book();
    book.setBname("圣");
    PageBean pagebeam = new PageBean();
    List<Book> ckbook = new BookDaoS().ckbook1(book, pagebeam);
    for (Book book2 : ckbook) {
      System.out.println(book2);
    }
  }
  @SuppressWarnings("unused")
  @Test
  public void test2() throws Exception {
    System.out.println("test2======");
    BookDaoS bookDaoS = new BookDaoS();
    Book book = new Book();
    book.setBname("圣");
    PageBean pagebeam = new PageBean();
    List<Book> ckbook = new BookDaoS().ckbook2(book, pagebeam);
    for (Book book2 : ckbook) {
      System.out.println(book2);
    }
  }
  @Test
  public void test3() throws Exception {
    System.out.println("test3======");
    BookDaoS bookDaoS = new BookDaoS();
    Book book = new Book();
    book.setBname("圣");
    PageBean pagebeam = new PageBean();
    pagebeam.setPage(2);//
    pagebeam.setRows(20);
    pagebeam.setPagination(false);
    List<Book> ckbook = new BookDaoS().ckbook2(book, pagebeam);
    for (Book book2 : ckbook) {
      System.out.println(book2);
    }
    System.out.println(pagebeam);
  }
}

2.2.7创建实体类（Book）

package com.lya.entity;
public class Book {
  private int bid;
  private String bname;
  private float price;
  @Override
  public String toString() {
    return "Book [bid=" + bid + ", bname=" + bname + ", price=" + price + "]";
  }
  public int getBid() {
    return bid;
  }
  public void setBid(int bid) {
    this.bid = bid;
  }
  public String getBname() {
    return bname;
  }
  public void setBname(String bname) {
    this.bname = bname;
  }
  public float getPrice() {
    return price;
  }
  public void setPrice(float price) {
    this.price = price;
  }
}

2.2.8创建分页工具类

package com.lya.util;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
/**
 * 分页工具类
 *
 */
public class PageBean {
  private int page = 1;// 页码
  private int rows = 10;// 页大小
  private int total = 0;// 总记录数
  private boolean pagination = true;// 是否分页
  private Map<String, String[]> paramMap;// 接收多个关键词
  private PageBean pagebean;// 初始化
  private String url;// URL地址
  /**
   * 获取最大页方法
   * 
   * @return
   */
  public int maxpage() {
    if (this.total % this.page == 0) {
      return this.total / this.page;
    } else {
      return this.total / this.page + 1;
    }
  }
  /**
   * 获取上一页方法
   * 
   * @return
   */
  public int lastpage() {
    if (this.page > 1) {
      return this.page = this.page - 1;
    } else {
      return this.page;
    }
  }
  /**
   * 获取下一页方法
   * 
   * @return
   */
  public int nextpage() {
    if (this.page < this.maxpage()) {
      return this.page + 1;
    } else {
      return this.page;
    }
  }
  /**
   * 初始化页码（这里直接将servlet从页面获取的值传到这）
   * 
   * @param req
   */
  public void setRequest(HttpServletRequest req) {
    this.setPage(req.getParameter("page"));// 初始传过来的页码
    this.setRows(req.getParameter("rows"));// 初始传过来要显示的数量
    this.setPagination(req.getParameter("pagination"));// 初始传过来的是否分页
    this.setUrl(req.getRequestURL().toString());// 初始地址
    this.setParamMap(req.getParameterMap());// 初始关键词
  };
  /**
   * 将pagination转成integer类型
   * 
   * @param parameter
   */
  public void setPagination(String pagination) {
    // 判空
    if (StringUtils.isNotBlank(pagination)) {
      this.setPagination(!pagination.equals("false"));// 设置的值是true/false,默认true
    }
    ;
  }
  /**
   * 将rows转成integer类型
   * 
   * @param parameter
   */
  public void setRows(String rows) {
    // 判空
    if (StringUtils.isNotBlank(rows)) {
      this.setRows(Integer.valueOf(rows));// 重新设置setRows值（将传过来的新rows设置给老rows）
    }
    ;
  }
  /**
   * 将page转成integer类型
   * 
   * @param parameter
   */
  public void setPage(String page) {
    // 判空
    if (StringUtils.isNotBlank(page)) {
      this.setPage(Integer.valueOf(page));
    }
    ;
  }
  public Map<String, String[]> getParamMap() {
    return paramMap;
  }
  public void setParamMap(Map<String, String[]> paramMap) {
    this.paramMap = paramMap;
  }
  public void setUrl(String url) {
    this.url = url;
  }
  public PageBean getPagebean() {
    return pagebean;
  }
  public void setPagebean(PageBean pagebean) {
    this.pagebean = pagebean;
  }
  public PageBean() {
    super();
  }
  public int getPage() {
    return page;
  }
  public void setPage(int page) {
    this.page = page;
  }
  public int getRows() {
    return rows;
  }
  public void setRows(int rows) {
    this.rows = rows;
  }
  public String getUrl() {
    return url;
  }
  public int getTotal() {
    return total;
  }
  public void setTotal(int total) {
    this.total = total;
  }
  public void setTotal(String total) {
    this.total = Integer.parseInt(total);
  }
  public boolean isPagination() {
    return pagination;
  }
  public void setPagination(boolean pagination) {
    this.pagination = pagination;
  }
  /**
   * 获得起始记录的下标
   * 
   * @return
   */
  public int getStartIndex() {
    return (this.page - 1) * this.rows;
  }
  @Override
  public String toString() {
    return "PageBean [page=" + page + ", rows=" + rows + ", total=" + total + ", pagination=" + pagination + "]";
  }
}

2.2.9.注意，我们在页面传递数据到我们的后台时，要使用字符编码进行编码的统一设置（以*.action结尾必须加上）

将处理的代码封装起来并且加上@WebFilter("*.action")这样就可以对所有servlet以.action结尾进行编码处理了

以下的是实现解决中文乱码的代码：

package com.lya.util;
import java.io.IOException;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
 * 中文乱码处理
 * 
 */
@WebFilter("*.action")
public class EncodingFilter implements Filter {
  private String encoding = "UTF-8";// 默认字符集
  public EncodingFilter() {
    super();
  }
  public void destroy() {
  }
  public void doFilter(ServletRequest request, ServletResponse response,
      FilterChain chain) throws IOException, ServletException {
    HttpServletRequest req = (HttpServletRequest) request;
    HttpServletResponse res = (HttpServletResponse) response;
    // 中文处理必须放到 chain.doFilter(request, response)方法前面
    res.setContentType("text/html;charset=" + this.encoding);
    if (req.getMethod().equalsIgnoreCase("post")) {
      req.setCharacterEncoding(this.encoding);
    } else {
      Map map = req.getParameterMap();// 保存所有参数名=参数值(数组)的Map集合
      Set set = map.keySet();// 取出所有参数名
      Iterator it = set.iterator();
      while (it.hasNext()) {
        String name = (String) it.next();
        String[] values = (String[]) map.get(name);// 取出参数值[注：参数值为一个数组]
        for (int i = 0; i < values.length; i++) {
          values[i] = new String(values[i].getBytes("ISO-8859-1"),
              this.encoding);
        }
      }
    }
    chain.doFilter(request, response);
  }
  public void init(FilterConfig filterConfig) throws ServletException {
    String s = filterConfig.getInitParameter("encoding");// 读取web.xml文件中配置的字符集
    if (null != s && !s.trim().equals("")) {
      this.encoding = s.trim();
    }
  }
}

2.2.10通用Oracle，SQL server，MySQL连接数据库的帮助类

package com.lya.util;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
/**
 * 提供了一组获得或关闭数据库对象的方法
 * 
 */
public class DBAccess {
  private static String driver;
  private static String url;
  private static String user;
  private static String password;
  static {// 静态块执行一次，加载 驱动一次
    try {
      InputStream is = DBAccess.class
          .getResourceAsStream("config.properties");
      Properties properties = new Properties();
      properties.load(is);
      driver = properties.getProperty("driver");
      url = properties.getProperty("url");
      user = properties.getProperty("user");
      password = properties.getProperty("pwd");
      Class.forName(driver);
    } catch (Exception e) {
      e.printStackTrace();
      throw new RuntimeException(e);
    }
  }
  /**
   * 获得数据连接对象
   * 
   * @return
   */
  public static Connection getConnection() {
    try {
      Connection conn = DriverManager.getConnection(url, user, password);
      return conn;
    } catch (SQLException e) {
      e.printStackTrace();
      throw new RuntimeException(e);
    }
  }
  public static void close(ResultSet rs) {
    if (null != rs) {
      try {
        rs.close();
      } catch (SQLException e) {
        e.printStackTrace();
        throw new RuntimeException(e);
      }
    }
  }
  public static void close(Statement stmt) {
    if (null != stmt) {
      try {
        stmt.close();
      } catch (SQLException e) {
        e.printStackTrace();
        throw new RuntimeException(e);
      }
    }
  }
  public static void close(Connection conn) {
    if (null != conn) {
      try {
        conn.close();
      } catch (SQLException e) {
        e.printStackTrace();
        throw new RuntimeException(e);
      }
    }
  }
  public static void close(Connection conn, Statement stmt, ResultSet rs) {
    close(rs);
    close(stmt);
    close(conn);
  }
  public static boolean isOracle() {
    return "oracle.jdbc.driver.OracleDriver".equals(driver);
  }
  public static boolean isSQLServer() {
    return "com.microsoft.sqlserver.jdbc.SQLServerDriver".equals(driver);
  }
  public static boolean isMysql() {
    return "com.mysql.cj.jdbc.Driver".equals(driver);
  }
  public static void main(String[] args) {
    Connection conn = DBAccess.getConnection();
    System.out.println(conn);
    DBAccess.close(conn);
    System.out.println("isOracle：" + isOracle());
    System.out.println("isSQLServer：" + isSQLServer());
    System.out.println("isMysql：" + isMysql());
    System.out.println("数据库连接(关闭)成功");
  }
}

2.2.11通用Oracle，SQL server，MySQL连接数据库的属性文件

#oracle9i
#driver=oracle.jdbc.driver.OracleDriver
#url=jdbc:oracle:thin:@localhost:1521:orcl
#user=scott
#pwd=123
#sql2005
#driver=com.microsoft.sqlserver.jdbc.SQLServerDriver
#url=jdbc:sqlserver://localhost:1433;DatabaseName=test1
#user=sa
#pwd=123
#sql2000
#driver=com.microsoft.jdbc.sqlserver.SQLServerDriver
#url=jdbc:microsoft:sqlserver://localhost:1433;databaseName=unit6DB
#user=sa
#pwd=888888
#mysql
driver=com.mysql.jdbc.Driver//加载驱动
url=jdbc:mysql://localhost:3306/mybatis_ssm?useUnicode=true&characterEncoding=UTF-8//连接数据库的url
user=root//账号
pwd=123456//密码

2.2.12进行判空封装的方法

package com.lya.util;
public class StringUtils {
  // 私有的构造方法，保护此类不能在外部实例化
  private StringUtils() {
  }
  /**
   * 如果字符串等于null或去空格后等于""，则返回true，否则返回false
   * 
   * @param s
   * @return
   */
  public static boolean isBlank(String s) {
    boolean b = false;
    if (null == s || s.trim().equals("")) {
      b = true;
    }
    return b;
  }
  /**
   * 如果字符串不等于null或去空格后不等于""，则返回true，否则返回false
   * 
   * @param s
   * @return
   */
  public static boolean isNotBlank(String s) {
    return !isBlank(s);
  }
}

三.Debug工具

3.1Debug工具是什么？

Debug工具是在软件开发过程中用于诊断和调试代码问题的工具。

3.2如何使用Debug工具？(我是使用eclipse工具进行演示)

步骤：

1.使用Debug运行我们调试的代码

2.在调试的代码上打断点（双击鼠标左键）

3.我们此时刷新访问的页面，会一直转圈，原因时Debug的断点正在调试

4.然后eclipse页面会出现弹窗，当我们点击yes就会出现5个窗口，我们使用快捷键F6可以进行下一步的调试，此时我们用鼠标悬停在对应的变量上，便可以清楚的知道这个变量所指的内容是啥。

5.当我们不想使用Debug工具我们可以有两种方式：(1.删除Debug断点：但会不方便原因是我们下一次要用到Debug时，需要重新去标记，2.禁用Debug断点)

图片实例（以eclipse为例）

第一步：使用Debug工具运行

第二步：调试内容

第三步：标记断点

第四步：刷新浏览器，eclipse会弹出yes/no选项

第五步：选中yes

注意：1.右上角的Variables中的内容指的是：我们调试内容的所有变量

2.右上角的breakpoints中的内容指的是：我们在调试内容中打上断点的地方，点进去我们便可也跳到我们内容中打上断点的地方。

第五（2）步：选中no

当我们运行Dbuge出现以下错误是我们点击tomcat服务进行超时事件配置

点击no与yes区别：

显示的内容不一样，但是效果一样。

注意：3.我们获取到浏览器传递来的URL值时，Debug上面是不显示URL上附带的参数的。

4.F6功能是进行下一个变量的调试。

5.F8功能是自动跳过所有的断点调试。

3.3使用Debug工具好处是什么？

错误诊断：Debug工具允许开发人员逐步调试代码，跟踪程序执行的路径和变量的变化。通过观察代码的行为和检查变量的值，可以更准确地定位和诊断错误的根源。

问题解决：Debug工具提供了断点、单步执行和堆栈跟踪等功能，使开发人员能够深入分析代码的执行过程。这有助于发现潜在的问题和错误，并更好地理解代码的运行方式，从而更容易地解决问题。

代码优化：Debug工具允许开发人员观察代码的性能和行为。通过性能分析工具，开发人员可以识别代码中的瓶颈和低效之处，并进行优化。这有助于改进程序的性能和效率，提升用户体验。

测试和验证：Debug工具可以用于执行和调试单元测试，帮助开发人员验证代码的正确性和健壮性。通过断言和测试覆盖率报告，开发人员可以确认代码是否按预期工作，并追踪测试范围。

学习和理解代码：Debug工具是学习和理解代码的重要工具之一。通过逐步执行代码和观察变量的值，开发人员可以更好地理解代码的逻辑和工作流程。这有助于加深对代码的理解，提高开发人员的技能水平。

总而言之，Debug工具提供了强大的调试和分析功能，可以帮助开发人员更快地诊断和解决代码问题，提高代码质量和性能，加速开发过程，同时也是学习和理解代码的重要辅助工具。

四，总结：

通用分页就是方便我们简化代码的，先将分页写出来，然后提取公共构造，封装继承。通用分页步骤就是先分析分页条属性，然后封装属性实体，然后编写dao层方法提取公共部分，接着编写分页助手类，为了避免出现乱码问题，在编写一个字符过滤器，过滤所有请求，最后在标签库描述文件中添加分页标签，就可以按自己需求来使用了。

分页逻辑：通用分页通常涉及两个主要方面的逻辑：当前页的数据展示和页面导航。当前页的数据展示是指在每页显示固定数量的数据，例如每页显示10条记录。页面导航是指提供用户可切换到其他页面的链接或按钮，包括上一页、下一页、第一页、最后一页以及直接跳转到指定页码等功能。

页面参数：通用分页需要一些参数来指定数据的分页信息，如当前页码、每页显示数量、总记录数等。这些参数在服务器端进行处理，以正确计算和返回相应的数据。

数据查询与展示：通用分页通常结合数据库查询来获取指定页的数据。通过设置查询的偏移量和限制数量，可以获取特定页的数据，并将其展示在前端页面中。

前端交互：通用分页通常需要前端的用户交互，例如点击页面导航链接或按钮来切换到其他页。这些交互可以通过AJAX或其他技术实现，以提供更流畅的用户体验。

数据更新与缓存：分页数据可能会随着时间更新或被其他操作改变，因此在分页过程中需要注意数据的一致性和及时性。在某些情况下，可以使用缓存机制来提高分页数据的访问速度，减轻数据库负载。

优化性能：当数据量较大时，通用分页可能面临性能挑战。为了提高性能，可以考虑使用索引、优化查询语句、分批加载数据等策略。

总体而言，通用分页是一种常见且实用的技术，通过将大量数据分割成多个页面展示，提供了更好的用户体验和较快的页面加载速度。它需要在后端和前端实现分页逻辑和交互，并考虑数据更新、缓存和性能优化等方面的问题。

以上就是通用分页的全部内容了，希望能够帮助到你！！

如何实现通用分页（来看我这一篇就够了超级详细内含源码！！！）

一.页面显示分页效果

1.1分析页面展示所要展示的属性有哪些？

1.2分析页面有哪些每次发送请求有哪些公共的参数

二.具体实现前端通用分页？

2.1分析思路：

2.2具体实现的过程

2.2.1标签助手类

2.2.2创建标签库描述文件(tld)

2.2.3创建jsp页面

（这里我们要用到c标签的foreach循环，和我们自定义的通用分页标签）

2.2.4创建servlet页面

（这里我们servlet的@WebServlet名称用.action结尾，应为方便我们下一步操作）

2.2.5创建BaseDao类（用于通用分页）

2.2.6创建实例化的BookDao类（用于实现当前书籍数据分页）

2.2.7创建实体类（Book）

2.2.8创建分页工具类

以下的是实现解决中文乱码的代码：

2.2.10通用Oracle，SQL server，MySQL连接数据库的帮助类

2.2.11通用Oracle，SQL server，MySQL连接数据库的属性文件

2.2.12进行判空封装的方法

三.Debug工具

3.1Debug工具是什么？

3.2如何使用Debug工具？(我是使用eclipse工具进行演示)

3.3使用Debug工具好处是什么？

四，总结：

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

如何实现通用分页（来看我这一篇就够了超级详细内含源码！！！）

一.页面显示分页效果

1.1分析页面展示所要展示的属性有哪些？

1.2分析页面有哪些每次发送请求有哪些公共的参数

二.具体实现前端通用分页？

2.1分析思路：

2.2具体实现的过程

2.2.1标签助手类

2.2.2创建标签库描述文件(tld)

2.2.3创建jsp页面

（这里我们要用到c标签的foreach循环，和我们自定义的通用分页标签）

2.2.4创建servlet页面

（这里我们servlet的@WebServlet名称用.action结尾，应为方便我们下一步操作）

2.2.5创建BaseDao类（用于通用分页）

2.2.6创建实例化的BookDao类（用于实现当前书籍数据分页）

2.2.7创建实体类（Book）

2.2.8创建分页工具类

以下的是实现解决中文乱码的代码：

2.2.10通用Oracle，SQL server，MySQL连接数据库的帮助类

2.2.11通用Oracle，SQL server，MySQL连接数据库的属性文件

2.2.12进行判空封装的方法

三.Debug工具

3.1Debug工具是什么？

3.2如何使用Debug工具？(我是使用eclipse工具进行演示)

3.3使用Debug工具好处是什么？

四，总结：

热门文章

最新文章

相关课程

相关电子书

相关实验场景