J2EE之通用分页知识（上）（详解）-阿里云开发者社区

J2EE之通用分页知识（上）

前言

在我们以往做项目的时候难免会遇到有些数据从数据中获取到显示数据过多，导致页面显示不下又或者是影响了美观，所以或使用到分页功能，但之前使用的分页功能灵活又或者代码繁多。所以今天带大家了解我分享的通用分页知识，此次分享的是通用分页知识（上篇）指的是后端。让我们根据思维导图一起来学习一下。

1. java原生连接数据库和通用连接数据库的区别

1.1 原生连接数据库

这里是连接oracle数据库

package com.YX.Page.utils;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
/**
 * 数据库帮助类
 * 
 * @author 君易--鑨
   *
    */
   public class DBHelper {
   // 不是所有的电脑 后面都是orcl 服务
   private static final String URL = "jdbc:oracle:thin:@localhost:1521:orcl";
   /**
    * 加载驱动
      */
      static {
      // OracleDriver
      try {
        // oracle.jdbc.driver.OracleDriver
        Class.forName("oracle.jdbc.OracleDriver");
      } catch (Exception e) {
        e.printStackTrace();
      }
      }
   /**
    * 方法：获取数据库连接
    * 
    * @return conn 连接对象
      */
      public static Connection getConn() {
      Connection conn = null;
      try {
        conn = DriverManager.getConnection(URL, "scott", "123");
      } catch (Exception e) {
        e.printStackTrace();
      }
      return conn;
      }
   /**
    * 关闭连接
    * 
    * @param conn
    * @param ps
    * @param rs
      */
      public static void myClose(Connection conn, PreparedStatement ps, ResultSet rs) {
      try {
        if (rs != null) {
          rs.close();
        }
        if (ps != null) {
          ps.close();
        }
        if (conn != null && !conn.isClosed()) {
          conn.close();
        }
      } catch (Exception e) {
        e.printStackTrace();
      }
      }
//测试是否连接成功
   public static void main(String[] args) {
    System.out.println(getConn());
   }
}

1.2 通用连接数据库

这是通用SQLserver、Oracle、Mysql数据库

package com.YX.Page.untils;
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;
/**
 * 数据库连接工具类
 * 提供了一组获得或关闭数据库对象的方法
 * @author 君易--鑨
 */
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);
    }
  }
/**
 * 关闭数据库资源
 * @param rs
 */
  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("数据库连接(关闭)成功");
  }
}

通用测试连接数据控制台输出的结果（以连接mysql为例）

1.3 原生和通用连接数据库的区别

原生连接数据库的代码的使用范围局限，比较笨重不够灵活。
通用连接数据库的代码使用范围广泛，相比较原生连接数据库更加灵活，效率更高，在获取不同数据库中的数据时只需要微微调整即可。

2.通过利用反射的知识简化代码，实现通用

2.1 原生获取数据库数据（查询案例）

package com.YX.Page.Dao;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import com.YX.Page.entity.Book;
import com.YX.Page.untils.DBAccess;
/**
 * 实体Dao方法类 用于从数据库中获取数据和编辑数据
 * 
 * @author 君易--鑨
 *
 */
public class BookDao {
  /**
   * 原生获取数据库中的数据
   * 
   * @return list
   * @throws Exception
   */
  public List<Book> CXSY() throws Exception {
    // 创建连接数据的对象
    Connection conn = null;
    PreparedStatement ps = null;
    ResultSet rs = null;
    // 实例化存储实体对象
    Book b = null;
    List<Book> list = new ArrayList<Book>();
    // 连接数据库
    conn = DBAccess.getConnection();
    // 编写sql数据库执行语句
    String mysql = "select * from t_mvc_book";
    // 执行sql数据库语句
    // 在方法那直接抛出最大的异常
    ps = conn.prepareStatement(mysql);
    // 结果集对象接受数据
    rs = ps.executeQuery();
    // 迭代器遍历数据结果集对象数据
    while (rs.next()) {
      // 将数据存储到实体对象中
      b = new Book(rs.getInt(1), rs.getString(2), rs.getFloat(3));
      // 将对象存储到集合对象中
      list.add(b);
    }
    // 返回集合对象
    return list;
  }
//  打开主程序入口测试dao方法
  public static void main(String[] args) throws Exception {
         BookDao b=new BookDao();
         List<Book> cxsy = b.CXSY();
         for (Book book : cxsy) {
        System.out.println(book);
      }
  }
}

控制台数据结果（由于该表数据过多所以截取了一部分）

2.2 通用获取数据库数据（查询案例）

