目录
2. StringUtils.java这个类就是判断是否为空
5.DBAccess.java这个类就根DBHelper一样的
总结：junit 能够针对单个方法进行测试，相对于main方法而言，测试耦合性降低了
一.关于分页的五个类
1.PageBean.java分页工具类
package com.jiangwenjuan.util;
/**
* 分页工具类
* @author 蒋文娟
*
* @date 2022年6月21日 下午8:15:46
*/
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 + "]";
}
}
2. StringUtils.java这个类就是判断是否为空
package com.jiangwenjuan.util;
/**
* 判空
* @author 蒋文娟
*
* @date 2022年6月21日 下午8:15:19
*/
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);
}
}
3.EncodingFiter.java这个类就是过滤器
过滤器：就是把我们的字符编码集转成UTF-8,jsp默认的编码集是ISO-8859-1,这个就是我们编码集的作用
package com.jiangwenjuan.util;
import java.io.IOException;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* 中文乱码处理
* @author 蒋文娟
*
* @date 2022年6月21日 下午8:09:18
*/
public class EncodingFiter implements Filter {
private String encoding = "UTF-8";// 默认字符集
public EncodingFiter() {
super();
}
public void destroy() {
}
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
HttpServletRequest req = (HttpServletRequest) request;
HttpServletResponse res = (HttpServletResponse) response;
// 中文处理必须放到 chain.doFilter(request, response)方法前面
res.setContentType("text/html;charset=" + this.encoding);
if (req.getMethod().equalsIgnoreCase("post")) {
req.setCharacterEncoding(this.encoding);
} else {
Map map = req.getParameterMap();// 保存所有参数名=参数值(数组)的Map集合
Set set = map.keySet();// 取出所有参数名
Iterator it = set.iterator();
while (it.hasNext()) {
String name = (String) it.next();
String[] values = (String[]) map.get(name);// 取出参数值[注：参数值为一个数组]
for (int i = 0; i < values.length; i++) {
values[i] = new String(values[i].getBytes("ISO-8859-1"),
this.encoding);
}
}
}
chain.doFilter(request, response);
}
public void init(FilterConfig filterConfig) throws ServletException {
String s = filterConfig.getInitParameter("encoding");// 读取web.xml文件中配置的字符集
if (null != s && !s.trim().equals("")) {
this.encoding = s.trim();
}
}
}
4.连接某个数据库的类 比如我现在连的是MySQL数据库
#oracle9i
#driver=oracle.jdbc.driver.OracleDriver
#url=jdbc:oracle:thin:@localhost:1521:orcl
#user=scott
#pwd=123
#sql2005
#driver=com.microsoft.sqlserver.jdbc.SQLServerDriver
#url=jdbc:sqlserver://localhost:1433;DatabaseName=test1
#user=sa
#pwd=123
#sql2000
#driver=com.microsoft.jdbc.sqlserver.SQLServerDriver
#url=jdbc:microsoft:sqlserver://localhost:1433;databaseName=unit6DB
#user=sa
#pwd=888888
#mysql
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/student?useUnicode=true&characterEncoding=UTF-8&useSSL=false
user=root
pwd=123456
5.DBAccess.java这个类就根DBHelper一样的
package com.jiangwenjuan.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;
/**
* DBHelper类
* 提供了一组获得或关闭数据库对象的方法
* @author 蒋文娟
*
* @date 2022年6月21日 下午8:07:57
*/
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("数据库连接(关闭)成功");
}
}
第一步先要测试运行一下看能不能连接到mysql数据库，这样就说明没问题了
二.junit4
1.dao方法
package com.jiangwenjuan.dao;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import com.jiangwenjuan.entity.Book;
import com.jiangwenjuan.util.DBAccess;
import com.jiangwenjuan.util.PageBean;
import com.jiangwenjuan.util.StringUtils;
/**
* 书籍数据库访问层dao
* @author 蒋文娟
*
* @date 2022年6月21日 下午10:41:30
*/
public class BookDao {
public List<Book> list(Book book,PageBean pageBean) throws Exception{
List<Book> list = new ArrayList<Book>();
/*
* 1.拿到数据库连接
* 2.拿到 Preparestatement
* 3.执行SQL语句
*/
//创建连接
Connection con = DBAccess.getConnection();
//定义sql语句
String sql = "select * from tb_book where 1=1 ";
//假如按照书籍的名字查询
String bname = book.getBname();
//如果说这个书籍不为空，你就是想让书籍查询
if(StringUtils.isNotBlank(bname)) {
sql += " and bname like '%"+bname+"%'";
}
//假设按照id进行查询
int bid = book.getBid();
//判断是否为空
if(bid != 0) {
sql+=" and bid ="+bid;
}
//获取执行对象
PreparedStatement ps = con.prepareStatement(sql);
//获取结果集
ResultSet rs = ps.executeQuery();
//循环遍历结果集
while(rs.next()) {
list.add(new Book(rs.getInt("bid"), rs.getString("bname"), rs.getFloat("price")));
}
return list;
}
//增删改 junit
public static void main(String[] args) throws Exception {
List<Book> list = new BookDao().list(new Book(), null);
for (Book book : list) {
System.out.println(book);
}
}
}
然后我们运行的结果为：
三.反射通用后台查询方法
像我们之前写完一个dao方法测试的时候是不是就是在后面写一个main方法测试，然后如果有很多方法，然后还有注释掉，然后在写，就会很麻烦。
现在我们就有这种方法测试，能更简便测试效果
紧接着就会弹一个出来点ok就好了，然后就会自动创建一个类
我们在把之前在dao方法里面的main方法里面的方法copy过来，我这里就省略了，直接copy的主要加的部分.这里不管你要测试多少方法，然后copy一份testList（）方法即可。
package com.jiangwenjuan.dao;
import java.util.List;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import com.jiangwenjuan.entity.Book;
/**
* junit 能够针对单个方法进行测试
* 相对于main方法而言，测试耦合性降低了
* @author 蒋文娟
*
* @date 2022年6月22日 上午12:35:14
*/
public class BookDaoTest {
@Before
public void setUp() throws Exception {
System.out.println("被测试方法执行之前调用");
}
@After
public void tearDown() throws Exception {
System.out.println("被测试方法执行之后调用");
}
@Test
public void testList() throws Exception {
List<Book> list = new BookDao().list(new Book(), null);
for (Book book : list) {
System.out.println(book);
}
}
@Test
public void testList2() throws Exception {
System.out.println("测试代码2");
}
}
怎么运行呢？
运行出来的结果是一样的：
总结：junit 能够针对单个方法进行测试，相对于main方法而言，测试耦合性降低了
四.怎么去解决dao方法里面重复的代码块
这个是我们最原始的查询方法，会有很多重复代码块
package com.jiangwenjuan.dao;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import com.jiangwenjuan.entity.Book;
import com.jiangwenjuan.util.DBAccess;
import com.jiangwenjuan.util.PageBean;
import com.jiangwenjuan.util.StringUtils;
/**
* 书籍数据库访问层dao
* @author 蒋文娟
*
* @date 2022年6月21日 下午10:41:30
*/
public class BookDao {
public List<Book> list(Book book,PageBean pageBean) throws Exception{
List<Book> list = new ArrayList<Book>();
/*
* 1.拿到数据库连接
* 2.拿到 Preparestatement
* 3.执行SQL语句
*/
//创建连接
Connection con = DBAccess.getConnection();// 重复代码1
//定义sql语句
String sql = "select * from tb_book where 1=1 ";
//假如按照书籍的名字查询
String bname = book.getBname();
//如果说这个书籍不为空，你就是想让书籍查询
if(StringUtils.isNotBlank(bname)) {
sql += " and bname like '%"+bname+"%'";
}
//假设按照id进行查询
int bid = book.getBid();
//判断是否为空
if(bid != 0) {
sql+=" and bid ="+bid;
}
//获取执行对象
PreparedStatement ps = con.prepareStatement(sql);// 重复代码2
//获取结果集
ResultSet rs = ps.executeQuery();// 重复代码3
//循环遍历结果集
while(rs.next()) {
list.add(new Book(rs.getInt("bid"), rs.getString("bname"), rs.getFloat("price")));
}
return list;
}
//增删改 junit
public static void main(String[] args) throws Exception {
List<Book> list = new BookDao().list(new Book(), null);
for (Book book : list) {
System.out.println(book);
}
}
}
我们现在去创建一个类叫BaseDao.java
package com.jiangwenjuan.util;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import com.jiangwenjuan.dao.BookDao;
import com.jiangwenjuan.entity.Book;
/**
* 将来你不知道你要查询那张表，用泛型来代替
* T代表的是实体类，可以是Book/User/Goods...
* @author 蒋文娟
*
* @date 2022年6月22日 上午12:39:32
*/
public class BaseDao<T> {
public List<T> list(String sql,PageBean pageBean,CallBack<T> callBack) throws Exception{
/*
* 1.拿到数据库连接
* 2.拿到 Preparestatement
* 3.执行SQL语句
*/
//创建连接
Connection con = DBAccess.getConnection();// 重复代码1
//获取执行对象
PreparedStatement ps = con.prepareStatement(sql);// 重复代码2
//获取结果集
ResultSet rs = ps.executeQuery();// 重复代码3
//循环遍历结果集
// while(rs.next()) {
// list.add(new Book(rs.getInt("bid"), rs.getString("bname"), rs.getFloat("price")));
// }
//查询不同的表，必然要处理不同的结果集
//接口是调用方来实现
return callBack.foreach(rs);
}
}
我们创建一个接口CallBack.java
回调函数接口类的作用？
谁调用谁处理
package com.jiangwenjuan.util;
import java.sql.ResultSet;
import java.util.List;
/**
*
* @author 蒋文娟
*
* @date 2022年6月22日 上午12:48:34
*/
public interface CallBack<T> {
List<T> foreach(ResultSet rs);
}
解释一下这里的代码块：
我们现在来用一下
BookDao.java代码块：主要是继承了BookDao extends BaseDao<Book>，然后分了S阶段和Y阶段的，主要是Y阶段，返回的是调用executeQuery方法实现CallBack接口
package com.jiangwenjuan.dao;
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.jiangwenjuan.entity.Book;
import com.jiangwenjuan.util.BaseDao;
import com.jiangwenjuan.util.DBAccess;
import com.jiangwenjuan.util.PageBean;
import com.jiangwenjuan.util.StringUtils;
/**
* 书籍数据库访问层dao
* @author 蒋文娟
*
* @date 2022年6月21日 下午10:41:30
*/
public class BookDao extends BaseDao<Book>{
//S阶段
public List<Book> list(Book book,PageBean pageBean) throws Exception{
List<Book> list = new ArrayList<Book>();
/*
* 1.拿到数据库连接
* 2.拿到 Preparestatement
* 3.执行SQL语句
*/
//创建连接
Connection con = DBAccess.getConnection();// 重复代码1
//定义sql语句
String sql = "select * from tb_book where 1=1 ";
//假如按照书籍的名字查询
String bname = book.getBname();
//如果说这个书籍不为空，你就是想让书籍查询
if(StringUtils.isNotBlank(bname)) {
sql += " and bname like '%"+bname+"%'";
}
//假设按照id进行查询
int bid = book.getBid();
//判断是否为空
if(bid != 0) {
sql+=" and bid ="+bid;
}
//获取执行对象
PreparedStatement ps = con.prepareStatement(sql);// 重复代码2
//获取结果集
ResultSet rs = ps.executeQuery();// 重复代码3
//循环遍历结果集
while(rs.next()) {
list.add(new Book(rs.getInt("bid"), rs.getString("bname"), rs.getFloat("price")));
}
return list;
}
//Y阶段第1个版本
public List<Book> list2(Book book,PageBean pageBean) throws Exception{
//定义sql语句
String sql = "select * from tb_book where 1=1 ";
//假如按照书籍的名字查询
String bname = book.getBname();
//如果说这个书籍不为空，你就是想让书籍查询
if(StringUtils.isNotBlank(bname)) {
sql += " and bname like '%"+bname+"%'";
}
//假设按照id进行查询
int bid = book.getBid();
//判断是否为空
if(bid != 0) {
sql+=" and bid ="+bid;
}
//调用的rs的方法返回的是list集合，所以说list集合，返回Book里面的值
return super.executeQuery(sql, null, rs->{
List<Book> list = new ArrayList<>();
try {
while(rs.next()) {
list.add(new Book(rs.getInt("bid"), rs.getString("bname"), rs.getFloat("price")));
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return list;
});
}
//增删改 junit
public static void main(String[] args) throws Exception {
List<Book> list = new BookDao().list(new Book(), null);
for (Book book : list) {
System.out.println(book);
}
}
}
最终我们去junit里面去测试一下
package com.jiangwenjuan.dao;
import java.util.List;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import com.jiangwenjuan.entity.Book;
/**
* junit 能够针对单个方法进行测试
* 相对于main方法而言，测试耦合性降低了
* @author 蒋文娟
*
* @date 2022年6月22日 上午12:35:14
*/
public class BookDaoTest {
@Before
public void setUp() throws Exception {
System.out.println("被测试方法执行之前调用");
}
@After
public void tearDown() throws Exception {
System.out.println("被测试方法执行之后调用");
}
//之前测试的
@Test
public void testList() throws Exception {
List<Book> list = new BookDao().list(new Book(), null);
for (Book book : list) {
System.out.println(book);
}
}
//现在我们去除了重复代码块的的测试
@Test
public void testList2() throws Exception {
List<Book> list = new BookDao().list2(new Book(), null);
for (Book book : list) {
System.out.println(book);
}
}
}
运行结果为：
五.通用的分页后台查询方法
目前是第一版本的，其实还有二个版本
1.按S阶段的方式写了一个查询
发现了问题：①有重复代码②分页参数不清晰
解决方案：①BaseDao②pageBean
2.BaseDao
发现：不同的人调用，处理resultset方式是不一样的
解决方案：通过回调函数解决 CallBack
3.CallBack
这里的回调函数其实用的是23种设计模式中的策略模式
4.通用分页
原始SQL：调用方拼接好的SQL
分页SQL：页面要展示数据的SQL，第N也得数据
符合条件的总记录数SQL：是为了那到总记录数，计算总页面
第一个难理解的：关于S阶段，重复代码有三个,还有一个问题关于分页的参数始终都不知道我该传那些参数，那么现在就已经帮我们封装了PageBean，把所有分页的一些元素都封装到实体类里面去，要分页我不要管到底是用页码啊还是要总记录数啊还是每页展示多少条记录等，我们不需要，我们只要咋变就变就行了，那么处于这总考虑有很多重复代码的考虑，所以说我们就去封装了这个BaseDao<T>,怎么去封装的，先把单个查询粘贴过来，然后在进行改造，整个过程中这三个重复代码肯定是需要的，不要删掉，之类继承父类，所以我把公共部分保留了，对应不同的代码，我查不同的表，是不是肯定有不同的sql语句，所以说我们就单独的在这个父类baseDao《T》里面定义了一个sql的参数,在下面传过来的。
BaseDao《T》里面的返回的是callBack.java为什么是回调函数，被人调用的是不同的数据的，有可能是商品啊，书籍啊，用户啊等等，对于不同的表，谁调用谁处理。我这边查询的书籍，就按照书籍去处理就行了
//创建连接 Connection con = DBAccess.getConnection();// 重复代码1 //获取执行对象 PreparedStatement ps = con.prepareStatement(sql);// 重复代码2 //获取结果集 ResultSet rs = ps.executeQuery();// 重复代码3第二个难理解的：我要分页的话，我已经从调用方，组装好的sql语句进行分页，那么分页的话有两个东西非常重要，第一个对于用户而言我分页可能要展示第一页第二页第三页第四页的数据，那么对应的就要用 limit去查 那么后续话我们还要点下一页，那么一共有多少页我们要查出来，我们必须要得到总记录数，总记录数怎么的，是不是的从原始的SQL转换一个获取总记录的SQL
这个BookDao.java，返回值哪里返回了分页的条件
package com.jiangwenjuan.dao;
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.jiangwenjuan.entity.Book;
import com.jiangwenjuan.util.BaseDao;
import com.jiangwenjuan.util.DBAccess;
import com.jiangwenjuan.util.PageBean;
import com.jiangwenjuan.util.StringUtils;
/**
* 书籍数据库访问层dao
* @author 蒋文娟
*
* @date 2022年6月21日 下午10:41:30
*/
public class BookDao extends BaseDao<Book>{
//S阶段
public List<Book> list(Book book,PageBean pageBean) throws Exception{
List<Book> list = new ArrayList<Book>();
/*
* 1.拿到数据库连接
* 2.拿到 Preparestatement
* 3.执行SQL语句
*/
//创建连接
Connection con = DBAccess.getConnection();// 重复代码1
//定义sql语句
String sql = "select * from tb_book where 1=1 ";
//假如按照书籍的名字查询
String bname = book.getBname();
//如果说这个书籍不为空，你就是想让书籍查询
if(StringUtils.isNotBlank(bname)) {
sql += " and bname like '%"+bname+"%'";
}
//假设按照id进行查询
int bid = book.getBid();
//判断是否为空
if(bid != 0) {
sql+=" and bid ="+bid;
}
//获取执行对象
PreparedStatement ps = con.prepareStatement(sql);// 重复代码2
//获取结果集
ResultSet rs = ps.executeQuery();// 重复代码3
//循环遍历结果集
while(rs.next()) {
list.add(new Book(rs.getInt("bid"), rs.getString("bname"), rs.getFloat("price")));
}
return list;
}
//Y阶段第1个版本
public List<Book> list2(Book book,PageBean pageBean) throws Exception{
//定义sql语句
String sql = "select * from tb_book where 1=1 ";
//假如按照书籍的名字查询
String bname = book.getBname();
//如果说这个书籍不为空，你就是想让书籍查询
if(StringUtils.isNotBlank(bname)) {
sql += " and bname like '%"+bname+"%'";
}
//假设按照id进行查询
int bid = book.getBid();
//判断是否为空
if(bid != 0) {
sql+=" and bid ="+bid;
}
//调用的rs的方法返回的是list集合，所以说list集合，返回Book里面的值
return super.executeQuery(sql, pageBean, rs->{
List<Book> list = new ArrayList<>();
try {
while(rs.next()) {
list.add(new Book(rs.getInt("bid"), rs.getString("bname"), rs.getFloat("price")));
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return list;
});
}
//增删改 junit
public static void main(String[] args) throws Exception {
List<Book> list = new BookDao().list(new Book(), null);
for (Book book : list) {
System.out.println(book);
}
}
}
BaseDao.java 分页的代码块
package com.jiangwenjuan.util;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import com.jiangwenjuan.dao.BookDao;
import com.jiangwenjuan.entity.Book;
/**
* 将来你不知道你要查询那张表，用泛型来代替
* T代表的是实体类，可以是Book/User/Goods...
* @author 蒋文娟
*
* @date 2022年6月22日 上午12:39:32
*/
public class BaseDao<T> {
// public List<T> executeQuery(String sql,PageBean pageBean,CallBack<T> callBack) throws Exception{
// /*
// *1.拿到数据库连接
// *2.拿到Preparestatement
// *3.执行SQL语句
// */
// //创建连接
// Connection con = DBAccess.getConnection();// 重复代码1
// //获取执行对象
// PreparedStatement ps = con.prepareStatement(sql);// 重复代码2
// //获取结果集
// ResultSet rs = ps.executeQuery();// 重复代码3
// //循环遍历结果集
while(rs.next()) {
list.add(new Book(rs.getInt("bid"), rs.getString("bname"), rs.getFloat("price")));
}
// //查询不同的表，必然要处理不同的结果集
// //接口是调用方来实现
// return callBack.foreach(rs);
// }
public List<T> executeQuery(String sql,PageBean pageBean,CallBack<T> callBack) throws Exception{
// select * from tb_book where bname like '%o%';
//这个查询不行，因为跟上面代码查询组装不起来
// select count(*) from tb_book where bname like '%o%'
//所以说为什么要这么变，因为不仅仅考虑写出来简单，你还要发现转变的问题
// String countsql="select count(1) as n from ("+sql+") t";
//但这个可以组装
//从上面得到select count(1) as n from (select * from tb_book where bname like '%o%') t;
//目的是为了得到总记录数-->得到总页数
// select * from tb_book where bname like '%o%' limit 10,10;
/*
*1.拿到数据库连接
*2.拿到Preparestatement
*3.执行SQL语句
*/
//创建连接
Connection con = null;// 重复代码1
//获取执行对象
PreparedStatement ps = null;// 重复代码2
//获取结果集
ResultSet rs = null;// 重复代码3
//判断是否分页 并且判断是否为true
if(pageBean != null && pageBean.isPagination()) {//说明要分页
//拿到总记录数 拼接原始的mysql
String countSQL = getcountSQL(sql);
con = DBAccess.getConnection();// 重复代码1
ps = con.prepareStatement(countSQL);// 重复代码2
rs= ps.executeQuery();// 重复代码3
//查询出来的总行数是不是单行单列啊，所以说不需要while,判断即可
if(rs.next()) {
//把我们查询出来的总记录数放在pageBean里面，pageBean它是包含了所有的分页的一些元素的实体类
//当前实体类就包含了总记录数
pageBean.setTotal(rs.getString("n"));
}
//拼接
String pageSQL = pagePageSQL(sql,pageBean);
con = DBAccess.getConnection();// 重复代码1
ps = con.prepareStatement(pageSQL);// 重复代码2
rs= ps.executeQuery();// 重复代码3
}
else {
con = DBAccess.getConnection();// 重复代码1
ps = con.prepareStatement(sql);// 重复代码2
rs= ps.executeQuery();// 重复代码3
}
return callBack.foreach(rs);
}
/**
* 拼装第N页的数据的SQL
* @param sql
* @param pageBean
* @return
*/
private String pagePageSQL(String sql, PageBean pageBean) {
//这里相当于limit 1,10
return sql+" limit "+pageBean.getStartIndex()+","+pageBean.getRows();
}
/**
* 拼装符合条件总记录数的SQL
* @param sql
* @return
*/
private String getcountSQL(String sql) {
// select * from tb_book where bname like '%o%';
//这个查询不行，因为跟上面代码查询组装不起来
// select count(*) from tb_book where bname like '%o%'
//所以说为什么要这么变，因为不仅仅考虑写出来简单，你还要发现转变的问题
// String countsql="select count(1) as n from ("+sql+") t";
//下面这行代码就解决了上面的问题，由原始SQL换成查询总行数的SQL
//为什么不是*因为*代表的所以列，而写1代表的是一列，哪个性能更好，肯定是1
return "select count(1) as n from ("+sql+") t";
}
}
PageBean.java
package com.jiangwenjuan.util;
/**
* 分页工具类
* @author 蒋文娟
*
* @date 2022年6月21日 下午8:15:46
*/
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 + "]";
}
}
BookDaoText.java测试方法针对单个方法进行测试
package com.jiangwenjuan.dao;
import java.util.List;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import com.jiangwenjuan.entity.Book;
import com.jiangwenjuan.util.PageBean;
/**
* junit 能够针对单个方法进行测试
* 相对于main方法而言，测试耦合性降低了
* @author 蒋文娟
*
* @date 2022年6月22日 上午12:35:14
*/
public class BookDaoTest {
@Before
public void setUp() throws Exception {
System.out.println("被测试方法执行之前调用");
}
@After
public void tearDown() throws Exception {
System.out.println("被测试方法执行之后调用");
}
@Test
public void testList() throws Exception {
List<Book> list = new BookDao().list(new Book(), null);
for (Book book : list) {
System.out.println(book);
}
}
@Test
public void testList2() throws Exception {
List<Book> list = new BookDao().list2(new Book(), null);
for (Book book : list) {
System.out.println(book);
}
}
@Test
public void testList3() throws Exception {
Book b = new Book();
//如果说只想查询关于一个的o
b.setBname("o");
PageBean pageBean = new PageBean();
//如果想要查询第二的数据
pageBean.setPage(1);
//如果我一页不想显示10条想显示20
pageBean.setRows(20);
List<Book> list = new BookDao().list2(b, pageBean);
for (Book book : list) {
System.out.println(book);
}
}
}
分页的所用的类：
记得导入jia包：
扫一扫
101
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
