通用查询与分页

于 2021-08-29 22:38:28 发布
阅读量177 收藏 1
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxy15974062965/article/details/119973780
版权

 所需类与架构包

 

后端 ：

1、首先介绍一些助手类

数据库帮助类——DBAccess

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

 对于tld文件

注🐖：需要加载驱动包，驱动包根据MySQL的版本不同而不同

                mysql5.7——com.mysql.jdbc.Driver
                mysql8——com.mysql.cj.jdbc.Driver

#oracle9i
#driver=oracle.jdbc.driver.OracleDriver
#url=jdbc:oracle:thin:@localhost:1521:ora9
#user=test
#pwd=test


#sql2005
#driver=com.microsoft.sqlserver.jdbc.SQLServerDriver
#url=jdbc:sqlserver://localhost:1423;DatabaseName=test
#user=sa
#pwd=sa


#sql2000
#driver=com.microsoft.jdbc.sqlserver.SQLServerDriver
#url=jdbc:microsoft:sqlserver://localhost:1433;databaseName=unit6DB
#user=sa
#pwd=888888


#mysql8
driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/mybatis_ssm?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT&useSSL=true
user=root
pwd=123456

 EncodingFiter—编码过滤类

package com.zxy.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.annotation.WebFilter;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 中文乱码处理
 * 
 */
@WebFilter("/book/*")
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();
		}
	}

}

 二.简单的查询功能

1.编码思路 ：

①建立数据库连接

②定义预定义对象preparestatement

③.查询结果集

④返回结果集

2.不足之处：①数据库连接   定义预定义对象 查询结果集 都是重复代码
              ②都是要返回数据库表对应的集合
             ③都是要处理结果集 
3.代码不一样在于：①具体体现在 不同表有不同的字段，那么实体类对应的属性就会不一样
                               ②  需要写大量的重复代码，系统的查询功能越多重复代码量越大

4. 解决方案：①:抽取变化部分作为参数

                      ②抽取公共的父类，把重复性的代码抽出来

 展示：类为BaseDao<T>是所有dao类的父类

package com.zxy.dao;

import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

import com.zxy.entity.Book;
import com.zxy.util.DBAccess;
import com.zxy.util.PageBean;
import com.zxy.util.StringUtils;
/**
 * 所有dao层的父类
 * @author zjjt
 *
 * @param <T>
 */
	public List<T> list(String sql,Class<T> clz) throws Exception{
		List<T> list=new ArrayList<T>();
		//不确定list集合装了什么东西
		
		Connection con=DBAccess.getConnection();
		PreparedStatement ps = con.prepareStatement(sql);
		ResultSet rs = ps.executeQuery();
		while(rs.next()) {
			//1实例化了一个对象 2从ResultSet的对象的属性(bid)获取值赋值给了前面赋值的实例化对象
			//books.add(new Book(rs.getInt("bid"),rs.getString("bname"), rs.getFloat("price"))); 
		T t=clz.newInstance();
		Field[] fields = clz.getDeclaredFields();
		for (Field f : fields) {
			//打开权限
			f.setAccessible(true);
			f.set(t,rs.getObject(f.getName()));
		
		}
		//3把已经赋值了的对象添加到list集合中
		list.add(t);
		}
		return list;
}
}

 bookDao：

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

public class bookDao extends BaseDao<Book>{
	/**
	 * 简单的查询
	 * 思路 ：1建立数据库连接
	 * 2定义预定义对象preparestatement
	 * 3查询结果集
	 * 4返回结果集
	 * 不足之处：1数据库连接   定义预定义对象 查询结果集 都是重复代码
	 *          2都是要返回数据库表对应的集合
	 *          3都是要处理结果集 
	 * 代码不一样在于：具体体现在 不同表有不同的字段，那么实体类对应的属性就会不一样
	 * 
	 * 需要写大量的重复代码，系统的查询功能越多重复代码量越大
	 * 解决：
	 *  1抽取变化部分作为参数
	 *  sql，Class对象（Book，Article）
	 *  2.抽取公共的父类：把重复性代码剥离出来啊
	 * 
	 * @throws Exception 
	 */
普通方法 没有继承父类
	public List<Book> list(Book book) throws Exception{
		List<Book> books=new ArrayList<Book>();
		String sql="select * from t_mvc_book where 1=1 ";
		//书籍名称
		String bname = book.getBname();
		//书籍名称模糊查询  圣墟最终是通过jsp页面传递过来的
		if(StringUtils.isNotBlank(bname)) {
			sql+=" and bname like '%"+bname+"%'";
		}
		Connection con=DBAccess.getConnection();
		PreparedStatement ps = con.prepareStatement(sql);
		ResultSet rs = ps.executeQuery();
		while(rs.next()) {
			books.add(new Book(rs.getInt("bid"),rs.getString("bname"), rs.getFloat("price"))); 
		}
		return books;
	}
	
