详细介绍 Hibernate 泛型 DAO 及其使用方法

编写Spring+Hibernate框架下的应用，总是离不了编写一个通用的泛型GenericHibernateDao。查阅了网上不少的GenericHibernateDao实现，归纳整理为如下实现，供后续编码参考。

首先定义接口泛型DAO接口 GenericDao

packagecom.th.huz;

importjava.io.Serializable;
importjava.util.Collection;
importjava.util.Iterator;
importjava.util.List;
importorg.hibernate.Criteria;
importorg.hibernate.LockMode;
importorg.hibernate.criterion.DetachedCriteria;

/**
*
*@authorlny
*/
publicinterfaceGenericDao<TextendsSerializable,PKextendsSerializable>{
//--------------------基本检索、增加、修改、删除操作--------------------

//根据主键获取实体。如果没有相应的实体，返回null。
publicTget(PKid);

//根据主键获取实体并加锁。如果没有相应的实体，返回null。
publicTgetWithLock(PKid,LockModelock);

//根据主键获取实体。如果没有相应的实体，抛出异常。
publicTload(PKid);

//根据主键获取实体并加锁。如果没有相应的实体，抛出异常。
publicTloadWithLock(PKid,LockModelock);

//获取全部实体。
publicList<T>loadAll();

//loadAllWithLock()?

//更新实体
publicvoidupdate(Tentity);

//更新实体并加锁
publicvoidupdateWithLock(Tentity,LockModelock);

//存储实体到数据库
publicvoidsave(Tentity);

//saveWithLock()

//增加或更新实体
publicvoidsaveOrUpdate(Tentity);

//增加或更新集合中的全部实体
publicvoidsaveOrUpdateAll(Collection<T>entities);

//删除指定的实体
publicvoiddelete(Tentity);

//加锁并删除指定的实体
publicvoiddeleteWithLock(Tentity,LockModelock);

//根据主键删除指定实体
publicvoiddeleteByKey(PKid);

//根据主键加锁并删除指定的实体
publicvoiddeleteByKeyWithLock(PKid,LockModelock);

//删除集合中的全部实体
publicvoiddeleteAll(Collection<T>entities);

//--------------------HSQL----------------------------------------------

//使用HSQL语句直接增加、更新、删除实体
publicintbulkUpdate(StringqueryString);

//使用带参数的HSQL语句增加、更新、删除实体
publicintbulkUpdate(StringqueryString,Object[]values);

//使用HSQL语句检索数据
publicListfind(StringqueryString);

//使用带参数的HSQL语句检索数据
publicListfind(StringqueryString,Object[]values);

//使用带命名的参数的HSQL语句检索数据
publicListfindByNamedParam(StringqueryString,String[]paramNames,
Object[]values);

//使用命名的HSQL语句检索数据
publicListfindByNamedQuery(StringqueryName);

//使用带参数的命名HSQL语句检索数据
publicListfindByNamedQuery(StringqueryName,Object[]values);

//使用带命名参数的命名HSQL语句检索数据
publicListfindByNamedQueryAndNamedParam(StringqueryName,
String[]paramNames,Object[]values);

//使用HSQL语句检索数据，返回Iterator
publicIteratoriterate(StringqueryString);

//使用带参数HSQL语句检索数据，返回Iterator
publicIteratoriterate(StringqueryString,Object[]values);

//关闭检索返回的Iterator
publicvoidcloseIterator(Iteratorit);

//--------------------------------Criteria------------------------------

//创建与会话无关的检索标准对象
publicDetachedCriteriacreateDetachedCriteria();

//创建与会话绑定的检索标准对象
publicCriteriacreateCriteria();

//使用指定的检索标准检索数据
publicListfindByCriteria(DetachedCriteriacriteria);

//使用指定的检索标准检索数据，返回部分记录
publicListfindByCriteria(DetachedCriteriacriteria,intfirstResult,
intmaxResults);

//使用指定的实体及属性检索（满足除主键外属性＝实体值）数据
publicList<T>findEqualByEntity(Tentity,String[]propertyNames);

//使用指定的实体及属性(非主键)检索（满足属性like串实体值）数据
publicList<T>findLikeByEntity(Tentity,String[]propertyNames);

//使用指定的检索标准检索数据，返回指定范围的记录
publicIntegergetRowCount(DetachedCriteriacriteria);

//使用指定的检索标准检索数据，返回指定统计值
publicObjectgetStatValue(DetachedCriteriacriteria,StringpropertyName,
StringStatName);

//--------------------------------Others--------------------------------

//加锁指定的实体
publicvoidlock(Tentity,LockModelockMode);

//强制初始化指定的实体
publicvoidinitialize(Objectproxy);

//强制立即更新缓冲数据到数据库（否则仅在事务提交时才更新）
publicvoidflush();

}

