自己对分页的理解

        最近要启动一个比较大的项目了。回忆以前做的那些web项目，快乐，痛苦，成功，失败都是经历过了。
        好久没动那些web了，都块忘记这么设计了，今天在java重新找出一些关于hibernate分页的帖子，受益良多。
        robbin大哥的说的最详细的 www.iteye.com/topic/14657
         www.iteye.com/topic/17857
        哈哈，有时间多复习是不错的。
         
        分页的主要思想是：
1：构造一个Page对象，把相关的属性设置好，比如记录数，每页包含条数，是否有下一页，是否有上一页，当前页，总页数等，然后通过Page工厂生成一个Page对象（构造的前题是：你必须知道记录总数，一般从数据中获取），最后通过对于数据库的分页语句得到结果，比如hibernate分页的写法是：

java 代码

 

1. String querySentence = "FROM user in class com.adt.po.User";    
2.        Query query = getSession().createQuery(querySentence);    
3.       query.setFirstResult(page.getBeginIndex())    
4.             .setMaxResults(page.getEveryPage());    
5.         return query.list();    

这样做的充分利用数据各自的特性，提供性能。
2：直接从数据load出所有数据，然后再对结果集进行处理。
    对所有数据的操作都是用一条语句就ok了，方便处理，缺点是，数据量大的时候性能会有影响。而且每次都去load这么多数据，不合理。看看代码，很简单

java 代码

 