	继承了父类的方法   代码明显要少，
	public List<Book> list1(Book book) throws Exception{
		String sql="select * from t_mvc_book where 1=1";
		String bname = book.getBname();
		//书籍名称模糊查询  圣墟最终是通过jsp页面传递过来的
		if(StringUtils.isNotBlank(bname)) {
			sql+=" and bname like '%"+bname+"%'";
		}
		return super.list(sql, Book.class);
	}
	
	测试
	public static void main(String[] args) throws Exception {
		bookDao bo=new bookDao();
		Book book=new Book();
		book.setBname("圣墟");
	List<Book> list=bo.list(book);
	for (Book book2 : list) {
		System.out.println(book2);
	}
}
}

三.通用前台分页

1.目标：利用<z:page><z:page>标签，无需写任何js，html代码就可以完成分页

PageBean

①、 page=1        页码        视图层传递过来

②、rows=10         页大小      视图层传递过来

③、total=0       总记录数    后台查出来

④、pagination=true  是否分页    视图层传递过来

package com.zxy.util;

import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

/**
 * 分页工具类
 *
 */
public class PageBean {

	private int page = 1;// 页码

	private int rows = 10;// 页大小

	private int total = 0;// 总记录数

	private boolean pagination = true;// 是否分页
	
	private String url;//保存上一次请求的url
	
	private Map<String, String[]> paraMap=new HashMap<>();//保存上一次请求的参数
/**
 * 初始化pagebean的，保存上一次的重要的参数
 * @param req
 */
	public void setRequest(HttpServletRequest req) {
		//①.需要保存上一次请求的URL
		this.setUrl(req.getRequestURI().toString());
		// ②.需要保存上一次请求的参数 如bname price
		this.setParaMap(req.getParameterMap());
		 //   ③.需要保存上一次请求的分页设置 pagination
		this.setPagination(req.getParameter("pagination"));
		  //  ④.需要保存上一次请求的展示条目数
		this.setRows(req.getParameter("rows"));
		  //  ⑤.初始化请求的页码page
		this.setPage(req.getParameter("page"));
	}
	
	private void setPage(String page) {
	// TODO Auto-generated method stub
	if(StringUtils.isNotBlank(page)) {
		this.setPage(Integer.valueOf(page));
	}
}

	private void setRows(String rows) {
	// TODO Auto-generated method stub
		if(StringUtils.isNotBlank(rows)) {
			this.setRows(Integer.valueOf(rows));
		}
	
}

	public void setPagination(String pagination) {
	//只有在前台jsp填写pagination=false，才代表不分页
	if(StringUtils.isNotBlank(pagination)) {
		this.setPagination(!"false".equals(pagination));
	}
}

	public String getUrl() {
	return url;
}

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

public Map<String, String[]> getParaMap() {
	return paraMap;
}

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

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

	/**
	 * 获得最大页
	 */
	public int maxPage() {
		return this.total % this.rows == 0 ? this.total / this.rows : this.total / this.rows + 1;
	}
	/**
	 * 获得下一页
	 * @return
	 */
	public int nextPage() {
		//如果当前页小于最大页，那么下一页+1，如果不小于，说明当前页数是最大页，那么无需+1
		return this.page < this.maxPage() ? this.page + 1 : this.page;
	}
	/**
	 * 获得上一页
	 * @return
	 */
	public int previousPage() {
		return this.page > 1 ? this.page - 1 : this.page;
	}
	@Override
	public String toString() {
		return "PageBean [page=" + page + ", rows=" + rows + ", total=" + total + ", pagination=" + pagination + "]";
	}

}

  2.自定义page标签：定义pagebean 因为pagebean中包含了分页的所有属性（page，rows，        pagination，total，nextpage，previousPage，maxpage

