`

一个非常强大的SSH分页方法

    博客分类：
  • SSH
 
阅读更多

分页基本上是每个项目都会用到的模块。在这里我总结了一下网上主流的分页模式，自己做了一套。跟大家分享下

 

这个分页方法可以完成对任意表，任意查询条件的查询和分页。基本上可以代替项目中所有的数据库查询功能，当然只限于简单逻辑上的。初步整理，有什么不妥的地方还望大家指出、探讨。

 

首先是分页实体类：

 

view plain
  1. package  engine.entity;  
  2.   
  3. import  java.util.List;  
  4.   
  5. public   class  Pager {  
  6.     /**  
  7.      *  是否有上一页   
  8.      */   
  9.     private   boolean  hasPrePage;  
  10.     /**  
  11.      * 是否有下一页   
  12.      */   
  13.     private   boolean  hasNextPage;  
  14.     /**  
  15.      *  每页的数量   
  16.      */   
  17.     private   int  everyPage;  
  18.     /**  
  19.      *  总页数  
  20.      */   
  21.     private   int  totalPage;  
  22.     /**  
  23.      * 当前页   
  24.      */   
  25.     private   int  currentPage;   
  26.     /**  
  27.      *  起始点   
  28.      */   
  29.     private   int  beginIndex;   
  30.     /**  
  31.      *  总记录数  
  32.      */   
  33.     private   int  totalCount;   
  34.     /**  
  35.      * 该页名称  
  36.      */   
  37.     private  String pageName;   
  38.     /**  
  39.      * 查询条件  
  40.      */   
  41.     private  String conString;  
  42.     public  String getConString() {  
  43.         return  conString;  
  44.     }  
  45.     /**  
  46.      * 设置查询条件  
  47.      */   
  48.     public   void  setConString(String conditionString) {  
  49.         this .conString = conditionString;  
  50.     }  
  51.     /**  
  52.      * 设置该页名称（即查询表名）  
  53.      */   
  54.     public  String getPageName() {  
  55.         return  pageName;  
  56.     }  
  57.   
  58.     public   void  setPageName(String tableName) {  
  59.         this .pageName = tableName;  
  60.     }  
  61.   
  62.     public   int  getTotalCount() {  
  63.         return  totalCount;  
  64.     }  
  65.     /**  
  66.      *  设置总记录数  
  67.      */   
  68.     public   void  setTotalCount( int  totalCount) {  
  69.         this .totalCount = totalCount;  
  70.     }  
  71.     // construct the page by everyPage    
  72.     public  Pager( int  everyPage){  
  73.         this .everyPage = everyPage;  
  74.     }  
  75.     //The whole constructor    
  76.     public  Pager( boolean  hasPrePage,  boolean  hasNextPage,   
  77.                     int  everyPage,  int  totalPage,  
  78.                     int  currentPage,  int  beginIndex, int  totalCount,  
  79.                     String pageName,String conString) {  
  80.         this .hasPrePage = hasPrePage;  
  81.         this .hasNextPage = hasNextPage;  
  82.         this .everyPage = everyPage;  
  83.         this .totalPage = totalPage;  
  84.         this .currentPage = currentPage;  
  85.         this .beginIndex = beginIndex;  
  86.         this .totalCount = totalCount;  
  87.         this .pageName = pageName;  
  88.         this .conString = conString;  
  89.     }  
  90.     public   int  getBeginIndex() {  
  91.         return  beginIndex;  
  92.     }  
  93.     /**  
  94.      *  设置起始点   
  95.      */   
  96.     public   void  setBeginIndex( int  beginIndex) {  
  97.         this .beginIndex = beginIndex;  
  98.     }  
  99.     public   int  getCurrentPage() {  
  100.         return  currentPage;  
  101.     }  
  102.     /**  
  103.      * 设置当前页   
  104.      */   
  105.     public   void  setCurrentPage( int  currentPage) {  
  106.         this .currentPage = currentPage;  
  107.     }  
  108.     public   int  getEveryPage() {  
  109.         return  everyPage;  
  110.     }  
  111.     /**  
  112.      *  设置每页的数量   
  113.      */   
  114.     public   void  setEveryPage( int  everyPage) {  
  115.         this .everyPage = everyPage;  
  116.     }  
  117.     /**  
  118.      * 是否有下一页   
  119.      */   
  120.     public   boolean  getHasNextPage() {  
  121.         return  hasNextPage;  
  122.     }  
  123.     public   void  setHasNextPage( boolean  hasNextPage) {  
  124.         this .hasNextPage = hasNextPage;  
  125.     }  
  126.     /**  
  127.      * 是否有上一页   
  128.      */   
  129.     public   boolean  getHasPrePage() {  
  130.         return  hasPrePage;  
  131.     }  
  132.     public   void  setHasPrePage( boolean  hasPrePage) {  
  133.         this .hasPrePage = hasPrePage;  
  134.     }  
  135.     public   int  getTotalPage() {  
  136.         return  totalPage;  
  137.     }  
  138.     /**  
  139.      *  设置总页数  
  140.      */   
  141.     public   void  setTotalPage( int  totalPage) {  
  142.         this .totalPage = totalPage;  
  143.     }  
  144.   
  145. }  

 

然后创建分页结果集（将分页结果打包，便于访问）：

 

view plain
  1. package  engine.entity;  
  2.   
  3. import  java.util.List;  
  4.   
  5. public   class  Result {  
  6.     private  Pager pager;    
  7.     private  List content;    
  8.   
  9.          //The default constructor    
  10.         public  Result() {  
  11.             super ();  
  12.         }   
  13.          /**  
  14.           * @param 分页信息  
  15.           * @param 每页显示的集合  
  16.           */   
  17.         public  Result(Pager pager, List content) {  
  18.             this .pager = pager;  
  19.             this .content = content;  
  20.         }  
  21.   
  22.          
  23.         public  List getContent() {  
  24.             return  content;  
  25.         }  
  26.   
  27.          
  28.         public  Pager getPager() {  
  29.             return  pager;  
  30.         }  
  31.   
  32.          
  33.         public   void  setContent(List content) {  
  34.             this .content = content;  
  35.         }  
  36.   
  37.          
  38.         public   void  setPager(Pager pager) {  
  39.             this .pager = pager;  
  40.         }  
  41. }  

 

构建一个page的工厂PageUtil（处理分页相关计算）：

 

view plain
  1. package  engine;  
  2.   
  3. import  engine.entity.Pager;  
  4.   
  5. public   class  PagerUtil {  
  6.     // Use the origin page to create a new page   
  7.   
  8.   
  9.     public   static  Pager createPage(Pager page,  int  totalRecords) {  
  10.         return  createPage(page.getEveryPage(), page.getCurrentPage(),page.getPageName(),  
  11.                 page.getConString(),totalRecords);  
  12.     }  
  13.   
  14.   
  15.     //the basic page utils not including exception handler   
  16.   
  17.   
  18.     public   static  Pager createPage( int  everyPage,  int  currentPage,  
  19.             String pageName,String conString,int  totalRecords) {  
  20.         everyPage = getEveryPage(everyPage);  
  21.         currentPage = getCurrentPage(currentPage);  
  22.         int  beginIndex = getBeginIndex(everyPage, currentPage);  
  23.         int  totalPage = getTotalPage(everyPage, totalRecords);  
  24.         boolean  hasNextPage = hasNextPage(currentPage, totalPage);  
  25.         boolean  hasPrePage = hasPrePage(currentPage);  
  26.         System.out.println(everyPage+"*" +totalPage+ "*" +  
  27.                 currentPage+"*" +beginIndex+ "*" +totalRecords);  
  28.         return   new  Pager(hasPrePage, hasNextPage, everyPage, totalPage,  
  29.                 currentPage, beginIndex, totalRecords, pageName, conString);  
  30.     }  
  31.   
  32.     private   static   int  getEveryPage( int  everyPage) {  
  33.         return  everyPage ==  0  ?  10  : everyPage;  
  34.     }  
  35.   
  36.     private   static   int  getCurrentPage( int  currentPage) {  
  37.         return  currentPage ==  0  ?  1  : currentPage;  
  38.     }  
  39.   
  40.     private   static   int  getBeginIndex( int  everyPage,  int  currentPage) {  
  41.         return  (currentPage -  1 ) * everyPage;  
  42.     }  
  43.   
  44.     private   static   int  getTotalPage( int  everyPage,  int  totalRecords) {  
  45.         int  totalPage =  0 ;  
  46.       
  47.         if  (totalRecords % everyPage ==  0 )  
  48.             totalPage = totalRecords / everyPage;  
  49.         else   
  50.             totalPage = totalRecords / everyPage + 1 ;  
  51.       
  52.         return  totalPage;  
  53.     }  
  54.   
  55.     private   static   boolean  hasPrePage( int  currentPage) {  
  56.         return  currentPage ==  1  ?  false  :  true ;  
  57.     }  
  58.   
  59.     private   static   boolean  hasNextPage( int  currentPage,  int  totalPage) {  
  60.         return  currentPage == totalPage || totalPage ==  0  ?  false  :  true ;  
  61.     }  
  62.   
  63. }  

 

数据访问层接口：

 

view plain
  1. package  hibernate.dao;  
  2.   
  3. import  java.util.List;  
  4.   
  5. import  engine.entity.Pager;  
  6.   
  7. public   interface  PagerProductDAO {  
  8.     public   void  setPager(Pager pager);  
  9.     /**  
  10.      * @return 分页后的数据  
  11.      */   
  12.     public  List getProductByPage();   
  13.     /**  
  14.      * 不使用分页  
  15.      * @return 所有符合条件的数据  
  16.      */   
  17.     public  List getProducts();  
  18.     /**  
  19.      * @return 数据的总数  
  20.      */   
  21.     public   int  getProductCount();    
  22. }  

 

数据访问层接口实现：

 

view plain
  1. package  hibernate.dao;  
  2.   
  3. import  java.sql.SQLException;  
  4. import  java.util.List;  
  5.   
  6. import  org.hibernate.HibernateException;  
  7. import  org.hibernate.Query;  
  8. import  org.hibernate.Session;  
  9. import  org.springframework.orm.hibernate3.HibernateCallback;  
  10. import  org.springframework.orm.hibernate3.support.HibernateDaoSupport;  
  11.   
  12. import  engine.entity.Pager;  
  13.   
  14.   
  15. public   class  PagerProductDAOImpl  extends  HibernateDaoSupport  implements  PagerProductDAO {  
  16.   
  17.     Pager pager;  
  18.     public  Pager getPager() {  
  19.         return  pager;  
  20.     }  
  21.     public   void  setPager(Pager page) {  
  22.         this .pager = page;  
  23.     }  
  24.     public  List getProductByPage() {  
  25.         // TODO Auto-generated method stub   
  26.         return  getHibernateTemplate().executeFind( new  HibernateCallback(){  
  27.             public  Object doInHibernate(Session session)  throws  HibernateException, SQLException {  
  28.                 Query query=session.createQuery("from " +pager.getPageName()+ " where " +pager.getConString());  
  29.                 query.setFirstResult(pager.getBeginIndex()); //hibernate分页的精髓   
  30.                 query.setMaxResults(pager.getEveryPage());  
  31.                 return  query.list();  
  32.             }  
  33.             });  
  34.     }  
  35.     public  List getProducts(){  
  36.         return  getHibernateTemplate().find( "from " +pager.getPageName()+ " where " +pager.getConString());  
  37.           
  38.     }  
  39.     public   int  getProductCount() {  
  40.         // TODO Auto-generated method stub   
  41.         List list=getHibernateTemplate().find("from " +pager.getPageName()+ " where " +pager.getConString());  
  42.         return  ((Integer)list.size()).intValue();  
  43.   
  44.     }  
  45.   
  46. }  

 

业务层接口：

 

view plain
  1. package  engine;  
  2.   
  3. import  engine.entity.Pager;  
  4. import  engine.entity.Result;  
  5.   
  6. public   interface  PagerProduct {  
  7.     public  Result listProduct(Pager pager);  
  8. }  

 

业务层接口实现：

 

view plain
  1. package  engine.impl;  
  2.   
  3. import  java.util.List;  
  4.   
  5. import  engine.PagerProduct;  
  6. import  engine.PagerUtil;  
  7. import  engine.entity.Pager;  
  8. import  engine.entity.Result;  
  9. import  hibernate.dao.PagerProductDAO;  
  10.   
  11. public   class  PagerProductImpl  implements  PagerProduct {  
  12.   
  13.     private  PagerProductDAO pagerProductDAO;  
  14.     public  PagerProductDAO getPagerProductDAO() {  
  15.         return  pagerProductDAO;  
  16.     }  
  17.     public   void  setPagerProductDAO(PagerProductDAO pagerProductDAO) {  
  18.         this .pagerProductDAO = pagerProductDAO;  
  19.     }  
  20.     public  Result listProduct(Pager pager) {  
  21.         // TODO Auto-generated method stub   
  22.         this .pagerProductDAO.setPager(pager);  
  23.         List products=null ;  
  24.         if (pager.getEveryPage()== 0 ){  
  25.             //不使用分页   
  26.             products = this .pagerProductDAO.getProducts();  
  27.         }  
  28.         else {  
  29.             int  totalRecords =  this .pagerProductDAO.getProductCount();  
  30.             pager = PagerUtil.createPage(pager, totalRecords);  
  31.             //载入新生产的page   
  32.             this .pagerProductDAO.setPager(pager);  
  33.             products = this .pagerProductDAO.getProductByPage();       
  34.         }  
  35.         return   new  Result(pager, products);  
  36.     }  
  37.       
  38. }  

 

呼~~终于到productAction啦

 

 

view plain
  1. public   class  PlaceAction extends DispatchAction {  
  2.       
  3.     private  PagerProduct pagerProduct;  
  4.     public  PagerProduct getPagerProduct() {  
  5.         return  pagerProduct;  
  6.     }  
  7.   
  8.     public   void  setPagerProduct(PagerProduct pagerProduct) {  
  9.         this .pagerProduct = pagerProduct;  
  10.     }  
  11.   
  12.     public  ActionForward find(ActionMapping mapping, ActionForm form,  
  13.             HttpServletRequest request, HttpServletResponse response)  
  14.             throws Exception {  
  15.         Pager pager=new  Pager(10); //设置每页10条记录。若不想使用分页设为0即可   
  16.         String tableName="Place" ; //查询Place表   
  17.         pager.setPageName(tableName);  
  18.         String conditionString="Place_id>0" ; //设置查询条件即sql中where后面的语句   
  19.         pager.setConString(conditionString);  
  20.         int  pageNum=1; //当前显示第1页   
  21.         pager.setCurrentPage(pageNum);  
  22.         Result result = pagerProduct.listProduct(pager);  
  23.         //获取新的page，此时的page已经包所有的信息   
  24.         pager = result.getPager();  
  25.         request.setAttribute("PlaceView" , result);  
  26.         return  mapping.findForward( "PlaceView" );  
  27.     }  
  28. }  

在jsp页面中

 

view plain
  1. <%@ page language= "java"  pageEncoding= "gb2312" %>  
  2.   
  3. <%@ taglib uri="http://struts.apache.org/tags-bean"  prefix= "bean"  %>  
  4. <%@ taglib uri="http://struts.apache.org/tags-logic"  prefix= "logic"  %>  
  5.   
  6. <bean:define id="list"  name= "PlaceView"  property= "content"  type= "java.util.List" ></bean:define>  
  7. <bean:define id="pager"  name= "PlaceView"  property= "pager"  type= "engine.entity.Pager" ></bean:define>  
  8. <bean:define id="hasNextPage"  name= "pager"  property= "hasNextPage"  type= "java.lang.Boolean" ></bean:define>  
  9. <bean:define id="hasPrePage"  name= "pager"  property= "hasPrePage"  type= "java.lang.Boolean" ></bean:define>       
  10.          
  11.         <logic:empty name="list" >  
  12.             <div id="empty" >    
  13.                 <table border="0" >  
  14.                 <tr>  
  15.                     <td colspan="6" >没有可以显示的数据</td>  
  16.                 </tr>  
  17.                 </table>  
  18.             </div>  
  19.         </logic:empty>  
  20.         <logic:notEmpty name="list" >  
  21.             <logic:iterate id="i"  name= "list"  >   
  22.             <div id="place_${i.placeId }" >    
  23.                 <table border="0" >  
  24.                 <tr>  
  25.                     <td>  
  26.                         <input type="checkbox"  name= "selectFlag"  value= "${i.placeId }" >  
  27.                     </td>  
  28.                     <td>${i.placeId }</td>    
  29.                     <td>${i.placeName }</td>  
  30.                     <td>${i.placeNotes }</td>  
  31.                 </tr>    
  32.                 </table>   
  33.               </div>  
  34.             </logic:iterate>    
  35.         </logic:notEmpty>  
  36.       <logic:equal value="false"  name= "hasPrePage" >  
  37.             <span>[上一页]</span>  
  38.       </logic:equal>  
  39.       <logic:equal value="true"  name= "hasPrePage"  >  
  40.             <span><a href="javascript:changePage(${pager.currentPage-1 })"  mce_href= "javascript:changePage(${pager.currentPage-1 })" >[上一页]</a></span>  
  41.       </logic:equal>  
  42.       ${pager.currentPage }/${pager.totalPage }  
  43.       <logic:equal value="false"  name= "hasNextPage" >  
  44.             <span>[下一页]</span>  
  45.       </logic:equal>  
  46.             <logic:equal value="true"  name= "hasNextPage"  >  
  47.             <span><a href="javascript:changePage(${pager.currentPage+1 })"  mce_href= "javascript:changePage(${pager.currentPage+1 })" >[下一页]</a></span>  
  48.       </logic:equal>  

 

这样所有的分页功能就完成了，至于changePage（）这个JavaScript函数就是处理翻页的动作啦，大家应该都知道了吧，就不多说了。

 

 

 

转载From:http://blog.csdn.net/hytfly/article/details/5787462

分享到：
| Hibernate+Spring+Struts2整合开发中的一个 ...
评论
发表评论

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

相关推荐

    强大ssh分页实现

    好强大的ssh分页，封装的很好，适合初学者研究下，可以更快帮助初学者掌握分页机制，学起来不是很容易，但是当你学会了就豁然开朗，其他的分页直接可以藐视了，哈。。。我就是这样学过来的 有相关教程：...

    SSH通用分页组件 SSH分页

    SSH分页 分页 通用分页 struts2分页

    SSH 通用分页插件

    因此，分页功能成为了一个必要的优化手段。 SSH分页插件的核心功能是将数据库查询结果按照一定的页码和每页记录数进行切割，使得用户可以逐页浏览，提高用户体验并减轻服务器负担。这个插件通常会集成到SSH框架中，...

    很好的一个SSH分页小例子

    3. **Hibernate**：是一个强大的ORM（对象关系映射）框架，负责将Java对象与数据库中的表进行映射，简化了数据库操作。在分页中，Hibernate提供查询功能，以获取指定范围内的数据。 分页实现步骤如下： 1. **配置*...

    非常强大的SSH分页

    这里提到的“非常强大的SSH分页”可能指的是一个用于Java后端开发的SSH（Spring、Struts2、Hibernate）框架中的高效分页实现。 首先，我们来看一下提供的`Page`类，这是一个简单的分页对象，包含了分页所需的基本...

    SSH分页查询方法

    "SSH分页查询方法"是指在使用Struts2、Hibernate和Spring三大Java开发框架集成开发时实现的分页功能。 首先，Struts2是一个MVC（Model-View-Controller）框架，它负责处理用户请求并将其转发到相应的控制器，进而...

    ssh分页经典代码

    3. **编写分页服务**: 在Service层，创建一个接口和实现类，定义分页查询的方法。这个方法接收页码和每页条数作为参数，调用DAO层的分页查询方法，返回分页结果。 4. **视图层处理**: 在Struts2的Action类中，调用...

    struts hibernate spring 分页ssh分页

    综上所述，SSH分页是Java企业级开发中的一个重要技术，它涉及到了Struts的控制层、Hibernate的数据访问层和Spring的整合及服务层，是提升应用性能和用户体验的关键手段之一。通过熟练掌握SSH分页，开发者可以更高效...

    ssh 分页 控件 （分页插件）

    总的来说，"ssh 分页 控件 （分页插件）"是一个便捷的工具，能够帮助SSH框架的开发者在JSP页面中轻松实现数据分页功能，提升项目开发效率和用户体验。通过对分页插件的配置和使用，我们可以更专注于业务逻辑，而不用...

    SSH分页_完整例子

    SSH（Struts + Spring + Hibernate）是一个经典的Java Web开发框架，它将MVC设计模式、依赖注入和持久层管理结合在一起，提供了强大的企业级应用开发能力。在这个"SSH分页_完整例子"中，我们将深入探讨如何在SSH框架...

    SSH+Mysql无刷新分页实例

    无刷新分页技术是现代网页设计中的一个重要特性，它允许用户在不重新加载整个页面的情况下浏览页面的不同部分。在SSH框架中实现这一功能，通常会用到AJAX（Asynchronous JavaScript and XML）技术。AJAX可以向服务器...

    SSH分页技术详解与实例

    SSH分页技术是Java Web开发中一种常见的数据处理方法，主要应用于大数据量的展示场景，如用户在浏览商品列表或论坛帖子时，通过分页来避免一次性加载所有数据导致的性能问题和用户体验下降。SSH指的是Spring、Struts...

    SSH分页完整实例

    在Struts中，我们可以创建一个Action类来处理分页请求。这个Action类会接收前端传来的参数，如当前页数和每页显示的数量，然后调用业务层进行处理。 Spring作为应用上下文和依赖注入框架，负责管理对象的生命周期和...

    SSH实现分页实例

    在分页场景中，我们需要创建一个专门的分页Action，该Action接收请求参数（如当前页数、每页条数），并调用服务层方法获取相应的分页数据。 Spring作为IoC/DI容器，负责管理对象的生命周期和依赖关系。在分页实例中...

    SSH分页（很实用）

    SSH分页技术是Java开发中一个非常实用的功能，尤其在处理大数据量的Web应用时，它能够有效地提高用户体验，避免一次性加载过多数据导致的性能问题。SSH是指Spring、Struts和Hibernate这三大开源框架的组合，它们在...

    用ssh实现的一个简单的分页

    这个项目为初学者提供了一个实践平台，通过学习和理解这三种分页方法，可以更好地掌握SSH框架在处理复杂业务场景时的能力。 压缩包内的SSHPaginationDemo文件可能包含以下几个关键部分： 1. **Action类**：实现了...

    SSH分页组件

    SSH（Struts + Spring + Hibernate）是Java Web开发中常用的一种技术栈，它结合了三个强大的开源框架：Struts作为MVC（Model-View-Controller）框架，Spring提供依赖注入和事务管理，Hibernate则用于对象关系映射。...

    ssh分页完整实例数据库mysql

    这个压缩包提供了一个使用SSH框架实现分页功能的完整实例，结合了MySQL数据库进行数据操作，非常适合初学者进行学习和实践。 首先，让我们深入理解SSH框架的核心组件： 1. **Struts2**：作为MVC（模型-视图-控制器...

    ssh 分页组件，含使用示例

    在给定的文件中，`Page.java`可能是一个代表分页信息的实体类，包含如当前页码、每页记录数、总记录数、总页数等属性，以及相应的getter和setter方法。这样的类有助于封装分页参数，并在前后端之间传递。 `...

    SSH分页源代码

    总的来说，这个"SSH分页源代码"实例是一个学习如何在Java Web环境中整合SSH框架，并利用它们处理分页问题的好资源。通过分析和理解源代码，开发者可以加深对SSH框架的理解，提升在实际项目中的应用能力。

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