2.2.1 以我自己为例在com.YX.Page.untils包下新疆一个Class文件（数据访问公共类）

如图所示

BaseDao数据库类代码

（这里编写的是带有模糊查询的查询方法）

package com.YX.Page.untils;
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;
/***
 * 数据库公共类
 * 
 * @author 君易--鑨
 *
 * @param <T>
 */
public class BaseDao<T> {
  /**
   * 带有模糊查询的查询所有
   * 
   * @param sql
   *            执行的sql语句
   * @param cls
   *            Book.class实体对象
   * @param pagebean
   *            分页工具类（实现模糊查询暂时用不到）
   * @return list
   * @throws Exception
   */
  public List<T> list(String sql, Class cls, PageBean pagebean) throws Exception {
    // 实例化存储容器集合对象
    List<T> list = new ArrayList<T>();
    // 连接数据库
    Connection conn = DBAccess.getConnection();
    // 执行sql语句
    PreparedStatement ps = conn.prepareStatement(sql);
    // 结果集对象接受数据
    ResultSet rs = ps.executeQuery();
    // 迭代器遍历结果集对象数据
    while (rs.next()) {
      // 通过类类实例化实体对象
      T t = (T) cls.newInstance();// ==>Book book=new Book()
      // 通过cls获取对应对象的所有属性
      Field[] fileds = cls.getDeclaredFields();
      for (Field f : fileds) {// 遍历
        // 获取私有化访问权限
        f.setAccessible(true);
        // rs.getObject(f.getName())==>rs.getInt("bid")
        // f.set(t, rs.getObject(f.getName()));==>b.setBid(rs.getInt("bid"));
        // 设置对象的属性值
        f.set(t, rs.getObject(f.getName()));
      }
      // 在集合对象容器中添加通过类类方式实例化的实体对象t
      list.add(t);
    }
    // 返回集合对象
    return list;
  }
}

2.2.2 在Dao方法类中编写完整的方法实现功能

（以我自己为例我编写的是带模糊查询的查询所有的方法）

创建一个Dao方法类（BookDao）继承数据库公共类（BaseDao）

package com.YX.Page.Dao;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import com.YX.Page.entity.Book;
import com.YX.Page.untils.BaseDao;
import com.YX.Page.untils.DBAccess;
import com.YX.Page.untils.PageBean;
import com.YX.Page.untils.StringUtils;
/**
 * 实体Dao方法类 用于从数据库中获取数据和编辑数据
 * 
 * @author 君易--鑨
 *BookDao操作的是数据表（t_mvc_book）
 *      代码重复部分
 *      Connection conn=DBAccess.getConnection();
    PreparedStatement ps=conn.prepareStatement(sql);
    ResultSet rs=ps.executeQuery();
 *
 *      流程重复部分
 *      1.创建数据库表对应的实体类对象
 *      2.将查询出来的结果集数据添加到实例化对象的属性中
 *      3.已经被填充的实体对象添加到集合中
 *          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);
    }
 */
public class BookDao extends BaseDao<Book>{
  /**
   * 通用查询
   * @param book 查询的条件对象
   * @param pagebean 分页工具类
   * @return
   * @throws Exception
   */
  public List<Book> list(Book book,PageBean pagebean) throws Exception {
    Connection conn=DBAccess.getConnection();
    String sql="select * from t_mvc_book where 1=1 ";
    String bname=book.getBname();
    if (StringUtils.isNotBlank(bname)) {
      sql+=" and bname like '%"+bname+"%'";
    }
    return super.list(sql, Book.class, pagebean);
  }
//  打开主程序入口测试dao方法
  public static void main(String[] args) throws Exception {
            //实例化Dao方法
         BookDao b=new BookDao();
         //实例化实体对象
         Book book=new Book();
             //设置查询内容
         book.setBname("圣墟");
             //实例化分页工具类
         PageBean pagebean=new PageBean();
         //调用查询方法
         List<Book> cxsy = b.list(book, pagebean);
         //遍历集合对象
             for (Book bo : cxsy) {
        System.out.println(bo);
      }
  }
}

类注释中说明的流程重复部分和代码重复部分是相对于原生访问数据库获取数据可以优化的地方。

控制台输出结果

3.junit

3.1 什么是junit？

JUnit是一个Java开发者使用的单元测试框架，能够自动化地进行单元测试，帮助开发者快速检验代码的正确性。

3.2 junit的重要性

3.2.1 好处：

JUnit提供了一些注解和断言方法，可以帮助开发者编写出简洁易懂、可维护的单元测试代码。通过JUnit，在开发过程中可以更快捷地发现和修复代码中的问题，从而提高代码的质量和稳定性。