package com.zxy.tag;

import java.io.IOException;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.tagext.BodyTagSupport;

import com.zxy.util.PageBean;

public class PageTag extends BodyTagSupport {
	private PageBean  pageBean;//所有分页相关的元素
	
	public PageBean getPageBean() {
		return pageBean;
	}

	public void setPageBean(PageBean pageBean) {
		this.pageBean = pageBean;
	}

	@Override
	public int doStartTag() throws JspException {
		// 没有标签体，要输出内容
		JspWriter out = pageContext.getOut();
		try {
			out.print(toHTML());
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return super.doStartTag();
	}

	private String toHTML() {
		StringBuffer s=new StringBuffer();
		// 1.隐藏的form表单 这个就是上一次请求下一次重新发的意义所在
		//上一次请求的url
		s.append("<form action='"+pageBean.getUrl()+"' id='pageBeanForm' method='post'>");
		s.append(" <input type='hidden' name='page'>");
		//上一次请求的参数
		Map<String, String[]> paraMap = pageBean.getParaMap();
		if(paraMap !=null&&paraMap.size()>0) {
			Set<Entry<String, String[]>> entrySet = paraMap.entrySet();
			for (Entry<String, String[]> entry : entrySet) {
				//参数名
				String key = entry.getKey();
				//参数值
				
				for (String value : entry.getValue()) {
					//上一次请求的参数，再一次组装成新的form表单
					//注意：page参数每次都会提交，我们需要避免
					if(!"page".equals(key)) {
					s.append(" <input type='hidden' name='"+key+"' value='"+value+"'>");
					}
					}
			}
		}
		s.append("</form>");
		
		
		
		
		
		//分页条
		s.append("<ul class='pagination justify-content-center'>");
		s.append(" <li class='page-item "+(pageBean.getPage()==1?"disabled":"")+"'><a class='page-link'");
		s.append(" href='javascript:gotoPage(1)'>首页</a></li>");
		s.append(" <li class='page-item "+(pageBean.getPage()==1?"disabled":"")+"'><a class='page-link'");
		s.append(" href='javascript:gotoPage("+pageBean.previousPage()+")'>&lt;</a></li>");
//		s.append(" <li class='page-item'><a class='page-link' href='#'>1</a></li>");
//		s.append(" <li class='page-item'><a class='page-link' href='#'>2</a></li>");
		s.append(" <li class='page-item active'><a class='page-link' href='#'>"+pageBean.getPage()+"</a></li>");
		s.append(" <li class='page-item "+(pageBean.getPage()==pageBean.maxPage()?"disabled":"")+"'><a class='page-link' href='javascript:gotoPage("+pageBean.nextPage()+")'>&gt;</a></li>");
		s.append(" <li class='page-item "+(pageBean.getPage()==pageBean.maxPage()?"disabled":"")+"'><a class='page-link' href='javascript:gotoPage("+pageBean.maxPage()+")'>尾页</a></li>");
		s.append(" <li class='page-item go-input'><b>到第</b><input class='page-link'");
		s.append(" type='text' id='skipPage' name='' /><b>页</b></li>");
		s.append(" <li class='page-item go'><a class='page-link'");
		s.append(" href='javascript:skipPage()'>确定</a></li>");
		s.append(" <li class='page-item'><b>共"+pageBean.getTotal()+"条</b></li>");
		s.append("</ul>");

		//分页执行的jsp代码
		s.append("<script type='text/javascript'>");
		s.append(" function gotoPage(page) {");
		s.append(" 	document.getElementById('pageBeanForm').page.value = page;");
		s.append(" 	document.getElementById('pageBeanForm').submit();");
		s.append(" }");
		s.append(" function skipPage() {");
		s.append(" 	var page = document.getElementById('skipPage').value;");
		s.append(" 	if (!page || isNaN(page) || parseInt(page) < 1 || parseInt(page) > "+pageBean.maxPage()+") {");
		s.append(" 		alert('请输入1~"+pageBean.maxPage()+"的数字');");
		s.append(" 		return;");
		s.append(" 	}");
		s.append(" 	gotoPage(page);");
		s.append(" }");
		s.append(" </script>");
		return s.toString();
	}

}

