通用分页（一）

目的：作用通用的分页的查询方法

1.完成一个普通的查询方法
2.将原有的查询方法进行反射优化，转变成一个可以被所有实体类dao层所继承的通用查询方法
3.考虑该方法可以进行分页

思路：
1、将原有的查询向上抽取
2、让返回值变成泛型
3、使用回调函数处理resultset
4、利用反射处理回调函数
5、获取总记录数（页面展示，计算总页数）
6、拼接分页sql语句，获取对应的结果集

1.完成一个普通的查询方法

1.1导入jar包

1.2导入uitl包

切记： 检查config.properties类url,user,pwd是否正确,如下：

然后再检查数据库是否连接成功，如下：

1.3创建一个实体类，再写一个dao方法(本人创建的是BookDao)
以下是dao方法的代码：

public class BookDao {

	/*
	 * book 封装jsp传递过来的查询参数
	 * pageBean 决定dao层的list调用时是否分页
	 * */
	public List<Book> list(Book book,PageBean pageBean) throws SQLException{
		String sql ="select * from t_mvc_book where true";
		String bname = book.getBname();
		if(StringUtils.isNotBlank(bname)) {
			sql+=" and bname like '%"+bname+"%'";
		}
		Connection con = DBAccess.getConnection();
		PreparedStatement pst=con.prepareStatement(sql);
		ResultSet rs = pst.executeQuery();
		List<Book> list=new ArrayList<>();
		while(rs.next()) {
			list.add(new Book(rs.getInt("bid"), rs.getString("bname"), rs.getFloat("price")));
		}
		DBAccess.close(con, pst, rs);
		return list;
	}
	public static void main(String[] args) {
		BookDao bookDao=new BookDao();
		Book book=new Book();
		try {
			List<Book> list=bookDao.list(book, null);
			for (Book b : list) {
				System.out.println(b);
			}
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

这个写的方法是查询所有的方法，所以输出的结果是表中所有数据：

以下代码模糊查：

输出的结果为：

2.将原有的查询方法进行反射优化，转变成一个可以被所有实体类dao层所继承的通用查询方法

2.1创建一个BaseDao类

package com.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.entity.Book;
import com.uitl.DBAccess;
import com.uitl.PageBean;

public class BaseDao<T> {
/*
 * T代表你要对哪个实体类对应的表进行分页查询
 * 
 * sql 查询不同的实体类，那么对应的sql不同，所以需要传递
 * cla 生产出不同的实体类对应的实例，然后装进list容器返回
 * pageBean 决定是否分页
 * */
	public List<T> executeQuery(String sql,Class cla,PageBean pageBean) throws SQLException, InstantiationException, IllegalAccessException{
		Connection con = DBAccess.getConnection();
		PreparedStatement pst=con.prepareStatement(sql);
		ResultSet rs = pst.executeQuery();
		List<T> list=new ArrayList<>();
		T t;
		while(rs.next()) {
			/*
			 * 1.实例化一个book对象(该对象是空的，这里的空不是指null，是值所有属性都没有属性值)
			 * 2.取book所有属性，然后给其赋值
			 *   2.1.获取所有属性对象
			 *   2.2.给属性对象赋值
			 * 3.赋完值的book对象装进list容器中
			 * */
//			list.add(new Book(rs.getInt("bid"), rs.getString("bname"), rs.getFloat("price")));
			t=(T)cla.newInstance();
			Field[] fields = cla.getDeclaredFields();
			for (Field field : fields) {
				field.setAccessible(true);
				field.set(t, rs.getObject(field.getName()));
			}
			list.add(t);
		}
		DBAccess.close(con, pst, rs);
		return list;
	}
}

2.2在BookDao类里继承我们所运用泛型的BaseDao类

普通查询方法跟通用查询方法相比较的话，我觉得通用查询方法比普通查询方法更方便，只用写一个泛型其他dao层继承它就行了，不用像普通查询方法那样重复着写相同的代码，而且通用查询方法代码量有一定的减少。

3.考虑该方法可以进行分页

3.1 算总记录数
3.2 查询出当前页的结果集

public class BaseDao<T> {
/*
 * T代表你要对哪个实体类对应的表进行分页查询
 * 
 * sql 查询不同的实体类，那么对应的sql不同，所以需要传递
 * cla 生产出不同的实体类对应的实例，然后装进list容器返回
 * pageBean 决定是否分页
 * */
	public List<T> executeQuery(String sql,Class cla,PageBean pageBean) throws SQLException, InstantiationException, IllegalAccessException{
		Connection con = DBAccess.getConnection();
		PreparedStatement pst= null;
		ResultSet rs = null;
		
		if(pageBean!=null && pageBean.isPagination()) {  //当pageBean!=null 且让它分页（分页工具类以及写好了isPagination()方法默认是分页）
			//需要分页
            //1.算总记录数	
			String countSql=getCountSql(sql);
			pst=con.prepareStatement(countSql);
			rs = pst.executeQuery();
			if(rs.next()) {
				pageBean.setTotal(rs.getLong(1)+"");
			}
			
			//查询出当前页的结果集
			String pageSql=getPageSql(sql,pageBean);
			pst=con.prepareStatement(pageSql);
			rs = pst.executeQuery();
			
		}else { //不分页的代码
			pst=con.prepareStatement(sql);
			rs = pst.executeQuery();
		}
		
		//处理所有的结果集
		List<T> list=new ArrayList<>();
		T t;
		while(rs.next()) {
			/*
			 * 1.实例化一个book对象(该对象是空的，这里的空不是指null，是值所有属性都没有属性值)
			 * 2.取book所有属性，然后给其赋值
			 *   2.1.获取所有属性对象
			 *   2.2.给属性对象赋值
			 * 3.赋完值的book对象装进list容器中
			 * */
//			list.add(new Book(rs.getInt("bid"), rs.getString("bname"), rs.getFloat("price")));
			t=(T)cla.newInstance();
			Field[] fields = cla.getDeclaredFields();
			for (Field field : fields) {
				field.setAccessible(true);
				field.set(t, rs.getObject(field.getName()));
			}
			list.add(t);
		}
		DBAccess.close(con, pst, rs);
		return list;
	}

	/*
	 * 利用原生sql拼接出符合条件的结果集的查询sql
	 * */
	private String getPageSql(String sql, PageBean pageBean) {
	// TODO Auto-generated method stub
	return sql+" limit "+pageBean.getStartIndex()+","+pageBean.getRows()+"";
}

	/*
	 * 获取符合条件的总记录数的sql语句
	 * */
	private String getCountSql(String sql) {
		// TODO Auto-generated method stub
		return "select count(1) from ("+sql+") t";
	}
}

输出的结果为：

如果这时我们要查看第二页的结果：

//你所查看的第几页
pageBean.setPage(2);

输出的结果是第二页的内容：

如果这时我们传了值又不想分页的话：

//选择true则分页；false则不分页
pageBean.setPagination(false);

由此可见，通用分页使我们大大的减少了一些不必要的代码量