• 基于MySql的通用分页

    1、通用分页概述（基于MySql数据库的通用分页）

    通用分页就是把我们经常使用的分页方法进行封装,然后用泛型传递对象,利用反射获取对象的所有属性并且赋值。

    2、为何要使用通用分页？

    一般在实际项目的开发过程中我们会有很多数据的展示，并且数据量大，展示的数据种类繁多，这意味着我们要写很多重复的代码，我们可将重复相同的代码提取出来进行封装，后期进行调用即可。

    3、通用分页核心思路：将上一次查询请求再发一次，只不过页码变了

    4、环境配置（如何实现分页）

    1、明确我们的需求是什么？
    2、在实际项目开发中分页需要哪些参数？

    页码(每页所展示的数据)、总记录数、是否分页、点击下一页或者上一页所需地址

    1.    PageBean
    2.    分页三要素 
    3.    page        页码        视图层传递过来
    4.    rows        页大小      视图层传递过来
    5.    total       总记录数    后台查出来
    6.  
    7.    pagination  是否分页    视图层传递过来
    8.  
    9.    getStartIndex()        基于MySql数据库分页，获取分页开始标记

    4.1.以书籍为例，创建一个书籍表，同时再创建一个书籍项目

    1. create table t_book(
    2. 	book_id int not null primary key auto_increment comment '书本编号',
    3. 	book_name varchar(30) not null comment '书本名称',
    4. 	book_name_pinyin varchar(30) null comment '书本拼音',
    5. 	book_price float default 0 comment '书本价格',
    6. 	book_type varchar(10) not null comment '书本类型'
    7. )comment '书本信息表';
    8.  
    9.  
    10. #分页（limit）
    11. #limit 参数1，参数2				(page-1)*rows
    12. #参数1：从第几条数据开始	
    13. #参数2：每次返回多少条数据	rows
    14. #第一页：从0开始，返回2条
    15. #第二页：从2开始，返回2条

     4.2.项目中的相关配置以及导入必要的依赖

    依赖：

    mysql-connector-java-5.1.44-bin.jar        MySQL的驱动类

    pinyin4j-2.5.0.jar        拼音的jar，作用是可以快速的将中文转变成英文，只提取拼音首字母

    standard-1.1.2.jar        jstl标签

    jstl-1.2.jar

    工具类：

    CommonUtils.java        反射封装ResultSet结果集

    DBHelper.java        连接数据库

    config.properties        资源文件 
    EncodingFiter.java        中文乱码过滤器
    StringUtils.java        判断字符串是否存在（为空）
    PageTag.java        自定义标签的助手类
    PageBean.java        分页工具类

    PinYinUtil.java         拼音工具类

    4.3.先写一个分页工具类，用于实现分页效果。

    1. package com.zking.pagination.util;
    2.  
    3. import java.io.Serializable;
    4. import java.util.Map;
    5.  
    6. import javax.servlet.http.HttpServletRequest;
    7.  
    8. /**
    9.  * 	分页工具类
    10.  * @author gss
    11.  *
    12.  */
    13. public class PageBean implements Serializable{
    14. 	//当前页码，默认1
    15. 	private int page=1;
    16. 	//页面显示条数，默认10
    17. 	private int rows=10;
    18. 	//总记录数，默认0
    19. 	private int total=0;
    20. 	//是否分页标记，默认分页
    21. 	private boolean pageination=true;
    22. 	
    23. 	//http://localhost:8080/pagination/BookServlet.action
    24. 	///pagination/BookServlet.action
    25. 	//获取上一次请求路径
    26. 	private String url;
    27. 	
    28. 	//获取上一次请求的请求参数集合
    29. 	// Map params=req.getParameterMap();
    30. 	//	
    31. 	private Map<String,String[]> params;
    32. 	
    33. 	public PageBean() {
    34. 		super();
    35. 	}
    36. 	
    37. 	/**
    38. 	 * 获取起始记录的下标(基于Mysql分页，计算limit分页开始位置)
    39. 	 * @return
    40. 	 */
    41. 	public int getStartIndex() {
    42. 		return (this.page-1)*this.rows;
    43. 	}
    44. 	
    45. 	public void setRequest(HttpServletRequest req) {
    46. 		//获取前端提交的请求参数（分页三要素：页码、页大小、总记录数 ）
    47. 		String page = req.getParameter("page");
    48. 		String rows = req.getParameter("rows");
    49. 		String pagination = req.getParameter("pagination");
    50. 		
    51. 		//赋值
    52. 		this.setPage(page);
    53. 		this.setRows(rows);
    54. 		this.setPageination(pagination);
    55. 		
    56. 		//获取上一次请求的请求路径
    57. 		//http://localhost:8080/pagination/BookServlet.action
    58. 		//	req.getRequestURI()==等同于/pagination/BookServlet.action
    59. 		//	req.getContextPath()==项目名/pagination
    60. 		//	req.getServletPath()==请求路径/BookServlet.action
    61. 		//当前路径
    62. 		this.url = req.getRequestURI();
    63. 		//获取上一次请求的请求参数集合
    64. 		//Map-->params.put("bookname",new String[]{"",""})
    65. 		this.params = req.getParameterMap();
    66. 	}
    67. 	/**
    68. 	 * 	获取最大页码
    69. 	 * @return
    70. 	 */
    71. 	public int getMaxPager() {
    72. 		int p = this.total/this.rows;
    73. 		//判断是否有余数，如果有余数，则最大页码+1
    74. 		if(this.total%this.rows!=0)
    75. 			p++;
    76. 		return p;
    77. 	}
    78. 	/**
    79. 	 * 	获取上一页
    80. 	 * @return
    81. 	 */
    82. 	public int getProviousPager() {
    83. 		int p = this.page-1;
    84. 		if(p<1)
    85. 			p=1;
    86. 		return p;
    87. 	}
    88. 	/**
    89. 	 * 	获取下一页
    90. 	 * @return
    91. 	 */
    92. 	public int getNextPager() {
    93. 		int p = this.page+1;
    94. 		if(this.page>=this.getMaxPager())
    95. 			p=this.getMaxPager();
    96. 		return p;
    97. 	}
    98. 	
    99. 	public void setPage(String page) {
    100. 		if(null!=page)
    101. 			this.page = Integer.parseInt(page);
    102. 	}
    103. 	public void setRows(String rows) {
    104. 		if(null!=rows)
    105. 			this.rows = Integer.parseInt(rows);
    106. 	}
    107. 	public void setPageination(String pageination) {
    108. 		if(null!=pageination)
    109. 		this.pageination = Boolean.parseBoolean(pageination);
    110. 	}
    111. 	
    112. 	
    113. 	public int getPage() {
    114. 		return page;
    115. 	}
    116.  
    117. 	public void setPage(int page) {
    118. 		this.page = page;
    119. 	}
    120.  
    121. 	public int getRows() {
    122. 		return rows;
    123. 	}
    124.  
    125. 	public void setRows(int rows) {
    126. 		this.rows = rows;
    127. 	}
    128.  
    129. 	public int getTotal() {
    130. 		return total;
    131. 	}
    132.  
    133. 	public void setTotal(int total) {
    134. 		this.total = total;
    135. 	}
    136.  
    137. 	public boolean isPageination() {
    138. 		return pageination;
    139. 	}
    140.  
    141. 	public void setPageination(boolean pageination) {
    142. 		this.pageination = pageination;
    143. 	}
    144.  
    145. 	public String getUrl() {
    146. 		return url;
    147. 	}
    148.  
    149. 	public void setUrl(String url) {
    150. 		this.url = url;
    151. 	}
    152.  
    153. 	public Map<String, String[]> getParams() {
    154. 		return params;
    155. 	}
    156.  
    157. 	public void setParams(Map<String, String[]> params) {
    158. 		this.params = params;
    159. 	}
    160.  
    161. 	@Override
    162. 	public String toString() {
    163. 		return "PageBean [page=" + page + ", rows=" + rows + ", total=" + total + ", pageination=" + pageination
    164. 				+ ", url=" + url + ", params=" + params + "]";
    165. 	}
    166.  
    167. }

    BaseDao.java（是一个通用的父类方法，来帮助我们实现通用的分类）

    1. package com.zking.pagination.dao;
    2.  
    3. import java.sql.Connection;
    4. import java.sql.PreparedStatement;
    5. import java.sql.ResultSet;
    6. import java.sql.SQLException;
    7. import java.util.List;
    8. import com.zking.pagination.util.DBHelper;
    9. import com.zking.pagination.util.PageBean;
    10.  
    11. public class BaseDao {
    12. 	public static interface CallBack{
    13. 		//只用于遍历ResultSet结果集
    14. 		public List foreachRs(ResultSet rs) throws SQLException;
    15. 	}
    16. 	
    17. 	/**
    18. 	 * 	通用分页方法（既支持分页，也支持不分页）
    19. 	 * @param sql	普通的sql
    20. 	 * @param pageBean	pageBean 分页对象
    21. 	 * @return	查询结果集
    22. 	 */
    23. 	public List excuteQuery(String sql,PageBean pageBean,CallBack callBack){
    24. 		//声明对象
    25. 		Connection conn = null;
    26. 		PreparedStatement stmt = null;
    27. 		ResultSet rs = null;
    28. 		try {
    29. 			//获取连接对象
    30. 			conn = DBHelper.getConnection();
    31. 			//根据pageBean分页对象判断是否分页
    32. 			if(null!=pageBean&&pageBean.isPageination()) {
    33. 				//1.分页
    34. 				//1)根据满足条件查询总记录数
    35. 				String countSQL = this.getCountSQL(sql);
    36. 				//创建执行对象
    37. 				stmt = conn.prepareStatement(countSQL);
    38. 				//执行sql语句并返回总记录数
    39. 				rs = stmt.executeQuery();
    40. 				//获取总记录数
    41. 				if(rs.next()) {
    42. 					pageBean.setTotal(rs.getInt(1));
    43. 				}
    44. 				//2)根据满足条件查询分页结果集
    45. 				sql = this.getPagerSQL(sql, pageBean);//覆盖
    46. 			}
    47. 			//创建执行对象
    48. 			stmt = conn.prepareStatement(sql);
    49. 			//查询结果集
    50. 			rs = stmt.executeQuery();
    51. 			
    52. 			return callBack.foreachRs(rs);
    53. 		} catch (Exception e) {
    54. 			e.printStackTrace();
    55. 		}finally {
    56. 			DBHelper.close(conn, stmt, rs);
    57. 		}
    58. 		return null;
    59. 	}
    60. 		
    61. 		/**
    62. 		 * 将普通的sql语句转换成查询总记录条数的sql语句
    63. 		 * 	select * from t_book
    64. 		 * 	select * from t_book where ...
    65. 		 * 	select book_id,book_name from t_book
    66. 		 * 	select book_id,book_name from t_book where ...
    67. 		 * 	------------>
    68. 		 * 	select count(0) from t_book where ...
    69. 		 * @param sql	普通的sql
    70. 		 * @return 查询总记录数的sql
    71. 		 */
    72. 		private String getCountSQL(String sql) {
    73. 			return "select count(0) from ("+sql+") temp";
    74. 		}
    75. 		
    76. 		/**
    77. 		 * 将普通的sql语句转换成查询分页结果集的sql语句
    78. 		 * 	select * from t_book
    79. 		 * 	select * from t_book where ...
    80. 		 * 	select book_id,book_name from t_book
    81. 		 * 	select book_id,book_name from t_book where ...
    82. 		 * 	------------>
    83. 		 * 	select * from t_book limit
    84. 		 * 	select * from t_book where 1=1 limit 
    85. 		 * @param sql	普通的sql
    86. 		 * @param pageBean	分页对象（包含当前页码和每页条数，用于计算分页的关键数据）
    87. 		 * @return	查询分页结果集的sql
    88. 		 */
    89. 		private String getPagerSQL(String sql,PageBean pageBean) {
    90. 			return sql+" limit "+pageBean.getStartIndex()+","+pageBean.getRows();
    91. 		}
    92. 		
    93. }

    BookDao.java（dao类继承了BaseDao 父类，代码简洁，通用的方法都在父类中）

    1. package com.zking.pagination.dao;
    2.  
    3. import java.sql.Connection;
    4. import java.sql.PreparedStatement;
    5. import java.sql.ResultSet;
    6. import java.sql.SQLException;
    7. import java.util.ArrayList;
    8. import java.util.List;
    9. import javax.management.RuntimeErrorException;
    10. import com.zking.pagination.entity.Book;
    11. import com.zking.pagination.util.DBHelper;
    12. import com.zking.pagination.util.PageBean;
    13. import com.zking.pagination.util.StringUtils;
    14.  
    15. public class BookDao extends BaseDao{
    16. 	//1、书本新增
    17. 	public void addBook(Book book) {
    18. 		//声明对象
    19. 		Connection conn = null;
    20. 		PreparedStatement stmt = null;
    21. 		try {
    22. 			//获取连接对象
    23. 			conn= DBHelper.getConnection();
    24. 			//定义sql语句
    25. 			String sql = "insert into t_book(book_name,book_name_pinyin,book_price,book_type) values(?,?,?,?)";
    26. 			//创建执行对象
    27. 			stmt = conn.prepareStatement(sql);
    28. 			//参数赋值
    29. 			stmt.setString(1, book.getBook_name());
    30. 			stmt.setString(2, book.getBook_name_pinyin());
    31. 			stmt.setFloat(3, book.getBook_price());
    32. 			stmt.setString(4, book.getBook_type());
    33. 			//执行sql语句并返回影响行数
    34. 			int i = stmt.executeUpdate();
    35. 			if(i<1) {
    36. 				throw new RuntimeException("影响行数为0，添加失败");
    37. 			}
    38. 		} catch (Exception e) {
    39. 			e.printStackTrace();
    40. 		}finally {
    41. 			DBHelper.close(conn, stmt, null);
    42. 		}
    43. 	}
    44. 	
    45. 	/**
    46. 	 * 2、书本分页查询 	query/find/select/get
    47. 	 * @param book 要查询的对象
    48. 	 * @return	返回结果集
    49. 	 */
    50. 	public List queryBookPager(Book book,PageBean pageBean){
    51. 		//定义sql语句
    52. 		String sql = "select book_id,book_name,book_name_pinyin,book_price,book_type from t_book where 1=1";
    53. 		//拼接查询条件，按照书本名称模糊查询
    54. 		if(StringUtils.isNotBlank(book.getBook_name()))
    55. 			sql+=" and book_name like '%"+book.getBook_name()+"%'";
    56. 		//按照书本编号降序排序
    57. 		sql+=" order by book_id desc";
    58. 		System.out.println(sql);
    59. 		
    60. 		 return super.excuteQuery(sql, pageBean, new CallBack() {
    61. 			
    62. 			@Override
    63. 			public List foreachRs(ResultSet rs) throws SQLException {
    64. 				List blist = new ArrayList<>();
    65. 				//定义Book对象
    66. 				Book b = null;
    67. 				//循环遍历结果集
    68. 				while(rs.next()) {
    69. 					//创建Book对象
    70. 					b = new Book();
    71. 					b.setBook_id(rs.getInt("book_id"));
    72. 					b.setBook_name(rs.getString("book_name"));
    73. 					b.setBook_name_pinyin(rs.getString("book_name_pinyin"));
    74. 					b.setBook_price(rs.getFloat("book_price"));
    75. 					b.setBook_type(rs.getString("book_type"));
    76. 					//将对象添加到集合中
    77. 					blist.add(b);
    78. 				}
    79. 				return blist;
    80. 			}
    81. 		});
    82. 		
    83. 		//以下为查询原生态代码
    84. 	/*	List blist = new ArrayList<>();
    85. 		Connection conn = null;
    86. 		PreparedStatement stmt = null;
    87. 		ResultSet rs = null;
    88. 		try {
    89. 			//获取连接对象
    90. 			conn= DBHelper.getConnection();
    91. 			//定义sql语句
    92. 			String sql = "select book_id,book_name,book_name_pinyin,book_price,book_type from t_book where 1=1";
    93. 			//拼接查询条件，按照书本名称模糊查询
    94. 			if(StringUtils.isNotBlank(book.getBook_name()))
    95. 				sql+=" and book_name like '%"+book.getBook_name()+"%'";
    96. 			//按照书本编号降序排序
    97. 			sql+=" order by book_id desc";
    98. 			System.out.println(sql);
    99. 			//创建执行对象
    100. 			stmt = conn.prepareStatement(sql);
    101. 			//执行sql语句并返回查询结果集
    102. 			rs = stmt.executeQuery();
    103. 			//定义Book对象
    104. 			Book b = null;
    105. 			//循环遍历结果集
    106. 			while(rs.next()) {
    107. 				//创建Book对象
    108. 				b = new Book();
    109. 				b.setBook_id(rs.getInt("book_id"));
    110. 				b.setBook_name(rs.getString("book_name"));
    111. 				b.setBook_name_pinyin(rs.getString("book_name_pinyin"));
    112. 				b.setBook_price(rs.getFloat("book_price"));
    113. 				b.setBook_type(rs.getString("book_type"));
    114. 				//将对象添加到集合中
    115. 				blist.add(b);
    116. 			}
    117. 		} catch (Exception e) {
    118. 			e.printStackTrace();
    119. 		}finally {
    120. 			DBHelper.close(conn, stmt, rs);
    121. 		}
    122. 		return blist;*/
    123. 	}
    124. }

     BookDaoTest.java        使用Junit测试

    1. package com.zking.pagination.dao;
    2.  
    3. import static org.junit.Assert.*;
    4. import java.util.List;
    5. import org.junit.After;
    6. import org.junit.Before;
    7. import org.junit.Test;
    8. import com.zking.pagination.entity.Book;
    9. import com.zking.pagination.util.PageBean;
    10. import com.zking.pagination.util.PinYinUtil;
    11.  
    12. public class BookDaoTest {
    13. 	Book book = null;
    14. 	BookDao bd = new BookDao();
    15.  
    16. 	@Before
    17. 	public void setUp() throws Exception {
    18. 		//初始化一次
    19. 		book = new Book();
    20. 		//System.out.println("setUp");
    21. 	}
    22.  
    23. 	@After
    24. 	public void tearDown() throws Exception {
    25. 		//System.out.println("tearDown");
    26. 	}
    27.  
    28. 	@Test
    29. 	public void testAddBook() {
    30. 		for (int i = 0; i < 64; i++) {
    31. 			book = new Book();
    32. 			book.setBook_name("红楼梦第"+(i+1)+"章");
    33. 			book.setBook_name_pinyin(PinYinUtil.toPinyin("红楼梦第"+(i+1)+"章").toLowerCase());
    34. 			book.setBook_price(128f);
    35. 			book.setBook_type("文学");
    36. 			//调用dao类添加方法
    37. 			bd.addBook(book);
    38. 		}
    39. 		//System.out.println("testAddBook");
    40. 	}
    41.  
    42. 	@Test
    43. 	public void testQueryBookPager() {
    44. 		//模糊查询
    45. 		book.setBook_name("2");
    46. 		PageBean pageBean = new PageBean();
    47. 		pageBean.setPage(2);//第二页
    48. 		pageBean.setRows(8);//每页条数
    49. 		//pageBean.setPageination(false);//不分页
    50. 		//调用dao类查询方法
    51. 		List books = bd.queryBookPager(book,pageBean);
    52. 		System.out.println("总记录数:"+pageBean.getTotal());
    53. 		books.forEach(System.out::println);
    54. 	}
    55. }

    BookServlet.java

    1. package com.zking.pagination.action;
    2.  
    3. import java.io.IOException;
    4. import java.util.List;
    5. import javax.servlet.ServletException;
    6. import javax.servlet.http.HttpServlet;
    7. import javax.servlet.http.HttpServletRequest;
    8. import javax.servlet.http.HttpServletResponse;
    9. import com.zking.pagination.dao.BookDao;
    10. import com.zking.pagination.entity.Book;
    11. import com.zking.pagination.util.PageBean;
    12.  
    13. public class BookServlet extends HttpServlet {
    14.  
    15. 	@Override
    16. 	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    17. 		this.doPost(req, resp);
    18. 	}
    19.  
    20. 	@Override
    21. 	protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    22. 		//获取请求查询参数
    23. 		String bookname = req.getParameter("bookname");
    24. 		//实例化BookDao
    25. 		BookDao bd = new BookDao();
    26. 		//实例化Book
    27. 		Book book = new Book();
    28. 		book.setBook_name(bookname);
    29. 		//创建PageBean
    30. 		PageBean pageBean = new PageBean();
    31. 		//必须在查询之前完成请求参数赋值
    32. 		pageBean.setRequest(req);
    33. 		//实现书本查询
    34. 		List books = bd.queryBookPager(book,pageBean);
    35. 		//将查询的结果books保存到request作用域中
    36. 		req.setAttribute("books", books);
    37. 		//将pageBean对象存入到request作用域中
    38. 		req.setAttribute("pageBean", pageBean);
    39. 		//转发到指定页面并显示查询结果
    40. 		req.getRequestDispatcher("/bookList.jsp").forward(req, resp);;
    41. 	}
    42.  
    43. }

          配置web.xml

    2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
    3.   <display-name>paginationdisplay-name>
    4.   
    5.   
    6.   <filter>
    7.   	<filter-name>encodingFilterfilter-name>
    8.   	<filter-class>com.zking.pagination.util.EncodingFilterfilter-class>
    9.   filter>
    10.   <filter-mapping>
    11.   	<filter-name>encodingFilterfilter-name>
    12.   	<url-pattern>/*url-pattern>
    13.   filter-mapping>
    14.   
    15.   
    16.   <servlet>
    17.   	<servlet-name>BookServletservlet-name>
    18.   	<servlet-class>com.zking.pagination.action.BookServletservlet-class>
    19.   servlet>
    20.   <servlet-mapping>
    21.   	<servlet-name>BookServletservlet-name>
    22.   	<url-pattern>/BookServlet.actionurl-pattern>
    23.   servlet-mapping>
    24.  
    25. web-app>

    z标签：是我们的分页标签它还有一个主要的类-----PaginationTag助手类，是整个分页的灵魂所在。 

    1. package com.zking.pagination.tag;
    2.  
    3. import java.util.Map;
    4. import java.util.Map.Entry;
    5. import java.util.Set;
    6. import javax.servlet.jsp.JspException;
    7. import javax.servlet.jsp.JspWriter;
    8. import javax.servlet.jsp.tagext.BodyTagSupport;
    9. import com.zking.pagination.util.PageBean;
    10.  
    11. public class PaginationTag extends BodyTagSupport {
    12.  
    13. 	private PageBean pageBean;
    14. 	
    15. 	@Override
    16. 	public int doEndTag() throws JspException {
    17. 		return EVAL_PAGE;
    18. 	}
    19.  
    20. 	@Override
    21. 	public int doStartTag() throws JspException {
    22. 		JspWriter out = pageContext.getOut();
    23. 		try {
    24. 			out.write(toHtml());
    25. 		} catch (Exception e) {
    26. 			e.printStackTrace();
    27. 		}
    28. 		return SKIP_BODY;
    29. 	}
    30. 	
    31. 	private String toHtml() {
    32. 		//判断是否分页
    33. 		if(null==pageBean||!pageBean.isPageination())
    34. 			return "";
    35. 		else {
    36. 			StringBuilder sb=new StringBuilder();
    37. 			//TODO
    38. 			sb.append("
      ");
    39. 			
    40. 			//拼接Form表单
    41. 			sb.append("
      +pageBean.getUrl()+"\" method=\"post\">");
    42. 			
    43. 			//设置page隐藏域
    44. 			sb.append("");
    45. 			
    46. 			//拼接请求参数集合
    47. 			Map map = pageBean.getParams();
    48. 			//获取请求参数集合键值对
    49. 			Set> entrySet = map.entrySet();
    50. 			//遍历请求参数键值对
    51. 			for (Entry entry : entrySet) {
    52. 				//获取请求参数名，也就是来自于表单中的name属性名称
    53. 				String name=entry.getKey();
    54. 				//如果参数为page，则continue跳过
    55. 				if(name.equals("page"))
    56. 					continue;
    57. 				//获取请求参数对应的值，String[]
    58. 				String[] values=entry.getValue();
    59. 				//遍历value值
    60. 				for (String value : values) {
    61. 					//拼接请求参数
    62. 					sb.append("");
    63. 				}
    64. 			}
    65. 			
    66. 			sb.append("");
    67. 			
    68. 			//拼接共几页/第几页
    69. 			sb.append("[第"+pageBean.getPage()+"页/共"+pageBean.getMaxPager()+"页]");
    70. 			
    71. 			//拼接首页、上一页、下一页、末页
    72. 			if(pageBean.getPage()==1)
    73. 				sb.append("首页 上一页 ");
    74. 			else {
    75. 				sb.append("首页 ");
    76. 				sb.append("+pageBean.getProviousPager()+")\">上一页 ");
    77. 			}
    78. 			if(pageBean.getPage()==pageBean.getMaxPager())
    79. 				sb.append("下一页 末页 ");
    80. 			else {
    81. 				sb.append("+pageBean.getNextPager()+")\">下一页 ");
    82. 				sb.append("+pageBean.getMaxPager()+")\">末页 ");
    83. 			}
    84. 			
    85. 			//拼接跳转页码
    86. 			sb.append("");
    87. 			sb.append("");
    88. 			
    89. 			//拼接javascript跳转方法
    90. 			sb.append("");
    91. 			
    92. 			sb.append("
      ");
  • return sb.toString();
  • }
  • }
  • public PageBean getPageBean() {
  • return pageBean;
  • }
  • public void setPageBean(PageBean pageBean) {
  • this.pageBean = pageBean;
  • }
  • }

    • 启动Tomcat 

    bookList.jsp

    1. <%@ page language="java" contentType="text/html; charset=UTF-8"
    2.     pageEncoding="UTF-8"%>
    3. <%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
    4. <%@taglib uri="/zking" prefix="z" %>
    5. html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    6. <html>
    7. <head>
    8. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    9. <title>Insert title heretitle>
    11. head>
    12. <body>
    13. <form action="BookServlet.action" method="post" align="center">
    14. 	<label>书本名称：label><input type="text" name="bookname"/>
    15. 	<input type="submit" value="查询"/>
    16. form>
    17.  
    18. <table width="100%" border="1" cellpadding="0" cellspacing="0">
    19. 	<tr>
    20. 		<th>书本编号th>
    21. 		<th>书本名称th>
    22. 		<th>书本拼音th>
    23. 		<th>书本价格th>
    24. 		<th>书本类型th>
    25. 	tr>
    26. 	<c:forEach items="${books }" var="b">
    27. 		<tr>
    28. 			<th>${b.book_id }th>
    29. 			<th>${b.book_name }th>
    30. 			<th>${b.book_name_pinyin }th>
    31. 			<th>${b.book_price }th>
    32. 			<th>${b.book_type }th>
    33. 		tr>
    34. 	c:forEach>
    35. table>
    36. <z:pagination pageBean="${pageBean }"/>
    37. <%-- <div style="float: right;">
    38. 	<form id="ff" action="${pageBean.getUrl()}" method="post">
    39. 		<input type="hidden" name="page"/>
    40. 		
    41. 		Map maps = ${pageBean.getParams() }
    42. 		
    43. 		<input type="hidden" name="bookname" value="1"/>
    44. 	form>
    45. 	[第${pageBean.getPage()}页/共${pageBean.getMaxPager()}页]
    46. 	<a href="javascript:gotoPage(1);">首页a>
    47. 	<a href="javascript:gotoPage(${pageBean.getProviousPager()});">上一页a>
    48. 	<a href="javascript:gotoPage(${pageBean.getNextPager()});">下一页a>
    49. 	<a href="javascript:gotoPage(${pageBean.getMaxPager()});">末页a>
    50. 	<input type="text" id="go" style="width:18px"/>
    51. 	<input type="button" value="GO" onclick="skipPage(${pageBean.getMaxPager()})" />
    52. div> --%>
    53. body>
    54. html>

    效果图：

  • 相关阅读:
    win10 通过wmic命令行设置系统环境变量
    记GitLab服务器迁移后SSH访问无法生效的问题解决过程
    Python爬虫实战，requests+parsel模块，爬取二手房房源信息数据
    Tomcat报404问题的原因分析
    Hugging News #0821: Hugging Face 完成 2.35 亿美元 D 轮融资
    Jenkins集成newman
    那些惊艳一时的 CSS 属性
    Kruskal 重构树
    嵌入式数据库sqlite3【基础篇】基本命令操作，小白一看就懂（C/C++）
    【LeetCode动态规划#14】子序列系列题（最长递增子序列、最长连续递增序列、最长重复子数组、最长公共子序列）
  • 原文地址：https://blog.csdn.net/m0_61911999/article/details/125973777