菜鸟求比较通用的分页结构

Question

我是这样做的,
dao 里面的方法PageModel findAll(PageModel p);PageModel是我写的一个分页的类,里面有page,prePage,nextPage,searchCondition搜索条件,方法实现里面,先处理一下搜索条件,然后查出总记录数
本人用的是hibernate,利用Criteria来查询设置firstResult和maxResult和Restrictions然后调用list方法.
不知道这样做有什么缺点,大家都有什么好的点子,谢谢分享一下.

Answer 1

这是我工程里面用到分页的通用类，currentPage是当前查询的是第几页，maxRow是每页显示的记录条数 public List<T> findByPage(final DetachedCriteria detachedCriteria,final int currentPage, final int maxRow) {
        try 
        {   
return getHibernateTemplate().executeFind(new HibernateCallback() 
{
public Object doInHibernate(Session session) throws SQLException, HibernateException {
Criteria criteria = detachedCriteria.getExecutableCriteria(session);
criteria.setFirstResult((currentPage - 1) * maxRow);
criteria.setMaxResults(maxRow);
return criteria.list();
}
});
        } 
        catch (RuntimeException re) 
        {   
         DBLog.info(re.getMessage());
            throw re;   
        }   
}

Answer 2

我还有一个简单方法啊！比较通用的分页技术！不过我的框架是SSH
1.在Action中定义如下几个变量,并加入相关get set方法
private int pagesize=10;//每页显示记录条数
private int page;//当前第几页
private int total;//总页数其中pagesize可以不要，可以在程序中写死.2.定义分页方法
/*
*参数list:待分页的原始集合
*返回值:分页后的第几页结果集合
*/
public List getPageResult(List list){
if(list.size()>0){
total=(int)Math.ceil(list.size()*1.0/pagesize);//总页数
if(page<1)page=1;
if(page>total)page=total;
int sindex=(page-1)*pagesize;
sindex=(sindex<list.size())?sindex:list.size()-1;
int eindex=sindex+pagesize;
eindex=(eindex<list.size())?eindex:list.size();
list=list.subList(sindex,eindex);
}
return list;
}

Answer 3

我的也是只传一个List集合，分页的方法是挺多的但没用过“自定义标签”！
请问Lz的页面是用Jsp吗？
为什么不拿出来分享一下呢？

Answer 4

package com.ezsoft.ezit.util;import java.util.Collections;
import java.util.List;import org.apache.commons.lang.StringUtils;/**
 * 与具体ORM实现无关的分页参数及查询结果封装.
 * 注意�?有序号从1�?�?.
 * 
 * @param <T> Page中记录的类型.
 * 
 * @author calvin
 */
