hibernate3+spring+struts的分页问题

[my202com4]

//查找数据库中的相关信息列表的方法，附分页
public List queryList(String curPage,String l_user){
//如果页数是空，那么把页数设置为第一页
long start=System.currentTimeMillis();

if(curPage==null){
curPage="1";
}
//创建查询，把传过来的参数转化成Login对象
Login login=(Login)this.getHibernateTemplate().get(Login.class,l_user);
//创建查询，把传过来的参数转化成Login对象
List list=this.getSession().createQuery("from Addrlist a where a.login=:user").setParameter("user",login)
//指定从当前记录开始
.setFirstResult((Integer.parseInt(curPage)-1)*PAGE_ROW_COUNT)
//指定每页显示多少行
.setMaxResults(PAGE_ROW_COUNT).list();
//关闭会话工厂
this.getSession().close();
long end=System.currentTimeMillis();
System.out.println(end-start+"queryList");
return list;
}
//获取当前会话中的当前行数
public int rowCount(){
//获得连接工厂中当前的会话，获取行数信息
List list=this.getSession().createCriteria(Addrlist.class)
.setProjection(Projections.projectionList()
.add(Projections.rowCount())).list();
//获得集合的第一项信息
int result=Integer.parseInt(list.get(0).toString());
this.getSession().close();
System.out.println(result+"rowCount");
return result;
}
//获得总页数
public int pageCount(){
long start=System.currentTimeMillis();
//获得总行数
int rowCount=this.rowCount();
/*
* 计算总页数,如果行数和显示页数的余数等于0
* 那么总页数就是总行数除以每页显示的行数，
* 否则总页数等于总行数除以每页显示的行数加1
*/
if(rowCount%PAGE_ROW_COUNT==0){
pageCount=rowCount/PAGE_ROW_COUNT;
}else{
pageCount=(rowCount/PAGE_ROW_COUNT)+1;
}
System.out.println(pageCount);
long end=System.currentTimeMillis();
System.out.println(end-start+"pageCount");
return pageCount;
}
一开始还行但点了七八次页面之后分页就慢的厉害以上是我写的方法，有没有高手指点一下，我这三个方法那里写的不合适

[killme2008]

springside的一个封装类,LZ看看:

package org.springside.framework.commons;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.criterion.CriteriaSpecification;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.ObjectRetrievalFailureException;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springside.framework.utils.GenericsUtils;

import java.io.Serializable;
import java.util.List;
import java.util.Map;