实现GenericDao接口的Hibernate的实现类 GenericHibernateDao

packagecom.th.huz;

importjava.io.Serializable;
importjava.lang.reflect.ParameterizedType;
importjava.lang.reflect.Type;
importjava.util.Collection;
importjava.util.Iterator;
importjava.util.List;
importorg.apache.commons.beanutils.PropertyUtils;
importorg.hibernate.Criteria;
importorg.hibernate.LockMode;
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.support.HibernateDaoSupport;

/**
*GenericHibernateDao继承HibernateDao，简单封装HibernateTemplate各项功能，
*简化基于HibernateDao的编写。
*
*@authorlny
*/
@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){
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);
}
}
criteria.add(exam);
return(List<T>)criteria.list();
}

//使用指定的实体及属性检索（满足属性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();
}
}

//以上代码来自网上收集

以上就实现了泛型的 Hibernate Dao 了，下面的例子就是业务对象对 GenericHibernateDao的使用

业务对象 Article 对应文章表的 aticle 表

packagecom.th.huz.model;

importjava.io.Serializable;
importjava.util.Date;

publicclassArticleimplementsSerializable{

privatestaticfinallongserialVersionUID=1072812006693587010L;

privatelongid;
privateStringtitle;
privateStringauthor;
privateDatepubDate;
privateStringcontent;

publiclonggetId(){
returnid;
}

publicvoidsetId(longid){
this.id=id;
}

publicStringgetTitle(){
returntitle;
}

publicvoidsetTitle(Stringtitle){
this.title=title;
}

publicStringgetAuthor(){
returnauthor;
}

publicvoidsetAuthor(Stringauthor){
this.author=author;
}

publicDategetPubDate(){
returnpubDate;
}

publicvoidsetPubDate(DatepubDate){
this.pubDate=pubDate;
}

publicStringgetContent(){
returncontent;
}

publicvoidsetContent(Stringcontent){
this.content=content;
}
}

定义 Article 业务对象的Dao 接口 IArticleDao ，它继承自 GenericDao 接口，以获得其中的方法

你可以在 IArticleDao 中添加 Article 业务对象特有的方法，也可以直接使用 GenericDao 中提供的所有方法IArticleDao接口指定业务对象的类型和主键的类型 <Article,Long>

packagecom.th.huz.model;

importcom.th.huz.dao.GenericDao;
importcom.th.huz.model.Article;
publicinterfaceIArticleDAOextendsGenericDao<Article,Long>{
//publicvoidfindById(Longid);
}

然后就可以定义 ArticleHibernateDao 类了，它只要实现 IArticleDao 接口并继承 GenericHibernateDao 类就可以使用所有的 Generic接口和IArticleDao 接口中的定义的方法。如果你在 IArticleDao 接口里指定了Article业务对象特有的方法，就在ArticleHibernateDao实现这些方法。而Generic接口中的方法，在ArticleHibernateDao 的父类 GenericHibernateDao 中已经全部实现了，直接调用就可以方便的访问数据库。

packagecom.th.huz.model;

importcom.th.huz.dao.GenericHibernateDao;

publicclassArticleHibernateDaoextendsGenericHibernateDao<Article,Long>implements
IArticleDAO{

}

其他的业务对象也可以参照 Article 和ArticleHibernateDao 类来定义， GenericDao 接口中有的通用方法就直接调用，不足的以后补充，其他业务对象特有的方法就在其他业务对象的 Dao接口(继承GenericDao接口) 中定义并通过 GenericHibernateDao 子类来实现。节省很多重复代码，简单几步就可以使用GenericDao接口的实现类GenericHibernateDao 方便地访问数据库。

最后提供一个Article 业务对象的 Hibernate 映射文件 和 建表SQL脚本 和一个 ArticleHibernateDao 类的测试类

Article的映射文件

