新一篇: 用戶,角色,功能三者之間的關係視圖
編寫Spring+Hibernate框架下的應用,總是離不了編寫一個通用的泛型GenericHibernateDao。查閱了網上不少的GenericHibernateDao實現,歸納整理爲如下實現,供後續編碼參考。
GenericDao.java:
package dao;
編寫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;
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>
{
// -------------------- 基本檢索、增加、修改、刪除操作 --------------------
*
* @author lny
*/
public interface GenericDao<T extends Serializable, PK extends Serializable>
{
// -------------------- 基本檢索、增加、修改、刪除操作 --------------------
// 根據主鍵獲取實體。如果沒有相應的實體,返回 null。
public T get(PK id);
public T get(PK id);
// 根據主鍵獲取實體並加鎖。如果沒有相應的實體,返回 null。
public T getWithLock(PK id, LockMode lock);
public T getWithLock(PK id, LockMode lock);
// 根據主鍵獲取實體。如果沒有相應的實體,拋出異常。
public T load(PK id);
public T load(PK id);
// 根據主鍵獲取實體並加鎖。如果沒有相應的實體,拋出異常。
public T loadWithLock(PK id, LockMode lock);
public T loadWithLock(PK id, LockMode lock);
// 獲取全部實體。
public List<T> loadAll();
public List<T> loadAll();
// loadAllWithLock() ?
// 更新實體
public void update(T entity);
public void update(T entity);
// 更新實體並加鎖
public void updateWithLock(T entity, LockMode lock);
public void updateWithLock(T entity, LockMode lock);
// 存儲實體到數據庫
public void save(T entity);
public void save(T entity);
// saveWithLock()
// 增加或更新實體
public void saveOrUpdate(T entity);
public void saveOrUpdate(T entity);
// 增加或更新集合中的全部實體
public void saveOrUpdateAll(Collection<T> entities);
public void saveOrUpdateAll(Collection<T> entities);
// 刪除指定的實體
public void delete(T entity);
public void delete(T entity);
// 加鎖並刪除指定的實體
public void deleteWithLock(T entity, LockMode lock);
public void deleteWithLock(T entity, LockMode lock);
// 根據主鍵刪除指定實體
public void deleteByKey(PK id);
public void deleteByKey(PK id);
// 根據主鍵加鎖並刪除指定的實體
public void deleteByKeyWithLock(PK id, LockMode lock);
public void deleteByKeyWithLock(PK id, LockMode lock);
// 刪除集合中的全部實體
public void deleteAll(Collection<T> entities);
public void deleteAll(Collection<T> entities);
// -------------------- HSQL ----------------------------------------------
// 使用HSQL語句直接增加、更新、刪除實體
public int bulkUpdate(String queryString);
public int bulkUpdate(String queryString);
// 使用帶參數的HSQL語句增加、更新、刪除實體
public int bulkUpdate(String queryString, Object[] values);
public int bulkUpdate(String queryString, Object[] values);
// 使用HSQL語句檢索數據
public List find(String queryString);
public List find(String queryString);
// 使用帶參數的HSQL語句檢索數據
public List find(String queryString, Object[] values);
public List find(String queryString, Object[] values);
// 使用帶命名的參數的HSQL語句檢索數據
public List findByNamedParam(String queryString, String[] paramNames, Object[] values);
public List findByNamedParam(String queryString, String[] paramNames, Object[] values);
// 使用命名的HSQL語句檢索數據
public List findByNamedQuery(String queryName);
public List findByNamedQuery(String queryName);
// 使用帶參數的命名HSQL語句檢索數據
public List findByNamedQuery(String queryName, Object[] values);
public List findByNamedQuery(String queryName, Object[] values);
// 使用帶命名參數的命名HSQL語句檢索數據
public List findByNamedQueryAndNamedParam(String queryName, String[] paramNames, Object[] values);
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 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 Criteria createCriteria();
// 使用指定的檢索標準檢索數據
public List findByCriteria(DetachedCriteria criteria);
// 使用指定的檢索標準檢索數據,返回部分記錄
public List findByCriteria(DetachedCriteria criteria, int firstResult, int maxResults);
public List findByCriteria(DetachedCriteria criteria);
// 使用指定的檢索標準檢索數據,返回部分記錄
public List findByCriteria(DetachedCriteria criteria, int firstResult, int maxResults);
// 使用指定的實體及屬性檢索(滿足除主鍵外屬性=實體值)數據
public List<T> findEqualByEntity(T entity, String [] propertyNames);
public List<T> findEqualByEntity(T entity, String [] propertyNames);
// 使用指定的實體及屬性(非主鍵)檢索(滿足屬性 like 串實體值)數據
public List<T> findLikeByEntity(T entity, String [] propertyNames);
public List<T> findLikeByEntity(T entity, String [] propertyNames);
// 使用指定的檢索標準檢索數據,返回指定範圍的記錄
public Integer getRowCount(DetachedCriteria criteria);
// 使用指定的檢索標準檢索數據,返回指定統計值
public Object getStatValue(DetachedCriteria criteria, String propertyName, String StatName);
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 lock(T entity, LockMode lockMode);
// 強制初始化指定的實體
public void initialize(Object proxy);
// 強制立即更新緩衝數據到數據庫(否則僅在事務提交時才更新)
public void flush();
}
public void flush();
}
GenericHibernateDao.java
package dao;
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;
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;
* 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];
}
}
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);
}
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 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 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 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);
}
public List<T> loadAll()
{
return (List<T>) getHibernateTemplate().loadAll(entityClass);
}
// loadAllWithLock() ?
// 更新實體
public void update(T entity)
{
getHibernateTemplate().update(entity);
}
// 更新實體
public void update(T entity)
{
getHibernateTemplate().update(entity);
}
// 更新實體並加鎖
public void updateWithLock(T entity, LockMode lock)
{
getHibernateTemplate().update(entity, lock);
this.flush(); // 立即刷新,否則鎖不會生效。
}
public void updateWithLock(T entity, LockMode lock)
{
getHibernateTemplate().update(entity, lock);
this.flush(); // 立即刷新,否則鎖不會生效。
}
// 存儲實體到數據庫
public void save(T entity)
{
getHibernateTemplate().save(entity);
}
public void save(T entity)
{
getHibernateTemplate().save(entity);
}
// saveWithLock()?
// 增加或更新實體
public void saveOrUpdate(T entity)
{
getHibernateTemplate().saveOrUpdate(entity);
}
public void saveOrUpdate(T entity)
{
getHibernateTemplate().saveOrUpdate(entity);
}
// 增加或更新集合中的全部實體
public void saveOrUpdateAll(Collection<T> entities)
{
getHibernateTemplate().saveOrUpdateAll(entities);
}
public void saveOrUpdateAll(Collection<T> entities)
{
getHibernateTemplate().saveOrUpdateAll(entities);
}
// 刪除指定的實體
public void delete(T entity)
{
getHibernateTemplate().delete(entity);
}
public void delete(T entity)
{
getHibernateTemplate().delete(entity);
}
// 加鎖並刪除指定的實體
public void deleteWithLock(T entity, LockMode lock)
{
getHibernateTemplate().delete(entity, lock);
this.flush(); // 立即刷新,否則鎖不會生效。
}
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 deleteByKey(PK id)
{
this.delete(this.load(id));
}
// 根據主鍵加鎖並刪除指定的實體
public void deleteByKeyWithLock(PK id, LockMode lock)
{
this.deleteWithLock(this.load(id), lock);
}
public void deleteByKeyWithLock(PK id, LockMode lock)
{
this.deleteWithLock(this.load(id), lock);
}
// 刪除集合中的全部實體
public void deleteAll(Collection<T> entities)
{
getHibernateTemplate().deleteAll(entities);
}
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)
{
return getHibernateTemplate().bulkUpdate(queryString);
}
// 使用帶參數的HSQL語句增加、更新、刪除實體
public int bulkUpdate(String queryString, Object[] values)
{
return getHibernateTemplate().bulkUpdate(queryString, values);
}
public int bulkUpdate(String queryString, Object[] values)
{
return getHibernateTemplate().bulkUpdate(queryString, values);
}
// 使用HSQL語句檢索數據
public List find(String queryString)
{
return getHibernateTemplate().find(queryString);
}
public List find(String queryString)
{
return getHibernateTemplate().find(queryString);
}
// 使用帶參數的HSQL語句檢索數據
public List find(String queryString, Object[] values)
{
return getHibernateTemplate().find(queryString, values);
}
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);
}
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);
}
public List findByNamedQuery(String queryName)
{
return getHibernateTemplate().findByNamedQuery(queryName);
}
// 使用帶參數的命名HSQL語句檢索數據
public List findByNamedQuery(String queryName, Object[] values)
{
return getHibernateTemplate().findByNamedQuery(queryName, values);
}
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);
}
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);
}
public Iterator iterate(String queryString)
{
return getHibernateTemplate().iterate(queryString);
}
// 使用帶參數HSQL語句檢索數據,返回 Iterator
public Iterator iterate(String queryString, Object[] values)
{
return getHibernateTemplate().iterate(queryString, values);
}
public Iterator iterate(String queryString, Object[] values)
{
return getHibernateTemplate().iterate(queryString, values);
}
// 關閉檢索返回的 Iterator
public void closeIterator(Iterator it)
{
getHibernateTemplate().closeIterator(it);
}
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 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 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);
}
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 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 initialize(Object proxy)
{
getHibernateTemplate().initialize(proxy);
}
// 強制立即更新緩衝數據到數據庫(否則僅在事務提交時才更新)
public void flush()
{
getHibernateTemplate().flush();
}
}
public void flush()
{
getHibernateTemplate().flush();
}
}