• JSP自定义标签之自定义分页01

    目录

    一、建立分页信息实体（PageBean）

    用于存储和传递分页参数，主要内容如下：

    用于存储和传递分页参数，主要内容如下：

    页码，从页面传递过来
    每页行数，从也能传递过来
    总记录数， 从数据库中统计得到
    是否分页， 如果为false，则查询所有记录
    查询参数， 点击上一页或下一页时需要及携带用户输入的所有查询参数
    另外提供上页，下页，总页数等计算
    代码实现：

    package com.zking.mymvc.util;

import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import com.mysql.jdbc.StringUtils;

public class PageBean {
	
	/**
	 * 页码(默认为1)
	 */
	private int page = 1;

	/**
	 * 每页显示的记录数
	 */
	private int rows = 10;

	/**
	 * 总记录数(是统计出来的数据)
	 */
	private int total = 0;

	/**
	 * 是否分页
	 */
	private boolean pagination = true;
	
	/**
	 * 记录查询的url，以便于点击分页时再次使用(保存url，就是我们查询的url，我们查询的什么的时候肯定要提交url，在使用上一页下一页的时候也要使用url)
	 */
	private String url;
	
	/**
	 * 存放请求参数，用于生成隐藏域中的元素(保存查询条件，parameterMap这里的意思就是查询条件，例如男款衣服，在上一页下一页时这个条件肯定是不能变的)
	 */
	private Map<String,String[]> parameterMap;
	
	/**
	 * 根据传入的Request初始化分页对象(这个方法就是简化我们获取页面参数的方法)
	 * page 页数
	 * rows 行数
	 * pagination 是否需要分页
	 * @param request
	 * 解释方法：我们这里面的这些参数是要走页面传进来的，那么传进来过后我们要对这些参数进行处理，
	 * 例如在进行下一页时要当前页面+1，
	 */
	public void setRequest(HttpServletRequest request) {
		
		if(!StringUtils.isNullOrEmpty(request.getParameter("page"))) {
			this.page = Integer.valueOf(request.getParameter("page"));
		}
		if(!StringUtils.isNullOrEmpty(request.getParameter("rows"))) {
			this.rows = Integer.valueOf(request.getParameter("rows"));
		}
		if(!StringUtils.isNullOrEmpty(request.getParameter("pagination"))) {
			this.pagination = Boolean.valueOf(request.getParameter("pagination"));
		}
		
		this.url = request.getRequestURI();//这个就是获取url，然后保存起来，为什么要保存起来？因为我么在进行上一页或者下一页时，这个url肯定是不能变的
		this.parameterMap = request.getParameterMap();//getParameterMap()把我一次提交的所有的参数都保存起来；获取到我所有的参数，以备下次使用
		
		request.setAttribute("pageBean", this);//我又把自己放到pageBean里面去了，为什么？因为我到页面里面需要用（放到pageBean里面后我们在页面上可以直接使用），例如要显示当前是第几页，上一页下一页总页码那些东西
	}


	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 boolean isPagination() {
		return pagination;
	}

	public void setPagination(boolean pagination) {
		this.pagination = pagination;
	}
	
	public String getUrl() {
		return url;
	}

	public void setUrl(String url) {
		this.url = url;
	}

	public Map<String, String[]> getParameterMap() {
		return parameterMap;
	}

	public void setParameterMap(Map<String, String[]> parameterMap) {
		this.parameterMap = parameterMap;
	}

	//计算起始页码
	public int getStartIndex() {
		return (this.page - 1) * this.rows;
	}
	
	//获取总页数
	public int getTotalPage() {
		if (this.getTotal() % this.rows == 0) {
			return this.getTotal() / this.rows;
		} else {
			return this.getTotal() / this.rows + 1;
		}
	}

	//上一页
	public int getPreviousPage() {
		return this.page - 1 > 0 ? this.page - 1 : 1;//如果当前页码-1>0,那么当前页面正常-1;如果当前页面-1<0,那么就为1
	}
	
