🥳🥳Welcome Huihui's Code World ! !🥳🥳

接下来看看由辉辉所写的关于通用分页的相关操作吧

目录

🥳🥳Welcome Huihui's Code World ! !🥳🥳

导读：

💡辉辉小贴士：那么通用分页常常被用在哪些场景呢？

简易版本的查询

通用版本的查询 

通用分页查询

JUnit

是什么

为什么要用

怎么用

通用分页的工具类方法

数据库辅助类的配置文件

分页工具方法类

实体类

---

导读：

        相信在看到这个标题的这一刻，我们就能够知道这篇博客的内容是什么了。顾名思义，“通用分页”就是能够在多个页面使用以及封装好的通用分页的代码，这样可以有效地优化页面加载速度，提高用户体验，同时降低服务器的数据传输压力

💡辉辉小贴士：那么通用分页常常被用在哪些场景呢？

• 通用分页主要应用于需要大量数据展示的网站或应用程序，例如电商网站、新闻门户、数据分析平台等
• 通用分页可以优化页面加载速度，提高用户体验，并能帮助用户从大量数据中快速找到自己需要的信息

总之，运用在需要将大量数据展示的地方！！

为了体现通用分页的这个通用，那么接下来我将展示一个简易版本的查询，和通用版本的查询

简易版本的查询

package com.wh.dao;

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

import org.junit.Test;

import com.wh.entity.Book;
import com.wh.util.BaseDao;
import com.wh.util.DBAccess;
import com.wh.util.PageBean;
import com.wh.util.StringUtils;