3.2.2 作用：

提高代码质量：JUnit可以帮助开发者快速发现代码中的问题，尤其是在修改代码时可以保证修改不会破坏已有的功能。
自动化测试：JUnit可以自动运行测试用例，无需手动执行，可以大大节省测试时间。
可重复测试：JUnit可以确保每次测试都是相同的环境，避免测试结果因为不同环境或手动测试不一致。
代码可维护性：JUnit提供了一些约束和规范，可以帮助开发者编写更加简洁、规范的测试代码，从而提高代码可维护性。

3.3 Junit的使用

3.3.1 载入Junit到项目中

在eclipse中右击项目文件夹，然后点击Build Path,再点击Configure Build Path选项就会弹出一个窗口。（如下图所示）

后续操作如图所示

选择junit

最后配置junit（完成即可）

3.3.2 在项目中运用

package com.YX.Page.Dao;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
import com.YX.Page.entity.Book;
import com.YX.Page.untils.BaseDao;
import com.YX.Page.untils.DBAccess;
import com.YX.Page.untils.PageBean;
import com.YX.Page.untils.StringUtils;
/**
 * 实体Dao方法类 用于从数据库中获取数据和编辑数据
 * 
 * @author 君易--鑨
 *BookDao操作的是数据表（t_mvc_book）
 *      代码重复部分
 *      Connection conn=DBAccess.getConnection();
    PreparedStatement ps=conn.prepareStatement(sql);
    ResultSet rs=ps.executeQuery();
 *
 *      流程重复部分
 *      1.创建数据库表对应的实体类对象
 *      2.将查询出来的结果集数据添加到实例化对象的属性中
 *      3.已经被填充的实体对象添加到集合中
 *          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);
    }
 */
public class BookDao extends BaseDao<Book>{
  /**
   * 通用查询
   * @param book 查询的条件对象
   * @param pagebean 分页工具类
   * @return
   * @throws Exception
   */
  public List<Book> list(Book book,PageBean pagebean) throws Exception {
    Connection conn=DBAccess.getConnection();
    String sql="select * from t_mvc_book where 1=1 ";
    String bname=book.getBname();
    if (StringUtils.isNotBlank(bname)) {
      sql+=" and bname like '%"+bname+"%'";
    }
    return super.list(sql, Book.class, pagebean);
  }
//  运用Junit
  @Test
  public void text01() throws Exception {
    System.out.println("text01........................");
         BookDao b=new BookDao();
         Book book=new Book();
         book.setBname("圣墟");
         PageBean pagebean=new PageBean();
         List<Book> cxsy = b.list(book, pagebean);
         for (Book bo : cxsy) {
        System.out.println(bo);
      }
  }
  @Test
  public void text02() throws Exception {
    System.out.println("text02........................");
         BookDao b=new BookDao();
         Book book=new Book();
         book.setBname("圣墟");
         PageBean pagebean=new PageBean();
         List<Book> cxsy = b.list(book, pagebean);
         for (Book bo : cxsy) {
        System.out.println(bo);
      }
  }
}

如上述代码所示我右击选中text01()，再右击选择run as,选择Junit Text运行。控制台结果如下图所示

当然也可以同时选择多个（下面是我选择text01和text02的控制台输出的结果），如下图示

注意事项

个人不建议选择多个运行。

4. Dao方法中增加通用查询并融入分页元素

4.1 导入或编写工具类到项目中的.untils下

EncodingFiter类

package com.YX.Page.untils;
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.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
 * 中文乱码处理类
 * 用于处理数据显示中文乱码
 * @author 君易--鑨
 *
 */
public class EncodingFiter implements Filter {
  private String encoding = "UTF-8";// 默认字符集
  public EncodingFiter() {
    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();
    }
  }
}

PageBean类

package com.YX.Page.untils;
/**
 * 分页工具类
 * 用于实现分页显示的工具类
 *@author 君易--鑨
 */
public class PageBean {
  private int page = 1;// 页码
  private int rows = 10;// 页大小
  private int total = 0;// 总记录数
  private boolean pagination = true;// 是否分页
  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 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 + "]";
  }
}

StringUtils类

package com.YX.Page.untils;
/**
 * 工具类
 * 用于判断属性或者对象
 * @author 君易--鑨
 *
 */
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);
  }
}

4.2 在BaseDao中融入分页元素

BaseDao类

package com.YX.Page.untils;
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;
/***
 * 数据库公共类
 * 
 * @author 君易--鑨
 *
 * @param <T>
 */