/**
* SpringSide Hibernate Entity Dao基类
*
* @author calvin,ajax
*/
abstract public class BaseHibernateDao<T> extends HibernateDaoSupport {
protected final Log logger = LogFactory.getLog(getClass());

/** Dao所管理的Entity类型 */
private Class entityClass;

/**
* 在构造函数中将T赋给supportsClass
*/
public BaseHibernateDao() {
entityClass = GenericsUtils.getGenericClass(getClass());
}

protected Class getEntityClass()
{
return entityClass;
}

public T get(Serializable id) {
T o = (T) getHibernateTemplate().get(getEntityClass(), id);

if (o == null)
throw new ObjectRetrievalFailureException(getEntityClass(), id);

return o;
}

public List getAll() {
return getHibernateTemplate().loadAll(getEntityClass());
}

public void save(Object o) {
getHibernateTemplate().saveOrUpdate(o);
}

public void remove(Serializable id) {
remove(get(id));
}

public void remove(Object o) {
getHibernateTemplate().delete(o);
}

public List<T> find(String hsql) {
return getHibernateTemplate().find(hsql);
}

public List<T> find(String hsql, Object value) {
return getHibernateTemplate().find(hsql, value);
}

public List<T> find(String hsql, Object[] values) {
return getHibernateTemplate().find(hsql, values);
}

/**
* 无参数分页查询，默认使用的jdbc支持scroll方式
*/
public Page pagedQuery(String qryHql, int pageNo, int pageSize) {
return pagedQuery(qryHql, pageNo, pageSize, true);
}

/**
* 无参数分页查询,可以指定使用的数据库的Jdbc是否支持scroll方式
*/
public Page pagedQuery(String qryHql, int pageNo, int pageSize, boolean isScroll) {
return pagedQuery(qryHql, null, pageNo, pageSize, isScroll);
}

/**
* 有参数的分页查询，默认使用的jdbc支持scroll方式
*/
public Page pagedQuery(String qryHql, Object[] args, int pageNo, int pageSize) {
return pagedQuery(qryHql, args, pageNo, pageSize, true);
}

/**
* 有参数分页查询,可以指定使用的数据库的Jdbc是否支持scroll方式
*/
public Page pagedQuery(String qryHql, Object[] args, int pageNo, int pageSize, boolean isScroll) {
if (qryHql == null)
throw new IllegalArgumentException("NULL is not a valid string");

Query query = null;
if (args == null)
query = getSession().createQuery(qryHql);
else {
query = getSession().createQuery(qryHql);
for (int i = 0; i < args.length; i++) {
query.setParameter(i, args[i]);
}
}
return HqlPage.getHibernatePageInstance(query, pageNo, pageSize, isScroll);
}

/**
* 使用Criteria进行分页查询，默认是jdbc支持scroll
*/
public Page pagedQuery(Criteria criteria, int pageNo, int pageSize) {
return pagedQuery(criteria, pageNo, pageSize, true);
}

/**
* 使用Criteria进行分页查询，可以指定jdbc是否支持scroll
*/
public Page pagedQuery(Criteria criteria, int pageNo, int pageSize, boolean isScroll) {
return CriteriaPage.getHibernatePageInstance(criteria, pageNo, pageSize, isScroll);
}

/**
* 根据属性名和属性值查询对象 ，返回唯一对象
*/
public T findBy(String name, Object value) {
Criteria criteria = getSession().createCriteria(getEntityClass());
criteria.add(Restrictions.eq(name, value));
return (T) criteria.uniqueResult();
}

/**
* 根据属性名和属性值查询对象 ，返回符合条件的对象列表
*/
public List<T> findAllBy(String name, Object value) {
Criteria criteria = getSession().createCriteria(getEntityClass());
criteria.add(Restrictions.eq(name, value));
return criteria.list();
}

/**
* 根据属性名和属性值查询对象 ，返回符合条件的对象列表
*/
public List<T> findAllByLike(String name, String value) {
Criteria criteria = getSession().createCriteria(getEntityClass());
criteria.add(Restrictions.like(name, value, MatchMode.ANYWHERE));
return criteria.list();
}

/**
* 根据map中过滤条件进行查询，无分页
*/
public List<T> findAllBy(Map filter) {
Criteria criteria = getSession().createCriteria(getEntityClass());
filterCriteria(criteria, filter);
return criteria.list();
}

/**
* 根据Map中过滤条件和分页参数查询。
*
* @param filter 过滤条件。
* @param sortMap 排序条件。
* @param pageNo 当前页码
* @param pageSize 每页显示记录数。
*/
public Page findAllBy(Map filter, Map sortMap, int pageNo, int pageSize) {
Criteria criteria = getSession().createCriteria(getEntityClass());

filterCriteria(criteria, filter);

sortCriteria(criteria, sortMap);

criteria.setProjection(null);
criteria.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);

return pagedQuery(criteria, pageNo, pageSize);
}

/**
* 构造criteria的过滤条件的回调函数
*/
protected void filterCriteria(Criteria criteria, Map filter) {

}

/**
* 构造Criteria的排序条件。
*
* @param sortMap 排序条件。
* @param criteria Criteria实例。
*/
private void sortCriteria(Criteria criteria, Map sortMap) {
if (!sortMap.isEmpty()) {
for (Object o : sortMap.keySet()) {
String fieldName = o.toString();
String orderType = sortMap.get(fieldName).toString();

if ("asc".equalsIgnoreCase(orderType)) {
criteria.addOrder(Order.asc(fieldName));
} else {
criteria.addOrder(Order.desc(fieldName));
}
}
}
}
}