1. /** 
2.  * @author wuhua 
3.  *  
4.  * 分页代码，实现策略是，用List类来保存所有对象，并以page为分页标记 
5.  */  
6.   
7. import java.util.List;  
8.   
9. public class PageModel {  
10.     private int page = 1; // 当前页  
11.   
12.     public int totalPages = 0; // 总页数  
13.   
14.     private int pageRecorders;// 每页5条数据  
15.   
16.     private int totalRows = 0; // 总数据数  
17.   
18.     private int pageStartRow = 0;// 每页的起始数  
19.   
20.     private int pageEndRow = 0; // 每页显示数据的终止数  
21.   
22.     private boolean hasNextPage = false; // 是否有下一页  
23.   
24.     private boolean hasPreviousPage = false; // 是否有前一页  
25.   
26.     private List list;  
27.   
28.     // private Iterator it;  
29.   
30.     public PageModel(List list, int pageRecorders) {  
31.         init(list, pageRecorders);// 通过对象集，记录总数划分  
32.     }  
33.   
34.     /** 
35.      *  
36.      */  
37.     public PageModel() {  
38.     }  
39.   
40.     /** 
41.      * @param list 
42.      * @param pageRecorders 
43.      */  
44.     public void init(List list, int pageRecorders) {  
45.         this.pageRecorders = pageRecorders;  
46.         this.list = list;  
47.         totalRows = list.size();  
48.         // it = list.iterator();  
49.         hasPreviousPage = false;  
50.         if ((totalRows % pageRecorders) == 0) {  
51.             totalPages = totalRows / pageRecorders;  
52.         } else {  
53.             totalPages = totalRows / pageRecorders + 1;  
54.         }  
55.   
56.         if (page >= totalPages) {  
57.             hasNextPage = false;  
58.         } else {  
59.             hasNextPage = true;  
60.         }  
61.   
62.         if (totalRows < pageRecorders) {  
63.             this.pageStartRow = 0;  
64.             this.pageEndRow = totalRows;  
65.         } else {  
66.             this.pageStartRow = 0;  
67.             this.pageEndRow = pageRecorders;  
68.         }  
69.     }  
70.   
71.     /** 
72.      * @return 返回 page。 
73.      */  
74.     public int getPage() {  
75.         return page;  
76.     }  
77.   
78.     /** 
79.      * @param page 
80.      *            要设置的 page。 
81.      */  
82.     public void setPage(int page) {  
83.         this.page = page;  
84.     }  
85.   
86.     /** 
87.      * @return Returns the pageRecorders. 
88.      */  
89.     public int getPageRecorders() {  
90.         return pageRecorders;  
91.     }  
92.   
93.     /** 
94.      * @param pageRecorders 
95.      *            The pageRecorders to set. 
96.      */  
97.     public void setPageRecorders(int pageRecorders) {  
98.         this.pageRecorders = pageRecorders;  
99.     }  
100.   
101.     /** 
102.      * @return Returns the pageEndRow. 
103.      */  
104.     public int getPageEndRow() {  
105.         return pageEndRow;  
106.     }  
107.   
108.     /** 
109.      * @return Returns the pageStartRow. 
110.      */  
111.     public int getPageStartRow() {  
112.         return pageStartRow;  
113.     }  
114.   
115.     /** 
116.      * @return Returns the totalPages. 
117.      */  
118.     public String getTotalPages() {  
119.         return this.toString(totalPages);  
120.     }  
121.   
122.     /** 
123.      * @return Returns the totalRows. 
124.      */  
125.     public String getTotalRows() {  
126.         return this.toString(totalRows);  
127.     }  
128.   
129.     /** 
130.      * @return Returns the hasNextPage. 
131.      */  
132.     public boolean isHasNextPage() {  
133.         return hasNextPage;  
134.     }  
135.   
136.     /** 
137.      * @param hasNextPage 
138.      *            The hasNextPage to set. 
139.      */  
140.     public void setHasNextPage(boolean hasNextPage) {  
141.         this.hasNextPage = hasNextPage;  
142.     }  
143.   
144.     /** 
145.      * @return Returns the hasPreviousPage. 
146.      */  
147.     public boolean isHasPreviousPage() {  
148.         return hasPreviousPage;  
149.     }  
150.   
151.     // 判断要不要分页  
152.     public boolean isNext() {  
153.         return list.size() > 8;  
154.     }  
155.   
156.     /** 
157.      * @param hasPreviousPage 
158.      *            The hasPreviousPage to set. 
159.      */  
160.     public void setHasPreviousPage(boolean hasPreviousPage) {  
161.         this.hasPreviousPage = hasPreviousPage;  
162.     }  
163.   
164.     public String toString(int temp) {  
165.         String str = Integer.toString(temp);  
166.         return str;  
167.     }  
168.   
169.     public void description() {  
170.   
171.         String description = "共有数据数:" + this.getTotalRows() +  
172.   
173.         "共有页数: " + this.getTotalPages() +  
174.   
175.         "当前页数为:" + this.getPage() +  
176.   
177.         " 是否有前一页: " + this.isHasPreviousPage() +  
178.   
179.         " 是否有下一页:" + this.isHasNextPage() +  
180.   
181.         " 开始行数:" + this.getPageStartRow() +  
182.   
183.         " 终止行数:" + this.getPageEndRow();  
184.   
185.         System.out.println(description);  
186.     }  
187.   
188.     public List getNextPage() {  
189.         page = page + 1;  
190.   
191.         disposePage();  
192.   
193.         System.out.println("用户凋用的是第" + page + "页");  
194.         this.description();  
195.         return getObjects(page);  
196.     }  
197.   
198.     /** 
199.      * 处理分页 
200.      */  
201.     private void disposePage() {  
202.   
203.         if (page == 0) {  
204.             page = 1;  
205.         }  
206.   
207.         if ((page - 1) > 0) {  
208.             hasPreviousPage = true;  
209.         } else {  
210.             hasPreviousPage = false;  
211.         }  
212.   
213.         if (page >= totalPages) {  
214.             hasNextPage = false;  
215.         } else {  
216.             hasNextPage = true;  
217.         }  
218.     }  
219.   
220.     public List getPreviousPage() {  
221.   
222.         page = page - 1;  
223.   
224.         if ((page - 1) > 0) {  
225.             hasPreviousPage = true;  
226.         } else {  
227.             hasPreviousPage = false;  
228.         }  
229.         if (page >= totalPages) {  
230.             hasNextPage = false;  
231.         } else {  
232.             hasNextPage = true;  
233.         }  
234.         this.description();  
235.         return getObjects(page);  
236.     }  
237.   
238.     /** 
239.      * 获取第几页的内容 
240.      *  
241.      * @param page 
242.      * @return 
243.      */  
244.     public List getObjects(int page) {  
245.         if (page == 0)  
246.             this.setPage(1);  
247.         else  
248.             this.setPage(page);  
249.         this.disposePage();  
250.         if (page * pageRecorders < totalRows) {// 判断是否为最后一页  
251.             pageEndRow = page * pageRecorders;  
252.             pageStartRow = pageEndRow - pageRecorders;  
253.         } else {  
254.             pageEndRow = totalRows;  
255.             pageStartRow = pageRecorders * (totalPages - 1);  
256.         }  
257.   
258.         List objects = null;  
259.         if (!list.isEmpty()) {  
260.             objects = list.subList(pageStartRow, pageEndRow);  
261.         }  
262.         this.description();  
263.         return objects;  
264.     }  
265.   
266.     public List getFistPage() {  
267.         if (this.isNext()) {  
268.             return list.subList(0, pageRecorders);  
269.         } else {  
270.             return list;  
271.         }  
272.     }  
273.   
274.     /** 
275.      * @return 返回 list。 
276.      */  
277.     public List getList() {  
278.         return list;  
279.     }  
280.   
281.     /** 
282.      * @param list 
283.      *            要设置的 list。 
284.      */  
285.     public void setList(List list) {  
286.         this.list = list;  
287.     }  
288.   
289.     /** 
290.      * @param totalRows 
291.      *            要设置的 totalRows。 
292.      */  
293.     public void setTotalRows(int totalRows) {  
294.         this.totalRows = totalRows;  
295.     }  
296. }  

3：采用缓存的机制，用户在第一次查询的时候把查询结果存入缓存中，这样用户下载下一页的时候，就不用再去从数据库中查询，也可以通过第一中方法，先查询，然后在存入缓存，可以这样理解，智能的记录用户的操作，如果用户有重复操作就可以把上次的操作结果展示给用户