編寫Spring+Hibernate框架下的應用，總是離不了編寫一個通用的泛型GenericHibernateDao。查閱了網上不少的GenericHibernateDao實現，歸納整理為如下實現，供后續編碼參考。
GenericDao.java:
package dao;
import java.io.Serializable;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import org.hibernate.Criteria;
import org.hibernate.LockMode;
import org.hibernate.criterion.DetachedCriteria;
/**
*
* @author lny
*/
public interface GenericDao<T extends Serializable, PK extends Serializable>
{
// -------------------- 基本檢索、增加、修改、刪除操作 --------------------
// 根據主鍵獲取實體。如果沒有相應的實體，返回 null。
public T get(PK id);
// 根據主鍵獲取實體并加鎖。如果沒有相應的實體，返回 null。
public T getWithLock(PK id, LockMode lock);
// 根據主鍵獲取實體。如果沒有相應的實體，拋出異常。
public T load(PK id);
// 根據主鍵獲取實體并加鎖。如果沒有相應的實體，拋出異常。
public T loadWithLock(PK id, LockMode lock);
// 獲取全部實體。
public List<T> loadAll();
// loadAllWithLock() ?
// 更新實體
public void update(T entity);
// 更新實體并加鎖
public void updateWithLock(T entity, LockMode lock);
// 存儲實體到數據庫
public void save(T entity);
// saveWithLock()
// 增加或更新實體
public void saveOrUpdate(T entity);
// 增加或更新集合中的全部實體
public void saveOrUpdateAll(Collection<T> entities);
// 刪除指定的實體
public void delete(T entity);
// 加鎖并刪除指定的實體
public void deleteWithLock(T entity, LockMode lock);
// 根據主鍵刪除指定實體
public void deleteByKey(PK id);
// 根據主鍵加鎖并刪除指定的實體
public void deleteByKeyWithLock(PK id, LockMode lock);
// 刪除集合中的全部實體
public void deleteAll(Collection<T> entities);
// -------------------- HSQL ----------------------------------------------
// 使用HSQL語句直接增加、更新、刪除實體
public int bulkUpdate(String queryString);
// 使用帶參數的HSQL語句增加、更新、刪除實體
public int bulkUpdate(String queryString, Object[] values);
// 使用HSQL語句檢索數據
public List find(String queryString);
// 使用帶參數的HSQL語句檢索數據
public List find(String queryString, Object[] values);
// 使用帶命名的參數的HSQL語句檢索數據
public List findByNamedParam(String queryString, String[] paramNames, Object[] values);
// 使用命名的HSQL語句檢索數據
public List findByNamedQuery(String queryName);
// 使用帶參數的命名HSQL語句檢索數據
public List findByNamedQuery(String queryName, Object[] values);
// 使用帶命名參數的命名HSQL語句檢索數據
public List findByNamedQueryAndNamedParam(String queryName, String[] paramNames, Object[] values);
// 使用HSQL語句檢索數據，返回 Iterator
public Iterator iterate(String queryString);
// 使用帶參數HSQL語句檢索數據，返回 Iterator
public Iterator iterate(String queryString, Object[] values);
// 關閉檢索返回的 Iterator
public void closeIterator(Iterator it);
// -------------------------------- Criteria ------------------------------
// 創建與會話無關的檢索標準對象
public DetachedCriteria createDetachedCriteria();
// 創建與會話綁定的檢索標準對象
public Criteria createCriteria();
// 使用指定的檢索標準檢索數據
public List findByCriteria(DetachedCriteria criteria);
// 使用指定的檢索標準檢索數據，返回部分記錄
public List findByCriteria(DetachedCriteria criteria, int firstResult, int maxResults);
// 使用指定的實體及屬性檢索（滿足除主鍵外屬性＝實體值）數據
public List<T> findEqualByEntity(T entity, String [] propertyNames);
// 使用指定的實體及屬性(非主鍵)檢索（滿足屬性 like 串實體值）數據
public List<T> findLikeByEntity(T entity, String [] propertyNames);
// 使用指定的檢索標準檢索數據，返回指定范圍的記錄
public Integer getRowCount(DetachedCriteria criteria);
// 使用指定的檢索標準檢索數據，返回指定統計值
public Object getStatValue(DetachedCriteria criteria, String propertyName, String StatName);
// -------------------------------- Others --------------------------------
// 加鎖指定的實體
public void lock(T entity, LockMode lockMode);
// 強制初始化指定的實體
public void initialize(Object proxy);
// 強制立即更新緩沖數據到數據庫（否則僅在事務提交時才更新）
public void flush();
}
GenericHibernateDao.java
package dao;
import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import org.apache.commons.beanutils.PropertyUtils;
import org.hibernate.Criteria;
import org.hibernate.LockMode;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Example;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
/**
* GenericHibernateDao 繼承 HibernateDao，簡單封裝 HibernateTemplate 各項功能，
* 簡化基于Hibernate Dao 的編寫。
*
* @author lny
*/
@SuppressWarnings("unchecked")
public class GenericHibernateDao<T extends Serializable, PK extends Serializable>
extends HibernateDaoSupport implements GenericDao<T, PK>
{
// 實體類類型(由構造方法自動賦值)
private Class<T> entityClass;
// 構造方法，根據實例類自動獲取實體類類型
public GenericHibernateDao()
{
this.entityClass = null;
Class c = getClass();
Type t = c.getGenericSuperclass();
if (t instanceof ParameterizedType)
{
Type[] p = ((ParameterizedType) t).getActualTypeArguments();
this.entityClass = (Class<T>) p[0];
}
}
// -------------------- 基本檢索、增加、修改、刪除操作 --------------------
// 根據主鍵獲取實體。如果沒有相應的實體，返回 null。
public T get(PK id)
{
return (T) getHibernateTemplate().get(entityClass, id);
}
// 根據主鍵獲取實體并加鎖。如果沒有相應的實體，返回 null。
public T getWithLock(PK id, LockMode lock)
{
T t = (T) getHibernateTemplate().get(entityClass, id, lock);
if (t != null)
{
this.flush(); // 立即刷新，否則鎖不會生效。
}
return t;
}
// 根據主鍵獲取實體。如果沒有相應的實體，拋出異常。
public T load(PK id)
{
return (T) getHibernateTemplate().load(entityClass, id);
}
// 根據主鍵獲取實體并加鎖。如果沒有相應的實體，拋出異常。
public T loadWithLock(PK id, LockMode lock)
{
T t = (T) getHibernateTemplate().load(entityClass, id, lock);
if (t != null)
{
this.flush(); // 立即刷新，否則鎖不會生效。
}
return t;
}
// 獲取全部實體。
public List<T> loadAll()
{
return (List<T>) getHibernateTemplate().loadAll(entityClass);
}
// loadAllWithLock() ?
// 更新實體
public void update(T entity)
{
getHibernateTemplate().update(entity);
}
// 更新實體并加鎖
public void updateWithLock(T entity, LockMode lock)
{
getHibernateTemplate().update(entity, lock);
this.flush(); // 立即刷新，否則鎖不會生效。
}
// 存儲實體到數據庫
public void save(T entity)
{
getHibernateTemplate().save(entity);
}
// saveWithLock()？
// 增加或更新實體
public void saveOrUpdate(T entity)
{
getHibernateTemplate().saveOrUpdate(entity);
}
// 增加或更新集合中的全部實體
public void saveOrUpdateAll(Collection<T> entities)
{
getHibernateTemplate().saveOrUpdateAll(entities);
}
// 刪除指定的實體
public void delete(T entity)
{
getHibernateTemplate().delete(entity);
}
// 加鎖并刪除指定的實體
public void deleteWithLock(T entity, LockMode lock)
{
getHibernateTemplate().delete(entity, lock);
this.flush(); // 立即刷新，否則鎖不會生效。
}
// 根據主鍵刪除指定實體
public void deleteByKey(PK id)
{
this.delete(this.load(id));
}
// 根據主鍵加鎖并刪除指定的實體
public void deleteByKeyWithLock(PK id, LockMode lock)
{
this.deleteWithLock(this.load(id), lock);
}
// 刪除集合中的全部實體
public void deleteAll(Collection<T> entities)
{
getHibernateTemplate().deleteAll(entities);
}
// -------------------- HSQL ----------------------------------------------
// 使用HSQL語句直接增加、更新、刪除實體
public int bulkUpdate(String queryString)
{
return getHibernateTemplate().bulkUpdate(queryString);
}
// 使用帶參數的HSQL語句增加、更新、刪除實體
public int bulkUpdate(String queryString, Object[] values)
{
return getHibernateTemplate().bulkUpdate(queryString, values);
}
// 使用HSQL語句檢索數據
public List find(String queryString)
{
return getHibernateTemplate().find(queryString);
}
// 使用帶參數的HSQL語句檢索數據
public List find(String queryString, Object[] values)
{
return getHibernateTemplate().find(queryString, values);
}
// 使用帶命名的參數的HSQL語句檢索數據
public List findByNamedParam(String queryString, String[] paramNames, Object[] values)
{
return getHibernateTemplate().findByNamedParam(queryString, paramNames, values);
}
// 使用命名的HSQL語句檢索數據
public List findByNamedQuery(String queryName)
{
return getHibernateTemplate().findByNamedQuery(queryName);
}
// 使用帶參數的命名HSQL語句檢索數據
public List findByNamedQuery(String queryName, Object[] values)
{
return getHibernateTemplate().findByNamedQuery(queryName, values);
}
// 使用帶命名參數的命名HSQL語句檢索數據
public List findByNamedQueryAndNamedParam(String queryName, String[] paramNames, Object[] values)
{
return getHibernateTemplate().findByNamedQueryAndNamedParam(queryName, paramNames, values);
}
// 使用HSQL語句檢索數據，返回 Iterator
public Iterator iterate(String queryString)
{
return getHibernateTemplate().iterate(queryString);
}
// 使用帶參數HSQL語句檢索數據，返回 Iterator
public Iterator iterate(String queryString, Object[] values)
{
return getHibernateTemplate().iterate(queryString, values);
}
// 關閉檢索返回的 Iterator
public void closeIterator(Iterator it)
{
getHibernateTemplate().closeIterator(it);
}
// -------------------------------- Criteria ------------------------------
// 創建與會話無關的檢索標準
public DetachedCriteria createDetachedCriteria()
{
return DetachedCriteria.forClass(this.entityClass);
}
// 創建與會話綁定的檢索標準
public Criteria createCriteria()
{
return this.createDetachedCriteria().getExecutableCriteria(this.getSession());
}
// 檢索滿足標準的數據
public List findByCriteria(DetachedCriteria criteria)
{
return getHibernateTemplate().findByCriteria(criteria);
}
// 檢索滿足標準的數據，返回指定范圍的記錄
public List findByCriteria(DetachedCriteria criteria, int firstResult, int maxResults)
{
return getHibernateTemplate().findByCriteria(criteria, firstResult, maxResults);
}
// 使用指定的實體及屬性檢索（滿足除主鍵外屬性＝實體值）數據
public List<T> findEqualByEntity(T entity, String [] propertyNames)
{
Criteria criteria = this.createCriteria();
Example exam = Example.create(entity);
exam.excludeZeroes();
String [] defPropertys = getSessionFactory().getClassMetadata(entityClass).getPropertyNames();
for(String defProperty : defPropertys)
{
int ii = 0;
for(ii = 0; ii < propertyNames.length; ++ii)
{
if(defProperty.equals(propertyNames[ii]))
{
criteria.addOrder(Order.asc(defProperty));
break;
}
}
if(ii == propertyNames.length)
{
exam.excludeProperty(defProperty);
}
}
criteria.add(exam);
return (List<T>) criteria.list();
}
// 使用指定的實體及屬性檢索（滿足屬性 like 串實體值）數據
public List<T> findLikeByEntity(T entity, String [] propertyNames)
{
Criteria criteria = this.createCriteria();
for(String property : propertyNames)
{
try
{
Object value = PropertyUtils.getProperty(entity, property);
if(value instanceof String)
{
criteria.add(Restrictions.like(property, (String) value, MatchMode.ANYWHERE));
criteria.addOrder(Order.asc(property));
}
else
{
criteria.add(Restrictions.eq(property, value));
criteria.addOrder(Order.asc(property));
}
}
catch(Exception ex)
{
// 忽略無效的檢索參考數據。
}
}
return (List<T>) criteria.list();
}
// 使用指定的檢索標準獲取滿足標準的記錄數
public Integer getRowCount(DetachedCriteria criteria)
{
criteria.setProjection(Projections.rowCount());
List list = this.findByCriteria(criteria, 0, 1);
return (Integer) list.get(0);
}
// 使用指定的檢索標準檢索數據，返回指定統計值(max,min,avg,sum)
public Object getStatValue(DetachedCriteria criteria, String propertyName, String StatName)
{
if (StatName.toLowerCase().equals("max"))
criteria.setProjection(Projections.max(propertyName));
else if(StatName.toLowerCase().equals("min"))
criteria.setProjection(Projections.min(propertyName));
else if(StatName.toLowerCase().equals("avg"))
criteria.setProjection(Projections.avg(propertyName));
else if(StatName.toLowerCase().equals("sum"))
criteria.setProjection(Projections.sum(propertyName));
else return null;
List list = this.findByCriteria(criteria, 0, 1);
return list.get(0);
}
// -------------------------------- Others --------------------------------
// 加鎖指定的實體
public void lock(T entity, LockMode lock)
{
getHibernateTemplate().lock(entity, lock);
}
// 強制初始化指定的實體
public void initialize(Object proxy)
{
getHibernateTemplate().initialize(proxy);
}
// 強制立即更新緩沖數據到數據庫（否則僅在事務提交時才更新）
public void flush()
{
getHibernateTemplate().flush();
}
}
posted on 2007-11-20 14:21
飛鷹 閱讀(4305)
評論(0) 編輯 收藏