打造SSH1整合下的通用泛型DAO+分页，基于HibernateTemplate

注：其中分页封装的思想和代码来自springside，特此感谢！

个人也是初学SSH，这也是对以前我发布的通用泛型DAO的一个升级（J2EE学习笔记——初试SSH之泛型通用DAO ）

 

共包含3个类：BaseHibernateDAO，Page，QueryParameter

 

BaseHibernateDAO.java

 

Java代码

1. /**  
2.  * DAO操作基类<br>  
3.  * 本DAO层实现了通用的数据操作  
4.  *   
5.  * @author   
6.  *   
7.  * @param <T>  
8.  *            POJO实体对象  
9.  * @param <ID>  
10.  *            ID  
11.  */   
12. @SuppressWarnings ( "unchecked" )  
13. public   class  BaseHibernateDAO<T, ID  extends  Serializable>  extends   
14.         HibernateDaoSupport {  
15.   
16.     private   static   final  Logger logger = Logger  
17.             .getLogger(BaseHibernateDAO.class );  
18.   
19.     /**  
20.      * 保存指定实体类  
21.      *   
22.      * @param entityobj  
23.      *            实体类  
24.      */   
25.     public   void  save(T entity) {  
26.         try  {  
27.             getHibernateTemplate().save(entity);  
28.             if  (logger.isDebugEnabled()) {  
29.                 logger.debug("保存实体类成功,"  + entity.getClass().getName());  
30.             }  
31.         } catch  (RuntimeException e) {  
32.             logger.error("保存实体异常,"  + entity.getClass().getName(), e);  
33.             throw  e;  
34.         }  
35.     }  
36.   
37.     /**  
38.      * 删除指定实体  
39.      *   
40.      * @param entityobj  
41.      *            实体类  
42.      */   
43.     public   void  delete(T entity) {  
44.         try  {  
45.             getHibernateTemplate().delete(entity);  
46.             if  (logger.isDebugEnabled()) {  
47.                 logger.debug("删除实体类成功,"  + entity.getClass().getName());  
48.             }  
49.         } catch  (RuntimeException e) {  
50.             logger.error("删除实体异常" , e);  
51.             throw  e;  
52.         }  
53.     }  
54.   
55.     /**  
56.      * 获取所有实体集合  
57.      *   
58.      * @param entityClass  
59.      *            实体  
60.      * @return 集合  
61.      */   
62.     public  List<T> findAll(Class<T> entityClass) {  
63.         try  {  
64.             if  (logger.isDebugEnabled()) {  
65.                 logger.debug("开始删除实体："  + entityClass.getName());  
66.             }  
67.             return  getHibernateTemplate().find( "from "  + entityClass.getName());  
68.         } catch  (RuntimeException e) {  
69.             logger.error("查找指定实体集合异常，实体："  + entityClass.getName(), e);  
70.             throw  e;  
71.         }  
72.     }  
73.   
74.     /**  
75.      * 更新或保存指定实体  
76.      *   
77.      * @param entity  
78.      *            实体类  
79.      */   
80.     public   void  saveOrUpdate(T entity) {  
81.         try  {  
82.             getHibernateTemplate().saveOrUpdate(entity);  
83.             if  (logger.isDebugEnabled()) {  
84.                 logger.debug("更新或者保存实体成功,"  + entity.getClass().getName());  
85.             }  
86.         } catch  (RuntimeException e) {  
87.             logger.error("更新或保存实体异常" , e);  
88.             throw  e;  
89.         }  
90.     }  
91.   
92.     /**  
93.      * 查找指定ID实体类对象  
94.      *   
95.      * @param entityClass  
96.      *            实体Class  
97.      * @param id  
98.      *            实体ID  
99.      * @return 实体对象  
100.      */   
101.     public  T findById(Class<T> entityClass, ID id) {  
102.         try  {  
103.             if  (logger.isDebugEnabled()) {  
104.                 logger.debug("开始查找ID为"  + id +  "的实体："  + entityClass.getName());  
105.             }  
106.             return  (T) getHibernateTemplate().get(entityClass, id);  
107.         } catch  (RuntimeException e) {  
108.             logger.error("查找指定ID实体异常，ID："  + id, e);  
109.             throw  e;  
110.         }  
111.     }  
112.   
113.     /**  
114.      * 查询指定HQL，并返回集合  
115.      *   
116.      * @param hql  
117.      *            HQL语句  
118.      * @param values  
119.      *            可变的参数列表  
120.      * @return 集合  
121.      */   
122.     public  List<Object> find(String hql, Object... values) {  
123.         try  {  
124.             if  (logger.isDebugEnabled()) {  
125.                 logger.debug("开始查询指定HQL语句,"  + hql);  
126.             }  
127.             return  getHibernateTemplate().find(hql, values);  
128.         } catch  (RuntimeException e) {  
129.             logger.error("查询指定HQL异常，HQL："  + hql, e);  
130.             throw  e;  
131.         }  
132.     }  
133.   
134.     /**  
135.      * 按照HQL语句查询唯一对象.  
136.      *   
137.      * @param hql  
138.      *            HQL语句  
139.      * @param values  
140.      *            可变参数集合  
141.      * @return OBJECT对象  
142.      */   
143.     public  Object findUnique( final  String hql,  final  Object... values) {  
144.         try  {  
145.             if  (logger.isDebugEnabled()) {  
146.                 logger.debug("开始查询返回唯一结果的HQL语句,"  + hql);  
147.             }  
148.             return  getHibernateTemplate().execute( new  HibernateCallback() {  
149.                 public  Object doInHibernate(Session s)  
150.                         throws  HibernateException, SQLException {  
151.                     Query query = createQuery(s, hql, values);  
152.                     return  query.uniqueResult();  
153.                 }  
154.             });  
155.         } catch  (RuntimeException e) {  
156.             logger.error("查询指定HQL异常，HQL："  + hql, e);  
157.             throw  e;  
158.         }  
159.     }  
160.   
161.     /**  
162.      * 查找指定HQL并返回INT型  
163.      *   
164.      * @param hql  
165.      *            HQL语句  
166.      * @param values  
167.      *            可变参数列表  
168.      * @return INT  
169.      */   
170.     public   int  findInt( final  String hql,  final  Object... values) {  
171.         return  Tools.null2Int(findUnique(hql, values));  
172.     }  
173.   
174.     /**  
175.      * 获取指定实体Class指定条件的记录总数  
176.      *   
177.      * @param entityClass  
178.      *            实体Class  
179.      * @param where  
180.      *            HQL的查询条件,支持参数列表  
181.      * @param values  
182.      *            可变参数列表  
183.      * @return 记录总数  
184.      */   
185.     public   int  findTotalCount(Class<T> entityClass,  final  String where,  
186.             final  Object... values) {  
187.         String hql = "select count(e) from "  + entityClass.getName() +  " as e "   
188.                 + where;  
189.         return  findInt(hql, values);  
190.     }  
191.   
192.     /**  
193.      * 获取指定实体Class的记录总数  
194.      *   
195.      * @param entityClass  
196.      *            实体Class  
197.      * @return 记录总数  
198.      */   
199.     public   int  findTotalCount(Class<T> entityClass) {  
200.         return  findTotalCount(entityClass,  "" );  
201.     }  
202.   
203.     /**  
204.      * 查找指定属性的实体集合  
205.      *   
206.      * @param entityClass  
207.      *            实体  
208.      * @param propertyName  
209.      *            属性名  
210.      * @param value  
211.      *            条件  
212.      * @return 实体集合  
213.      */   
214.     public  List<T> findByProperty(Class<T> entityClass, String propertyName,  
215.             Object value) {  
216.         try  {  
217.             if  (logger.isDebugEnabled()) {  
218.                 logger.debug("开始查找指定属性："  + propertyName +  "为"  + value +  "的实体"   
219.                         + entityClass.getName());  
220.             }  
221.             String queryStr = "from "  + entityClass.getName()  
222.                     + " as model where model."  + propertyName +  "=?" ;  
223.             return  getHibernateTemplate().find(queryStr, value);  
224.         } catch  (RuntimeException e) {  
225.             logger.error("查找指定条件实体集合异常，条件："  + propertyName, e);  
226.             throw  e;  
227.         }  
228.     }  
229.   
230.     /**  
231.      * 模糊查询指定条件对象集合 <br>  
232.      * 用法：可以实例化一个空的T对象，需要查询某个字段，就set该字段的条件然后调用本方法<br>  
233.      * 缺点：目前测试貌似只能支持String的模糊查询，虽然有办法重写，但没必要，其他用HQL<br>  
234.      *   
235.      * @param entity  
236.      *            条件实体  
237.      * @return 结合  
238.      */   
239.     public  List<T> findByExample(T entity) {  
240.         try  {  
241.             List<T> results = getHibernateTemplate().findByExample(entity);  
242.             return  results;  
243.         } catch  (RuntimeException re) {  
244.             logger.error("查找指定条件实体集合异常" , re);  
245.             throw  re;  
246.         }  
247.     }  
248.   
249.     /**  
250.      * 补充方法(未测) 据说可以无视session的状态持久化对象  
251.      *   
252.      * @param entity  
253.      *            实体类  
254.      * @return 持久后的实体类  
255.      */   
256.     public  T merge(T entity) {  
257.         try  {  
258.             T result = (T) getHibernateTemplate().merge(entity);  
259.             return  result;  
260.         } catch  (RuntimeException re) {  
261.             logger.error("merge异常" , re);  
262.             throw  re;  
263.         }  
264.     }  
265.   
266.     /**  
267.      * 清除实体的锁定状态<br>  
268.      * 方法未测  
269.      *   
270.      * @param entity  
271.      *            实体  
272.      */   
273.     public   void  attachClean(T entity) {  
274.         try  {  
275.             getHibernateTemplate().lock(entity, LockMode.NONE);  
276.         } catch  (RuntimeException re) {  
277.             logger.error("实体解锁异常" , re);  
278.             throw  re;  
279.         }  
280.     }  
281.   
282.     /**  
283.      * 按HQL分页查询.  
284.      *   
285.      * @param page  
286.      *            页面对象  
287.      * @param hql  
288.      *            HQL语句  
289.      * @param values  
290.      *            可变参数列表  
291.      * @return 分页数据  
292.      */   
293.     public  Page<T> findByPage( final  Page<T> page,  final  String hql,  
294.             final  Object... values) {  
295.         try  {  
296.             if  (logger.isDebugEnabled()) {  
297.                 logger.debug("开始查找指定HQL分页数据,"  + hql);  
298.             }  
299.             return  (Page<T>) getHibernateTemplate().execute(  
300.                     new  HibernateCallback() {  
301.                         public  Object doInHibernate(Session s)  
302.                                 throws  HibernateException, SQLException {  
303.                             Query query = createQuery(s, hql, values);  
304.                             if  (page.isFirstSetted()) {  
305.                                 query.setFirstResult(page.getFirst());  
306.                             }  
307.                             if  (page.isPageSizeSetted()) {  
308.                                 query.setMaxResults(page.getPageSize());  
309.                             }  
310.                             page.setResult(query.list());  
311.                             if  (logger.isDebugEnabled()) {  
312.                                 logger.debug("查找指定HQL分页数据成功,"  + hql);  
313.                             }  
314.                             return  page;  
315.                         }  
316.                     });  
317.         } catch  (RuntimeException e) {  
318.             logger.error("分页查询异常，HQL："  + hql, e);  
319.             throw  e;  
320.         }  
321.     }  
322.   
323.     /**  
324.      * 根据查询条件与参数列表创建Query对象  
325.      *   
326.      * @param session  
327.      *            Hibernate会话  
328.      * @param hql  
329.      *            HQL语句  
330.      * @param objects  
331.      *            参数列表  
332.      * @return Query对象  
333.      */   
334.     public  Query createQuery(Session session, String hql, Object... objects) {  
335.         Query query = session.createQuery(hql);  
336.         if  (objects !=  null ) {  
337.             for  ( int  i =  0 ; i < objects.length; i++) {  
338.                 query.setParameter(i, objects[i]);  
339.             }  
340.         }  
341.         return  query;  
342.     }  
343.   
344.     /**  
345.      * 从Spring上下文中获取本类对象<br>  
346.      * 此方法可能存在线程并发问题（待测）  
347.      *   
348.      * @param context  
349.      *            Spring上下文  
350.      * @return 本类对象  
351.      */   
352.     public   static  BaseHibernateDAO getFromApplicationContext(  
353.             WebApplicationContext context) {  
354.         return  (BaseHibernateDAO) context.getBean( "BaseHibernateDAO" );  
355.     }  
356.   
357. }</strong></strong></strong></strong></strong>  

