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

azheng270

浏览: 93005 次
性别:
来自: 杭州

最近访客更多访客>>

4351901

hitgnu

belldeep

xlwn

博主相关

博客

微博

相册

留言

关于我

文章分类

全部博客 (68)

社区版块

存档分类

DAO Hibernate Spring 脚本 SQL

编写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">

<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
浏览 1032
评论(0)
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论