Hibernate范型-离线分页实现（上）

         我们现在学习的是基于Hibernate的离线查询分页，我们在Web设计中可以选用Struts框架、JSTL等等来实现其功能。<o:p></o:p>

首先，我们要理解分页的算法，也要讲究效率，也就是说我们不能把所有的记录取出来，我们只取一个页面中需要显示的纪录，那么怎么去实现是我们关心的问题！不要着急，重在理解而是单纯技术实现。我采用Web框架两种方式来实现，attention!<o:p></o:p>

分页算法，也就是我们提供给客户方便的操作。一般有哪些东西呢？<o:p></o:p>

       上页、下页、首页、末页、导航到X页，页码导航。说到这里我们先放下，我们来说说取出页面的记录，也就是只取一段的记录。打开Hibernate API 看到Criteria 接口，public Criteria setMaxResults(int maxResults)，意思为：设置记录对象数目的上限，第二方法,public Criteria setFirstResult setFirstResult(int firstResult),意思：设置开始取得记录对象的下标，其中的第一对象下标为0。这样我们可以看出Hibernate提供很好的方法给我们实现分页。<o:p></o:p>

       我们产生了思路：我们只有设置firstResult得下标，我们这里把它叫做游标。我们只要控制游标就可以控制取得的记录就是我们想要得到的，下面要做的工作就是我们来控制index,下面我写了一个HPage的类来实现这个工作，也就是取得一些相关的值，其中我们关系的有：当前的页码、当前的游标等等，下面我们结合代码来说明下！~~~<o:p></o:p>

实现代码如下：

java 代码