 3.标签库描述文件

<?xml version="1.0" encoding="UTF-8" ?>

<taglib xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
    version="2.0">
    
    
  <description>zking 1.1 core library</description>
  <display-name>zking core</display-name>
  <tlib-version>1.1</tlib-version>
  <short-name>zking</short-name>
  <uri>http://jsp.veryedu.cn</uri>

<tag>
  
    <name>Page</name>
    <tag-class>com.zxy.tag.PageTag</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <name>pageBean</name>
        <required>true</required>
        <!--是否支持EL表达式  -->
        <rtexprvalue>true</rtexprvalue>
    </attribute>
  </tag>

</taglib>

 四 .通用后台分页

1.该思考的问题：在项目中会大量的出现分页的需求（如：订单列表 商品列表 学生列表）

2.目标：①想要做一个通用的分页查询，子类去继承父类，自带了分页功能并且代码量极少

               ②最终当分页的需求时，只要写少量代码

3.编码思路：①原来list集合中返回的是符合条件的所有数据，现在我需要返回第page页的数据，                                那么意味着sql要加工
                   ②需要分页那么要求符合条件的总记录数 保存到pagebean中，那么意味着sql加工成                        countsql

示例BaseDao：

package com.zxy.dao;

import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

import com.zxy.entity.Book;
import com.zxy.util.DBAccess;
import com.zxy.util.PageBean;
import com.zxy.util.StringUtils;
/**
 * 所有dao层的父类
 * @author zjjt
 *
 * @param <T>
 */
public class BaseDao<T> {
	/*1抽取变化部分作为参数
	 *  sql，Class对象（Book，Article）
	 *  2.抽取公共的父类：把重复性代码剥离出来啊
	 * s
	 * @throws Exception 
	 */

	/**
	 * 通用分页查询
	 * @param sql
	 * @param clz
	 * @return
	 * @throws Exception
	 */
	public List<T> FQuery(String sql,Class<T> clz,PageBean pageBean) throws Exception{
		List<T> list=new ArrayList<T>();
		
		Connection con=DBAccess.getConnection();
		PreparedStatement ps =null;
		ResultSet rs =null;
		//是否需要分页？
		//无需分页的（如：项目中的下拉框，查询条件教员下拉框，无需分页）
		//必须分页（如：项目中列表类需求，订单列表，商品列表，学生列表）
		if(pageBean!=null&&pageBean.isPagination()) {
			//必须分页（列表需求）
			
			 String countSql=getCountSql(sql);
			 ps = con.prepareStatement(countSql);// 
			 rs = ps.executeQuery();
			 if(rs.next()) {
			 pageBean.setTotal(String.valueOf(rs.getObject(1)));
			 }
			 
			 String pageSql=getPageSql(sql,pageBean);
			 ps = con.prepareStatement(pageSql);//符合条件的某一页数据
			 rs = ps.executeQuery();
		}else {
			//不分页（select需求）
			con=DBAccess.getConnection();
			 ps = con.prepareStatement(sql);//符合条件的所有数据
			 rs = ps.executeQuery();
		}
		while(rs.next()) {
		T t=clz.newInstance();
		Field[] fields = clz.getDeclaredFields();
		for (Field f : fields) {
			//打开权限
			f.setAccessible(true);
			f.set(t,rs.getObject(f.getName()));
		
		}
		//3把已经赋值了的对象添加到list集合中
		list.add(t);
		}
		return list;
	}
/**
 * 将原生sql转换成符合条件的总记录数countsql
 * @param sql
 * @return
 */
	private String getCountSql(String sql) {
		// TODO Auto-generated method stub
		return "select count(1) from ("+sql+") t ";
	}
/**
 * 将原生sql转换成pagesql
 * @param sql
 * @param pageBean
 * @return
 */
	private String getPageSql(String sql,PageBean pageBean) {
		// TODO Auto-generated method stub

		return sql+" limit "+pageBean.getStartIndex()+","+pageBean.getRows();
	}

	


}

bookDao:

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

public class bookDao extends BaseDao<Book>{
/**
	 * 思考：
	 * 在项目中大量的出现分页的需求（如：订单列表 商品列表 学生列表）
	 * 目标：想要做一个通用的分页查询 子类去继承父类，自带分页功能
	 *     并且代码量极少 最终当碰到分页的时候只要写少量代码就可以实现
	 *     （n-1）*rows，rows
	 *     mysql 分页是通过limit关键字，分页数据库sql格式：select * from 表名 limit 起始下标，展现数目
	 * 1.mysql分页
	 * 分页通常有关键的因数：第几页（page） 显示数目（rows），符合查询条件的总记录数（total）
	 * sql=select * from t_mvc_book where bname like '%圣墟%'
	 * pagesql=select * from t_mvc_book where bname like '%圣墟%' limit 0,10  (limit（n-1）*rows，rows)
	 * countsql=select count(1) from t_mvc_book where bname like '%圣墟%'
	 * 共几页的算法：total%rows==0？total/rows:total/rows+1
	 * 2.编码思路
	 *   ①原来list集合中返回的是符合条件的所有数据，现在我需要返回第page页的数据，那么意味着sql要加工
	 *   ②需要分页那么要求符合条件的总记录数 保存到pagebean中，那么意味着sql加工成countsql
	 * @param args
	 * @throws Exception
	 */