public class BaseDao<T> {
  /**
   * 带有模糊查询的查询所有
   * 
   * @param sql
   *            执行的原生sql语句
   * @param cls
   *            Book.class实体对象
   * @param pagebean
   *            分页工具类（实现模糊查询暂时用不到）
   * @return list
   * @throws Exception
   */
  public List<T> list(String sql, Class cls, PageBean pagebean) throws Exception {
    // 实例化存储容器集合对象
    List<T> list = new ArrayList<T>();
    // 连接数据库
    Connection conn = null;
    // 执行sql语句
    PreparedStatement ps = null;
    // 结果集对象接受数据
    ResultSet rs = null;
//    sql=SELECT * FROM t_mvc_book where bname like '%圣墟%'
//    countSQL=SELECT COUNT(1) as n FROM (SELECT * FROM t_mvc_book where bname like '%圣墟%') t
//    pageSQL=SELECT * FROM t_mvc_book where bname like '%圣墟%' LIMIT 0,10
    if (pagebean !=null && pagebean.isPagination()) {//判断分页工具不为null,并且是判断使用分页功能
//      编写分页查询总数的SQL语句
      String countSQL=getCountSQL(sql);//通过getCountSQL()获取编写分页查询总数的SQL语句
//      连接数据库
      conn=DBAccess.getConnection();
//      执行数据库查询语句
      ps=conn.prepareStatement(countSQL);
//      结果集对象接收
      rs=ps.executeQuery();
//      迭代器判断是否有下一个数值
      if (rs.next()) {
//        将获取到的总数结果赋值给pagebean对象中的total属性（总记录数）
        pagebean.setTotal(rs.getObject("n").toString());
      }
//      编写分页查询的SQL语句   从...到...
        String pageSQL=getCountSQL(pagebean,sql);//通过getCountSQL()获取编写分页查询的SQL语句
//      连接数据库
        conn=DBAccess.getConnection();
//      执行数据库查询语句
      ps=conn.prepareStatement(pageSQL);
//      结果集对象接收
      rs=ps.executeQuery();
    }else {
//      连接数据库
      conn=DBAccess.getConnection();
//      执行数据库查询语句
      ps=conn.prepareStatement(sql);
//      结果集对象接收
      rs=ps.executeQuery();
    }
    // 迭代器遍历结果集对象数据
    while (rs.next()) {
      // 通过类类实例化实体对象
      T t = (T) cls.newInstance();// ==>Book book=new Book()
      // 通过cls获取对应对象的所有属性
      Field[] fileds = cls.getDeclaredFields();
      for (Field f : fileds) {// 遍历
        // 获取私有化访问权限
        f.setAccessible(true);
        // rs.getObject(f.getName())==>rs.getInt("bid")
        // f.set(t, rs.getObject(f.getName()));==>b.setBid(rs.getInt("bid"));
        // 设置对象的属性值
        f.set(t, rs.getObject(f.getName()));
      }
      // 在集合对象容器中添加通过类类方式实例化的实体对象t
      list.add(t);
    }
    // 返回集合对象
    return list;
  }
  /**
   * 拼接出最终展示出数据的SQL
   * @param pagebean   
   * @param sql   原生sql
   * @return
   */
  private String getCountSQL(PageBean pagebean, String sql) {
    return sql+" limit "+pagebean.getStartIndex()+","+pagebean.getRows();
  }
  /**
   * 拼接出查询符合条件的总记录数SQL
   * @param sql
   * @return
   */
  private String getCountSQL(String sql) {
    return "SELECT COUNT(1) as n FROM ("+sql+") t";
  }
}

BookDao类编写和测试

package com.YX.Page.Dao;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
import com.YX.Page.entity.Book;
import com.YX.Page.untils.BaseDao;
import com.YX.Page.untils.DBAccess;
import com.YX.Page.untils.PageBean;
import com.YX.Page.untils.StringUtils;
/**
 * 实体Dao方法类 用于从数据库中获取数据和编辑数据
 * 
 * @author 君易--鑨 BookDao操作的是数据表（t_mvc_book） 代码重复部分 Connection
 *         conn=DBAccess.getConnection(); PreparedStatement
 *         ps=conn.prepareStatement(sql); ResultSet rs=ps.executeQuery();
 *
 *         流程重复部分 1.创建数据库表对应的实体类对象 2.将查询出来的结果集数据添加到实例化对象的属性中 3.已经被填充的实体对象添加到集合中
 *         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); }
 */