public class Page<T> {
//-- 公共变量 --//
public static final String ASC = "asc";
public static final String DESC = "desc"; //-- 分页参数 --//
protected int pageNo = 1;
protected int pageSize = 1;
protected String orderBy = null;
protected String order = null;
protected boolean autoCount = true;

protected int first;//start //-- 返回结果 --//
protected List<T> result = Collections.emptyList();
protected long totalCount = -1; //-- 构�?�函�? --//
public Page() {
} public Page(int pageSize) {
this.pageSize = pageSize;
} //-- 访问查询参数函数 --//
/**
 * 获得当前页的页号,序号�?1�?�?,默认�?1.
 */
public int getPageNo() {
return pageNo;
} /**
 * 设置当前页的页号,序号�?1�?�?,低于1时自动调整为1.
 */
public void setPageNo(final int pageNo) {
this.pageNo = pageNo; if (pageNo < 1) {
this.pageNo = 1;
}
} public Page<T> pageNo(final int thePageNo) {
setPageNo(thePageNo);
return this;
} /**
 * 获得每页的记录数�?,默认�?1.
 */
public int getPageSize() {
return pageSize;
} /**
 * 设置每页的记录数�?,低于1时自动调整为1.
 */
public void setPageSize(final int pageSize) {
this.pageSize = pageSize; if (pageSize < 1) {
this.pageSize = 1;
}
} public Page<T> pageSize(final int thePageSize) {
setPageSize(thePageSize);
return this;
} /**
 * 根据pageNo和pageSize计算当前页第�?条记录在总结果集中的位置,序号�?1�?�?.
 */
public int getFirst() {
return  first;//((pageNo - 1) * pageSize) + 1;
} public void setFirst(int first) {
this.first = first;
} /**
 * 获得排序字段,无默认�??.多个排序字段时用','分隔.
 */
public String getOrderBy() {
return orderBy;
} /**
 * 设置排序字段,多个排序字段时用','分隔.
 */
public void setOrderBy(final String orderBy) {
this.orderBy = orderBy;
} public Page<T> orderBy(final String theOrderBy) {
setOrderBy(theOrderBy);
return this;
} /**
 * 获得排序方向.
 */
public String getOrder() {
return order;
} /**
 * 设置排序方式�?.
 * 
 * @param order 可�?��?�为desc或asc,多个排序字段时用','分隔.
 */
public void setOrder(final String order) {
//�?查order字符串的合法�?
String[] orders = StringUtils.split(StringUtils.lowerCase(order), ',');
for (String orderStr : orders) {
if (!StringUtils.equals(DESC, orderStr) && !StringUtils.equals(ASC, orderStr)) {
throw new IllegalArgumentException("排序方向" + orderStr + "不是合法�?");
}
} this.order = StringUtils.lowerCase(order);
} public Page<T> order(final String theOrder) {
setOrder(theOrder);
return this;
} /**
 * 是否已设置排序字�?,无默认�??.
 */
public boolean isOrderBySetted() {
return (StringUtils.isNotBlank(orderBy) && StringUtils.isNotBlank(order));
} /**
 * 查询对象时是否自动另外执行count查询获取总记录数, 默认为false.
 */
public boolean isAutoCount() {
return autoCount;
} /**
 * 查询对象时是否自动另外执行count查询获取总记录数.
 */
public void setAutoCount(final boolean autoCount) {
this.autoCount = autoCount;
} public Page<T> autoCount(final boolean theAutoCount) {
setAutoCount(theAutoCount);
return this;
} //-- 访问查询结果函数 --// /**
 * 取得页内的记录列�?.
 */
public List<T> getResult() {
return result;
} /**
 * 设置页内的记录列�?.
 */
public void setResult(final List<T> result) {
this.result = result;
} /**
 * 取得总记录数, 默认值为-1.
 */
public long getTotalCount() {
return totalCount;
} /**
 * 设置总记录数.
 */
public void setTotalCount(final long totalCount) {
this.totalCount = totalCount;
} /**
 * 根据pageSize与totalCount计算总页�?, 默认值为-1.
 */
public long getTotalPages() {
if (totalCount < 0) {
return -1;
} long count = totalCount / pageSize;
if (totalCount % pageSize > 0) {
count++;
}
return count;
} /**
 * 是否还有下一�?.
 */
public boolean isHasNext() {
return (pageNo + 1 <= getTotalPages());
} /**
 * 取得下页的页�?, 序号�?1�?�?.
 * 当前页为尾页时仍返回尾页序号.
 */
public int getNextPage() {
if (isHasNext()) {
return pageNo + 1;
} else {
return pageNo;
}
} /**
 * 是否还有上一�?.
 */
public boolean isHasPre() {
return (pageNo - 1 >= 1);
} /**
 * 取得上页的页�?, 序号�?1�?�?.
 * 当前页为首页时返回首页序�?.
 */
public int getPrePage() {
if (isHasPre()) {
return pageNo - 1;
} else {
return pageNo;
}
}
}

Answer 5