/**
 * DAO操作基类<br>
 * 本DAO层实现了通用的数据操作
 * 
 * @author 
 * 
 * @param <T>
 *            POJO实体对象
 * @param <ID>
 *            ID
 */
@SuppressWarnings("unchecked")
public class BaseHibernateDAO<T, ID extends Serializable> extends
		HibernateDaoSupport {

	private static final Logger logger = Logger
			.getLogger(BaseHibernateDAO.class);

	/**
	 * 保存指定实体类
	 * 
	 * @param entityobj
	 *            实体类
	 */
	public void save(T entity) {
		try {
			getHibernateTemplate().save(entity);
			if (logger.isDebugEnabled()) {
				logger.debug("保存实体类成功," + entity.getClass().getName());
			}
		} catch (RuntimeException e) {
			logger.error("保存实体异常," + entity.getClass().getName(), e);
			throw e;
		}
	}

	/**
	 * 删除指定实体
	 * 
	 * @param entityobj
	 *            实体类
	 */
	public void delete(T entity) {
		try {
			getHibernateTemplate().delete(entity);
			if (logger.isDebugEnabled()) {
				logger.debug("删除实体类成功," + entity.getClass().getName());
			}
		} catch (RuntimeException e) {
			logger.error("删除实体异常", e);
			throw e;
		}
	}

	/**
	 * 获取所有实体集合
	 * 
	 * @param entityClass
	 *            实体
	 * @return 集合
	 */
	public List<T> findAll(Class<T> entityClass) {
		try {
			if (logger.isDebugEnabled()) {
				logger.debug("开始删除实体：" + entityClass.getName());
			}
			return getHibernateTemplate().find("from " + entityClass.getName());
		} catch (RuntimeException e) {
			logger.error("查找指定实体集合异常，实体：" + entityClass.getName(), e);
			throw e;
		}
	}

	/**
	 * 更新或保存指定实体
	 * 
	 * @param entity
	 *            实体类
	 */
	public void saveOrUpdate(T entity) {
		try {
			getHibernateTemplate().saveOrUpdate(entity);
			if (logger.isDebugEnabled()) {
				logger.debug("更新或者保存实体成功," + entity.getClass().getName());
			}
		} catch (RuntimeException e) {
			logger.error("更新或保存实体异常", e);
			throw e;
		}
	}

	/**
	 * 查找指定ID实体类对象
	 * 
	 * @param entityClass
	 *            实体Class
	 * @param id
	 *            实体ID
	 * @return 实体对象
	 */
	public T findById(Class<T> entityClass, ID id) {
		try {
			if (logger.isDebugEnabled()) {
				logger.debug("开始查找ID为" + id + "的实体：" + entityClass.getName());
			}
			return (T) getHibernateTemplate().get(entityClass, id);
		} catch (RuntimeException e) {
			logger.error("查找指定ID实体异常，ID：" + id, e);
			throw e;
		}
	}

	/**
	 * 查询指定HQL，并返回集合
	 * 
	 * @param hql
	 *            HQL语句
	 * @param values
	 *            可变的参数列表
	 * @return 集合
	 */
	public List<Object> find(String hql, Object... values) {
		try {
			if (logger.isDebugEnabled()) {
				logger.debug("开始查询指定HQL语句," + hql);
			}
			return getHibernateTemplate().find(hql, values);
		} catch (RuntimeException e) {
			logger.error("查询指定HQL异常，HQL：" + hql, e);
			throw e;
		}
	}

	/**
	 * 按照HQL语句查询唯一对象.
	 * 
	 * @param hql
	 *            HQL语句
	 * @param values
	 *            可变参数集合
	 * @return OBJECT对象
	 */
	public Object findUnique(final String hql, final Object... values) {
		try {
			if (logger.isDebugEnabled()) {
				logger.debug("开始查询返回唯一结果的HQL语句," + hql);
			}
			return getHibernateTemplate().execute(new HibernateCallback() {
				public Object doInHibernate(Session s)
						throws HibernateException, SQLException {
					Query query = createQuery(s, hql, values);
					return query.uniqueResult();
				}
			});
		} catch (RuntimeException e) {
			logger.error("查询指定HQL异常，HQL：" + hql, e);
			throw e;
		}
	}

	/**
	 * 查找指定HQL并返回INT型
	 * 
	 * @param hql
	 *            HQL语句
	 * @param values
	 *            可变参数列表
	 * @return INT
	 */
	public int findInt(final String hql, final Object... values) {
		return Tools.null2Int(findUnique(hql, values));
	}

	/**
	 * 获取指定实体Class指定条件的记录总数
	 * 
	 * @param entityClass
	 *            实体Class
	 * @param where
	 *            HQL的查询条件,支持参数列表
	 * @param values
	 *            可变参数列表
	 * @return 记录总数
	 */
	public int findTotalCount(Class<T> entityClass, final String where,
			final Object... values) {
		String hql = "select count(e) from " + entityClass.getName() + " as e "
				+ where;
		return findInt(hql, values);
	}

	/**
	 * 获取指定实体Class的记录总数
	 * 
	 * @param entityClass
	 *            实体Class
	 * @return 记录总数
	 */
	public int findTotalCount(Class<T> entityClass) {
		return findTotalCount(entityClass, "");
	}

	/**
	 * 查找指定属性的实体集合
	 * 
	 * @param entityClass
	 *            实体
	 * @param propertyName
	 *            属性名
	 * @param value
	 *            条件
	 * @return 实体集合
	 */
	public List<T> findByProperty(Class<T> entityClass, String propertyName,
			Object value) {
		try {
			if (logger.isDebugEnabled()) {
				logger.debug("开始查找指定属性：" + propertyName + "为" + value + "的实体"
						+ entityClass.getName());
			}
			String queryStr = "from " + entityClass.getName()
					+ " as model where model." + propertyName + "=?";
			return getHibernateTemplate().find(queryStr, value);
		} catch (RuntimeException e) {
			logger.error("查找指定条件实体集合异常，条件：" + propertyName, e);
			throw e;
		}
	}

	/**
	 * 模糊查询指定条件对象集合 <br>
	 * 用法：可以实例化一个空的T对象，需要查询某个字段，就set该字段的条件然后调用本方法<br>
	 * 缺点：目前测试貌似只能支持String的模糊查询，虽然有办法重写，但没必要，其他用HQL<br>
	 * 
	 * @param entity
	 *            条件实体
	 * @return 结合
	 */
	public List<T> findByExample(T entity) {
		try {
			List<T> results = getHibernateTemplate().findByExample(entity);
			return results;
		} catch (RuntimeException re) {
			logger.error("查找指定条件实体集合异常", re);
			throw re;
		}
	}

	/**
	 * 补充方法(未测) 据说可以无视session的状态持久化对象
	 * 
	 * @param entity
	 *            实体类
	 * @return 持久后的实体类
	 */
	public T merge(T entity) {
		try {
			T result = (T) getHibernateTemplate().merge(entity);
			return result;
		} catch (RuntimeException re) {
			logger.error("merge异常", re);
			throw re;
		}
	}

	/**
	 * 清除实体的锁定状态<br>
	 * 方法未测
	 * 
	 * @param entity
	 *            实体
	 */
	public void attachClean(T entity) {
		try {
			getHibernateTemplate().lock(entity, LockMode.NONE);
		} catch (RuntimeException re) {
			logger.error("实体解锁异常", re);
			throw re;
		}
	}

	/**
	 * 按HQL分页查询.
	 * 
	 * @param page
	 *            页面对象
	 * @param hql
	 *            HQL语句
	 * @param values
	 *            可变参数列表
	 * @return 分页数据
	 */
	public Page<T> findByPage(final Page<T> page, final String hql,
			final Object... values) {
		try {
			if (logger.isDebugEnabled()) {
				logger.debug("开始查找指定HQL分页数据," + hql);
			}
			return (Page<T>) getHibernateTemplate().execute(
					new HibernateCallback() {
						public Object doInHibernate(Session s)
								throws HibernateException, SQLException {
							Query query = createQuery(s, hql, values);
							if (page.isFirstSetted()) {
								query.setFirstResult(page.getFirst());
							}
							if (page.isPageSizeSetted()) {
								query.setMaxResults(page.getPageSize());
							}
							page.setResult(query.list());
							if (logger.isDebugEnabled()) {
								logger.debug("查找指定HQL分页数据成功," + hql);
							}
							return page;
						}
					});
		} catch (RuntimeException e) {
			logger.error("分页查询异常，HQL：" + hql, e);
			throw e;
		}
	}

	/**
	 * 根据查询条件与参数列表创建Query对象
	 * 
	 * @param session
	 *            Hibernate会话
	 * @param hql
	 *            HQL语句
	 * @param objects
	 *            参数列表
	 * @return Query对象
	 */
	public Query createQuery(Session session, String hql, Object... objects) {
		Query query = session.createQuery(hql);
		if (objects != null) {
			for (int i = 0; i < objects.length; i++) {
				query.setParameter(i, objects[i]);
			}
		}
		return query;
	}

	/**
	 * 从Spring上下文中获取本类对象<br>
	 * 此方法可能存在线程并发问题（待测）
	 * 
	 * @param context
	 *            Spring上下文
	 * @return 本类对象
	 */
	public static BaseHibernateDAO getFromApplicationContext(
			WebApplicationContext context) {
		return (BaseHibernateDAO) context.getBean("BaseHibernateDAO");
	}

}

  

