Hibernate 数据库操作 模板基类 实现类GenericHibernateDao
package com.ddhome.dao.hibernate;
importjava.io.Serializable;
importjava.lang.reflect.ParameterizedType;
importjava.lang.reflect.Type;
importjava.sql.SQLException;
importjava.util.Collection;
importjava.util.Iterator;
importjava.util.List;
importorg.apache.commons.beanutils.PropertyUtils;
importorg.hibernate.Criteria;
importorg.hibernate.HibernateException;
importorg.hibernate.LockMode;
importorg.hibernate.Query;
importorg.hibernate.Session;
importorg.hibernate.criterion.DetachedCriteria;
importorg.hibernate.criterion.Example;
importorg.hibernate.criterion.MatchMode;
importorg.hibernate.criterion.Order;
importorg.hibernate.criterion.Projections;
importorg.hibernate.criterion.Restrictions;
importorg.springframework.orm.hibernate3.HibernateCallback;
importorg.springframework.orm.hibernate3.support.HibernateDaoSupport;
importcom.ddhome.dao.GenericDao;
/**
*GenericHibernateDao继承HibernateDao，简单封装HibernateTemplate各项功能，
*简化基于HibernateDao的编写。
*
*@authorTXC
*/
@SuppressWarnings("unchecked")
publicclassGenericHibernateDao<TextendsSerializable,PKextendsSerializable>
extendsHibernateDaoSupportimplementsGenericDao<T,PK>{
//实体类类型(由构造方法自动赋值)
privateClass<T>entityClass;
//构造方法，根据实例类自动获取实体类类型
publicGenericHibernateDao(){
this.entityClass=null;
Classc=getClass();
Typet=c.getGenericSuperclass();
if(tinstanceofParameterizedType){
Type[]p=((ParameterizedType)t).getActualTypeArguments();
this.entityClass=(Class<T>)p[0];
}
}
//--------------------基本检索、增加、修改、删除操作--------------------
//根据主键获取实体。如果没有相应的实体，返回null。
publicTget(PKid){
return(T)getHibernateTemplate().get(entityClass,id);
}
//根据主键获取实体并加锁。如果没有相应的实体，返回null。
publicTgetWithLock(PKid,LockModelock){
Tt=(T)getHibernateTemplate().get(entityClass,id,lock);
if(t!=null){
this.flush();//立即刷新，否则锁不会生效。
}
returnt;
}
//根据主键获取实体。如果没有相应的实体，抛出异常。
publicTload(PKid){
return(T)getHibernateTemplate().load(entityClass,id);
}
//根据主键获取实体并加锁。如果没有相应的实体，抛出异常。
publicTloadWithLock(PKid,LockModelock){
Tt=(T)getHibernateTemplate().load(entityClass,id,lock);
if(t!=null){
this.flush();//立即刷新，否则锁不会生效。
}
returnt;
}
//获取全部实体。
publicList<T>loadAll(){
return(List<T>)getHibernateTemplate().loadAll(entityClass);
}
//loadAllWithLock()?
//更新实体
publicvoidupdate(Tentity){
getHibernateTemplate().update(entity);
}
//更新实体并加锁
publicvoidupdateWithLock(Tentity,LockModelock){
getHibernateTemplate().update(entity,lock);
this.flush();//立即刷新，否则锁不会生效。
}
//存储实体到数据库
publicvoidsave(Tentity){
getHibernateTemplate().save(entity);
}
//saveWithLock()？
//增加或更新实体
publicvoidsaveOrUpdate(Tentity){
getHibernateTemplate().saveOrUpdate(entity);
}
//增加或更新集合中的全部实体
publicvoidsaveOrUpdateAll(Collection<T>entities){
getHibernateTemplate().saveOrUpdateAll(entities);
}
//删除指定的实体
publicvoiddelete(Tentity){
getHibernateTemplate().delete(entity);
}
//加锁并删除指定的实体
publicvoiddeleteWithLock(Tentity,LockModelock){
getHibernateTemplate().delete(entity,lock);
this.flush();//立即刷新，否则锁不会生效。
}
//根据主键删除指定实体
publicvoiddeleteByKey(PKid){
this.delete(this.load(id));
}
//根据主键加锁并删除指定的实体
publicvoiddeleteByKeyWithLock(PKid,LockModelock){
this.deleteWithLock(this.load(id),lock);
}
//删除集合中的全部实体
publicvoiddeleteAll(Collection<T>entities){
getHibernateTemplate().deleteAll(entities);
}
//--------------------HSQL----------------------------------------------
//使用HSQL语句直接增加、更新、删除实体
publicintbulkUpdate(StringqueryString){
returngetHibernateTemplate().bulkUpdate(queryString);
}
//使用带参数的HSQL语句增加、更新、删除实体
publicintbulkUpdate(StringqueryString,Object[]values){
returngetHibernateTemplate().bulkUpdate(queryString,values);
}
//使用HSQL语句检索数据
publicListfind(StringqueryString){
returngetHibernateTemplate().find(queryString);
}
//使用带参数的HSQL语句检索数据
publicListfind(StringqueryString,Object[]values){
returngetHibernateTemplate().find(queryString,values);
}
//使用带命名的参数的HSQL语句检索数据
publicListfindByNamedParam(StringqueryString,String[]paramNames,
Object[]values){
returngetHibernateTemplate().findByNamedParam(queryString,paramNames,
values);
}
//使用命名的HSQL语句检索数据
publicListfindByNamedQuery(StringqueryName){
returngetHibernateTemplate().findByNamedQuery(queryName);
}
//使用带参数的命名HSQL语句检索数据
publicListfindByNamedQuery(StringqueryName,Object[]values){
returngetHibernateTemplate().findByNamedQuery(queryName,values);
}
//使用带命名参数的命名HSQL语句检索数据
publicListfindByNamedQueryAndNamedParam(StringqueryName,
String[]paramNames,Object[]values){
returngetHibernateTemplate().findByNamedQueryAndNamedParam(queryName,
paramNames,values);
}
//使用HSQL语句检索数据，返回Iterator
publicIteratoriterate(StringqueryString){
returngetHibernateTemplate().iterate(queryString);
}
//使用带参数HSQL语句检索数据，返回Iterator
publicIteratoriterate(StringqueryString,Object[]values){
returngetHibernateTemplate().iterate(queryString,values);
}
//关闭检索返回的Iterator
publicvoidcloseIterator(Iteratorit){
getHibernateTemplate().closeIterator(it);
}
//--------------------------------Criteria------------------------------
//创建与会话无关的检索标准
publicDetachedCriteriacreateDetachedCriteria(){
returnDetachedCriteria.forClass(this.entityClass);
}
//创建与会话绑定的检索标准
publicCriteriacreateCriteria(){
returnthis.createDetachedCriteria().getExecutableCriteria(
this.getSession());
}
//检索满足标准的数据
publicListfindByCriteria(DetachedCriteriacriteria){
returngetHibernateTemplate().findByCriteria(criteria);
}
//检索满足标准的数据，返回指定范围的记录
publicListfindByCriteria(DetachedCriteriacriteria,intfirstResult,
intmaxResults){
returngetHibernateTemplate().findByCriteria(criteria,firstResult,
maxResults);
}
//使用指定的实体及属性检索（满足除主键外属性＝实体值）数据
publicList<T>findEqualByEntity(Tentity,String[]propertyNames){
returnfindEqualByEntity(entity,propertyNames,-1,-1);
}
//使用指定的实体及属性检索（满足除主键外属性＝实体值）数据实现分页
publicList<T>findEqualByEntity(Tentity,String[]propertyNames,intfromIdx,intfetchCount){
Criteriacriteria=this.createCriteria();
Exampleexam=Example.create(entity);
exam.excludeZeroes();
String[]defPropertys=getSessionFactory().getClassMetadata(
entityClass).getPropertyNames();
for(StringdefProperty:defPropertys){
intii=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);
}
}
if(fromIdx>-1)
criteria.setFirstResult(fromIdx);
if(fetchCount>-1)
criteria.setMaxResults(fetchCount);
criteria.add(exam);
return(List<T>)criteria.list();
}
publicTfindUniqueEqualByEntity(Tentity,String[]propertyNames){
List<T>result=findEqualByEntity(entity,propertyNames,0,1);
if(result==null||result.isEmpty())
returnnull;
returnresult.get(0);
}
//使用指定的实体及属性检索（满足属性like串实体值）数据
publicList<T>findLikeByEntity(Tentity,String[]propertyNames){
Criteriacriteria=this.createCriteria();
for(Stringproperty:propertyNames){
try{
Objectvalue=PropertyUtils.getProperty(entity,property);
if(valueinstanceofString){
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(Exceptionex){
//忽略无效的检索参考数据。
}
}
return(List<T>)criteria.list();
}
//使用指定的检索标准获取满足标准的记录数
publicIntegergetRowCount(DetachedCriteriacriteria){
criteria.setProjection(Projections.rowCount());
Listlist=this.findByCriteria(criteria,0,1);
return(Integer)list.get(0);
}
//使用指定的检索标准检索数据，返回指定统计值(max,min,avg,sum)
publicObjectgetStatValue(DetachedCriteriacriteria,StringpropertyName,
StringStatName){
if(StatName.toLowerCase().equals("max"))
criteria.setProjection(Projections.max(propertyName));
elseif(StatName.toLowerCase().equals("min"))
criteria.setProjection(Projections.min(propertyName));
elseif(StatName.toLowerCase().equals("avg"))
criteria.setProjection(Projections.avg(propertyName));
elseif(StatName.toLowerCase().equals("sum"))
criteria.setProjection(Projections.sum(propertyName));
else
returnnull;
Listlist=this.findByCriteria(criteria,0,1);
returnlist.get(0);
}
//--------------------------------Others--------------------------------
//加锁指定的实体
publicvoidlock(Tentity,LockModelock){
getHibernateTemplate().lock(entity,lock);
}
//强制初始化指定的实体
publicvoidinitialize(Objectproxy){
getHibernateTemplate().initialize(proxy);
}
//强制立即更新缓冲数据到数据库（否则仅在事务提交时才更新）
publicvoidflush(){
getHibernateTemplate().flush();
}
publicListfind(finalStringqueryString,finalObject[]values,finalintstart,finalintlimit){
return(List)getHibernateTemplate().execute(newHibernateCallback(){
publicObjectdoInHibernate(Sessionarg0)
throwsHibernateException,SQLException{
Queryquery=arg0.createQuery(queryString);
if(values!=null)
{
for(inti=0;i<values.length;i++)
{
query.setParameter(i,values[i]);
}
}
if(start>-1)
query.setFirstResult(start);
if(limit>-1)
query.setMaxResults(limit);
returnquery.list();
}
});
}
publicintgetRow(finalStringqueryString,finalObject[]values){
return(Integer)getHibernateTemplate().execute(newHibernateCallback(){
publicObjectdoInHibernate(Sessionarg0)
throwsHibernateException,SQLException{
Queryquery=arg0.createQuery(queryString);
if(values!=null)
{
for(inti=0;i<values.length;i++)
{
query.setParameter(i,values[i]);
}
}
returnquery.uniqueResult();
}
});
}
publicTfindUniqueByCriteria(DetachedCriteriacriteria){
Listlist=this.findByCriteria(criteria,0,1);
if(list==null||list.size()==0)
returnnull;
return(T)list.get(0);
}
}