public class BookDao {
	/**
	 * 简易版查询
	 * @param b
	 * @param pageBean
	 * @return
	 */
	public List<Book> select(Book b,PageBean pageBean) {
		Book book = null;//实体类
		List<Book> list = new ArrayList<>();//集合
		Connection conn = null;//连接对象
		PreparedStatement ps = null;//执行对象
		ResultSet rs = null;//结果集对象
		try {
			conn = DBAccess.getConnection();//获取连接对象
			String sql = " select * from t_mvc_book where 1 = 1";//定义sql语句
			String bname = b.getBname();//拿到模糊查询关键字
			if(StringUtils.isNotBlank(bname)) {//如果模糊查询的关键字不为空
				sql+=" and bname like '%"+bname+"%' ";//那么就拼接sql语句进行模糊查询
			}
			ps = conn.prepareStatement(sql);//执行sql语句
			rs=ps.executeQuery();//获取结果集对象
			while(rs.next()) {//遍历结果集
				book=new Book(rs.getInt(1), rs.getString(2), rs.getFloat(3));
			list.add(book);//将对象加到集合中
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return list;//返回集合
	}
	
	
	public static void main(String[] args) {
		BookDao bookDao = new BookDao();
		Book book = new Book();
		PageBean pageBean = new PageBean();
		List<Book> select = bookDao.select(book, pageBean);
		for (Book book2 : select) {
			System.out.println(book2);
		}
	}
}

结果：

通用版本的查询 

package com.wh.util;

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;

public class BaseDao<T> {
	
	public List<T> select (String sql,Class clas,PageBean pageBean) throws Exception{
		Connection conn = null;//连接对象
		PreparedStatement ps = null;//执行对象
		ResultSet rs = null;//结果集对象
		List<T> list= new ArrayList<T>();//集合
			conn = DBAccess.getConnection();//获取连接对象
			ps = conn.prepareStatement(sql);//执行sql语句
			rs=ps.executeQuery();//获取结果集对象
		while(rs.next()) {
			T t= (T) clas.newInstance();//类类
			Field[] fields = clas.getDeclaredFields();//拿到特定实体的所有的属性
			for (Field field : fields) {//遍历所有的属性
				field.setAccessible(true);//打开权限通道，可以拿到私有的属性
				field.set(t, rs.getObject(field.getName()));//为指定的实体对象更改指定的属性
			}
			list.add(t);//将其加入到集合中
		}
		return list;//返回集合
	}

}

在对应的需要查询的dao方法中继承basedao即可👇👇

package com.wh.dao;

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

import org.junit.Test;

import com.wh.entity.Book;
import com.wh.util.BaseDao;
import com.wh.util.DBAccess;
import com.wh.util.PageBean;
import com.wh.util.StringUtils;

public class BookDao extends BaseDao<Book>{
	public List<Book> select1(Book b,PageBean pageBean)throws Exception{
		String sql = " select * from t_mvc_book where 1 = 1";//定义sql语句
		String bname = b.getBname();//拿到模糊查询关键字
		if(StringUtils.isNotBlank(bname)) {//如果模糊查询的关键字不为空
			sql+=" and bname like '%"+bname+"%' ";//那么就拼接sql语句进行模糊查询
		}
		return super.select(sql, Book.class, pageBean);
		
	}
	
	public static void main(String[] args) throws Exception {
		BookDao bookDao = new BookDao();
		Book book = new Book();
		PageBean pageBean = new PageBean();
		pageBean.setPagination(false);
		List<Book> select = bookDao.select1(book, pageBean);
		for (Book book2 : select) {
			System.out.println(book2);
		}
	}
}

 运行结果

相信通过上述代码的演示，你已经非常直观的看到了通用查询的妙处，以后像查询这样的代码，我们只用写一次便可以啦！！并且无论是对于什么的查询，都可以完成！！是不是非常的方便呢！那么接下来的通用分页便也是如此啦，感兴趣的便继续看下去吧~~

通用分页查询

package com.wh.util;

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;

public class BaseDao<T> {
	/**
	 * 通用版分页查询
	 * @param sql sql语句
	 * @param clas 指定对象类类
	 * @param pageBean 分页工具类
	 * @return list 结果集
	 * @throws Exception
	 */
	public List<T> select (String sql,Class clas,PageBean pageBean) throws Exception{
		Connection conn = null;//连接对象
		PreparedStatement ps = null;//执行对象
		ResultSet rs = null;//结果集对象
		List<T> list= new ArrayList<T>();//集合
		
		if(pageBean!=null&&pageBean.isPagination()) {//如果分页的工具类传进来了【不为空】，并且分页工具类的是否分页的方法的返回值是true时
			//那么便定义分页的sql语句和符合条件的总记录数
			
			String countSql=getCountSql(sql);//符合条件的总记录数的sql
			conn = DBAccess.getConnection();//获取连接对象
			ps = conn.prepareStatement(countSql);//执行sql语句
			rs=ps.executeQuery();//获取结果集对象
			if(rs.next()) {
				pageBean.setTotal(rs.getObject("n").toString());//结果集查询的结果设置到分页工具类的总记录的方法中
			}
			
			
			String pageSql=getPageSql(sql,pageBean);//分页的sql
			conn = DBAccess.getConnection();//获取连接对象
			ps = conn.prepareStatement(pageSql);//执行sql语句
			rs=ps.executeQuery();//获取结果集对象
		}else {
			conn = DBAccess.getConnection();//获取连接对象
			ps = conn.prepareStatement(sql);//执行sql语句
			rs=ps.executeQuery();//获取结果集对象
		}
		while(rs.next()) {
			T t= (T) clas.newInstance();//类类
			Field[] fields = clas.getDeclaredFields();//拿到特定实体的所有的属性
			for (Field field : fields) {//遍历所有的属性
				field.setAccessible(true);//打开权限通道，可以拿到私有的属性
				field.set(t, rs.getObject(field.getName()));//为指定的实体对象更改指定的属性
			}
			list.add(t);//将其加入到集合中
		}
		return list;//返回集合
	}

	/**
	 * 符合条件的总记录数
	 * @param sql 查询的sql语句
	 * @return 符合条件的总记录数的sql语句
	 */
	private String getCountSql(String sql) {
		return " select count(1) as n from ( "+sql+" ) t";//sql语句
	}

	/**
	 * 分页的sql语句
	 * @param sql 查询的sql语句
	 * @param pageBean 分页工具类
	 * @return 分页的sql语句
	 */
	private String getPageSql(String sql, PageBean pageBean) {
		return sql+" limit  "+pageBean.getStartIndex()+", "+pageBean.getRows();//sql语句
	}

}

在对应的需要查询的dao方法中继承basedao即可👇👇

package com.wh.dao;

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

import org.junit.Test;

import com.wh.entity.Book;
import com.wh.util.BaseDao;
import com.wh.util.DBAccess;
import com.wh.util.PageBean;
import com.wh.util.StringUtils;

public class BookDao extends BaseDao<Book>{

	
	public List<Book> select1(Book b,PageBean pageBean)throws Exception{
		String sql = " select * from t_mvc_book where 1 = 1";//定义sql语句
		String bname = b.getBname();//拿到模糊查询关键字
		if(StringUtils.isNotBlank(bname)) {//如果模糊查询的关键字不为空
			sql+=" and bname like '%"+bname+"%' ";//那么就拼接sql语句进行模糊查询
		}
		return super.select(sql, Book.class, pageBean);
		
	}
	
	public static void main(String[] args) throws Exception {
		BookDao bookDao = new BookDao();
		Book book = new Book();
		book.setBname("圣墟");
		PageBean pageBean = new PageBean();
		List<Book> select = bookDao.select1(book, pageBean);
		for (Book book2 : select) {
			System.out.println(book2);
		}
	}

	

}

运行结果

 

看完上面的代码演示之后，是不是觉得耳目一新呢？其实我们在很多的地方都可以用到这种思想，将代码整十为一，将大量的重复代码抽离出来，放到一个类似于“公共类”的地方，以后需要用到的时候，直接调用即可。编程的路十漫长的，我们需要学的东西也是无尽的，所以我们需要的十养成一种好的编程习惯，锻炼出好的编程思维，同时也需要能够灵活的运用各种工具，这样会提高我们的开发效率，那么接下来就让我们接触一个好用的工具吧！

JUnit

是什么

JUnit是一个开源的Java语言测试框架，用于编写和运行可重复的自动化测试。JUnit旨在帮助开发人员编写可重复、自动化、可维护的测试

为什么要用

优点

• 1. 简单易用：使用注解和断言，使测试代码变得易于编写和阅读
• 2. 灵活自动化：可以自动运行测试代码，无需人工干预
• 3. 可扩展性：可以扩展JUnit库，以便于更好地适应新技术、环境和工具的使用

• 它提了一个测试执行器、断言（Assertion）和注释等基本测试元素，已经成为Java应用程序开发中最常用的测试框架之一
• JUnit能够简单地运行单元测试和重复运行测试，其目的是检查测试代码是否能够实现系统的正确性需求
• Unit的应用可为开发人员提供及时的反馈和错误报告，以及帮助快速发现和定位代码的问题

 总而言之，相比于我们之前在main方法中的测试来说，使用这个工具可以单独的测试每个方法，并且在一个类中可以多次使用

怎么用

 

 

 

 

按照上述的操作，先将 JUnit 配置为 Eclipse 的类路径 【右击项目->Properties->Java Build Path->Libraries->Add Library->选择JUNIT->选择JUNIT4->Finish】

package com.wh.dao;

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

import org.junit.Test;

import com.wh.entity.Book;
import com.wh.util.BaseDao;
import com.wh.util.DBAccess;
import com.wh.util.PageBean;
import com.wh.util.StringUtils;

public class BookDao extends BaseDao<Book>{
	/**
	 * 简易版查询
	 * @param b
	 * @param pageBean
	 * @return
	 */
	public List<Book> select(Book b,PageBean pageBean) {
		Book book = null;//实体类
		List<Book> list = new ArrayList<>();//集合
		Connection conn = null;//连接对象
		PreparedStatement ps = null;//执行对象
		ResultSet rs = null;//结果集对象
		try {
			conn = DBAccess.getConnection();//获取连接对象
			String sql = " select * from t_mvc_book where 1 = 1";//定义sql语句
			String bname = b.getBname();//拿到模糊查询关键字
			if(StringUtils.isNotBlank(bname)) {//如果模糊查询的关键字不为空
				sql+=" and bname like '%"+bname+"%' ";//那么就拼接sql语句进行模糊查询
			}
			ps = conn.prepareStatement(sql);//执行sql语句
			rs=ps.executeQuery();//获取结果集对象
			while(rs.next()) {//遍历结果集
				book=new Book(rs.getInt(1), rs.getString(2), rs.getFloat(3));
			list.add(book);//将对象加到集合中
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return list;//返回集合
	}
	

	
	@Test
	public void test() throws Exception {
		BookDao bookDao = new BookDao();
		Book book = new Book();
		book.setBname("圣墟");
		PageBean pageBean = new PageBean();
		pageBean.setPagination(true);
		List<Book> select = bookDao.select(book, pageBean);
		for (Book book2 : select) {
			System.out.println(book2);
	}
}
}

运行结果

 

 最后最后，附上

通用分页的工具类方法

数据库辅助类的配置文件

#oracle9i
#driver=oracle.jdbc.driver.OracleDriver
#url=jdbc:oracle:thin:@localhost:1521:orcl
#user=scott
#pwd=***
 
 
#sql2005
#driver=com.microsoft.sqlserver.jdbc.SQLServerDriver
#url=jdbc:sqlserver://localhost:1433;DatabaseName=test1
#user=sa
#pwd=***
 
 
#sql2000
#driver=com.microsoft.jdbc.sqlserver.SQLServerDriver
#url=jdbc:microsoft:sqlserver://localhost:1433;databaseName=unit6DB
#user=sa
#pwd=***
 
 
#mysql
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis_ssm?useUnicode=true&characterEncoding=UTF-8&useSSL=false
user=root
pwd=***

数据库辅助类

package com.wh.util;

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;

/**
 * 提供了一组获得或关闭数据库对象的方法
 * 数据库辅助类
 */
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);
		}
	}

	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("数据库连接(关闭)成功");
	}
}

分页工具方法类

package com.wh.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 + "]";
	}
	
	public static void main(String[] args) {
		PageBean pageBean = new PageBean();
		boolean pagination2 = pageBean.isPagination();
	System.out.println(pagination2);
	}

}

package com.wh.util;

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);
	}

}

实体类

package com.wh.entity;

public class Book {
	private int bid;
	private String bname;
	private float price;

	
	public Book() {
		// TODO Auto-generated constructor stub
	}
	
	
	public Book(int bid, String bname, float price) {
		super();
		this.bid = bid;
		this.bname = bname;
		this.price = 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;
	}

}

 

               好啦，今天的分享就到这了，希望能够帮到你呢！😊😊