1. public class HPage {   
2.     private int countPage;  //页面的数量   
3.     private int startIndex=0; //纪录游标       
4.     private int recordPerPage;  //每页中的记录数量   
5.     private int pageIndex=1;  //初始的页码   
6.     private boolean nextPage=true;   
7.     private boolean previousPage=false;   
8.     private boolean firstPage=true;   
9.     private boolean lastPage=false;   
10.     public int getCountPage()  //取得页面的数量   
11.     {   
12.         return countPage;   
13.     }   
14.     public int getStartIndex() //取得游标的位置   
15.     {   
16.         return startIndex;   
17.     }   
18.     public HPage(int countRecord,int recordPerPage)     
19.     //coutRecord参数：纪录的总数量；recordPerPage参数：设置每页的记录数量   
20.     {   
21.         this.recordPerPage=recordPerPage;   
22.         if(countRecord % recordPerPage == 0)   
23.             countPage=countRecord / recordPerPage;   
24.         else  
25.             countPage=countRecord / recordPerPage +1;   
26.     }   
27.     public int getPageIndex() // 取得当前页码   
28.     {   
29.         return pageIndex;   
30.     }   
31.     public int nextPage() // 游标下一页滚动   
32.     {   
33.         pageIndex++;   
34.         if(isOnlyOne())   
35.         {   
36.             nextPage=false;   
37.             previousPage=false;   
38.             firstPage=false;   
39.             lastPage=false;   
40.         }   
41.         else  
42.         {   
43.             previousPage=true;   
44.             firstPage=true;   
45.         }   
46.         if(pageIndex > countPage)   
47.             return lastPage();   
48.         else  
49.         {   
50.             return (startIndex=forwardPage(pageIndex));   
51.         }   
52.     }   
53.     public int previousPage()  // 游标上一页滚动   
54.     {   
55.         pageIndex--;   
56.         if(isOnlyOne())   
57.         {   
58.             nextPage=false;   
59.             previousPage=false;   
60.             firstPage=false;   
61.             lastPage=false;   
62.         }   
63.         else  
64.         {   
65.             nextPage=true;   
66.             lastPage=true;   
67.         }   
68.         if(pageIndex <= 1)   
69.             return firstPage();   
70.         else  
71.         {   
72.             return (startIndex=forwardPage(pageIndex));   
73.         }   
74.     }   
75.     public int lastPage() // 游标向末页滚动   
76.     {   
77.         pageIndex=countPage;   
78.         if(isOnlyOne())   
79.         {   
80.             nextPage=false;   
81.             previousPage=false;   
82.             firstPage=false;   
83.             lastPage=false;   
84.         }   
85.         else  
86.         {   
87.             nextPage=false;   
88.             previousPage=true;   
89.             firstPage=true;   
90.             lastPage=false;   
91.         }   
92.         return (startIndex=(countPage-1) * recordPerPage);   
93.     }   
94.     public int firstPage() // 游标向首页滚动   
95.     {   
96.         pageIndex=1;   
97.         if(isOnlyOne())   
98.         {   
99.             nextPage=false;   
100.             previousPage=false;   
101.             firstPage=false;   
102.             lastPage=false;   
103.         }   
104.         else  
105.         {   
106.             nextPage=true;   
107.             previousPage=false;   
108.             firstPage=false;   
109.             lastPage=true;   
110.         }   
111.         return (startIndex=0);   
112.     }   
113.     public int forwardPage(int pageIndex) //导向制定页面   
114.     {   
115.            
116.         if(pageIndex >= countPage)   
117.         {   
118.             pageIndex=countPage;   
119.             return (startIndex=lastPage());   
120.         }   
121.         else if(pageIndex <= 1)   
122.         {   
123.             pageIndex=1;   
124.             return startIndex=firstPage();   
125.         }   
126.         this.pageIndex=pageIndex;   
127.         if(isOnlyOne())   
128.         {   
129.             nextPage=false;   
130.             previousPage=false;   
131.             firstPage=false;   
132.             lastPage=false;   
133.         }   
134.         else  
135.         {   
136.             nextPage=true;   
137.             previousPage=true;   
138.             firstPage=true;   
139.             lastPage=true;   
140.         }   
141.         return (startIndex=(this.pageIndex -1)* recordPerPage);        
142.     }   
143.     private boolean isOnlyOne() //是否只有一页   
144.     {   
145.         return countPage==1 ? true : false;   
146.     }   
147.     public boolean isNextPage() //是否有下页   
148.     {   
149.         return nextPage;   
150.     }   
151.     public boolean isPreviousPage() //是否有上页   
152.     {   
153.         return previousPage;   
154.     }   
155.     public boolean isFirstPage() //是否首页   
156.     {   
157.         return firstPage;   
158.     }   
159.     public boolean isLastPage() //是否末页   
160.     {   
161.         return lastPage;   
162.     }      
163. }   

 

不是很难吧！好的，现在我们做好的工作就是取得了我们要的数值，下面要做的是加到Hibernate查询里面去，下面的工作很简单。但是我们要注意几个问题，第一个问题，我们的设计的目的不是为了解决一个问题，而是抽象出一个方案提供给相似的问题的解决方案。这样的话，我们最大化重利用代码，那么我们采用范性的特点（注意JDK5.0的特征，以前的版本会报错误）。下面我分析一下代码：<o:p></o:p>

java 代码