QueryParameter.java

 

Java代码

1. / **  
2.  * 本类封装分页和排序查询请求参数.  
3.  * 本类参考自springside的ORM封装设计  
4.  *   
5.  *   
6.  *   
7.  */   
8. public   class  QueryParameter {  
9.       
10.     public   static   final  String ASC =  "asc" ;  
11.     public   static   final  String DESC =  "desc" ;  
12.   
13.     protected   int  pageNo =  1 ;  
14.     protected   int  pageSize = - 1 ;  
15.     protected  String orderBy =  null ;  
16.     protected  String order = ASC;  
17.     protected   boolean  autoCount =  false ;  
18.   
19.     /**  
20.      * 获得每页的记录数量,无默认值.  
21.      */   
22.     public   int  getPageSize() {  
23.         return  pageSize;  
24.     }  
25.   
26.     public   void  setPageSize( int  pageSize) {  
27.         this .pageSize = pageSize;  
28.     }  
29.   
30.     /**  
31.      * 是否已设置每页的记录数量.  
32.      */   
33.     public   boolean  isPageSizeSetted() {  
34.         return  pageSize > - 1 ;  
35.     }  
36.   
37.     /**  
38.      * 获得当前页的页号,序号从1开始,默认为1.  
39.      */   
40.     public   int  getPageNo() {  
41.         return  pageNo;  
42.     }  
43.   
44.     public   void  setPageNo( int  pageNo) {  
45.         this .pageNo = pageNo;  
46.     }  
47.   
48.     /**  
49.      * 根据pageNo和pageSize计算当前页第一条记录在总结果集中的位置,序号从0开始.  
50.      */   
51.     public   int  getFirst() {  
52.         if  (pageNo <  1  || pageSize <  1 )  
53.             return  - 1 ;  
54.         else   
55.             return  ((pageNo -  1 ) * pageSize);  
56.     }  
57.   
58.     /**  
59.      * 是否已设置第一条记录记录在总结果集中的位置.  
60.      */   
61.     public   boolean  isFirstSetted() {  
62.         return  (pageNo >  0  && pageSize >  0 );  
63.     }  
64.   
65.     /**  
66.      * 获得排序字段,无默认值.  
67.      */   
68.     public  String getOrderBy() {  
69.         return  orderBy;  
70.     }  
71.   
72.     public   void  setOrderBy(String orderBy) {  
73.         this .orderBy = orderBy;  
74.     }  
75.   
76.     /**  
77.      * 是否已设置排序字段.  
78.      */   
79.     public   boolean  isOrderBySetted() {  
80.         return  StringUtils.isNotBlank(orderBy);  
81.     }  
82.   
83.     /**  
84.      * 获得排序方向,默认为asc.  
85.      */   
86.     public  String getOrder() {  
87.         return  order;  
88.     }  
89.   
90.     /**  
91.      * 设置排序方式向.  
92.      *   
93.      * @param order  
94.      *            可选值为desc或asc.  
95.      */   
96.     public   void  setOrder(String order) {  
97.         if  (ASC.equalsIgnoreCase(order) || DESC.equalsIgnoreCase(order)) {  
98.             this .order = order.toLowerCase();  
99.         } else   
100.             throw   new  IllegalArgumentException(  
101.                     "order should be 'desc' or 'asc'" );  
102.     }  
103.   
104.     /**  
105.      * 是否自动获取总页数,默认为false. 注意本属性仅于query by Criteria时有效,query by HQL时本属性无效.  
106.      */   
107.     public   boolean  isAutoCount() {  
108.         return  autoCount;  
109.     }  
110.   
111.     public   void  setAutoCount( boolean  autoCount) {  
112.         this .autoCount = autoCount;  
113.     }  
114. }  