	/**
	 * 通用查询分页
	 * 继承了父类的方法，代码明显要少
	 * @param book
	 * @return
	 * @throws Exception
	 */
	public List<Book> list2(Book book,PageBean pageBean) throws Exception{
		String sql="select * from t_mvc_book where 1=1";
		String bname = book.getBname();
		//书籍名称模糊查询  圣墟最终是通过jsp页面传递过来的
		if(StringUtils.isNotBlank(bname)) {
			sql+=" and bname like '%"+bname+"%'";
		}
		return super.FQuery(sql,Book.class, pageBean);
	}
	
	//测试
	public static void main(String[] args) throws Exception {
		bookDao bo=new bookDao();
		Book book=new Book();
		book.setBname("圣墟");
	//List<Book> list=bo.list(book);
		PageBean pageBean=new PageBean();
		//不分页
	//	 pageBean.setPagination(false);
		List<Book> list=bo.list2(book, pageBean);
	for (Book book2 : list) {
		System.out.println(book2);
	}
}
}

 4.①全部最终运行结果（每一页10条数据，可点击下一页，末页，跳转页数，）

 ②这是查询书名为圣墟的数据（共85条数据）

 ③这是查询书名为不死不灭的数据（共11081条数据） 

 

 see you~

小滦不秃头‍♂️
关注
通用查询分页
m0_60385807的博客
08-26 267
思维导图 一、后端 加载驱动（驱动包由MySQL版本决定） mysql5.7--com.mysql.jdbc.Driver mysql8--com.mysql.cj.jdbc.Driver 工具类（可以匹配多个数据源） 一（1）简单查询 1.1步骤 1、建立数据库连接 2、预定义对象prepareStartement 3、执行查询sql 4、处理结果集 代码： public List<Book> list(Book book...
通用查询&分页代码
qq_63492318的博客
06-22 994
学会编写通用分页、通用后台代码，减少代码量！
通用分页宇通用查询
A2895922320的博客
08-25 144
思维导图 一：通用查询 第一步:连接数据库 package com.sg.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;...
分页查询的通用方法
weixin_45253713的博客
06-07 1167
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数..
一个通用分页查询方法
NiluChen的专栏
09-24 1843
/** * HQL分页查询,可以指定具体的模式, * 采用getCount方式,须在此层完成hsql的转换与查询。 * 注意参数Object...args的应用,可以在查询的设置查询条件用的(JDK5.0语法) */ public Page pagedQuery(String hql, int pageNo, int pageSize, Object... args) {
实现查询与分页
weixin_33845881的博客
09-17 122
2019独角兽企业重金招聘Python工程师标准>>> ...
防SQL注入 生成参数化的通用分页查询语句
01-01
但问题就出在这种通用分页存储过程是在存储过程内部进行SQL语句拼接，根本无法修改为参数化的查询语句，因此这种通用分页存储过程是不可取的。但是如果不用通用的分页存储过程，则意味着必须为每个具体的分页查询写...
SQL Server 分页查询通用存储过程(只做分页查询用)
01-19
这段存储过程的的原创者（SORRY，忘记名字了），写得这段SQL代码很不错，我在这个基础上，按照我的习惯以及思维方式，调整了代码，只做分页查询用。 /*---------------------------------------------- *procedure ...
JSP实现带查询条件的通用分页组件
10-16
【JSP实现带查询条件的通用分页组件】 在Web应用开发中，分页功能是不可或缺的一部分，尤其是在处理大量数据的展示时。JSP（JavaServer Pages）是一种动态网页技术，能够结合Java代码来生成HTML页面。本篇将详细...
使用SQL语句实现通用分页查询
10-14
使用SQL语句实现通用分页查询，支持模糊查询等。
分页查询
lx127372的博客
07-28 357
分页查询是Java Web开发中常用的技术，在数据库量非常大的情况下，不适合将所有的数据都显示到一个页面中，此时就要对数据进行分页查询。 MySQL数据库里面提供的分页机制limit关键字 limit arg1,arg2 参数说明： arg1用于指定查询记录的起始位置 arg2用于指定查询数据所返回的记录数 例：通过MySQL数据库提供的分页机制，实现分页查询功能，将分页数据显示在JS...
通用分页查询
文忠专栏
09-15 1710
要实现通用的分页查询要实现两个JavaBean 第一个是封装客户机带过来的分页请求信息 第二个是封装客户机要显示的分页信息 JavaBean的代码如下： package cn.test.domain; //封装客户机带过来的分页请求信息 public class
一个通用的分页查询语句
ancui2761的博客
04-15 84
今天没事翻翻书，看到这条查询语句，感觉思路简单，用起来也方便，就记下了，哈哈，虽然在业务层里或者数据层中实现分页也都可行，还是拿sql方便点 1selecttoppagesize*2from表3where条件andidnotin4(selecttoppagesize*(currentpageindex-1)id5from表6where条件ord...
通用查询、分页详解
隔壁的博客
08-27 346
J2EE 一、思维导图 二、后端 1、首先介绍一些助手类 DBHelper—数据库帮助类 package com.util.zwf; 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.
通用分页
qq_41227463的博客
05-25 170
通用分页学习总结
分页列表查询通用类
Mybatis框架
07-30 375
@Data public class PageResult <T> { private Integer totalPage; private Integer totalSize; private Integer pageSize; private Integer currentPage; private Integer offset; p...
通用分页完整版及通用模糊查询
m0_46699799的博客
06-05 351
通用分页+模糊查询最后效果概念及目的大概步骤具体代码实现总结 最后效果 （这个颜色别吐槽，吐槽就是你对） 概念及目的 目的： 基于bootatrap，考虑到通用的问题完成书籍的分页，查询。 概念： 举个例子—— 一个玩具表要做分页查询需要连接数据库-写sql语句-获取执行对象-得到结果集-返回结果集； 而一个书籍表要做分页查询也是差不多的步骤只不过sql语句不一样，返回的类型不一样，和获得结果集时不一样罢了。 那么分页的概念就是将每个表分页时都具有的共性代码写一个BaseDao完成所有的类似的查询需求。
Wicket1.4开发实例：通用查询与分页应用
标题："原创 Wicket开发手记（二）：通用范例与Filter集成" 在这个Wicket 1.4开发手记第二部分中，作者Steel.Ma分享了一个详尽的通用应用开发实例，旨在帮助读者快速掌握Wicket框架进行Web应用程序开发。该应用的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值