1. public class DisplayPageRecordList<t></t> { //泛型实现   
2.     private int startIndex;   
3.     private static final int DEFAULT_RECORD_PER_PAGE=5; //默认：每页中5条记录   
4.     private List<t></t> list;      
5.     private HPage page;   
6.     private int recordPerPage=DEFAULT_RECORD_PER_PAGE;   
7.     private final Session session=HibernateSessionFactory.getSession();   
8.     private DetachedCriteria deCriteria;   
9.     private Criteria criteria;     
10.     private int countRecord;   
11.     public DisplayPageRecordList(String className) throws ClassNotFoundException   
12.     //className参数：类的全定名称   
13.     {          
14.         deCriteria=DetachedCriteria.forClass(Class.forName(className)); //创造离线的查询   
15.         criteria=deCriteria.getExecutableCriteria(session);   
16.         criteria.setCacheable(true);           
17.         doInit();   
18.         page=new HPage(countRecord,recordPerPage);             
19.     }   
20.     public DisplayPageRecordList(int recordPerPage,String className) throws ClassNotFoundException   
21.     //recordPerPage参数：每页的纪录的条目数，className参数：同上个构造方法中   
22.     {   
23.            
24.         deCriteria=DetachedCriteria.forClass(Class.forName(className));   
25.         criteria=deCriteria.getExecutableCriteria(session);   
26.         criteria.setCacheable(true);   
27.         this.recordPerPage=recordPerPage;   
28.         doInit();   
29.         page=new HPage(countRecord,recordPerPage);             
30.     }      
31.     public DisplayPageRecordList(int recordPerPage,String className,Criterion criterion) throws ClassNotFoundException   
32.     //recordPerPage参数：同上个构造方法中，className参数：同上个构造方法中，criterion参数：设置查询条件   
33.     {   
34.            
35.         deCriteria=DetachedCriteria.forClass(Class.forName(className));   
36.         criteria=deCriteria.getExecutableCriteria(session);   
37.         criteria.add(criterion);   
38.         criteria.setCacheable(true);           
39.         doInit();   
40.         page=new HPage(countRecord,recordPerPage);             
41.     }      
42.     public void setRecordPerPage(int recordPerPage)   
43.     {   
44.         this.recordPerPage=recordPerPage;   
45.         page=new HPage(countRecord,recordPerPage);     
46.     }   
47.     private void doInit()   
48.     {   
49.         this.countRecord=criteria.list().size(); //计算数据库中所有的记录数        
50.     }   
51.     public void addCriterion(Criterion criterion)   
52.     {   
53.         criteria=criteria.add(criterion); //更改所有所有查询条件   
54.         doInit();   
55.     }   
56.     public void setCacheable(boolean cache) //是否启用缓存   
57.     {   
58.         criteria.setCacheable(cache);   
59.     }   
60.     public List doNextPage() //查询出下页中的纪录集   
61.     {   
62.         startIndex=page.nextPage();   
63.         criteria.setFirstResult(startIndex);   
64.         criteria.setMaxResults(this.recordPerPage);   
65.         list=criteria.list();   
66.         return list;   
67.     }   
68.     public List doPreviousPage() //查询出上页中的纪录集   
69.     {   
70.         startIndex=page.previousPage();   
71.         criteria.setFirstResult(startIndex);   
72.         criteria.setMaxResults(this.recordPerPage);   
73.         list=criteria.list();   
74.         return list;   
75.     }   
76.     public List doFirstPage() //查询出首页中的纪录集   
77.     {   
78.         startIndex=page.firstPage();   
79.         criteria.setFirstResult(startIndex);   
80.         criteria.setMaxResults(this.recordPerPage);   
81.         list=criteria.list();   
82.         return list;   
83.     }   
84.     public List doLastPage() //查询出末页中的纪录集   
85.     {   
86.         startIndex=page.lastPage();   
87.         criteria.setFirstResult(startIndex);   
88.         criteria.setMaxResults(this.recordPerPage);   
89.         list=criteria.list();   
90.         return list;   
91.     }   
92.     public List doForward(int pageIndex)   
93.     {   
94.         startIndex=page.forwardPage(pageIndex);   
95.         criteria.setFirstResult(startIndex);   
96.         criteria.setMaxResults(this.recordPerPage);   
97.         list=criteria.list();   
98.         return list;   
99.     }   
100.     public HPage getPage() //取得页面对象   
101.     {   
102.         return this.page;   
103.     }      
104. }   

 

以上代码中，实现了泛型-离线查询的页面的代码。上篇完，下篇我们来使用Struts和JSTL在网页上测试<o:p></o:p>

 

<o:p></o:p>