泛型Hibernate DAO实现基本操作

最新推荐文章于 2018-01-31 15:50:52 发布

onxs

最新推荐文章于 2018-01-31 15:50:52 发布

阅读量1.2k

点赞数

分类专栏： Java Hibernate

本文链接：https://blog.youkuaiyun.com/laukicn/article/details/72770891

版权

Java 同时被 2 个专栏收录

67 篇文章

订阅专栏

Hibernate

10 篇文章

订阅专栏

这个博客介绍了如何创建一个泛型Hibernate DAO，它基于Spring的HibernateDaoSupport，提供了包括CRUD操作、分页查询以及HQL、Criteria和DetachedCriteria的支持。代码示例展示了如何进行对象加载、条件查询、分页处理等基本操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一个泛型hibernate DAO，用了spring的HibernateDaoSupport。提供基本的CRUD操作，支持分页查询，可使用HQL、Criteria和DetachedCriteria.

[sql] view plain copy 
   
 package sgf4web.dao;  
   
 import java.io.Serializable;  
 import java.util.*;  
 import java.util.regex.Matcher;  
 import java.util.regex.Pattern;  
   
 import org.hibernate.*;  
 import org.hibernate.criterion.*;  
 import org.springframework.orm.hibernate3.HibernateCallback;  
 import org.springframework.orm.hibernate3.support.HibernateDaoSupport;  
   
 import sgf4web.dao.support.PaginationSupport;  
 import sgf4web.util.GenericsUtils;  
   
 /**  
  * 泛型Hibernate DAO类  
  *   
  * @author DigitalSonic  
  */  
 @SuppressWarnings("unchecked")  
 public class HibernateGenericDao<T, ID extends Serializable> extends HibernateDaoSupport {  
     private Class<T> pojoClass;  
       
     /**  
      * 初始化DAO，获取POJO类型  
      */  
     public HibernateGenericDao() {  
 //        this.pojoClass = (Class<T>)((ParameterizedType)getClass().getGenericSuperclass()).getActualTypeArguments()[0];  
         this.pojoClass = GenericsUtils.getSuperClassGenricType(getClass());  
     }  
       
     /**  
      * 获得该DAO对应的POJO类型  
      */  
     public Class<T> getPojoClass() {  
         return this.pojoClass;  
     }  
       
     /**  
      * 获得该DAO对应的POJO类型名  
      */  
     public String getPojoClassName() {  
         return getPojoClass().getName();  
     }  
   
     //加载对象  
       
     /**  
      * 加载所有的对象  
      */  
     public List<T> loadAll() {  
         return (List<T>)getHibernateTemplate().loadAll(getPojoClass());  
     }  
       
     /**  
      * 根据hql查询  
      *  
      * @param values 可变参数  
      */  
     public List find(String hql, Object... values) {  
         return getHibernateTemplate().find(hql, values);  
     }  
   
     /**  
      * 根据条件加载对象  
      *   
      * @param criteria Criteria实例  
      */  
     public List<T> findByCriteria(final Criteria criteria) {  
         List list = criteria.list();   
         return transformResults(list);  
     }  
       
     /**  
      * 根据条件加载对象  
      * @param detachedCriteria DetachedCriteria实例  
      */  
     public List<T> findByCriteria(final DetachedCriteria detachedCriteria) {  
         return (List<T>) getHibernateTemplate().execute(new HibernateCallback() {  
                public Object doInHibernate(Session session) throws HibernateException {  
                    Criteria criteria = detachedCriteria.getExecutableCriteria(session);  
                    List list = criteria.list();   
                    return transformResults(list);   
                }  
            }, true);  
     }  
       
     /**  
      * 根据给定的实例查找对象  
      */  
     public List<T> findByExample(T instance) {  
         List<T> results = (List<T>)getHibernateTemplate().findByExample(instance);  
         return results;  
     }      
       
     /**  
      * 根据ID查找对象  
      */  
     public T findById(ID id) {  
         return (T) getHibernateTemplate().get(getPojoClassName(), id);  
     }  
       
     /**  
      * 根据某个具体属性进行查找  
      */  
     public List<T> findByProperty(String propertyName, Object value) {  
        String queryString = "from " + getPojoClassName() + " as model where model."   
                                + propertyName + "= ?";  
        return (List<T>)getHibernateTemplate().find(queryString, value);  
     }  
       
     //新建、修改、删除  
       
     /**  
      * 新建对象实例化  
      */  
     public ID save(T transientInstance) {  
         return (ID)getHibernateTemplate().save(transientInstance);  
     }  
       
     /**  
      * 更新已存在的对象  
      */  
     public void update(T transientInstance) {  
         getHibernateTemplate().update(transientInstance);  
     }  
       
     /**  
      * 删除指定ID的对象  
      */  
     public void delete(ID id) {  
            T instance = findById(id);  
            if (instance != null)  
                getHibernateTemplate().delete(instance);  
     }  
       
     /**  
      * 删除指定对象  
      */  
     public void delete(T persistentInstance) {  
         getHibernateTemplate().delete(persistentInstance);  
     }      
       
     //分页  
     /**  
      * 根据Criteria加载分页，指定页大小和起始位置  
      */  
     public PaginationSupport findPageByCriteria(final Criteria criteria, final int pageSize, final int startIndex) {     
         int totalCount = getCountByCriteria(criteria);     
         criteria.setProjection(null);  
         List items = criteria.setFirstResult(startIndex).setMaxResults(pageSize).list();  
         items = transformResults(items);  
         PaginationSupport ps = new PaginationSupport(items, totalCount, pageSize, startIndex);  
         return ps;  
     }  
       
     /**  
      * 根据Criteria加载分页，默认页大小，从第0条开始  
      */  
     public PaginationSupport findPageByCriteria(final Criteria criteria) {     
         return findPageByCriteria(criteria, PaginationSupport.PAGESIZE, 0);     
     }     
    
     /**  
      * 根据Criteria加载分页，默认页大小，从第startIndex条开始  
      */  
     public PaginationSupport findPageByCriteria(final Criteria criteria, final int startIndex) {     
         return findPageByCriteria(criteria, PaginationSupport.PAGESIZE, startIndex);     
     }  
       
     /**  
      * 根据Criteria统计总数  
      */  
     public int getCountByCriteria(final Criteria criteria) {     
         Integer count = (Integer) criteria.setProjection(Projections.rowCount()).uniqueResult();      
         return count.intValue();     
     }  
       
     /**  
      * 根据DetachedCriteria加载分页，指定页大小和起始位置  
      */  
     public PaginationSupport findPageByCriteria(final DetachedCriteria detachedCriteria, final int pageSize, final int startIndex) {     
         return (PaginationSupport) getHibernateTemplate().execute(new HibernateCallback() {     
             public Object doInHibernate(Session session) throws HibernateException {     
                 Criteria criteria = detachedCriteria.getExecutableCriteria(session);  
                 int totalCount = ((Integer) criteria.setProjection(Projections.rowCount()).uniqueResult()).intValue();     
                 criteria.setProjection(null);  
                 List items = criteria.setFirstResult(startIndex).setMaxResults(pageSize).list();  
                 items = transformResults(items);  
                 PaginationSupport ps = new PaginationSupport(items, totalCount, pageSize, startIndex);     
                 return ps;     
             }  
         }, true);     
     }  
       
     /**  
      * 根据DetachedCriteria加载分页，默认页大小，从第0条开始  
      */  
     public PaginationSupport findPageByCriteria(final DetachedCriteria detachedCriteria) {     
         return findPageByCriteria(detachedCriteria, PaginationSupport.PAGESIZE, 0);     
     }     
     
     /**  
      * 根据DetachedCriteria加载分页，默认页大小，从第startIndex条开始  
      */  
     public PaginationSupport findPageByCriteria(final DetachedCriteria detachedCriteria, final int startIndex) {     
         return findPageByCriteria(detachedCriteria, PaginationSupport.PAGESIZE, startIndex);     
     }   
       
     /**  
      * 根据DetachedCriteria统计总数  
      */  
     public int getCountByCriteria(final DetachedCriteria detachedCriteria) {     
         Integer count = (Integer) getHibernateTemplate().execute(new HibernateCallback() {     
             public Object doInHibernate(Session session) throws HibernateException {     
                 Criteria criteria = detachedCriteria.getExecutableCriteria(session);     
                 return criteria.setProjection(Projections.rowCount()).uniqueResult();     
             }     
         }, true);     
         return count.intValue();     
     }   
       
     /**  
      * 根据hql加载分页，指定页大小和起始位置  
      */  
     public PaginationSupport findPageByQuery(final String hql, final int pageSize, final int startIndex, Object...values) {  
         int totalCount = getCountByQuery(hql, values);  
           
         if (totalCount < 1)  
             return new PaginationSupport(new ArrayList(0), 0);  
   
         Query query = createQuery(hql, values);  
         List items = query.setFirstResult(startIndex).setMaxResults(pageSize).list();  
         PaginationSupport ps = new PaginationSupport(items, totalCount, pageSize, startIndex);  
         return ps;  
     }  
       
     /**  
      * 根据hql加载分页，默认页大小，从第0条开始  
      */  
     public PaginationSupport findPageByQuery(final String hql, Object...values) {     
         return findPageByQuery(hql, PaginationSupport.PAGESIZE, 0, values);     
     }     
    
     /**  
      * 根据hql加载分页，默认页大小，从第startIndex条开始  
      */  
     public PaginationSupport findPageByQuery(final String hql, final int startIndex, Object...values) {     
         return findPageByQuery(hql, PaginationSupport.PAGESIZE, startIndex, values);    
     }  
       
     /**  
      * 根据hql统计总数  
      */  
     public int getCountByQuery(final String hql, Object...values) {     
         String countQueryString = " select count (*) " + removeSelect(removeOrders(hql));  
         List countlist = getHibernateTemplate().find(countQueryString, values);  
         return (Integer) countlist.get(0);  
     }  
       
     //创建Criteria和Query  
       
     /**  
      * 创建Criteria对象  
      *  
      * @param criterions 可变的Restrictions条件列表  
      */  
     public Criteria createCriteria(Criterion...criterions) {  
         Criteria criteria = getSession().createCriteria(getPojoClass());  
         for (Criterion c : criterions)  
             criteria.add(c);  
         return criteria;  
     }  
   
     /**  
      * 创建Criteria对象，带排序字段与升降序字段  
      */  
     public Criteria createCriteria(String orderBy, boolean isAsc, Criterion...criterions) {  
         Criteria criteria = createCriteria(criterions);  
         if (isAsc)  
             criteria.addOrder(Order.asc(orderBy));  
         else  
             criteria.addOrder(Order.desc(orderBy));  
         return criteria;  
     }  
       
     /**  
      * 方法取自SpringSide.  
      * 创建Query对象. 对于需要first,max,fetchsize,cache,cacheRegion等诸多设置的函数,可以在返回Query后自行设置.  
      * 留意可以连续设置,如下：  
      * <pre>  
      * dao.getQuery(hql).setMaxResult(100).setCacheable(true).list();  
      * </pre>  
      * 调用方式如下：  
      * <pre>  
      *        dao.createQuery(hql)  
      *        dao.createQuery(hql,arg0);  
      *        dao.createQuery(hql,arg0,arg1);  
      *        dao.createQuery(hql,new Object[arg0,arg1,arg2])  
      * </pre>  
      *  
      * @param values 可变参数.  
      */  
     public Query createQuery(String hql, Object... values) {  
         Query query = getSession().createQuery(hql);  
         for (int i = 0; i < values.length; i++) {  
             query.setParameter(i, values[i]);  
         }  
         return query;  
     }  
       
     /**  
      * 方法取自SpringSide.  
      * 去除hql的select子句，未考虑union的情况  
      */  
     private static String removeSelect(String hql) {  
         int beginPos = hql.toLowerCase().indexOf("from");  
         return hql.substring(beginPos);  
     }  
   
     /**  
      * 方法取自SpringSide.  
      * 去除hql的orderby子句  
      */  
     private static String removeOrders(String hql) {  
         Pattern p = Pattern.compile("order/s*by[/w|/W|/s|/S]*", Pattern.CASE_INSENSITIVE);  
         Matcher m = p.matcher(hql);  
         StringBuffer sb = new StringBuffer();  
         while (m.find()) {  
             m.appendReplacement(sb, "");  
         }  
         m.appendTail(sb);  
         return sb.toString();  
     }  
       
     /**  
      * 将联合查询的结果内容从Map或者Object[]转换为实体类型，如果没有转换必要则直接返回  
      */  
     private List transformResults(List items) {  
         if (items.size() > 0) {  
             if (items.get(0) instanceof Map) {  
                 ArrayList list = new ArrayList(items.size());  
                 for (int i = 0; i < items.size(); i++) {  
                     Map map = (Map)items.get(i);  
                     list.add(map.get(CriteriaSpecification.ROOT_ALIAS));  
                 }  
                 return list;  
             } else if (items.get(0) instanceof Object[]) {  
                 ArrayList list = new ArrayList(items.size());  
                 int pos = 0;  
                 for (int i = 0; i < ((Object[])items.get(0)).length; i++) {  
                     if (((Object[])items.get(0))[i].getClass() == getPojoClass()) {  
                         pos = i;  
                         break;  
                     }  
                 }  
                 for (int i = 0; i < items.size(); i++) {  
                     list.add(((Object[])items.get(i))[pos]);  
                 }  
                 return list;  
             } else  
                 return items;  
         } else  
             return items;  
     }  
 }  

