qiuriyuchen

也许有参考，这是在原来项目上临时用上这个新的分页，所以有的地比较乱。刚改的，比较匆忙。 以前全是自己写的，感觉这个比我的好一些，所以以后用这个了。 其实这个是做不死的，还要看实际的分页需求。有些是不必要的. 比如在分页时有些用户插入了新的记录，会造成分页的不同步。 我做的有一个想法，不知对不对。因为全是自己想的。 １。当用户在第一页，记录当前最新记录的时间。点下一页时，并不重新查询总页数，还是用原来上次的。而且查询第二页数据的的时候会加上一个where限定记录的时间<=最新记录的时间。这样即使 在点下一页时有的人加入新的记录，也不会造成分页数据不同步的问题。 ２。只有当用户点击第一页时，我再重新查询总页数，这样第一页是最新的数据，并更新记录当前最新记录的时间。 我觉得这样更好，符合用户的心理。因为第一页是最新的数据。当点下一页时，他的心理是想看到这一页以前的数据。如果不加上面的第一点。可能他想看到的数据已经被挤到下一页的下一页了。 而且这样效率也更好，因为只有当第一页时才需要查询总页数。 我原来就是这样做的，还没来的及把我的逻辑加入这个里面，呵呵。一下就加。 但都是自己想的，不知对不对。

public interface IPage {
    public boolean isFirstPage();

    public boolean isLastPage();

    public boolean isHasNextPage();

    public boolean isHasPreviousPage();

    public int getLastPageNumber();

    public int getNextPageNumber();

    public int getPreviousPageNumber();

    public int getCurrentPageNumber();

    public List getList();

    public int getTotalResults();

}


public abstract class AbstractPage implements IPage {

    protected List results = new ArrayList();

    protected int pageSize;

    protected int page;

    protected int totalResults = -1;
    protected abstract void init();
   
    //设置总记录数，并检查页数是否超出
    public void setTotalResults(int totalResults) {
        this.totalResults = totalResults;
        if (page > getLastPageNumber()) {
            page=this.getLastPageNumber();
        }
        if(page <1){
            page=1;
        }
    }

  
    //获得总页数
    public int getLastPageNumber() {
        return  (totalResults+pageSize-1) / pageSize;
    }
    //得到对象集合

    public List getList() {
        return  results;
    }
   //得到下一页页码
    public int getNextPageNumber() {
        return page + 1;
    }
//    得到上一页页码
    public int getPreviousPageNumber() {
        return page - 1;
    }

//    得到当前页页码
    public int getCurrentPageNumber() {
        return page;
    }
//    得到总记录数
    public int getTotalResults() {
        return totalResults;
    }

    public boolean isHasNextPage() {
        return this.page<this.getLastPageNumber();
    }

    public boolean isHasPreviousPage() {
        return page > 1;
    }

    public boolean isFirstPage() {
        return page <= 1;
    }

    public boolean isLastPage() {
        return page >= getLastPageNumber();
    }

}

public class HibernatePage extends AbstractPage {
    private Query query;

    public HibernatePage(Query query, int pageNumber, int pageSize) {
        this.page = pageNumber;
        this.pageSize = pageSize;
        this.query = query;

        init();
    }

    @Override
    protected void init() {

        ScrollableResults scrollableResults = query.scroll();
        scrollableResults.first();
        scrollableResults.last();

        // 下面这个函数检查页数是否大于总页数，以及是否小于０
        setTotalResults(scrollableResults.getRowNumber() + 1);

        this.results = query.setFirstResult((page - 1) * pageSize)
                .setMaxResults(pageSize).list();
    }

}
dao


public class EquipmentDAOHibernate extends BaseDAOHibernate<Equipment>
        implements IEquipmentDAO {
    public IPage finEquipmentsByCondition(final EquipmentFindDTO finddto,
            final int page, final int pageSize) {
        try {
            return (IPage) getHibernateTemplate().execute(
                    new HibernateCallback() {
                        public Object doInHibernate(Session session)
                                throws SQLException {
                            StringBuffer sql = new StringBuffer(100);
                            sql.append("from Equipment e where 1 = 1");

                   
                            if (StringUtils.isNotEmpty(finddto.getName())) {
                                sql.append(" and e.name like :name");
                            }
                            if (StringUtils.isNotEmpty(finddto
                                    .getEquipmentKind())) {
                                sql
                                        .append(" and e.equipmentKind = :equipmentKind");
                            }
                       
                            sql.append(" order by e.pk desc");

                            Query query = session.createQuery(sql.toString());

               
                            if (StringUtils.isNotEmpty(finddto.getName())) {
                                query.setString("name", "%" + finddto.getName()
                                        + "%");
                            }
                            if (StringUtils.isNotEmpty(finddto
                                    .getEquipmentKind())) {
                                query.setString("equipmentKind", finddto
                                        .getEquipmentKind());
                            }
                           
                            return new HibernatePage(query, page, pageSize);
                        }
                    });
        } catch (Exception e) {
            return null;
        }
    }


   
   
}
action
public class EquipmentAction extends BaseAction {
     public ActionForward doList(ActionMapping mapping, ActionForm form,
            HttpServletRequest request, HttpServletResponse response) {
        EquipmentForm frm = (EquipmentForm) form;// TODO
        EquipmentFindDTO finddto = new EquipmentFindDTO();
        finddto.setEquipmentKind(frm.getKindPk());
        finddto.setName(frm.getName());
        IPage page = this.equipmentManager.findEquipmentsByCondition(finddto,
                1, 2);
        request.getSession().setAttribute("finddto", finddto);
        frm.setPageObj(page);
        List listKind = this.equipmentKindManager.findAll();
        request.setAttribute("listKind", listKind);
        return mapping.findForward("list");
    }

    public ActionForward gotoPage(ActionMapping mapping, ActionForm form,
            HttpServletRequest request, HttpServletResponse response) {
        EquipmentForm frm = (EquipmentForm) form;// TODO
        EquipmentFindDTO finddto = (EquipmentFindDTO) request.getSession()
                .getAttribute("finddto");
        IPage page = this.equipmentManager.findEquipmentsByCondition(finddto,
                frm.getPageNo(), 2);
        frm.setPageObj(page);
        List listKind = this.equipmentKindManager.findAll();
        request.setAttribute("listKind", listKind);
        return mapping.findForward("list");
    }
}
这两个函数的作用是doList是在用户点击查询或其它改变查询条件时调用
在这里面需要重新得到用户的查询条件，更新session里的查询条件。并把这些条件传给底层。
gotoPage是在用户点击上一页下一页时调用，也就是当只是页数改变，但查询条件不变时调用
在这个函数里，直接得到保存在session中的查询条件。并把这些条件传给底层。
如果不想用session也可用url来回跟踪这些条件。
这两个函数也可以合成一个，但是还得增加是上面两种查询哪种的判断，我原来就是那样做的。
这样更清晰一点。
如果查询条件比较多，可以构造一个查询对象用来在不同层传送。
public class EquipmentFindDTO {
    private String name;

    private String equipmentKind;

    public String getEquipmentKind() {
        return equipmentKind;
    }

    public void setEquipmentKind(String equipmentKind) {
        this.equipmentKind = equipmentKind;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

怎么这么复杂，用hibernate统一来处理，或者针对不同的db来写sql

这个格式不太好，看下面的吧，我重发了。