通用分页（一）

思路

首先通用分页我们要考虑是否要使用分页，有些地方只是查所有而已。接下来考虑当前页数(page)和每一页的数据量(rows)。数据的来源在后台，前台告诉后台需要哪一页的数据以及这一页有多少条数据，rows是可以设定的，所以page是前台和后台交互的核心。那么后台接收到前台的page，要去识别它，根据这个参数到数据库取得数据返回给前台。

PageBean

将我们分页要的一些属性创建一个类

package com.shl.util;

/**
 * 分页工具类
 *
 */
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 + "]";
	}

}

BaseDao

要做一个通用的分页，当然要写一个所有类都可以用的一个父类来进行操作，父类里包含着分页dao方法的许多共同的特点，如果不分页，那么要先获取符合查询条件的值的数量，然后根据pageBean查询出用户所需的数据。

package com.shl.dao;

import java.lang.reflect.Field;
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.shl.entity.Book;
import com.shl.util.DBAccess;
import com.shl.util.PageBean;
import com.shl.util.StringUtils;
import com.sun.corba.se.impl.ior.GenericTaggedComponent;

public class BaseDao<T> {
	
	/**
	 * 
	 * @param sql  决定查询哪个表的数据
	 * @param clz  查询出来的数据封装到哪个实体类中
	 * @param p   决定是否分页
	 * @return
	 * @throws SQLException 
	 * @throws IllegalAccessException 
	 * @throws InstantiationException 
	 */
	public List<T> executeQuery(String sql,Class clz,PageBean p) throws SQLException, InstantiationException, IllegalAccessException{
		List<T> list = new ArrayList<>();
		Connection con = DBAccess.getConnection();
		PreparedStatement pst = null;
		ResultSet rs = null;
		try {
			//判断是否进行分页
			if (p != null && p.isPagination()) {
				//分页
				//查出符合条件的数据总数
				String countsql=getCountSql(sql);
				pst = con.prepareStatement(countsql);
				rs = pst.executeQuery();
				if(rs.next()) {
					p.setTotal(rs.getLong(1)+"");
				}
				
				//分页查询数据
				String pageSql=getPageSql(sql,p);
				pst = con.prepareStatement(pageSql);
				rs = pst.executeQuery();
				
			} else {
				//不分页，查询所有并全部展示
				pst = con.prepareStatement(sql);
				rs = pst.executeQuery();
			}
			while (rs.next()) {
				//1.创建了一个对象
				T t = (T) clz.newInstance();
				//从ResultSet结果集中获取值放入对象属性,并获取属性对象
				Field[] fields = clz.getDeclaredFields();
				//给属性对象赋值
				for (Field f : fields) {
					f.setAccessible(true);
					f.set(t, rs.getObject(f.getName()));
				}
				//将已经有值的book对象放入list集合中
				list.add(t);
			} 
		} finally {
			//shift+alt+z  
			DBAccess.close(con, pst, rs);
		}
		return list;
	}

	/**
	 * 将原生sql拼接出符合条件的某一页的数据查询sql
	 * @param sql
	 * @param p
	 * @return
	 */
	private String getPageSql(String sql,PageBean p) {
		// TODO Auto-generated method stub
		return sql+" limit " + p.getStartIndex()+","+p.getRows();
	}

	/**
	 * 用原生sql拼接出查询符合条件的记录数
	 * @param sql
	 * @return
	 */
	private String getCountSql(String sql) {
		return "select count(1) from ("+sql+") t";
	}
}

以Book为例

这里，我们以Book表为例，给大家演示一下分页效果

Book类的实例化

package com.shl.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;
	}
	public Book(int bid,String bname,float price) {
		this.bid = bid;
		this.bname = bname;
		this.price = price;
	}
	public Book() {}
}

BookDao
我们用BookDao继承前面写的BaseDao，写分页方法，获得父类的返回值。

public class BookDao extends BaseDao<Book>{
		public List<Book> list(Book book,PageBean pagebean) throws SQLException, InstantiationException, 		IllegalAccessException{
			String sql="select * from t_mvc_book where 1=1";
			
			if(StringUtils.isNotBlank(book.getBname())) {//如果book有bname值，则根据bname进行模糊查
				sql+=" and bname like '%"+book.getBname()+"%'";
			}
			
			return super.executeQuery(sql, Book.class, pagebean);//获得父类的返回值
		}
｝

可以明显的看出，Dao方法的量完全没有最简单的Dao方法量多

实例
写完Dao方法之后，就可以测试一下结果如何

public static void main(String[] args) throws SQLException, InstantiationException, IllegalAccessException {
		BookDao bd=new BookDao();
		Book b=new Book();
		PageBean p=new PageBean();
//		p.setPagination(false);//不分页
		p.setPage(2);//第二页
		b.setBname("圣");//设置模糊查参数
		List<Book> list = bd.list(b, p);
		for (Book book : list) {//遍历集合，输出
			System.out.println(book);
		}
	}

输出的结果为数据库中bname like ‘%圣%’ ，并且是第20到第29位的值