`
igogogo9
  • 浏览: 250759 次
  • 性别: Icon_minigender_1
  • 来自: 海口市
社区版块
存档分类
最新评论

struts+spring+hibernate通用分页方法

StrutsHibernateSpringDAOC 
阅读更多 
分页有2种办法：
1、    从数据库中取得记录，在内存中再划分，如果遇到记录数很大的时候效率很成问题，此法不可取。
2、    采用hibernate的物理分页，每次只是取一页。从客户端传进来的是第几页和每页多少条记录，要首先查询符合记录的总记录数，再根据总记录数和当前页，每页记录数可以算出要取的是数据库中的第几条记录。2次查询不可避免了。
单元测试如下：
java 代码
 
  1. public final void testFindAllRole() {  
  2.   
  3.             logger.debug("testFindAllRole");  
  4.   
  5.             long l1=System.currentTimeMillis();  
  6.   
  7.             String myaction="roleList.do";  
  8.   
  9.             String curPageNO = "1";  
  10.   
  11.             CriteriaQuery cq=new CriteriaQuery(Role.class,curPageNO,myaction);  
  12.   
  13.             cq.setPageSize(10);  
  14.   
  15.             PageSupport ps=BeanFactory.getInstance().getRightDelegate().findAllRole(cq, state);  
  16.   
  17.             long l2=System.currentTimeMillis();  
  18.   
  19.             AppUtils.printCollection(ps.getResultList());    
  20.   
  21.             System.out.println("一共用时为 ：  "+(l2-l1));            
  22.   
  23.         }  
CriteriaQuery类是对hibernate QBC查询方法的封装，需要的参数是当前操作的实体类，myaction，curPageNO，pageSize，以便构造出相应的上下翻页的工具条。
在delegate中只是将值向下传：
java 代码
 
  1. public PageSupport findAllRole(CriteriaQuery cq, IState state) {  
  2.   
  3.         if (DelegateUtil.isNullParam(cq, "CriteriaQuery", state)) {  
  4.   
  5.             return null;  
  6.   
  7.         }  
  8.   
  9.         Request req = new Request();  
  10.   
  11.         req.setServiceName(ServiceConsts.FindAllRoleProcessor);  
  12.   
  13.         req.setValue("CriteriaQuery", cq);  
  14.   
  15.         try {  
  16.   
  17.             Response resp = getDelegate().execute(req);  
  18.   
  19.             DelegateUtil.setIState(state, resp);  
  20.   
  21.             return (PageSupport) (resp.getValue("PageSupport"));  
  22.   
  23.         } catch (Exception e) {  
  24.   
  25.             DelegateUtil.handleException(e, "findAllRole", state);  
  26.   
  27.         }  
  28.   
  29.         return new PageSupport();  
  30.   
  31.     } 
在业务逻辑模块command中:
java 代码
 
  1. public class FindAllRole extends Command  
  2. {  
  3.     private RoleDao dao;  
  4.     public void setDao(RoleDao dao) {  
  5.         this.dao = dao;  
  6.     }  
  7.     public void execute(Map params, Map response) throws Exception  
  8.   
  9.     {  
  10.         response.put("PageSupport", (PageSupport)dao.find((CriteriaQuery) params.get("CriteriaQuery"),true));  
  11.     }  
  12. ……  
  13.   
  14. }  
直接就是调用dao的find方法：   
java 代码
 
  1. public PageSupport find(final CriteriaQuery cq,final boolean isOffset) {  
  2.        return (PageSupport)getHibernateTemplate().execute(  
  3.                new HibernateCallback() {  
  4.                    public Object doInHibernate(Session session) throws HibernateException, SQLException {  
  5.                        Criteria criteria = cq.getDetachedCriteria().getExecutableCriteria(session);   
  6.                        //得到总行数  
  7.                        int allCounts = ((Integer) criteria.setProjection(Projections.rowCount()).uniqueResult()).intValue();   
  8.                        criteria.setProjection(null);//还原    
  9.                        int curPageNO = PagerUtil.getCurPageNO(cq.getCurPage());// 当前页  
  10.                        int offset = PagerUtil.getOffset(allCounts, curPageNO, cq.getPageSize());  
  11.                        String toolBar = PagerUtil.getBar(cq.getMyaction(),allCounts,curPageNO,cq.getPageSize());  
  12.   
  13.                        if(isOffset){  
  14.   
  15.                            criteria.setFirstResult(offset);  
  16.   
  17.                            criteria.setMaxResults(cq.getPageSize());  
  18.   
  19.                        }  
  20.                        return new PageSupport(criteria.list(),toolBar,offset,curPageNO);  
  21.   
  22.                            }  
  23.                      }  
  24.   
  25.                ,true);  
  26.    }  

在后台的整个操作中非常简练，只需要将带上参数的CriteriaQuery传到dao就可以实现。CriteriaQuery封装了hibernate的DetachedCriteria。
java 代码
 
  1. public class CriteriaQuery implements Serializable{  
  2.     public CriteriaQuery(){  
  3.         super();  
  4.     }  
  5.     private static final long serialVersionUID = -1464383406564081554L;  
  6.     // 初始化list  
  7.     private String curPage=null ;  
  8.     private int pageSize=10;  
  9.     private String myaction;  
  10.     private String myform;  
  11.     private CriterionList criterionList;  
  12.     private DetachedCriteria detachedCriteria;  
  13.   
  14.     public CriteriaQuery(Class c) {  
  15.         this.criterionList = new CriterionList();  
  16.         this.detachedCriteria=DetachedCriteria.forClass(c);  
  17.     }  
  18.     public CriteriaQuery(Class c,String curPage,String myaction,String myform) {  
  19.         this.myaction=myaction;  
  20.         this.myform=myform;  
  21.         this.curPage=curPage;  
  22.         this.criterionList = new CriterionList();  
  23.         this.detachedCriteria=DetachedCriteria.forClass(c);  
  24.     }  
  25.     public CriteriaQuery(Class c,String curPage,String myaction) {  
  26.         this.myaction=myaction;  
  27.         this.curPage=curPage;  
  28.         this.criterionList = new CriterionList();  
  29.         this.detachedCriteria=DetachedCriteria.forClass(c);  
  30.     }  
  31.     public CriterionList getCriterionList() {  
  32.         return criterionList;  
  33.     }  
  34.     public void setCriterionList(CriterionList criterionList) {  
  35.         this.criterionList = criterionList;  
  36.     }  
  37.   
  38.     public String getCurPage() {  
  39.         return curPage;  
  40.     }  
  41.     public void setCurPage(String curPage) {  
  42.         this.curPage = curPage;  
  43.     }  
  44.     public DetachedCriteria getDetachedCriteria() {  
  45.         return detachedCriteria;  
  46.     }  
  47.     public void setDetachedCriteria(DetachedCriteria detachedCriteria) {  
  48.         this.detachedCriteria = detachedCriteria;  
  49.     }  
  50.     public void add(Criterion c) {  
  51.             detachedCriteria.add(c);  
  52.     }  
  53.     public void add() {  
  54.         for(int i=0;i
  55.             add(getCriterionList().getParas(i));  
  56.         }  
  57.     }  
  58.     public void createAlias(String name){  
  59.         detachedCriteria.createCriteria(name);  
  60.     }  
  61.     public void createAlias(String name,String value){  
  62.         detachedCriteria.createCriteria(name,value);  
  63.     }  
  64.     public Criterion and(CriteriaQuery query, int source, int dest) {  
  65.         return Restrictions.and(query.getCriterionList().getParas(source),query.getCriterionList().getParas(dest));  
  66.     }  
  67.     public Criterion and(Criterion c,CriteriaQuery query, int source) {  
  68.         return Restrictions.and(c, query.getCriterionList().getParas(source));  
  69.     }  
  70.     public Criterion and(Criterion c1, Criterion c2) {  
  71.         return Restrictions.and(c1,c2);  
  72.     }  
  73.     public Criterion or(CriteriaQuery query, int source, int dest) {  
  74.         return Restrictions.or(query.getCriterionList().getParas(source),query.getCriterionList().getParas(dest));  
  75.     }  
  76.       
  77.     public Criterion or(Criterion c,CriteriaQuery query, int source) {  
  78.         return Restrictions.or(c, query.getCriterionList().getParas(source));  
  79.     }  
  80.       
  81.     public void or(Criterion c1, Criterion c2) {  
  82.         this.detachedCriteria.add(Restrictions.or(c1,c2));  
  83.     }  
  84.     public void addOrder(String ordername,String ordervalue) {  
  85.         // 写入order查询条件  
  86.         if ("asc".equals(ordername)) {  
  87.             detachedCriteria.addOrder(Order.asc(ordervalue));  
  88.         } else {  
  89.             detachedCriteria.addOrder(Order.desc(ordervalue));  
  90.         }  
  91.     }  
  92.     public void eq(String keyname,Object keyvalue){  
  93.         criterionList.addPara(Restrictions.eq(keyname, keyvalue));  
  94.     }  
  95.     public void notEq(String keyname,Object keyvalue){  
  96.         criterionList.addPara(Restrictions.or(Restrictions.gt(keyname, keyvalue),Restrictions.lt(keyname, keyvalue)));  
  97.     }  
  98.     public void like(String keyname,Object keyvalue){  
  99.         criterionList.addPara(Restrictions.like(keyname, keyvalue));  
  100.     }  
  101.     public void gt(String keyname,Object keyvalue){  
  102.         criterionList.addPara(Restrictions.gt(keyname, keyvalue));  
  103.     }  
  104.     public void lt(String keyname,Object keyvalue){  
  105.         criterionList.addPara(Restrictions.lt(keyname, keyvalue));  
  106.     }  
  107.     public void le(String keyname,Object keyvalue){  
  108.         criterionList.addPara(Restrictions.le(keyname, keyvalue));  
  109.     }  
  110.     public void ge(String keyname,Object keyvalue){  
  111.         criterionList.addPara(Restrictions.ge(keyname, keyvalue));  
  112.     }  
  113.     public void ilike(String keyname,Object[] keyvalue){  
  114.         criterionList.addPara(Restrictions.in(keyname, keyvalue));  
  115.     }  
  116.     public void between(String keyname,Object keyvalue1,Object keyvalue2) {  
  117.         Criterion c=null;// 写入between查询条件  
  118.         if (!AppUtils.isBlank(keyvalue1) && !AppUtils.isBlank(keyvalue2)) {  
  119.             c=Restrictions.between(keyname, keyvalue1, keyvalue2);  
  120.         } else if (!AppUtils.isBlank(keyvalue1)) {  
  121.             c=Restrictions.ge(keyname, keyvalue1);  
  122.         } else if (!AppUtils.isBlank(keyvalue2)) {  
  123.             c=Restrictions.le(keyname, keyvalue2);  
  124.         }  
  125.         criterionList.add(c);  
  126.     }  
  127.     public int getPageSize() {  
  128.         return pageSize;  
  129.     }  
  130.     public void setPageSize(int pageSize) {  
  131.         this.pageSize = pageSize;  
  132.     }  
  133.     public String getMyaction() {  
  134.         return myaction;  
  135.     }  
  136.     public void setMyaction(String myaction) {  
  137.         this.myaction = myaction;  
  138.     }  
  139.     public String getMyform() {  
  140.         return myform;  
  141.     }  
  142.     public void setMyform(String myform) {  
  143.         this.myform = myform;  
  144.     }  
  145. } 

另外需要一些辅助类的支持： 例如PageSupport  封装了返回的数据和工具条。
java 代码
 
  1. public class PageSupport  implements Serializable{  
  2.     private int curPageNO;  
  3.     private int offset;  
  4.     private String toolBar;  
  5.     private List resultList=null;  
  6.   
  7.     public PageSupport() {  
  8.   
  9.     }  
  10.     public PageSupport(List resultList,String toolBar,int offset,int curPageNO) {  
  11.         this.curPageNO=curPageNO;  
  12.         this.offset=offset;  
  13.         this.toolBar=toolBar;  
  14.         this.resultList=resultList;  
  15.     }  
  16.     public List getResultList() {  
  17.         return resultList;  
  18.     }  
  19.   
  20.     public void setResultList(List resultList) {  
  21.         this.resultList = resultList;  
  22.     }  
  23.   
  24.     public String getToolBar() {  
  25.         return toolBar;  
  26.     } 

CriterionList封装了Hibernate的参数:
java 代码
 
  1. /** 
  2.  * 封装了ArrayList，装的是Criterion 
  3.  */  
  4. public class CriterionList extends ArrayList {  
  5.     public final Criterion getParas(final int index) {  
  6.         return (Criterion) super.get(index);  
  7.     }  
  8.     public final void addPara(final int index, final Criterion p) {  
  9.         super.add(index, p);  
  10.     }  
  11.     public final void addPara(final Criterion p) {  
  12.         super.add(p);  
  13.     }  
  14.     public final int indexofPara(final Criterion p) {  
  15.         return super.indexOf(p);  
  16.     }  
  17.     public final void removePara(final int index) {  
  18.         super.remove(index);  
  19.     }  
  20. }  

PagerUtil用于将客户端的页码和每页多少个记录算出应该取数据库中的记录的位置，再由hibernate构造出一个三层的sql语句。
java 代码
 
  1. public class PagerUtil {  
  2.     /** 
  3.      *  
  4.      * @param allCounts 总记录数 
  5.      * @param curPageNO  
  6.      * @param pageSize  每页显示的记录数目 
  7.      * @return 
  8.      */  
  9.     public static String  getBar(String action,String form,int allCounts,int curPageNO, int pageSize){  
  10.         Pager pager = null;  
  11.             try {  
  12.                 if (curPageNO<1) curPageNO=1;  
  13.                 if (curPageNO> (int) Math.ceil((double) allCounts / pageSize))   
  14.                     curPageNO =(int) Math.ceil((double) allCounts / pageSize);  
  15.                 //得到offset  
  16.                 int offset = (curPageNO-1)*pageSize;//从第几条开始取值  
  17.                  //生成工具条  
  18.                  pager=new Pager(allCounts,offset,pageSize);  
  19.                  pager.setCurPageNO(curPageNO);//设置当前的页码  
  20.             } catch (Exception e) {  
  21.                 System.out.println("生成工具条出错!");  
  22.           }  
  23.          return pager.getToolBar(action,form);  
  24.     }  
  25.       
  26.     public static String  getBar(String url,int allCounts,int curPageNO, int pageSize){  
  27.         Pager pager = null;  
  28.             try {  
  29.                 if (curPageNO<1) curPageNO=1;  
  30.                 if (curPageNO> (int) Math.ceil((double) allCounts / pageSize))   
  31.                     curPageNO =(int) Math.ceil((double) allCounts / pageSize);  
  32.                 //得到offset  
  33.                 int offset = (curPageNO-1)*pageSize;//从第几条开始取值  
  34.                  //生成工具条  
  35.                  pager=new Pager(allCounts,offset,pageSize);  
  36.                  pager.setCurPageNO(curPageNO);//设置当前的页码  
  37.             } catch (Exception e) {  
  38.                 System.out.println("生成工具条出错!");  
  39.           }  
  40.          return pager.getToolBar(url);  
  41.     }  
  42.       
  43.     public static int getOffset(int rowCounts,int curPageNO, int pageSize){  
  44.         int offset=0;  
  45.             try {  
  46.                 //得到第几页  
  47.                 if (curPageNO<1) curPageNO=1;  
  48.                 if (curPageNO> (int) Math.ceil((double) rowCounts / pageSize))   
  49.                     curPageNO =(int) Math.ceil((double) rowCounts / pageSize);  
  50.                 //得到offset  
  51.                   offset = (curPageNO-1)*pageSize;  
  52.             } catch (Exception e) {  
  53.                 System.out.println("getOffset出错!");  
  54.             }    
  55.        return offset;  
  56.     }  
  57.       
  58.     public static int getCurPageNO(String curPage){  
  59.             int curPageNO;  
  60.              if (curPage==null||"".equals(curPage.trim())) {  
  61.                  curPageNO=1;//第一次处于第一页  
  62.               } else {  
  63.                   try {  
  64.                       curPageNO = Integer.parseInt(curPage);//得到当前页  
  65.                 } catch (Exception e) {  
  66.                     curPageNO=1;  
  67.                 }  
  68.               }  
  69.              return curPageNO;  
  70.         }  
  71. } 

在struts的Action中：

java 代码
 
  1. private ActionForward findAllRole(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) {  
  2.         String curPageNO = request.getParameter("curPageNO");  
  3.         String myaction;  
  4.         String search=request.getParameter("search");  
  5.         //String myform="forms[0]";  
  6.         if(search==null){  
  7.             search="";  
  8.             myaction="findAllRole.do";  
  9.         }else{  
  10.             myaction="findAllRole.do?search="+search;  
  11.         }  
  12.         removeRequestAttribute(mapping,request);  
  13.         try {  
  14.             //Qbc查找方式  
  15.             CriteriaQuery cq=new CriteriaQuery(Role.class,curPageNO,myact
  • pager.rar (9.3 KB)
  • 描述: pager.rar
  • 下载次数: 92
分享到：
| JSP内部对象详解
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Struts+Spring+Hibernate通用分页解决方案

    7. **文件`struts+spring+hibernate通用分页方法.doc`**：这个文档可能包含了具体的实现步骤、代码示例和注意事项，详细阐述如何将Struts、Spring和Hibernate整合起来，构建一个通用的分页功能。读者可以参考文档中...

    Struts2 + Spring2 + Hibernate3经典分页（包含java及jsp源码）

    ### Struts2 + Spring2 + Hibernate3 经典分页技术解析 #### 一、概述 在企业级应用开发中，分页显示是常见的需求之一。对于数据量较大的查询结果，采用分页的方式不仅能减轻服务器的压力，提高用户体验，还能更好...

    struts+hibernate+spring集成实现分页

    Struts、Hibernate和Spring是Java开发中的三大框架，它们各自负责不同的职责，组合起来可以构建出高效、松耦合的企业级应用。SSH（Struts、Spring、Hibernate）集成是Java Web开发中的常见模式，用于创建复杂的业务...

    struts2+spring2+hibernate3注册查询搜索分页实例

    总的来说，这个"Struts2+Spring2+Hibernate3注册查询搜索分页实例"是一个很好的学习资源，涵盖了Java Web开发中的基础和核心部分。通过学习这个实例，开发者不仅可以掌握三大框架的基本用法，还能了解到如何将它们...

    使用Struts + Spring + Hibernate完成分页笔记

    "使用Struts + Spring + Hibernate完成分页笔记"这个主题涵盖了三个关键的Java EE框架：Struts、Spring和Hibernate，它们分别负责表现层、业务逻辑层和数据访问层的管理。下面将详细介绍这三个框架在分页实现中的...

    新闻发布系统JAVA源码(struts+spring+hibernate)

    【新闻发布系统JAVA源码(struts+spring+hibernate)】是一个典型的Java Web应用程序，它利用了Struts、Spring和Hibernate三大开源框架的集成来构建高效、可维护的新闻发布平台。这个系统的主要目的是提供一个发布、...

    struts+spring+hibernate 分页

    在 Struts+Spring+Hibernate 结构中实现分页，需要结合这三大框架的特点来设计和实现。 首先，Struts 在控制器层中处理用户的请求，比如用户点击分页链接时，Struts 框架会调用相应的Action类方法。在这个方法中，...

    Struts＋Spring＋Hibernate开发实例 （SSH整合）

    Struts、Spring、Hibernate（SSH）是Java Web开发中三个非常重要的开源框架，它们分别用于MVC模式的实现、依赖注入和持久化管理。SSH整合是将这三个框架结合在一起，以构建更高效、可维护性更强的企业级应用。本文...

    struts2 + spring 3 + hibernate3.3整合实现图书馆管理管理

    Struts2、Spring和Hibernate是Java Web开发中的三大框架，它们的整合应用广泛用于构建复杂的Web应用程序，如本例中的图书馆管理系统。这个系统实现了用户登录和注册功能，并且提供了对书籍表的操作，包括增、删、改...

    Struts+Spring+Hibernate(CRUD操作案例)-分页查询

    前段时间时间当我在学习SSH框架技术的时候,在网上很难找到关于SSH的完整例子，比如最基本的CRUD操作和用的比较多的查询分页技术。为了让SSH初学者更清楚全面的学习，不再像我初学时候迷失方向。特花了2天时间做一个...

Magicbox
Global site tag (gtag.js) - Google Analytics