hibernate 通用泛型DAO hibernate3 通用dao

发布时间：2018年04月10日 19:23:46分享人:迷离哥要很潮来源:互联网30
hibernate 通用泛型DAO

博客分类：ssh

DAOHibernateCC++C#

接口代码　　

packageorg.lzpeng.dao;

importjava.io.Serializable;

importjava.util.List;

importorg.hibernate.Criteria;

importorg.hibernate.Query;

importorg.hibernate.criterion.Criterion;

importorg.springside.modules.orm.hibernate.Page;

/**

*

*@version2009-1-10

*@authorlzpeng

*

*/

publicinterfaceIGenericDAO<T,PKextendsSerializable>{

publicvoidsave(Tentity);

publicvoiddelete(Tentity);

publicvoiddelete(PKid);

publicList<T>findAll();

publicPage<T>findAll(Page<T>page);

/**

*按id获取对象.

*/

publicTget(finalPKid);

/**

*按HQL查询对象列表.

*

*@paramhql

*hql语句

*@paramvalues

*数量可变的参数

*/

publicListfind(Stringhql,Object...values);

/**

*按HQL分页查询.暂不支持自动获取总结果数,需用户另行执行查询.

*

*@parampage

*分页参数.包括pageSize和firstResult.

*@paramhql

*hql语句.

*@paramvalues

*数量可变的参数.

*

*@return分页查询结果,附带结果列表及所有查询时的参数.

*/

publicPage<T>find(Page<T>page,Stringhql,Object...values);

/**

*按HQL查询唯一对象.

*/

publicObjectfindUnique(Stringhql,Object...values);

/**

*按HQL查询Intger类形结果.

*/

publicIntegerfindInt(Stringhql,Object...values);

/**

*按HQL查询Long类型结果.

*/

publicLongfindLong(Stringhql,Object...values);

/**

*按Criterion查询对象列表.

*

*@paramcriterion

*数量可变的Criterion.

*/

publicList<T>findByCriteria(Criterion...criterion);

/**

*按Criterion分页查询.

*

*@parampage

*分页参数.包括pageSize、firstResult、orderBy、asc、autoCount.

*其中firstResult可直接指定,也可以指定pageNo.autoCount指定是否动态获取总结果数.

*

*@paramcriterion

*数量可变的Criterion.

*@return分页查询结果.附带结果列表及所有查询时的参数.

*/

publicPage<T>findByCriteria(Pagepage,Criterion...criterion);

/**

*按属性查找对象列表.

*/

publicList<T>findByProperty(StringpropertyName,Objectvalue);

/**

*按属性查找唯一对象.

*/

publicTfindUniqueByProperty(StringpropertyName,Objectvalue);

/**

*根据查询函数与参数列表创建Query对象,后续可进行更多处理,辅助函数.

*/

publicQuerycreateQuery(StringqueryString,Object...values);

/**

*根据Criterion条件创建Criteria,后续可进行更多处理,辅助函数.

*/

publicCriteriacreateCriteria(Criterion...criterions);

/**

*判断对象的属性值在数据库内是否唯一.

*

*/

publicbooleanisPropertyUnique(StringpropertyName,ObjectnewValue,

ObjectorgValue);

/**

*通过count查询获得本次查询所能获得的对象总数.

*

*@returnpage对象中的totalCount属性将赋值.

*/

publicintcountQueryResult(Page<T>page,Criteriac);

}

实现类代码　　

packageorg.lzpeng.dao.impl;

importjava.io.Serializable;

importjava.lang.reflect.ParameterizedType;

importjava.util.ArrayList;

importjava.util.List;

importorg.hibernate.Criteria;

importorg.hibernate.Query;

importorg.hibernate.Session;

importorg.hibernate.SessionFactory;

importorg.hibernate.criterion.CriteriaSpecification;

importorg.hibernate.criterion.Criterion;

importorg.hibernate.criterion.Order;

importorg.hibernate.criterion.Projection;

importorg.hibernate.criterion.Projections;