[sql] view plain copy 
   
 package sgf4web.util;  
   
 import java.lang.reflect.ParameterizedType;  
 import java.lang.reflect.Type;  
   
 /**  
  * 泛型参数辅助类  
  *   
  * @author DigitalSonic  
  */  
 @SuppressWarnings("unchecked")  
 public class GenericsUtils {  
     /**  
      * 通过反射，获得定义Class时声明的父类的第一个范型参数的类型。  
      */  
     public static Class getSuperClassGenricType(Class clazz) {  
         return getSuperClassGenricType(clazz, 0);  
     }  
       
     /**  
      * 通过反射，获得定义Class时声明的父类的范型参数的类型。  
      * 如没有找到符合要求的范型参数，则递归向上直到Object。  
      *  
      * @param clazz 要进行查询的类  
      * @param index 如有多个范型声明该索引从0开始  
      * @return 在index位置的范型参数的类型，如果无法判断则返回<code>Object.class</code>  
      */  
     public static Class getSuperClassGenricType(Class clazz, int index) {  
         boolean flag = true;  
         Type genType = clazz.getGenericSuperclass();  
         Type[] params = null;  
           
         if (!(genType instanceof ParameterizedType))  
             flag = false;  
         else {  
             params = ((ParameterizedType) genType).getActualTypeArguments();  
             if (index >= params.length || index < 0)  
                 flag = false;  
             if (!(params[index] instanceof Class))  
                 flag = false;  
         }  
         if (!flag) {  
             clazz = clazz.getSuperclass();  
             if (clazz == Object.class)  
                 return Object.class;  
             else  
                 return getSuperClassGenricType(clazz, index);  
         }  
           
         return (Class) params[index];  
     }  
 }  