<?xmlversion="1.0"?>
<!DOCTYPEhibernate-mappingPUBLIC"-//Hibernate/HibernateMappingDTD3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!--Article.hbm.xml-->
<hibernate-mapping>
<classname="com.th.huz.model.Article"table="article">
<idname="id"type="java.lang.Long">
<columnname="id"/>
<generatorclass="native"/>
</id>
<propertyname="title"type="java.lang.String">
<columnname="title"length="100"/>
</property>
<propertyname="author">
<columnname="author"length="32"/>
</property>
<propertyname="pubDate"type="java.util.Date">
<columnname="pubDate"/>
</property>
<propertyname="content"type="java.lang.String">
<columnname="content"/>
</property>
</class>
</hibernate-mapping>

Article对应的article表的建表脚本

ifexists<span style=

分享到：

JAVA 内部类的简单总结 | Dom4j 使用简介

• 2008-03-31 09:29
• 浏览 1015
• 评论(0)
• 查看更多

相关推荐

Hibernate泛型DAO及使用方法

Hibernate泛型DAO及使用方法.

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

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

Hibernate泛型Dao

基于hibernate5 泛型Dao实例，下载后改一下数据库 配置直接可以用

Hibernate泛型DAO及使用方法.doc

就是这份文档: 描述了hibernateDAO如何使用,是hibernate访问数据库可以变的简单.

泛型dao 泛型dao 泛型dao

Struts2、Hibernate、Spring整合的泛型DAO （本人评价: 代码开发效率提高30% 代码出错率减少70%） 对于大多数开发人员，系统中的每个 DAO 编写几乎相同的代码到目前为止已经成为一种习惯。虽然所有人都将这种重复...

spring hibernate 泛型DAO

泛型DAO 完善的dao代码及criteria查询底层代码

Hibernate泛型DAO（结合spring模板支持）

NULL 博文链接：https://zhaoshijie.iteye.com/blog/982232

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

NULL 博文链接：https://dr-yanglong.iteye.com/blog/2009075

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

Hibernate 对泛型Dao接口的实现主要通过继承泛型Dao接口，使用 Hibernate 的 Session 对象来实现数据访问。 Hibernate 对泛型Dao接口的实现的优点： 1. 简化数据访问：Hibernate 对泛型Dao接口的实现可以简化数据...

一个很好的通用泛型dao（含源码）

而泛型DAO是一个类型安全的，代码精简的设计模式（相对于传统DAO），尤其在DAO组件数量庞大的时候，代码量的减少更加明显。 泛型DAO的核心是定义一个GenericDao接口，声明基本的CRUD操作： 用hibernate作为持久化...

大家看看我设计的泛型DAO（使用Spring的Anotation和Hibernate）

NULL 博文链接：https://287854442.iteye.com/blog/746718

Struts2 Spring3 Hibernate 注解功能 DAO 泛型 通用分页

Struts2 Spring3 Hibernate 注解功能 DAO 泛型 通用分页

虚拟数据层 Struts2、Hibernate、Spring整合的泛型DAO Version 2010.9.27

Struts2、Hibernate、Spring整合的泛型DAO （本人评价: 代码开发效率提高30% 代码出错率减少70%） 对于大多数开发人员，系统中的每个 DAO 编写几乎相同的代码到目前为止已经成为一种习惯。虽然所有人都将这种重复...

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

NULL 博文链接：https://simon-9527.iteye.com/blog/2307148

虚拟数据层：Struts2、Hibernate、Spring整合的泛型DAO 代码

泛型dao 即：不写重复的dao 。这个技术 能让 dao层 和 service层 不写一行代码。外国都用这个泛型DAO了 中国还是一个类一个dao的写，我生气就写了这个文章了。 在本文中，我将为您展示如何避免再三地重复 DAO 代码

hibernate不是泛型的通用DAo1

DAo.hibernate3不是泛型的通用DAo我在网上找了好多都是泛型的，需要继承才能用，本人比较懒，找了好久才找到了这么个，不需要继承可以直接用的hibernate dao

基于hibernate的泛型Dao框架

NULL 博文链接：https://llying.iteye.com/blog/406058

Struts2+hibernate+spring整合泛型DAO

减少重复代码的编写，增强DAO层代码的重用。

hibernate spring通用dao

spring集成hibernate通用dao，泛型，server都可以调用