importorg.hibernate.criterion.Restrictions;

importorg.hibernate.impl.CriteriaImpl;

importorg.hibernate.transform.ResultTransformer;

importorg.slf4j.Logger;

importorg.slf4j.LoggerFactory;

importorg.springframework.orm.hibernate3.support.HibernateDaoSupport;

importorg.springframework.util.Assert;

importorg.lzpeng.dao.IGenericDAO;

importorg.springside.modules.utils.BeanUtils;

importorg.springside.modules.orm.hibernate.Page;

importorg.springside.modules.orm.hibernate.QueryParameter;

/**

*Hibernate的范型基类.

*<p>

*可以在service类中直接创建使用.也可以继承出DAO子类

*</p>

*修改自SpringsideSimpleHibernateTemplate

*

*@param<T>

*DAO操作的对象类型

*@param<PK>

*主键类型

*

*

*/

@SuppressWarnings("unchecked")

publicclassGenericDAOImpl<T,PKextendsSerializable>extends

HibernateDaoSupportimplementsIGenericDAO<T,PK>{

protectedLoggerlogger=LoggerFactory.getLogger(getClass());

protectedSessionFactorysessionFactory;

protectedSessionsession;

protectedClass<?>entityClass;

publicGenericDAOImpl(){

this.entityClass=(Class<?>)((ParameterizedType)getClass()

.getGenericSuperclass()).getActualTypeArguments()[0];

}

publicGenericDAOImpl(SessionFactorysessionFactory,Class<T>entityClass){

super.setSessionFactory(sessionFactory);

this.entityClass=entityClass;

}

publicvoidsave(Tentity){

Assert.notNull(entity);

super.getHibernateTemplate().saveOrUpdate(entity);

logger.info("saveentity:{}",entity);

}

publicvoiddelete(Tentity){

Assert.notNull(entity);

super.getHibernateTemplate().delete(entity);

logger.info("deleteentity:{}",entity);

}

publicvoiddelete(PKid){

Assert.notNull(id);

delete(get(id));

}

publicList<T>findAll(){

returnfindByCriteria();

}

publicPage<T>findAll(Page<T>page){

returnfindByCriteria(page);

}

publicTget(finalPKid){

if(super.getHibernateTemplate()==null){

System.out.println("asdfasdf");

}

return(T)super.getHibernateTemplate().get(entityClass,id);

}

publicListfind(Stringhql,Object...values){

returncreateQuery(hql,values).list();

}

publicPage<T>find(Page<T>page,Stringhql,Object...values){

Assert.notNull(page);

if(page.isAutoCount()){

logger.warn("HQL查询暂不支持自动获取总结果数,hql为{}",hql);

}

Queryq=createQuery(hql,values);

if(page.isFirstSetted()){

q.setFirstResult(page.getFirst());

}

if(page.isPageSizeSetted()){

q.setMaxResults(page.getPageSize());

}

page.setResult(q.list());

returnpage;

}

/**

*按HQL查询唯一对象.

*/

publicObjectfindUnique(Stringhql,Object...values){

returncreateQuery(hql,values).uniqueResult();

}

publicIntegerfindInt(Stringhql,Object...values){

return(Integer)findUnique(hql,values);

}

publicLongfindLong(Stringhql,Object...values){

return(Long)findUnique(hql,values);

}

publicList<T>findByCriteria(Criterion...criterion){

returncreateCriteria(criterion).list();

}

publicPage<T>findByCriteria(Pagepage,Criterion...criterion){

Assert.notNull(page);

Criteriac=createCriteria(criterion);

if(page.isAutoCount()){

page.setTotalCount(countQueryResult(page,c));

}

if(page.isFirstSetted()){

c.setFirstResult(page.getFirst());

}

hibernate 通用泛型DAO hibernate3 通用dao
if(page.isPageSizeSetted()){

c.setMaxResults(page.getPageSize());

}

if(page.isOrderBySetted()){

if(page.getOrder().endsWith(QueryParameter.ASC)){

c.addOrder(Order.asc(page.getOrderBy()));

}else{

c.addOrder(Order.desc(page.getOrderBy()));

}

}

page.setResult(c.list());

returnpage;

}

/**

*按属性查找对象列表.

*/

publicList<T>findByProperty(StringpropertyName,Objectvalue){

Assert.hasText(propertyName);

returncreateCriteria(Restrictions.eq(propertyName,value)).list();

}

publicTfindUniqueByProperty(StringpropertyName,Objectvalue){

Assert.hasText(propertyName);

return(T)createCriteria(Restrictions.eq(propertyName,value))

.uniqueResult();

}

publicQuerycreateQuery(StringqueryString,Object...values){

Assert.hasText(queryString);

super.getSession().createQuery(queryString);

QueryqueryObject=super.getSession().createQuery(queryString);

if(values!=null){

for(inti=0;i<values.length;i++){

queryObject.setParameter(i,values[i]);

}

}

returnqueryObject;

}

publicCriteriacreateCriteria(Criterion...criterions){

Criteriacriteria=super.getSession().createCriteria(entityClass);

for(Criterionc:criterions){

criteria.add(c);

}

returncriteria;

}

publicbooleanisPropertyUnique(StringpropertyName,ObjectnewValue,

ObjectorgValue){

if(newValue==null||newValue.equals(orgValue))

returntrue;

Objectobject=findUniqueByProperty(propertyName,newValue);

return(object==null);

}

publicintcountQueryResult(Page<T>page,Criteriac){

CriteriaImplimpl=(CriteriaImpl)c;

//先把Projection、ResultTransformer、OrderBy取出来,清空三者后再执行Count操作

Projectionprojection=impl.getProjection();

ResultTransformertransformer=impl.getResultTransformer();

List<CriteriaImpl.OrderEntry>orderEntries=null;

try{

orderEntries=(List)BeanUtils.getFieldValue(impl,"orderEntries");

BeanUtils.setFieldValue(impl,"orderEntries",newArrayList());

}catch(Exceptione){

logger.error("不可能抛出的异常:{}",e.getMessage());

}

//执行Count查询

inttotalCount=(Integer)c.setProjection(Projections.rowCount())

.uniqueResult();

if(totalCount<1)

return-1;

//将之前的Projection和OrderBy条件重新设回去

c.setProjection(projection);

if(projection==null){

c.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);

}

if(transformer!=null){

c.setResultTransformer(transformer);

}

try{

BeanUtils.setFieldValue(impl,"orderEntries",orderEntries);

}catch(Exceptione){

logger.error("不可能抛出的异常:{}",e.getMessage());

}

returntotalCount;

}

}