/**
 * 本类封装分页和排序查询请求参数.
 * 本类参考自springside的ORM封装设计
 * 
 * 
 * 
 */
public class QueryParameter {
	
	public static final String ASC = "asc";
	public static final String DESC = "desc";

	protected int pageNo = 1;
	protected int pageSize = -1;
	protected String orderBy = null;
	protected String order = ASC;
	protected boolean autoCount = false;

	/**
	 * 获得每页的记录数量,无默认值.
	 */
	public int getPageSize() {
		return pageSize;
	}

	public void setPageSize(int pageSize) {
		this.pageSize = pageSize;
	}

	/**
	 * 是否已设置每页的记录数量.
	 */
	public boolean isPageSizeSetted() {
		return pageSize > -1;
	}

	/**
	 * 获得当前页的页号,序号从1开始,默认为1.
	 */
	public int getPageNo() {
		return pageNo;
	}

	public void setPageNo(int pageNo) {
		this.pageNo = pageNo;
	}

	/**
	 * 根据pageNo和pageSize计算当前页第一条记录在总结果集中的位置,序号从0开始.
	 */
	public int getFirst() {
		if (pageNo < 1 || pageSize < 1)
			return -1;
		else
			return ((pageNo - 1) * pageSize);
	}

	/**
	 * 是否已设置第一条记录记录在总结果集中的位置.
	 */
	public boolean isFirstSetted() {
		return (pageNo > 0 && pageSize > 0);
	}

