`
oceandeep
  • 浏览: 23796 次
  • 性别: Icon_minigender_1
  • 来自: 大连
社区版块
存档分类
最新评论

基于hibernate的泛型Dao框架

阅读更多

转载至http://llying.iteye.com/blog/406058

这个东西是一年前弄的,不过一直没用到,里面有些东西已经记不太清了,还好注释应该可以看懂。
目的是希望设计一个基于hibernate的泛型Dao框架
推荐一个J2EE的群:46176507

首先创建一个java项目GenericDao

我们创建一个包com.hb.generic.dao
该包用来作为我们的基础dao包
首先我们创建一个针对单个实体操作的泛型EntityDao<T>接口。

Java代码 复制代码
  1. /**  
  2.  * @author llying  
  3.  * @company qm  
  4.  */  
  5. public interface EntityDao<T> {   
  6.        
  7.     T get(Serializable id);   
  8.        
  9.     List<T> getAll();   
  10.        
  11.     void save(T newInstance);   
  12.        
  13.     void remove(T transientObject);   
  14.        
  15.     void removeById(Serializable id);   
  16.        
  17.     String getIdName(Class clazz);   
  18. }  
/**
 * @author llying
 * @company qm
 */
public interface EntityDao<T> {
	
	T get(Serializable id);
	
	List<T> getAll();
	
	void save(T newInstance);
	
	void remove(T transientObject);
	
	void removeById(Serializable id);
	
	String getIdName(Class clazz);
}


用于定义针对单个实体的CRUD操作。
接着我们在定义一个接口类HibernateCallback,定义一个回调接口。

Java代码 复制代码
  1. import org.hibernate.Session;   
  2. /**  
  3.  * @author llying  
  4.  * @company qm  
  5.  */  
  6. public interface HibernateCallback {   
  7.     Object doInHibernate(Session session);   
  8. }  
import org.hibernate.Session;
/**
 * @author llying
 * @company qm
 */
public interface HibernateCallback {
	Object doInHibernate(Session session);
}


接下来我们定义一个com.hb.generic.dao.utils包,
该包的目的是用于防治一些常用方法的抽取,该包中的一些类是我平时的收集和积累。
我们这里只对关键类进行说明
BeanUtils :工具类,通过反射机制对对象进行存取值
GenericUtils:工具类,取得类中的泛型类型
里面基本上都有都有注释
我们在com.hb.generic.dao.support包下创建一个分页类(不做具体介绍,基本上分页都差不多)
我们需要在com.hb.generic.dao包下创建HibernateDaoHandler接口

Java代码 复制代码
  1. import org.hibernate.Session;   
  2. /**  
  3.  * @author llying  
  4.  * @company qm  
  5.  */  
  6. public interface HibernateDaoHandler {   
  7.     Session getSession();   
  8. }  
import org.hibernate.Session;
/**
 * @author llying
 * @company qm
 */
public interface HibernateDaoHandler {
	Session getSession();
}


在用户使用的时候需要实现该接口获取session
接下来我们会创建HibernateDaoSupport类
Dao的基类: 提供分页函数和若干便捷查询方法,并对返回值作了泛型类型转换.

Java代码 复制代码
  1. package com.hb.generic.dao;   
  2.   
  3. import java.io.Serializable;   
  4. import java.util.ArrayList;   
  5. import java.util.List;   
  6. import java.util.regex.Matcher;   
  7. import java.util.regex.Pattern;   
  8.   
  9. import org.apache.commons.logging.Log;   
  10. import org.apache.commons.logging.LogFactory;   
  11. import org.hibernate.Criteria;   
  12. import org.hibernate.Query;   
  13. import org.hibernate.Session;   
  14. import org.hibernate.Transaction;   
  15. import org.hibernate.criterion.CriteriaSpecification;   
  16. import org.hibernate.criterion.Criterion;   
  17. import org.hibernate.criterion.Order;   
  18. import org.hibernate.criterion.Projection;   
  19. import org.hibernate.criterion.Projections;   
  20. import org.hibernate.criterion.Restrictions;   
  21. import org.hibernate.impl.CriteriaImpl;   
  22. import org.hibernate.impl.CriteriaImpl.OrderEntry;   
  23.   
  24. import com.hb.generic.dao.support.Page;   
  25. import com.hb.generic.dao.utils.Assert;   
  26. import com.hb.generic.dao.utils.BeanUtils;   
  27.   
  28. /**  
  29.  * Dao的基类.  
  30.  *   
  31.  * 提供分页函数和若干便捷查询方法,并对返回值作了泛型类型转换.  
  32.  * @author llying  
  33.  * @company qm  
  34.  */  
  35. public abstract class HibernateDaoSupport<T> implements HibernateDaoHandler {   
  36.   
  37.     private static final Log log = LogFactory.getLog(HibernateDaoSupport.class);   
  38.     public Object execute(HibernateCallback action){   
  39.         Assert.notNull(action, "Callback object 对象不能为 Null ");   
  40.         Session session = getSession();   
  41.         Transaction tr = session.beginTransaction();   
  42.         Object result = action.doInHibernate(session);   
  43.         tr.commit();   
  44.         session.close();   
  45.         return result;   
  46.     }   
  47.        
  48.     /**  
  49.      * 获取全部的对象  
  50.      * @param <T>  
  51.      * @param entityClass 对象类型  
  52.      * @return   
  53.      */  
  54.     @SuppressWarnings("unchecked")   
  55.     public <T>List<T> getAll(final Class<T> entityClass) {   
  56.         return (List<T>)execute(new HibernateCallback(){   
  57.             public Object doInHibernate(Session session) {   
  58.                 Criteria criteria = session.createCriteria(entityClass);   
  59.                 return criteria.list();   
  60.             }   
  61.         });   
  62.     }   
  63.        
  64.     /**  
  65.      * 获取全部对象,带排序功能  
  66.      * @param <T>  
  67.      * @param entityClass 实体对象  
  68.      * @param orderBy 排序字段  
  69.      * @param isAsc 升序或降序  
  70.      * @return  
  71.      */  
  72.     @SuppressWarnings({ "hiding""hiding""unchecked" })   
  73.     public <T> List <T> getAll(final Class<T> entityClass,final String orderBy,final boolean isAsc){   
  74.         Assert.hasText(orderBy);   
  75.         return (List<T>) execute(new HibernateCallback(){   
  76.   
  77.             public Object doInHibernate(Session session) {   
  78.                    
  79.                 if (isAsc)   
  80.                     return session.createCriteria(entityClass).addOrder(Order.asc(orderBy)).list();   
  81.                 return session.createCriteria(entityClass).addOrder(Order.desc(orderBy)).list();   
  82.             }   
  83.                
  84.         });   
  85.   
  86.     }   
  87.     /**  
  88.      * 保存对象  
  89.      * @param newInstance  
  90.      */  
  91.     @SuppressWarnings("unused")   
  92.     public void saveOrUpdate(final T newInstance){   
  93.         execute(new HibernateCallback(){   
  94.             public Object doInHibernate(Session session) {   
  95.                 session.saveOrUpdate(newInstance);   
  96.                 return null;   
  97.             }   
  98.         });   
  99.     }   
  100.     /**  
  101.      * 删除对象  
  102.      * @param transientObject  
  103.      */  
  104.     public void remove(final T transientObject) {   
  105.         execute(new HibernateCallback(){   
  106.             public Object doInHibernate(Session session) {   
  107.                 session.delete(transientObject);   
  108.                 return null;   
  109.             }   
  110.                
  111.         });   
  112.     }   
  113.        
  114.   
  115.        
  116.     /**  
  117.      *   
  118.      * @param entityClass  
  119.      * @param id  
  120.      */  
  121.     public void removeById(Class<T> entityClass, Serializable id) {   
  122.         remove( get(entityClass, id));   
  123.     }   
  124.        
  125.     /**  
  126.      * 根据Id获取对象。  
  127.      * @param <T>  
  128.      * @param entityClass  
  129.      * @param id 实体Id  
  130.      * @return 实体对象  
  131.      */  
  132.     @SuppressWarnings({ "hiding""unchecked" })   
  133.     public <T> T get(final Class<T> entityClass,final Serializable id) {   
  134.         return (T) execute(new HibernateCallback(){   
  135.             public Object doInHibernate(Session session) {   
  136.                 return session.get(entityClass, id);   
  137.             }   
  138.         });   
  139.     }   
  140.        
  141.     /**  
  142.      * 创建一个Query对象。  
  143.      * @param hql  
  144.      * @param values  
  145.      * @return  
  146.      */  
  147.     public Query createQuery(String hql,Object...values){   
  148.         Assert.hasText(hql);   
  149.         Query query = getSession().createQuery(hql);   
  150.         for(int i = 0;i<values.length;i++){   
  151.             query.setParameter(i, values[i]);   
  152.         }   
  153.         return query;   
  154.     }   
  155.        
  156.     /**  
  157.      * 创建Criteria对象。  
  158.      * @param <T>  
  159.      * @param entityClass  
  160.      * @param criterions  
  161.      * @return  
  162.      */  
  163.     public <T>Criteria createCriteria(Class<T> entityClass,Criterion...criterions){   
  164.         Criteria criteria = getSession().createCriteria(entityClass);   
  165.         for(Criterion c:criterions){   
  166.             criteria.add(c);   
  167.         }   
  168.         return criteria;   
  169.     }   
  170.     /**  
  171.      * 创建Criteria对象,有排序功能。  
  172.      * @param <T>  
  173.      * @param entityClass  
  174.      * @param orderBy  
  175.      * @param isAsc  
  176.      * @param criterions  
  177.      * @return  
  178.      */  
  179.     public <T>Criteria createCriteria(Class<T> entityClass,String orderBy,boolean isAsc,Criterion...criterions){   
  180.         Assert.hasText(orderBy);   
  181.         Criteria criteria = createCriteria(entityClass,criterions);   
  182.         if(isAsc){   
  183.             criteria.addOrder(Order.asc(orderBy));   
  184.         }else{   
  185.             criteria.addOrder(Order.desc(orderBy));   
  186.         }   
  187.         return criteria;   
  188.     }   
  189.        
  190.     /**  
  191.      * 根据hql查询  
  192.      * @param hql  
  193.      * @param values  
  194.      * @return  
  195.      */  
  196.     public List find(final String hql,final Object...values){   
  197.         Assert.hasText(hql);   
  198.            
  199.         return createQuery(hql, values).list();   
  200.            
  201. /*      return (List) execute(new HibernateCallback(){  
  202.  
  203.             public Object doInHibernate(Session session) {  
  204.                 Query query = session.createQuery(hql);  
  205.                 for(int i = 0;i<values.length;i++){  
  206.                     query.setParameter(i, values[i]);  
  207.                 }  
  208.                 return query.list();  
  209.             }  
  210.               
  211.         });*/  
  212.     }   
  213.        
  214.     /**  
  215.      * 根据属性名和属性值查询.  
  216.      *  
  217.      * @return  
  218.      */  
  219.     public <T>List<T> findBy(Class<T> entityClass,String propertyName,Object value){   
  220.         Assert.hasText(propertyName);   
  221.         return createCriteria(entityClass, Restrictions.eq(propertyName, value)).list();   
  222.     }   
  223.        
  224.     /**  
  225.      * 根据属性名和属性值查询. 有排序  
  226.      * @param <T>  
  227.      * @param entityClass  
  228.      * @param propertyName  
  229.      * @param value  
  230.      * @param orderBy  
  231.      * @param isAsc  
  232.      * @return  
  233.      */  
  234.     public <T>List<T> findBy(Class<T> entityClass,String propertyName,Object value,String orderBy,boolean isAsc){   
  235.         Assert.hasText(propertyName);   
  236.         Assert.hasText(orderBy);   
  237.         return createCriteria(entityClass, orderBy, isAsc, Restrictions.eq(propertyName, value)).list();   
  238.     }   
  239.        
  240.     /**  
  241.      * 根据属性名和属性值 查询 且要求对象唯一.  
  242.      *  
  243.      * @return 符合条件的唯一对象.  
  244.      */  
  245.     public <T>T findUniqueBy(Class<T> entityClass,String propertyName,Object value){   
  246.         Assert.hasText(propertyName);   
  247.         return (T)createCriteria(entityClass, Restrictions.eq(propertyName, value)).uniqueResult();   
  248.     }   
  249.     /**  
  250.      * 分页 通过hql进行  
  251.      * @param hql  
  252.      * @param pageNo  
  253.      * @param pageSize  
  254.      * @param values  
  255.      * @return  
  256.      */  
  257.     public Page pagedQuery(String hql,int pageNo,int pageSize,Object...values){   
  258.         Assert.hasText(hql);   
  259.         Assert.isTrue(pageNo>=1);   
  260.         String countQueryString = "select count(*)" + removeSelect(removeOrders(hql));   
  261.         System.out.println(countQueryString);   
  262.         List countList = find(countQueryString, values);   
  263.         long totalCount =  (Long) countList.get(0);   
  264.         System.out.println(totalCount);   
  265.         if(totalCount<1){   
  266.             return new Page();   
  267.         }   
  268.         int startIndex = Page.getStartOfPage(pageNo, pageSize);   
  269.         Query query = createQuery(hql,values);   
  270.         List list = query.setFirstResult(startIndex).setMaxResults(pageSize).list();   
  271.         return new Page(startIndex,totalCount,pageSize,list);   
  272.     }   
  273.     /**  
  274.      * 分页 通过criteria  
  275.      * @param criteria  
  276.      * @param pageNo  
  277.      * @param pageSize  
  278.      * @return  
  279.      */  
  280.     public Page pagedQuery(Criteria criteria,int pageNo,int pageSize){   
  281.         Assert.notNull(criteria);   
  282.         Assert.isTrue(pageNo>=1);   
  283.         CriteriaImpl criteriaImpl = (CriteriaImpl) criteria;   
  284.            
  285.         //先把Projection和OrderBy条件取出来,清空两者来执行Count操作   
  286.         Projection projection = criteriaImpl.getProjection();   
  287.         List<CriteriaImpl.OrderEntry> orderEntitys = null;   
  288.         try {   
  289.             orderEntitys=(List<OrderEntry>) BeanUtils.forceGetProperty(criteriaImpl, "orderEntries");   
  290.             BeanUtils.forceSetProperty(criteriaImpl, "orderEntries"new ArrayList());   
  291.         } catch (NoSuchFieldException e) {   
  292.             e.printStackTrace();   
  293.         }   
  294.         //取得总的数据数   
  295.         long totalCount = (Long) criteria.setProjection(Projections.rowCount()).uniqueResult();   
  296.         //将之前的Projection和OrderBy条件重新设回去   
  297.         criteria.setProjection(projection);   
  298.         if (projection == null) {   
  299.             criteria.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);   
  300.         }   
  301.            
  302.         try {   
  303.             BeanUtils.forceSetProperty(criteriaImpl, "orderEntries", orderEntitys);   
  304.         } catch (NoSuchFieldException e) {   
  305.             e.printStackTrace();   
  306.         }   
  307.         if(totalCount<1)   
  308.             return new Page();   
  309.         int startIndex = Page.getStartOfPage(pageNo, pageSize);   
  310.         List data = criteria.setFirstResult(startIndex).setMaxResults(pageSize).list();   
  311.         return new Page( startIndex, totalCount, pageSize, data);   
  312.     }   
  313.        
  314.     /**  
  315.      * 分页查询函数  
  316.      * @param entityClass  
  317.      * @param pageNo  
  318.      * @param pageSize  
  319.      * @param criterions  
  320.      * @return  
  321.      */  
  322.     public Page pagedQuery(Class<T> entityClass,int pageNo,int pageSize,Criterion...criterions){   
  323.         Criteria criteria = createCriteria(entityClass, criterions);   
  324.         return pagedQuery(criteria, pageNo, pageSize);   
  325.     }   
  326.        
  327.     /**  
  328.      * 分页查询带排序  
  329.      * @param entityClass  
  330.      * @param pageNo  
  331.      * @param pageSize  
  332.      * @param orderBy  
  333.      * @param isAsc  
  334.      * @param criterions  
  335.      * @return  
  336.      */  
  337.     public Page pagedQuery(Class<T> entityClass,int pageNo,int pageSize,String orderBy,boolean isAsc,Criterion...criterions){   
  338.         Criteria criteria = createCriteria(entityClass, orderBy, isAsc, criterions);   
  339.         return pagedQuery(criteria, pageNo, pageSize);   
  340.     }   
  341.        
  342.     /**  
  343.      * 去除hql的select子句。  
  344.      * @param hql  
  345.      * @return  
  346.      * @see #pagedQuery(String,int,int,Object[])  
  347.      */  
  348.     private static String removeSelect(String hql){   
  349.         Assert.hasText(hql);   
  350.         int beginPos = hql.toLowerCase().indexOf("from");   
  351.         Assert.isTrue(beginPos!=-1,hql);   
  352.         return hql.substring(beginPos);   
  353.     }   
  354.        
  355.     /**  
  356.      * 去除hql的orderBy子句。  
  357.      * @param hql  
  358.      * @return  
  359.      * @see #pagedQuery(String,int,int,Object[])  
  360.      */  
  361.     private static String removeOrders(String hql) {   
  362.         Assert.hasText(hql);   
  363.         Pattern p = Pattern.compile("order\\s*by[\\w|\\W|\\s|\\S]*", Pattern.CASE_INSENSITIVE);   
  364.         Matcher m = p.matcher(hql);   
  365.         StringBuffer sb = new StringBuffer();   
  366.         while (m.find()) {   
  367.             m.appendReplacement(sb, "");   
  368.         }   
  369.         m.appendTail(sb);   
  370.         return sb.toString();   
  371.     }   
  372.   
  373. }  
package com.hb.generic.dao;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.CriteriaSpecification;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.hibernate.impl.CriteriaImpl;
import org.hibernate.impl.CriteriaImpl.OrderEntry;

import com.hb.generic.dao.support.Page;
import com.hb.generic.dao.utils.Assert;
import com.hb.generic.dao.utils.BeanUtils;

/**
 * Dao的基类.
 * 
 * 提供分页函数和若干便捷查询方法,并对返回值作了泛型类型转换.
 * @author llying
 * @company qm
 */
public abstract class HibernateDaoSupport<T> implements HibernateDaoHandler {

	private static final Log log = LogFactory.getLog(HibernateDaoSupport.class);
	public Object execute(HibernateCallback action){
		Assert.notNull(action, "Callback object 对象不能为 Null ");
		Session session = getSession();
		Transaction tr = session.beginTransaction();
		Object result = action.doInHibernate(session);
		tr.commit();
		session.close();
		return result;
	}
	
	/**
	 * 获取全部的对象
	 * @param <T>
	 * @param entityClass 对象类型
	 * @return 
	 */
	@SuppressWarnings("unchecked")
	public <T>List<T> getAll(final Class<T> entityClass) {
		return (List<T>)execute(new HibernateCallback(){
			public Object doInHibernate(Session session) {
				Criteria criteria = session.createCriteria(entityClass);
				return criteria.list();
			}
		});
	}
	
	/**
	 * 获取全部对象,带排序功能
	 * @param <T>
	 * @param entityClass 实体对象
	 * @param orderBy 排序字段
	 * @param isAsc 升序或降序
	 * @return
	 */
	@SuppressWarnings({ "hiding", "hiding", "unchecked" })
	public <T> List <T> getAll(final Class<T> entityClass,final String orderBy,final boolean isAsc){
		Assert.hasText(orderBy);
		return (List<T>) execute(new HibernateCallback(){

			public Object doInHibernate(Session session) {
				
				if (isAsc)
					return session.createCriteria(entityClass).addOrder(Order.asc(orderBy)).list();
				return session.createCriteria(entityClass).addOrder(Order.desc(orderBy)).list();
			}
			
		});

	}
	/**
	 * 保存对象
	 * @param newInstance
	 */
	@SuppressWarnings("unused")
	public void saveOrUpdate(final T newInstance){
		execute(new HibernateCallback(){
			public Object doInHibernate(Session session) {
				session.saveOrUpdate(newInstance);
				return null;
			}
		});
	}
	/**
	 * 删除对象
	 * @param transientObject
	 */
	public void remove(final T transientObject) {
		execute(new HibernateCallback(){
			public Object doInHibernate(Session session) {
				session.delete(transientObject);
				return null;
			}
			
		});
	}
	

	
	/**
	 * 
	 * @param entityClass
	 * @param id
	 */
	public void removeById(Class<T> entityClass, Serializable id) {
		remove( get(entityClass, id));
	}
	
	/**
	 * 根据Id获取对象。
	 * @param <T>
	 * @param entityClass
	 * @param id 实体Id
	 * @return 实体对象
	 */
	@SuppressWarnings({ "hiding", "unchecked" })
	public <T> T get(final Class<T> entityClass,final Serializable id) {
		return (T) execute(new HibernateCallback(){
			public Object doInHibernate(Session session) {
				return session.get(entityClass, id);
			}
		});
	}
	
	/**
	 * 创建一个Query对象。
	 * @param hql
	 * @param values
	 * @return
	 */
	public Query createQuery(String hql,Object...values){
		Assert.hasText(hql);
		Query query = getSession().createQuery(hql);
		for(int i = 0;i<values.length;i++){
			query.setParameter(i, values[i]);
		}
		return query;
	}
	
	/**
	 * 创建Criteria对象。
	 * @param <T>
	 * @param entityClass
	 * @param criterions
	 * @return
	 */
	public <T>Criteria createCriteria(Class<T> entityClass,Criterion...criterions){
		Criteria criteria = getSession().createCriteria(entityClass);
		for(Criterion c:criterions){
			criteria.add(c);
		}
		return criteria;
	}
	/**
	 * 创建Criteria对象,有排序功能。
	 * @param <T>
	 * @param entityClass
	 * @param orderBy
	 * @param isAsc
	 * @param criterions
	 * @return
	 */
	public <T>Criteria createCriteria(Class<T> entityClass,String orderBy,boolean isAsc,Criterion...criterions){
		Assert.hasText(orderBy);
		Criteria criteria = createCriteria(entityClass,criterions);
		if(isAsc){
			criteria.addOrder(Order.asc(orderBy));
		}else{
			criteria.addOrder(Order.desc(orderBy));
		}
		return criteria;
	}
	
	/**
	 * 根据hql查询
	 * @param hql
	 * @param values
	 * @return
	 */
	public List find(final String hql,final Object...values){
		Assert.hasText(hql);
		
		return createQuery(hql, values).list();
		
/*		return (List) execute(new HibernateCallback(){

			public Object doInHibernate(Session session) {
				Query query = session.createQuery(hql);
				for(int i = 0;i<values.length;i++){
					query.setParameter(i, values[i]);
				}
				return query.list();
			}
			
		});*/
	}
	
	/**
	 * 根据属性名和属性值查询.
	 *
	 * @return
	 */
	public <T>List<T> findBy(Class<T> entityClass,String propertyName,Object value){
		Assert.hasText(propertyName);
		return createCriteria(entityClass, Restrictions.eq(propertyName, value)).list();
	}
	
	/**
	 * 根据属性名和属性值查询. 有排序
	 * @param <T>
	 * @param entityClass
	 * @param propertyName
	 * @param value
	 * @param orderBy
	 * @param isAsc
	 * @return
	 */
	public <T>List<T> findBy(Class<T> entityClass,String propertyName,Object value,String orderBy,boolean isAsc){
		Assert.hasText(propertyName);
		Assert.hasText(orderBy);
		return createCriteria(entityClass, orderBy, isAsc, Restrictions.eq(propertyName, value)).list();
	}
	
	/**
	 * 根据属性名和属性值 查询 且要求对象唯一.
	 *
	 * @return 符合条件的唯一对象.
	 */
	public <T>T findUniqueBy(Class<T> entityClass,String propertyName,Object value){
		Assert.hasText(propertyName);
		return (T)createCriteria(entityClass, Restrictions.eq(propertyName, value)).uniqueResult();
	}
	/**
	 * 分页 通过hql进行
	 * @param hql
	 * @param pageNo
	 * @param pageSize
	 * @param values
	 * @return
	 */
	public Page pagedQuery(String hql,int pageNo,int pageSize,Object...values){
		Assert.hasText(hql);
		Assert.isTrue(pageNo>=1);
		String countQueryString = "select count(*)" + removeSelect(removeOrders(hql));
		System.out.println(countQueryString);
		List countList = find(countQueryString, values);
		long totalCount =  (Long) countList.get(0);
		System.out.println(totalCount);
		if(totalCount<1){
			return new Page();
		}
		int startIndex = Page.getStartOfPage(pageNo, pageSize);
		Query query = createQuery(hql,values);
		List list = query.setFirstResult(startIndex).setMaxResults(pageSize).list();
		return new Page(startIndex,totalCount,pageSize,list);
	}
	/**
	 * 分页 通过criteria
	 * @param criteria
	 * @param pageNo
	 * @param pageSize
	 * @return
	 */
	public Page pagedQuery(Criteria criteria,int pageNo,int pageSize){
		Assert.notNull(criteria);
		Assert.isTrue(pageNo>=1);
		CriteriaImpl criteriaImpl = (CriteriaImpl) criteria;
		
		//先把Projection和OrderBy条件取出来,清空两者来执行Count操作
		Projection projection = criteriaImpl.getProjection();
		List<CriteriaImpl.OrderEntry> orderEntitys = null;
		try {
			orderEntitys=(List<OrderEntry>) BeanUtils.forceGetProperty(criteriaImpl, "orderEntries");
			BeanUtils.forceSetProperty(cr

  


  
分享到:
评论

相关推荐

    Hibernate泛型Dao

    【标题】"Hibernate泛型Dao"是针对Java开发中的数据持久化框架Hibernate的一个高级应用,主要目的是为了提高代码的复用性和简洁性。在传统的Hibernate使用中,针对每个实体类,我们都需要创建一个对应的Dao(Data ...

    Hibernate泛型DAO(结合spring模板支持)

    至于`Dao经典泛型.doc`文件,可能是更深入的关于Hibernate泛型DAO的文档,可能包含了如何配置Spring、如何处理复杂查询以及如何优化泛型DAO的更多细节。阅读这份文档将进一步提升你对泛型DAO的理解和应用能力。 ...

    Hibernate泛型DAO接口,大部分通用都已包括

    本篇将详细介绍"Hibernate泛型DAO接口,大部分通用都已包括"这一主题。 首先,让我们看看DAO的概念。DAO是软件设计模式中的一种,它的主要职责是封装对数据源的访问,以提供业务逻辑层与数据存储层之间的解耦。通过...

    spring hibernate 泛型DAO

    总结起来,"Spring Hibernate 泛型DAO"的主题涵盖了Spring框架的IoC容器与Hibernate的ORM能力,通过泛型和Criteria查询,我们可以实现更加高效、可复用的DAO层代码。这样的设计使得项目结构更加清晰,减少了代码冗余...

    Hibernate泛型DAO及使用方法

    而`Hibernate泛型DAO`则是为了减少代码重复性,提高代码复用性和可维护性的一种设计模式。本文将深入探讨`Hibernate泛型DAO`的实现及其使用方法。 首先,DAO(Data Access Object)模式是一种设计模式,它的主要...

    Hibernate泛型DAO及使用方法.doc

    而泛型DAO(Data Access Object)则是基于Hibernate进一步抽象出来的一个设计模式,用于提供更通用的数据操作方法。本文档主要探讨了如何在Spring+Hibernate环境中创建和使用泛型DAO。 首先,我们来看一下泛型DAO...

    Hibernate泛型DAO及使用方法借鉴.pdf

    《Hibernate泛型DAO及使用方法借鉴》 在Java开发中,特别是使用Spring+Hibernate框架时,泛型DAO(Data Access Object)是常见的设计模式,它提供了对数据库操作的一般化接口,以提高代码的重用性和可维护性。本文...

    经典泛型dao层代码,非常好用简易

    本文将深入探讨一种在SSH(Struts+Spring+Hibernate)框架中广泛应用的经典泛型DAO层实现方式,旨在展示其简洁性、高效性和灵活性。 #### 泛型DAO层:概念与优势 泛型DAO层通过利用Java的泛型机制,提供了一种类型...

    一个简单的Hibernate泛型Dao的实现 ---- 20160624

    本文将深入探讨如何实现一个简单的Hibernate泛型DAO(数据访问对象),以提高代码的可重用性和可维护性。 首先,我们来看`AbstractHibernateGenericDao`类,这是一个抽象类,它通常会包含一些基本的CRUD(创建、...

    基于泛型的通用Dao接口和hibernate的实现

    1. 耦合性低:泛型Dao接口可以与不同的持久层框架集成,例如 Hibernate、JPA 等。 2. 灵活性高:泛型Dao接口可以适应不同的业务需求,例如不同的数据库、不同的数据类型等。 3. 代码重用性高:泛型Dao接口可以在不同...

    泛型dao

    这尤其适用于那些基于ORM(对象关系映射)框架,如Hibernate或MyBatis的项目,它们提供了与数据库交互的基础设施,我们可以直接在泛型DAO上构建。 在实际应用中,我们可能还需要考虑一些额外的细节,如事务管理、...

    S2SH整合例子 注解配置 JSON 泛型Dao

    6. **泛型Dao**:在Java开发中,泛型Dao(Generic Dao)是一种设计模式,用于减少重复的数据库操作代码。通过定义一个通用的Dao接口,可以实现对不同类型的实体对象进行CRUD操作,提高了代码的复用性和可维护性。...

    Struts2+hibernate+spring整合泛型DAO

    总结来说,"Struts2+hibernate+spring整合泛型DAO"是一种常见的Java Web开发模式,它利用三大框架的优势,结合泛型设计,提高了代码复用,降低了维护成本,使得开发者能更专注于业务逻辑,而不是基础架构。

    Java Web程序运用中泛型DAO的作用.pdf

    泛型DAO模式是基于Java泛型技术的一种设计模式,它在数据访问层提供了一种更为通用且灵活的方式来操作数据库。 传统的DAO模式通常需要为每一种数据实体类创建一个对应的DAO接口和实现类,这样会导致大量重复的代码...

    泛型DAO,注释详细

    接下来,我们可以使用Hibernate或MyBatis等持久层框架实现这个泛型DAO。以Hibernate为例,一个简单的实现可能如下: ```java public class HibernateGenericDAO, ID extends Serializable&gt; implements GenericDAO, ...

    SSH 泛型DAO分页

    这个压缩包文件的标题"SSH 泛型DAO分页"表明它提供了一个实现SSH框架整合的示例,特别关注了泛型DAO(Data Access Object)以及分页功能。下面将详细介绍SSH框架及其分页和泛型DAO的概念。 1. **Struts2**: Struts2...

    ssh通用泛型DAO

    BaseHibernateDAO是基于Hibernate框架的一个基类,它封装了常见的数据库操作,如增删查改(CRUD)。通过继承这个基类,开发者可以快速创建自定义的DAO实现,避免重复编写相似的代码。BaseHibernateDAO通常会包含以下...

    hibernate不是泛型的通用DAo1

    在Java开发中,Hibernate是一个非常流行的ORM(对象关系映射)框架,它允许开发者使用面向对象的方式来操作数据库,而无需关心底层SQL语句的编写。然而,为了提高代码的复用性和可维护性,通常会设计一个通用DAO...

Global site tag (gtag.js) - Google Analytics