使用方法代码　　

1.service中直接使用

GenericDAOImpl<User,Integer>userDAO=newGenericDAOImpl<User,Integer>(sessionFactory,User.class);

2.继承出子DAO

interfaceIUserDAOextendsIGenericDAO<User,Integer>

classUserDAOImplextendsGenericDAOImpl<User,Integer>implementsIUserDAO

  
hibernate泛型dao 

爱华网本文地址 » http://www.aihuau.com/a/25101011/61609.html

更多阅读

通用电气 工业4.0 通用电气的百亿美元之难

文 《环球企业家》记者 沈霄戈 通用电气副董事长约翰·赖斯(John Rice)今年的第三次访华之旅，和以前相比似乎颇多“曲折”，因为他肩负一项以前从未遇到过的“特殊使命”。  在他来华的一周之前，通用电气全球董事长兼CEO伊梅尔特(

上汽通用别克官网 通用变阵 上汽上位(1)

　　刚刚过去的2009年，上汽集团与通用中国分别以272万辆与183万辆的销售业绩，成为中国汽车市场上本土与外资阵营中最大的赢家。这一成绩得益于10年前对上汽通用五菱的并购重组——10年后，它为上汽与通用中国贡献了超过106万辆的销售业

声明:《hibernate 通用泛型DAO hibernate3 通用dao》为网友迷离哥要很潮分享！如侵犯到您的合法权益请联系我们删除