package com.google.util;
import java.util.ArrayList;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
/**
* 定义一个处理分页查询的类
* @author Administrator
*
*/
public class PageObject {
private int totalRecord = 0;//总记录数
private int pageSize = 10;//一页显示的条数
private int currentPage = 1;//当前页
private int totalPage = 1;//总页数
private String hql; //执行查询的语句
private ArrayList params; //hql参数
private List result; //返回结果集
//创建构造器
public PageObject(){
}
/**
* 固定类的分页 from ClassPO
* @param hql 查询语句
* @param param 查询参数
* @param pageSize 每页的条数
* @param currentPage 当前页
*/
public PageObject(String hql, ArrayList params, int pageSize, int currentPage){
if(currentPage <=0 ){
this.currentPage = 1;
}else{
this.currentPage = currentPage;
}
if(pageSize <= 0){
this.pageSize = 10;
}else{
this.pageSize = pageSize;
}
this.hql = hql;
this.params = params;
getCount();
result();
}
public int getTotalRecord() {
return totalRecord;
}
public int getPageSize() {
return pageSize;
}
public int getCurrentPage() {
return currentPage;
}
public int getTotalPage() {
return totalPage;
}
public ArrayList getParams() {
return params;
}
public void setParams(ArrayList params) {
this.params = params;
}
public List getResult() {
return result;
}
public void setResult(List result) {
this.result = result;
}
/**
* 获取条数信息
*/
public void getCount(){
Session session = null;
List list = null;
try {
session = HibernateUtil.openSession();
if(session == null){
System.out.println("--------------------------");
}
String str = new String();
str = "select count(*) ";
//判断hql是不是select or SELECT开始的
if(hql.toLowerCase().trim().indexOf("select") == 0){
//如果是select 语句开始的，则在str中添加select count(*) from( hql )
//获取from开始的字串
str += hql.substring(hql.toLowerCase().indexOf("from"));
System.out.println("是select 开始的hql "+ str);
}else{
//如果是一个PO from CPO,则只是添加select count(*) 即可
str += hql;
System.out.println("不是select 开始的hql "+ str);
}
System.out.println("====================="+str);
Query query = session.createQuery(str);
query = addParams(query, params);
//设置总记录数
totalRecord = Integer.parseInt(query.uniqueResult().toString());
// this.setTotalRecord(Integer.parseInt(query.uniqueResult().toString()));
//设置总页数
totalPage = (totalRecord-1)/pageSize+1;
// this.setTotalPage((totalRecord-1)/pageSize+1);
} catch (Exception e) {
throw new RuntimeException("设置页面信息："+e.getMessage());
}finally{
if(session != null && session.isOpen()){
session.close();
}
}
}
//执行查询
public void result(){
Session session = null;
Transaction tx = null;
List list = null;
try {
session = HibernateUtil.getCurrentSession();
tx = session.beginTransaction();
System.out.println(this.hql);
Query query = session.createQuery(this.hql);
String str = "select count(*) from (";
str += this.hql;
str += ")";
query = addParams(query, params);
list = query.setFirstResult((currentPage-1)*pageSize).setMaxResults(pageSize).list();
this.setResult(list);
tx.commit();
} catch (Exception e) {
if(tx!=null){
tx.rollback();
}
e.printStackTrace();
throw new RuntimeException("----"+e.getMessage());
}finally{
if(session != null && session.isOpen()){
session.close();
}
}
}
public Query addParams(Query query, ArrayList params){
//添加参数到hql
if(params!=null && params.size() >0){
for(int i=0; i < params.size(); i++){
query.setParameter(i, params.get(i));
}
}
return query;
}
}
//附带HibernateUtil.java
package com.google.util;
//import org.hibernate.Session;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
final public class HibernateUtil {
private static SessionFactory sessionFactory = null;
private static ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();
public HibernateUtil(){
}
static{
sessionFactory = new Configuration().configure().buildSessionFactory();
}
//获取全新的session
public static Session openSession(){
return sessionFactory.openSession();
}
//获取和线程关联的session
public static Session getCurrentSession(){
Session session = threadLocal.get();
//判断是否得到
//add by yyy || !session.isOpen()
if(session == null || !session.isOpen()){
session = sessionFactory.openSession();
//session对象设置到threadLocal -- 相当于session和线程绑定
threadLocal.set(session);
}
return session;
}
/**
* 查询方法
*/
public static List executeQuery1(String hql, String[] parameters){
Session session = null;
List list = null;
try {
session = openSession();
Query query = session.createQuery(hql);
if(parameters != null && parameters.length > 0){
for(int i=0; i< parameters.length; i++){
query.setParameter(i, parameters[i]);
}
}
list = query.list();
} catch (Exception e) {
e.getStackTrace();
throw new RuntimeException(e.getMessage());
}finally{
if(session != null && session.isOpen()){
session.close();
}
}
return list;
}
/**
* 同意的查询方法：参数使用ArrayList
*/
public static List executeQuery(String hql, ArrayList al){
Session session = null;
List list = null;
try {
session = openSession();
Query query = session.createQuery(hql);
//注入参数
if(al!=null && al.size() > 0){
for(int i=0; i < al.size(); i++){
query.setParameter(i, al.get(i));
}
System.out.println(al.toString());
}
//执行查询
list = query.list();
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("Util executeQuery"+e.getMessage());
}finally{
if(session != null && session.isOpen()){
session.close();
}
}
return list;
}
/**
* 同意的分页查询方法 没有确定的PO
*/
public static Map executeQueryByPage(String hql, ArrayList parameter, int pageSize, int currentPage){
Session session = null;
int pageCount = 1;//总页数
int totalCount = 0;//总记录数
//pageSize一页显示的条数
//currentPage 当前页
List<Object[]> result = null;
HashMap map = new HashMap();
try {
session = openSession();
Query query = session.createQuery(hql);
if(parameter != null && parameter.size() > 0){
for(int i=0; i< parameter.size(); i++){
query.setParameter(i, parameter.get(i));
}
}
//获取总记录数
totalCount = query.list().size();
System.out.println(totalCount);
//计算总页数
if(totalCount >=1){
pageCount = (totalCount-1)/pageSize+1;
}
//先测试分页情况
/* for(int i=1; i<=pageCount; i++){
// System.out.println("------------第"+i+"页----------------");
result = query.setFirstResult((i-1)*pageSize).setMaxResults(i*pageSize).list();
}*/
/*if(result.size()>0){
for(int k = 0; k < result.size(); k++){
Object[] obj = result.get(k);
for(int j=0; j< obj.length; j++){
System.out.print(obj[j].toString()+" ");
}
System.out.println();
}
}*/
result = query.setFirstResult((currentPage-1)*pageSize).setMaxResults(pageSize).list();
map.put("TOTAL_COUNT", totalCount);
map.put("RESULT", result);
map.put("PAGE_COUNT", pageCount);
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
return map;
}
}
分享到：
相关推荐
Hibernate分页查询小结
### Hibernate 分页查询原理详解 #### 一、引言 在大数据量处理场景下，分页查询是提高数据检索效率的重要手段之一。Hibernate作为Java领域内最常用的持久层框架之一，其内置的分页功能非常实用且高效。本文将深入...
本篇将深入探讨Hibernate中的分页查询功能以及它如何处理数据库连接，帮助你更有效地管理大数据量的查询操作。 首先，我们来看一下什么是分页查询。在Web应用中，当用户需要浏览大量数据时，一次性加载所有数据不仅...
Hibernate，作为一个流行的Java对象关系映射（ORM）框架，为开发者提供了便捷的分页查询功能。让我们深入探讨Hibernate分页查询的相关知识点。 一、Hibernate分页原理 Hibernate分页查询基于SQL的LIMIT和OFFSET子句...
以下是如何使用Hibernate进行分页查询的详细说明： 1. **配置Hibernate分页**： 在Hibernate中，我们通常使用`Criteria`或`Query` API进行分页查询。`Criteria`提供了一种更面向对象的方式来执行SQL查询，而`Query...
本示例中，我们看到如何利用Struts2、Spring和Hibernate这三个流行框架来实现分页查询功能。下面我们将详细讲解这个实现过程。 1. **UserDao接口**： UserDao接口定义了分页查询的方法，通过`getUser(int offset, ...
在这个类中，我们可以通过编写Hibernate HQL或SQL查询语句来实现分页查询。 4. **Struts2 Action** 在Action类中，我们需要处理来自用户的请求参数，如当前页码和每页显示记录数等，并调用DAO中的分页查询方法获取...
在分页查询中，Hibernate提供了一种称为HQL（Hibernate Query Language）的SQL方言，可以方便地实现复杂的查询，包括分页查询。此外，Hibernate还支持Criteria查询，这是一种更加面向对象的查询方式，同样可以实现...
本篇主要围绕"Hibernate分页查询效果"这一主题，深入探讨如何利用Hibernate框架实现高效、便捷的分页功能。 首先，Hibernate是一个优秀的Java持久化框架，它提供了ORM（对象关系映射）解决方案，使得开发者可以使用...
接下来，我们讨论分页查询。在处理大量数据时，一次性加载所有结果可能会导致性能问题。因此，通常会采用分页的方式来获取数据。在Hibernate中，我们可以使用`Criteria`或`Query`对象的`setFirstResult()`和`...
这个压缩包提供的案例是这三个框架的整合使用，涵盖了基本的CRUD（创建、读取、更新、删除）操作，并且包含了分页查询的功能。下面将详细讲解这些知识点。 1. **Spring MVC** - Spring MVC是Spring框架的一个模块...
### Hibernate 实现分页查询详解 #### 一、引言 在进行数据库操作时，为了提高用户体验和系统性能，分页查询是一项非常重要的技术。Hibernate作为Java领域内一个优秀的对象关系映射（ORM）框架，提供了强大的数据...
总结，"Hibernate 多表连接分页查询示范项目"是一个实用的示例，它展示了如何在实际应用中利用 Hibernate Criteria API 实现复杂查询和分页，对于学习和掌握 Hibernate 的高级特性和数据库操作技巧非常有帮助。...
### 使用Hibernate实现分页查询 #### 一、分页查询概念及原理 分页查询是一种在数据量较大的情况下，为了提高用户体验和系统性能而采取的一种技术手段。它将查询结果分成若干页显示，用户可以通过翻页操作查看不同...
本文将深入探讨如何在Hibernate中进行分页查询的封装，并提供相关的源码和工具使用方法。 首先，我们需要了解Hibernate中的Criteria查询，这是实现分页查询的一种方式。Criteria API允许我们以面向对象的方式构建...
在Hibernate中，我们可以通过设置FirstResult（对应于SQL的LIMIT开始位置）和MaxResults（对应于SQL的LIMIT大小）参数来实现分页查询。 以下是一个简单的示例，展示如何在Spring和Hibernate中实现组合查询和分页： ...
本教程将详细讲解如何在Hibernate中实现分页查询，以及如何在MyEclipse集成环境中运行这段代码。 首先，让我们了解什么是分页查询。分页查询是数据库管理中的一个常见需求，特别是在处理大量数据时，为了提高用户...
综上所述，Struts2、Spring和Hibernate的整合使得开发者能够便捷地实现分页查询，从而优化Web应用的性能和用户体验。在实际项目中，需要根据具体需求和业务场景，选择合适的分页策略和实现方式，同时注意性能优化和...
在`MemberDao`接口中，我们定义了两个关键的方法，一个是用于分页查询，另一个是获取所有记录的数量。这两个方法分别如下： 1. `queryForPage` 方法接受三个参数：HQL（Hibernate Query Language）查询语句、开始...
5. **分页查询**: 在Hibernate的实现中，我们可以使用Criteria API或者HQL（Hibernate Query Language）配合Pageable接口进行分页查询。 6. **返回结果**: 将Page对象转换为前端需要的格式，如包含总页数、当前页...