public class BookDao extends BaseDao<Book> {
  /**
   * 通用查询
   * 
   * @param book
   *            查询的条件对象
   * @param pagebean
   *            分页工具类
   * @return
   * @throws Exception
   */
  public List<Book> list(Book book, PageBean pagebean) throws Exception {
    // 连接数据库
    Connection conn = DBAccess.getConnection();
    // 编写原生SQL语句
    String sql = "select * from t_mvc_book where 1 ";
    // 获取查询的内容
    String bname = book.getBname();
    // 判断查询内容是否为空
    if (StringUtils.isNotBlank(bname)) {
      sql += " and bname like '%" + bname + "%'";
    }
    // 返回数据
    return super.list(sql, Book.class, pagebean);
  }
//  测试方法结果
  public static void main(String[] args) throws Exception {
    // 实例化dao方法
    BookDao b = new BookDao();
    // 实例化对象
    Book book = new Book();
    // 设置查询内容到实例化的实体对象中
    book.setBname("圣墟");
    // 实例化分页工具类
    PageBean pagebean = new PageBean();
    // 调用方法，将包含查询内容的实体对象和分页工具类传入方法中
    List<Book> cxsy = b.list(book, pagebean);
    // 遍历数据
    for (Book bo : cxsy) {
      System.out.println(bo);
    }
//    打印总数据数
    System.out.println("总数据数："+pagebean.getTotal());
  }
}

控制台输出结果

当然我们可以自定义显示数据的起始页数和显示页数（案例如下）

package com.YX.Page.Dao;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
import com.YX.Page.entity.Book;
import com.YX.Page.untils.BaseDao;
import com.YX.Page.untils.DBAccess;
import com.YX.Page.untils.PageBean;
import com.YX.Page.untils.StringUtils;
/**
 * 实体Dao方法类 用于从数据库中获取数据和编辑数据
 * 
 * @author 君易--鑨 BookDao操作的是数据表（t_mvc_book） 代码重复部分 Connection
 *         conn=DBAccess.getConnection(); PreparedStatement
 *         ps=conn.prepareStatement(sql); ResultSet rs=ps.executeQuery();
 *
 *         流程重复部分 1.创建数据库表对应的实体类对象 2.将查询出来的结果集数据添加到实例化对象的属性中 3.已经被填充的实体对象添加到集合中
 *         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); }
 */
public class BookDao extends BaseDao<Book> {
  /**
   * 通用查询
   * 
   * @param book
   *            查询的条件对象
   * @param pagebean
   *            分页工具类
   * @return
   * @throws Exception
   */
  public List<Book> list(Book book, PageBean pagebean) throws Exception {
    // 连接数据库
    Connection conn = DBAccess.getConnection();
    // 编写原生SQL语句
    String sql = "select * from t_mvc_book where 1 ";
    // 获取查询的内容
    String bname = book.getBname();
    // 判断查询内容是否为空
    if (StringUtils.isNotBlank(bname)) {
      sql += " and bname like '%" + bname + "%'";
    }
    // 返回数据
    return super.list(sql, Book.class, pagebean);
  }
//  测试方法结果
  public static void main(String[] args) throws Exception {
    // 实例化dao方法
    BookDao b = new BookDao();
    // 实例化对象
    Book book = new Book();
    // 设置查询内容到实例化的实体对象中
    book.setBname("圣墟");
    // 实例化分页工具类
    PageBean pagebean = new PageBean();
    pagebean.setPage(2);//设置第二页
    pagebean.setRows(20);//设置每页显示20条
    // 调用方法，将包含查询内容的实体对象和分页工具类传入方法中
    List<Book> cxsy = b.list(book, pagebean);
    // 遍历数据
    for (Book bo : cxsy) {
      System.out.println(bo);
    }
//    打印总数据数
    System.out.println("总数据数："+pagebean.getTotal());
  }
}

控制台输出结果（如下图）

5. 总结

易于导航：通用分页可以让用户轻松地在网站或应用程序中进行导航。通过点击页面底部的数字或箭头，用户可以快速地跳转到其他页面。
提高用户体验：通用分页可以提高用户在网站或应用程序中的使用体验。它可以让用户更方便地访问页面，同时让用户更容易地理解页面的组织结构和内容。
促进页面流量：通用分页可以促进网站或应用程序的流量。通过分页，用户可以更轻松地访问更多的内容，从而增加他们在网站或应用程序中停留的时间。
分段式管理：通过通用分页，可以把大块的内容分界，把不同的模块分成几个页面，这样做可以减少单个页面内容过多，让用户更容易消化，提高页面访问的效果。

总之，通用分页一定程度上减少了程序员使用代码的代码量，提高了项目的开发效率，使其代码更加灵活，便于数据显示。

后续

下期博客分享J2EE之通用分页知识下,下期博客针对的是前端。

J2EE之通用分页知识（上）（详解）