	//下一页
	public int getNextPage() {
		return this.page + 1 > getTotalPage() ? getTotalPage() : this.page + 1;//如果当前页码+1大于总页数，那么正常+1;如果当前页码+1大于总页数，那么就为总页数
	}

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147

    二、后台分页数据查询

    1） 查询满足条件的总记录数
    2） 查询满足条件的当前页的数据
    3） 上两个步骤的查询条件要一致

    流程图：
    1） 查询满足条件的总记录数
    2） 查询满足条件的当前页的数据
    3） 上两个步骤的查询条件要一致

    流程图：
    请添加图片描述

    代码实现：
    1） 为简化数据库操作，需要一个DBUtil工具类

    package com.zking.mymvc.util;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;




public final class DBUtil {
	
    private static String DRIVER_NAME = "com.mysql.jdbc.Driver";//我需要加载的驱动程序的名称

    private static String DB_URL = "jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false";//连接语句

    private static String DB_USER = "root";//用户名

    private static String DB_PASSWORD = "123456";//密码

    //这是一个私有方法，因为我不希望别人去newDBUtil这个类
    private DBUtil() {
    }

    //静态代码块，因为驱动只需要加载一次
    static {
        try {
            Class.forName(DRIVER_NAME);

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    //获取一个连接对象
    public static Connection getConection() throws SQLException {
        Connection connection = DriverManager.getConnection(DB_URL, DB_USER, DB_PASSWORD);
        return connection;
    }

    //关闭资源，注意关闭的时候是跟我们打卡的顺序是相反的
    public static void closeDB(ResultSet rs, Statement ps, Connection con) {

        try {
            if (rs != null && !rs.isClosed()) {
                rs.close();
            }

            if (ps != null && !ps.isClosed()) {
                ps.close();
            }

            if(con != null && !con.isClosed()) {
                con.close();
            }

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    
    //重载方法，不关连接，因为有时候要重用连接（事务）
    public static void closeDB(ResultSet rs, Statement ps) {

        try {
            if (rs != null && !rs.isClosed()) {
                rs.close();
            }
            
            if (ps != null && !ps.isClosed()) {
                ps.close();
            }

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80

    2） student实体类

    package com.zking.mymvc.model;
/**
 * 用来测试的一个类
 * @author zjjt
 *
 */
public class Student {
	
	private Integer sid;
	
	private String sname;
	
	private Double score;
	
	private String clazz;

	public Integer getSid() {
		return sid;
	}

	public void setSid(Integer sid) {
		this.sid = sid;
	}

	public String getSname() {
		return sname;
	}

	public void setSname(String sname) {
		this.sname = sname;
	}

	public Double getScore() {
		return score;
	}

	public void setScore(Double score) {
		this.score = score;
	}

	public String getClazz() {
		return clazz;
	}

	public void setClazz(String clazz) {
		this.clazz = clazz;
	}

	@Override
	public String toString() {
		return "Student [sid=" + sid + ", sname=" + sname + ", score=" + score + ", clazz=" + clazz + "]";
	}

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55

    3） 数据库自行对照实体类建立

    4） 分页查询

    package com.zking.mymvc.util;

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 java.util.Objects;

import com.zking.mymvc.model.Student;
import com.zking.mymvc.util.BaseDao.ICovent;

public class StudentDao{
	
	/*
	 * public List getStudent(String sname, PageBean pageBean){
	 * 
	 * //把不变部分全部放到模板里，这叫模板设计模式
	 * 
	 * //第一步编写SQL语句，变化部分（这个可变部分，直接通过参数传进去就可以了） String sql =
	 * "select * from t_student t "; //第二步，判断是不是要进行分页 if (!Objects.isNull(sname) &&
	 * sname.length() > 0) {//如果你不为空，并且你的长度是大于0的 sql += " where t.sname like ?"; }
	 * 
	 * //返回个结果集，查询肯定是需要结果集去装的 List students = new ArrayList<>();
	 * 
	 * //建立连接语句，不变部分 Connection con = null; PreparedStatement ps = null; ResultSet
	 * rs = null; //以上就是一些准备工作
	 * 
	 * //不分页的情况，下面else开始就是分页的情况，不变部分 if (pageBean == null ||
	 * !pageBean.isPagination()) {//如果你传进来的pageBean为空或者是否需要分页为false的，那就不要分页 try {
	 * con = DBUtil.getConection(); ps = con.prepareStatement(sql);
	 * 
	 * //设置查询参数 if(sname != null) { ps.setObject(1, sname+"%"); }
	 * 
	 * rs = ps.executeQuery();
	 * 
	 * //变化部分（是因为我们不知道给它什么类型，如果用反射也可以通用，我可以把结果集给你） while(rs.next()) { Student stu =
	 * new Student(); stu.setSid(rs.getInt("sid"));
	 * stu.setSname(rs.getString("sname")); stu.setClazz(rs.getString("class"));
	 * students.add(stu); } //不变部分 } catch (SQLException e) { e.printStackTrace();
	 * }finally { DBUtil.closeDB(rs,ps,con); } //不变部分 }else { //需要分页的情况
	 * 
	 * //第一步查询总记录数(数据库查询总记录语句) String countSql = "SELECT COUNT(*) FROM ("+ sql
	 * +")tmp";
	 * 
	 * try { con = DBUtil.getConection(); ps = con.prepareStatement(sql);
	 * 
	 * //设置查询参数 if(sname != null) { ps.setObject(1, sname+"%"); }
	 * 
	 * rs = ps.executeQuery(); if(rs.next()) { Integer total = rs.getInt(1);
	 * pageBean.setTotal(total);//保存总记录数 }
	 * 
	 * //判断总记录数是否大于0，如果大于0表示有记录，需求查询当前记录 //如果没有的话就直接返回 if(pageBean.getTotal() <=0)
	 * {//如果总记录数<=0,那么直接返回 return students; }
	 * 
	 * //如果总记录数大于零，则查分页数据的SQL语句 String pagingSql = sql +
	 * "LIMIT "+pageBean.getStartIndex()+","+pageBean.getRows(); //设置查询参数 if(sname
	 * != null) { ps.setObject(1, sname+"%"); } rs = ps.executeQuery();
	 * 
	 * //变化部分 while(rs.next()) { Student stu = new Student();
	 * stu.setSid(rs.getInt("sid")); stu.setSname(rs.getString("sname"));
	 * stu.setClazz(rs.getString("class")); students.add(stu); } //不变部分 } catch
	 * (SQLException e) { e.printStackTrace(); }finally { DBUtil.closeDB(rs,ps,con);
	 * } }
	 * 
	 * 
	 * return students; }
	 */
//上面是封装之前的
//--------------------------------------------------------------------------------------
//下面是封装之后	
	
	public List<Student> getStudent02(String sname, PageBean pageBean){
		//第一步编写SQL语句，变化部分（这个可变部分，直接通过参数传进去就可以了）
		String sql = "select * from t_student t ";
		List<Object> param = new ArrayList<>();
		//第二步，判断是不是要进行分页
		if (!Objects.isNull(sname) && sname.length() > 0) {//如果你不为空，并且你的长度是大于0的
			sql += " where t.sname like ?";
			param.add(sname);
		}
		List<Student> list = BaseDao.query(sql, param.toArray(), pageBean, new ICovent<Student>() {

			public List<Student> convent(ResultSet rs) throws SQLException {
				List<Student> students = new ArrayList<>();
				while(rs.next()) {
					Student stu = new Student();
					stu.setSid(rs.getInt("sid"));
					stu.setSname(rs.getString("sname"));
					stu.setClazz(rs.getString("class"));
					students.add(stu); 
				}
				return students;
			}
			
		});
		return list;
	}
	
	public static void main(String[] args) {
		//测试
		StudentDao dao = new StudentDao();
		List<Student> list = dao.getStudent02(null, new PageBean());
		list.forEach(t->System.out.println(t));
	}
	
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109

    三、重构-提取公用方法

    1）为了进行公共方法的抽取，需要找出上面实习中的可通用部分，和差异化部分。

    只要是分页，就会统计总记录数，而总记录数的统计是在业务sql外封装了一个select count(*)是有规律可循的，可以通用

    只要是分页，则封装分页sql也是有规律可循的（在业务sql后加limit子句即可），可以通用

    因为每个查询对应的业务实体（即模型）不同，所以ORM映射部分不能通用

    2）公用方法封装思路

    将可通用的部分封装到模板中

    差异化部分（即不可通用部分），可以定义一个处理接口，以便于通过参数传入个性化的实现部分

    3） 具体实现
    通用分页查询模板类：
    BaseDao.class

    package com.zking.mymvc.util;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;


public final class BaseDao {

	private BaseDao() {};
	
	/**
	 * 回调函数接口
	 * @author zjjt
	 *
	 * @param 
	 */
	@FunctionalInterface
	public static interface ICovent<T> {
		List<T> convent(ResultSet rs) throws SQLException;
	}
	
	public static <T> List<T> query(String sql, 
			Object[] params, 
			PageBean pageBean,
			ICovent<T> covent
			){
		
		//返回个结果集，查询肯定是需要结果集去装的
		List<T> students = new ArrayList<>();
		
		//建立连接语句，不变部分
		Connection con = null;
		PreparedStatement ps = null;
		ResultSet rs = null;
		
		//不分页的情况，下面else开始就是分页的情况，不变部分
		if (pageBean == null || !pageBean.isPagination()) {//如果你传进来的pageBean为空或者是否需要分页为false的，那就不要分页
			try {
				con = DBUtil.getConection();
				ps = con.prepareStatement(sql);
				
				//设置查询参数
				int i = 1;
				for(Object param: params) {
					ps.setObject(i, param);
					i++;
				}
						
				rs = ps.executeQuery();
					
				//通过使用者传入的回调函数，执行转换
				students = covent.convent(rs);
				
				//不变部分
			} catch (SQLException e) {
				e.printStackTrace();
			}finally {
				DBUtil.closeDB(rs,ps,con);
			}
		}else {
			//需要分页的情况
			
			//第一步查询总记录数(数据库查询总记录语句)
			String countSql = "SELECT COUNT(*) FROM ("+ sql +") tmp";
			
			try {
				con = DBUtil.getConection();
				ps = con.prepareStatement(countSql);
				
				//设置查询参数
				int i = 1;
				for(Object param: params) {
					ps.setObject(i, param);
					i++;
				}
				
				rs = ps.executeQuery();
				
				if(rs.next()) {
					Integer total = rs.getInt(1);
					pageBean.setTotal(total);//保存总记录数
				}
				
				//判断总记录数是否大于0，如果大于0表示有记录，需求查询当前记录
				//如果没有的话就直接返回
				if(pageBean.getTotal() <=0) {//如果总记录数<=0,那么直接返回
					return students;
				}
				
				//如果总记录数大于零，则查分页数据的SQL语句
				String pagingSql = sql + "LIMIT "+pageBean.getStartIndex()+","+pageBean.getRows();
				ps = con.prepareStatement(pagingSql);

				//设置查询参数
				int j = 1;
				for(Object param: params) {
					ps.setObject(i, param);
					j++;
				}
				rs = ps.executeQuery();
				
				//变化部分
				students = covent.convent(rs);
				
				//不变部分
			} catch (SQLException e) {
				e.printStackTrace();
			}finally {
				DBUtil.closeDB(rs,ps,con);
			}
		}	
		
		
		return students;
	}
		
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122

    这章的内容就到这里下一章我们再来继续说自定义分页标签

  • 相关阅读:
    2.4.1 用户态协议栈设计实现
    《从零开始的Java世界》01基本程序设计
    Python基于Excel生成矢量图层及属性表信息：ArcPy
    信息化发展39
    MySQL运维10-Mycat分库分表之一致性哈希分片
    【c++提高1】拓扑排序
    如何把JavaWeb项目部署到服务器
    郑州软件开发|小程序跟服务号如何结合使用？
    信创办公–基于WPS的EXCEL最佳实践系列 （数据整理复制粘贴）
    大数据架构师——音乐数据中心平台离线数仓综合项目（四）
  • 原文地址：https://blog.csdn.net/Champion_me/article/details/126002436