PageModel类public class PageModel {
private int page = 1;
private int pageSize = 3;
private int maxPage = Integer.MAX_VALUE;
private int nextPage = page + 1;
private int prePage = 1;
private int maxCounts = 0;
private List datas;
private SearchCondition condition; public int getPage() {
return page;
} public void setPage(int page) {
if (page < 1)
page = 1;
nextPage = page >= maxPage ? maxPage : page + 1;
prePage = page == 1 ? 1 : page - 1;
this.page = page;
} public int getPageSize() {
return pageSize;
} public void setPageSize(int pageSize) {
this.pageSize = pageSize;
} public int getMaxPage() {
return maxPage;
} public void setMaxPage(int maxPage) {
this.maxPage = maxPage;
if (page >= maxPage)
setPage(maxPage);
} public int getNextPage() {
return page == maxPage ? page : page + 1;
} public void setNextPage(int nextPage) {
this.nextPage = nextPage;
} public int getPrePage() {
return page == 1 ? 1 : page - 1;
} public void setPrePage(int prePage) {
this.prePage = prePage;
} public List getDatas() {
return datas;
} public void setDatas(List datas) {
this.datas = datas;
} public void setCondition(SearchCondition condition) {
this.condition = condition;
} public SearchCondition getCondition() {
return condition;
} // 记录总条数,同时计算最大页数
public void setMaxCounts(int maxCounts) {
this.maxCounts = maxCounts;
maxPage = this.maxCounts / pageSize;
if (this.maxCounts % pageSize != 0) {
maxPage += 1;
}
setMaxPage(maxPage);
} public int getMaxCounts() {
return maxCounts;
}}
dao的一个方法public PageModel findAll(final PageModel p, final Class<T> clazz)
throws Exception { p.setMaxCounts(getRowCounts(clazz, p));
List<T> list = hibTemplate.executeFind(new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Criteria c = session.createCriteria(clazz);
initFindByPage(p, c);
return c.list();
}
});
p.setDatas(list);
return p;
}// 得到查询条件所对应的记录总条数
@Override
public final Integer getRowCounts(final Class<T> clazz, final PageModel pm)
throws Exception {
Integer counts = (Integer) hibTemplate.execute(new HibernateCallback() {
@Override
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Criteria c = session.createCriteria(clazz);
dealSearchCondition(pm, c);
c.setProjection(Projections.rowCount());
return c.uniqueResult();
}
});
return counts;
}
/*
 * 处理搜索条件. 可以被子类重载,定义自己的处理搜索条件的方法.
 */
protected void dealSearchCondition(PageModel p, Criteria c) { }
设置
private void initFindByPage(final PageModel p, Criteria c) {
c.setFirstResult((p.getPage() - 1) * p.getPageSize());
c.setMaxResults(p.getPageSize());
}
我总觉得这样不好.耦合太高

Answer 6

package page;/***
 * 分页通用方法
 * @author xk1126
 *
 */
public class PagaPing 
{
/** 当前页 */
private int page = 1;

/** 每页显示个数 */
private int pageSize;

/** 上一页 */
private int pageNext;

/** 下一页 */
private int pageNew;

/** 总记录数 */
private int count;

/** 总页数 */
private int pageCount;


public int getCount() 
{
return count;
} public void setCount(int count) 
{
this.count = count;
} public int getPage() 
{
return page;
} public void setPage(int page) 
{
this.page = page;
} public int getPageCount() 
{
return pageCount;
} public void setPageCount(int pageCount) 
{
this.pageCount = pageCount;
} public int getPageNew() 
{
return pageNew;
} public void setPageNew(int pageNew) 
{
this.pageNew = pageNew;
} public int getPageNext() 
{
return pageNext;
} public void setPageNext(int pageNext)
{
this.pageNext = pageNext;
} public int getPageSize() 
{
return pageSize;
} public void setPageSize(int pageSize) 
{
this.pageSize = pageSize;
}




/***
 * 分页方法
 *
 */
public void spiltPge() 
{
//上一页
this.pageNext = this.page;
if (this.page > 1) 
{
this.pageNext = this.page -1;
}

//总页数
this.pageCount = this.count / this.pageSize;
if (this.count % this.pageSize != 0) 
{
this.pageCount += 1;
}

//下一页
this.pageNew = this.page + 1;
if (this.pageNew >= this.pageCount) 
{
this.pageNew = this.pageCount;
}
}
}
那个类要实现分页，继承PagaPing
然后从数据中读取总数setCount()进去，每页显示个数setPageSize()进去,从页数获得当前页
setPage();
最好调用spiltPge()分页方法/***
 * 分页连接数据库
 * @param pageNo 当前页
 * @param pageSize 每页显示个数
 * @return
 */
public List<Object> pageList(int pageNo,int pageSize) 
{
int page = pageSize*(pageNo-1);

String sql = "select top " + pageSize +
" * from table where id in (select top " 
+ page +" id from table order by time) ordey by time";

}table是表名，time是以时间排序

Answer 7

public Page getPage(int currentPage,int pageSize,Criterion...crts){
Criteria c=session.createCriteria(House.class);
List list=null;
for (int i = 0; i < crts.length; i++) {
c.add(crts[i]);
}
c.setProjection(Projections.rowCount());
int totalRecord=Integer.valueOf(c.uniqueResult().toString());
c.setProjection(null);

c.setFirstResult((pageSize)*(currentPage-1));
c.setMaxResults(pageSize);
list=c.list();
Page page=new Page();
page.setCurrentPage(currentPage);
page.setPageSize(pageSize);
page.setTotalRecord(totalRecord);
page.setList(list);
return page;
}