[sql] view plain copy 
   
 package sgf4web.dao.support;  
   
 import java.util.List;  
   
 /**  
  * 分页类，参考自JavaEye及SpringSide  
  */  
 @SuppressWarnings("unchecked")  
 public class PaginationSupport {  
     public final static int PAGESIZE = 10;  
   
     private int pageSize = PAGESIZE;  
   
     private List items;  
   
     private int totalCount;  
   
     private int[] indexes = new int[0];  
   
     private int startIndex = 0;  
   
     public PaginationSupport(List items, int totalCount) {  
         setPageSize(PAGESIZE);  
         setTotalCount(totalCount);  
         setItems(items);  
         setStartIndex(0);  
     }  
   
     public PaginationSupport(List items, int totalCount, int startIndex) {  
         setPageSize(PAGESIZE);  
         setTotalCount(totalCount);  
         setItems(items);  
         setStartIndex(startIndex);  
     }  
   
     public PaginationSupport(List items, int totalCount, int pageSize, int startIndex) {  
         setPageSize(pageSize);  
         setTotalCount(totalCount);  
         setItems(items);  
         setStartIndex(startIndex);  
     }  
   
     /**  
      * 将页码转换为列表的startIndex，页大小为默认大小  
      */  
     public static int convertFromPageToStartIndex(int pageNo) {  
         return (pageNo - 1) * PAGESIZE;  
     }  
       
     /**  
      * 将页码转换为列表的startIndex  
      */  
     public static int convertFromPageToStartIndex(int pageNo, int pageSize) {  
         return (pageNo - 1) * pageSize;  
     }  
   
     public List getItems() {  
         return items;  
     }  
   
     public void setItems(List items) {  
         this.items = items;  
     }  
   
     public int getPageSize() {  
         return pageSize;  
     }  
   
     public void setPageSize(int pageSize) {  
         this.pageSize = pageSize;  
     }  
   
     public int getTotalCount() {  
         return totalCount;  
     }  
   
     /**  
      * 设置数据总数，并计算各页起始位置  
      */  
     public void setTotalCount(int totalCount) {  
         if (totalCount > 0) {  
             this.totalCount = totalCount;  
             int count = totalCount / pageSize;  
             if (totalCount % pageSize > 0)  
                 count++;  
             indexes = new int[count];  
             for (int i = 0; i < count; i++) {  
                 indexes[i] = pageSize * i;  
             }  
         } else {  
             this.totalCount = 0;  
         }  
     }  
   
     public int[] getIndexes() {  
         return indexes;  
     }  
   
     public void setIndexes(int[] indexes) {  
         this.indexes = indexes;  
     }  
   
     public int getStartIndex() {  
         return startIndex;  
     }  
   
     /**  
      * 设置当前起始位置  
      */  
     public void setStartIndex(int startIndex) {  
         if (totalCount <= 0)  
             this.startIndex = 0;  
         else if (startIndex >= totalCount)  
             this.startIndex = indexes[indexes.length - 1];  
         else if (startIndex < 0)  
             this.startIndex = 0;  
         else {  
             this.startIndex = indexes[startIndex / pageSize];  
         }  
     }  
   
     /**  
      * 获得下页起始位置  
      */  
     public int getNextIndex() {  
         int nextIndex = getStartIndex() + pageSize;  
         if (nextIndex >= totalCount)  
             return getStartIndex();  
         else  
             return nextIndex;  
     }  
   
     /**  
      * 获得上页起始位置  
      */  
     public int getPreviousIndex() {  
         int previousIndex = getStartIndex() - pageSize;  
         if (previousIndex < 0)  
             return 0;  
         else  
             return previousIndex;  
     }  
   
     /**  
      * 取总页数.  
      */  
     public long getTotalPageCount() {  
         if (totalCount % pageSize == 0)  
             return totalCount / pageSize;  
         else  
             return totalCount / pageSize + 1;  
     }  
   
     /**  
      * 取该页当前页码,页码从1开始.  
      */  
     public long getCurrentPageNo() {  
         return startIndex / pageSize + 1;  
     }  
   
     /**  
      * 该页是否有下一页.  
      */  
     public boolean hasNextPage() {  
         return this.getCurrentPageNo() < this.getTotalPageCount() - 1;  
     }  
   
     /**  
      * 该页是否有上一页.  
      */  
     public boolean hasPreviousPage() {  
         return this.getCurrentPageNo() > 1;  
     }  
 }  