	/**
	 * 获得排序字段,无默认值.
	 */
	public String getOrderBy() {
		return orderBy;
	}

	public void setOrderBy(String orderBy) {
		this.orderBy = orderBy;
	}

	/**
	 * 是否已设置排序字段.
	 */
	public boolean isOrderBySetted() {
		return StringUtils.isNotBlank(orderBy);
	}

	/**
	 * 获得排序方向,默认为asc.
	 */
	public String getOrder() {
		return order;
	}

	/**
	 * 设置排序方式向.
	 * 
	 * @param order
	 *            可选值为desc或asc.
	 */
	public void setOrder(String order) {
		if (ASC.equalsIgnoreCase(order) || DESC.equalsIgnoreCase(order)) {
			this.order = order.toLowerCase();
		} else
			throw new IllegalArgumentException(
					"order should be 'desc' or 'asc'");
	}

	/**
	 * 是否自动获取总页数,默认为false. 注意本属性仅于query by Criteria时有效,query by HQL时本属性无效.
	 */
	public boolean isAutoCount() {
		return autoCount;
	}

	public void setAutoCount(boolean autoCount) {
		this.autoCount = autoCount;
	}
}

 

Page.java

 

<strong><strong><strong><strong><strong>/**
 * 封装分页和排序查询的结果,并继承QueryParameter的所有查询请求参数.
 *
 * @param <T> Page中的记录类型.
 */
public class Page<T> extends QueryParameter {
    
    private List<T> result = null;

    private int totalCount = -1;

    public Page() {
    }

    public Page(int pageSize) {
        this.pageSize = pageSize;
    }

    public Page(int pageSize, boolean autoCount) {
        this.pageSize = pageSize;
        this.autoCount = autoCount;
    }

    /**