import cn.org.rapid_framework.page.Page;
import cn.org.rapid_framework.page.PageUtils;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Example;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projections;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
/**
* Hibernate基本DAO功能的封装.
*
* @author
*/
public abstract class BaseHibernateDao<E, PK extends Serializable> extends HibernateDaoSupport implements EntityDao<E, PK> {
private Class<E> entityClass;
protected Logger logger = LoggerFactory.getLogger(getClass()); //NOSONAR
private static final int DEFAULT_MAX_RESULTS = 2000;
@SuppressWarnings("unchecked") //NOSONAR
public BaseHibernateDao() {
Class typeCls = getClass();
Type genType = typeCls.getGenericSuperclass();
while (true) {
if (!(genType instanceof ParameterizedType)) {
typeCls = typeCls.getSuperclass();
genType = typeCls.getGenericSuperclass();
} else {
break;
}
}
this.entityClass = (Class<E>) ((ParameterizedType) genType).getActualTypeArguments()[0];
}
public void initDao() {
if (getHibernateTemplate().getMaxResults() == 0) {
setMaxResults(DEFAULT_MAX_RESULTS);
// logger.debug("Setting default max results of DAO to " + getHibernateTemplate().getMaxResults());
}
}
/**
* 设置getHibernateTemplate方式使用时默认的最大返回条数.
*
* @param maxResults
*/
public void setMaxResults(int maxResults) {
getHibernateTemplate().setMaxResults(maxResults);
}
/**
* 获取getHibernateTemplate方式使用时默认的最大返回条数.
*
* @return maxResult
*/
public int getMaxResults() {
return getHibernateTemplate().getMaxResults();
}
//TODO use javacommon.util.extjs.ExtJsPageHelper
protected Page<E> pageQuery(int pageNumber, int pageSize, DetachedCriteria detachedCriteria) {
Criteria criteria = detachedCriteria.getExecutableCriteria(getSession());
int totalCount = (
(Integer) criteria.setProjection(Projections.rowCount()).uniqueResult()
).intValue();
criteria.setProjection(null);
criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
//criteria = detachedCriteria.getExecutableCriteria(getSession());
List<E> items = criteria.setFirstResult(PageUtils.getFirstResult(pageNumber, pageSize)).setMaxResults(pageSize).list();
return new Page<E>(pageNumber, pageSize, totalCount, items);
}
protected Page<E> pageQuery(int pageNumber, int pageSize, DetachedCriteria detachedCriteria, Order[] orders) {
Criteria criteria = detachedCriteria.getExecutableCriteria(getSession());
int totalCount = (
(Integer) criteria.setProjection(Projections.rowCount()).uniqueResult()
).intValue();
criteria.setProjection(null);
criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
//criteria = detachedCriteria.getExecutableCriteria(getSession());
for (Order order : orders) {
criteria.addOrder(order);
}
List<E> items = criteria.setFirstResult(PageUtils.getFirstResult(pageNumber, pageSize)).setMaxResults(pageSize).list();
return new Page<E>(pageNumber, pageSize, totalCount, items);
}
/**
* 查询数据表所有数据.
*
* @return List
*/
@SuppressWarnings("unchecked") //NOSONAR
public List<E> findAll() {
return getSession().createCriteria(getEntityClass()).list();
}
// /**
// * 查询数据表所有的数据并排序.
// * @param defaultOrders
// * @return List
// */
// @SuppressWarnings("unchecked") //NOSONAR
// @Deprecated
// public List<E> findAll(LinkedHashMap<String, Boolean> defaultOrders) {
// Criteria criteria = getSession().createCriteria(getEntityClass());
// if (defaultOrders != null && !defaultOrders.isEmpty()){
// for(Entry<String, Boolean> defaultOrder: defaultOrders.entrySet()){
// criteria.addOrder(defaultOrder.getValue() ? Order.asc(defaultOrder.getKey()) : Order.desc(defaultOrder.getKey()));
// }
// }
// return criteria.list();
// }
/**
* 查询数据表分页数据.
*
* @param start
* @param limit
* @return List<Object>
*/
@SuppressWarnings("unchecked") //NOSONAR
public List<E> findAllUsePageLimit(int start, int limit) {
Criteria criteria = getSession().createCriteria(getEntityClass());
criteria.setFirstResult(start);
criteria.setMaxResults(limit);
return criteria.list();
}
// /**
// * 查询数据表分页数据并排序.
// * @param defaultOrders
// * @param start
// * @param limit
// * @return List<Object>
// */
// @SuppressWarnings("unchecked") //NOSONAR
// public List<E> findAllUsePageLimit(LinkedHashMap<String, Boolean> defaultOrders, int start, int limit) {
// Criteria criteria = getSession().createCriteria(getEntityClass());
// if (defaultOrders != null && !defaultOrders.isEmpty())
// for(Entry<String, Boolean> defaultOrder: defaultOrders.entrySet())
// criteria.addOrder(defaultOrder.getValue() ? Order.asc(defaultOrder.getKey()) : Order.desc(defaultOrder.getKey()));
// criteria.setFirstResult(start);
// criteria.setMaxResults(limit);
// return criteria.list();
// }
/**
* 保存记录.
*
* @param obj
*/
public void save(E obj) {
getSession().save(obj);
}
/**
* 保存或修改记录.
*
* @param obj
*/
public void saveOrUpdate(E obj) {
getSession().saveOrUpdate(obj);
}
/**
* 修改记录.
*
* @param obj
*/
public void update(E obj) {
getSession().update(obj);
}
/**
* 删除记录.
*
* @param obj
*/
public void delete(E obj) {
getSession().delete(obj);
}
/**
* 刷新记录.
*
* @param obj
*/
public void refresh(BaseEntity obj) {
getSession().refresh(obj);
}
/**
* 按照实例构建一个条件查询,实例NULL的属性将被排除条件
*
* @param obj
*/
public List<E> findByExample(E obj) {
return getSession()
.createCriteria(this.getEntityClass())
.add(Example.create(obj))
.list();
}
/**
* 按照实例构建一个条件查询,实例NULL的属性将被排除条件
*
* @param obj
*/
public E getByExample(E obj) {
List<?> list = getSession()
.createCriteria(this.getEntityClass())
.add(Example.create(obj))
.list();
return list.size() == 0 ? null : (E) list.get(0);
}
/**
* 使用数据库的update严格的更新,解决update对象生成脏数据的问题.
*
* @param fieldsMap
* @param conditionMap
* @return 影响的记录条数
*/
public int strictUpdate(Map<String, Object> fieldsMap, Map<String, Object> conditionMap) {
if (fieldsMap.isEmpty()) {
return 0;
}
StringBuilder sqlBuilder = new StringBuilder("update " + this.getEntityClass().getSimpleName() + " set ");
int i = 0;
for (String fieldName : fieldsMap.keySet()) {
if (i > 0) {
sqlBuilder.append(", ");
}
sqlBuilder.append(fieldName + " = :" + fieldName);
i++;
}
sqlBuilder.append(" where ");
i = 0;
for (String fieldName : conditionMap.keySet()) {
if (i > 0) {
sqlBuilder.append(" and ");
}
sqlBuilder.append(fieldName + " = :" + fieldName);
i++;
}
HashMap<String, Object> sqlParamMap = new HashMap<String, Object>();
sqlParamMap.putAll(fieldsMap);
sqlParamMap.putAll(conditionMap);
Query query = getSession().createQuery(sqlBuilder.toString());
for (Entry<String, Object> entry : sqlParamMap.entrySet()) {
query.setParameter(entry.getKey(), entry.getValue());
}
return query.executeUpdate();
}
/**
* 根据hibernate OID取记录.
*
* @param id
* @return Object
*/
@SuppressWarnings("unchecked") //NOSONAR
public E getById(PK id) {
return (E) getSession().get(getEntityClass(), id);
}
public void deleteById(PK id) {
E obj = getById(id);
if (obj != null) {
getSession().delete(obj);
}
}
/**
* 判断对象某些属性的值在数据库中是否唯一.
*
* @param uniquePropertyNames 在POJO里不能重复的属性列表,以逗号分割 如"name,loginid,password"
*/
public boolean isUnique(E entity, String[] uniquePropertyNames) {
// TODO implement it
return false;
}
public void flush() {
getHibernateTemplate().flush();
}
protected Class<E> getEntityClass() {
return entityClass;
}
}
分享到:
相关推荐
"Hibernate封装DAO层"就是将Hibernate的功能整合到DAO设计模式中,以实现更加高效、规范的数据库操作。 1. **DAO设计模式**: DAO模式是软件设计模式的一种,它的核心思想是创建一个独立于具体数据库操作的对象,...
综上所述,`JPA(hibernate) Dao 和 DaoSupport`涉及到Java持久化技术,主要关注如何通过面向对象的方式操作数据库,以及如何设计和使用DAO层来封装数据访问逻辑。在实际项目中,我们还需要了解如何使用Spring Data ...
在提供的代码片段中,我们可以看到一个`HibernateDao`类,它是对Hibernate的一些基本操作进行了封装,包括获取、删除等方法。下面将详细解释这些知识点。 1. **SessionFactory**: `SessionFactory`是Hibernate的...
`HibernateDao.java`是Hibernate框架中一个常见的数据访问对象(DAO,Data Access Object)类,它的主要职责是封装对数据库的操作,提供一套面向对象的接口,使得业务逻辑层可以无需关心底层SQL语句,直接通过对象...
本文将详细介绍如何进行Hibernate环境搭建,以及如何进行基本操作的封装,我们将以MySQL开源数据库作为数据存储后端。 一、Hibernate环境搭建 1. **安装MySQL数据库**: 首先,你需要在本地或者服务器上安装MySQL...
在实际开发中,HibernateDao通常包含以下功能: 1. 实现通用的CRUD操作,如增删改查。 2. 提供事务处理,确保数据一致性。 3. 支持动态SQL,允许根据条件生成不同的查询语句。 4. 可以封装分页、排序等复杂查询逻辑...
**Hibernate原生通用DAO**是基于Hibernate框架设计的一种简化数据访问操作的方式,它模仿了Spring框架中的`HibernateTemplate`类,旨在提供一个简单易用的DAO(Data Access Object)层,方便开发人员进行数据库操作...
通常,开发者会创建一个基类,比如HibernateDAO,提供通用的方法,然后为每个特定的数据模型创建继承自该基类的DAO实现。 在标签中,“源码”意味着讨论可能涉及到了具体的代码实现,而“工具”可能指的是Hibernate...
在Java Web开发中,DAO(Data Access Object)模式是一种常用的设计模式,用于封装对数据库的操作,使得业务逻辑层与数据访问层分离,提高代码的可重用性和可维护性。本资源“Hibernate_通用DAO模式”提供了一种适用...
GenericHibernateDao 继承 HibernateDao,简单封装 HibernateTemplate 各项功能,简化基于Hibernate Dao 的编写。
HibernateDAO(Data Access Object)主要负责数据库的读写操作,它封装了对Hibernate Session的操作,降低了业务层与数据库的直接交互,提高了代码的可维护性和可测试性。DAO设计模式是将数据库操作隔离出来,使得...
总的来说,SpringSide的Hibernate封装是面向实际开发需求的一套解决方案,它不仅简化了DAO层的编写,也提升了代码质量,降低了维护成本,是Spring和Hibernate集成项目中的一个优秀实践。对于开发者来说,理解并熟练...
在传统的Java应用程序中,DAO(Data Access Object)层是用于封装数据库访问逻辑的地方,它隔离了业务逻辑与数据存储之间的耦合。Hibernate的出现使得我们可以将SQL语句转换为对Java对象的操作,降低了直接操作...
通用DAO(Data Access Object)是一种设计模式,用于封装对数据库的操作,提供一套可重用的接口,以简化数据访问层的开发工作。本篇将深入探讨Hibernate中的通用DAO实现及其相关知识点。 **一、Hibernate简介** ...
标题“使用Hibernate封装方法”暗示我们将讨论如何在项目中通过封装Hibernate操作,以提高代码的复用性和可读性。通常,我们会在DAO(数据访问对象)层进行这些封装,将数据库的CRUD(创建、读取、更新、删除)操作...
标题中的“hibernate4 通用dao,service”指的是在Java开发中使用Hibernate框架实现的通用数据访问对象(DAO)和业务服务层(Service)。Hibernate是一个流行的对象关系映射(ORM)工具,它允许开发者使用面向对象的...
Dao层是应用与数据库之间的一层抽象,它封装了对数据库的所有操作,使得业务逻辑层可以专注于业务处理,而不必关心具体的SQL语句或者数据库连接管理。在Hibernate中,Dao层通常包含了一些对Hibernate Session的操作...
本主题主要探讨的是如何使用泛型和反射技术来实现Hibernate对DAO的封装,从而创建一个通用的DAO模板,减少开发者重复编写CRUD(Create、Read、Update、Delete)操作的工作。 首先,我们需要理解DAO(Data Access ...
首先,DAO(Data Access Object)模式是一种设计模式,它的主要作用是封装数据库访问的逻辑,使得业务层与数据访问层解耦。泛型DAO是DAO模式的一种改进,通过使用Java泛型,我们可以创建一个适用于任何类型的DAO接口...
DAO是软件设计模式中的一种,它的主要职责是封装对数据源的访问,以提供业务逻辑层与数据存储层之间的解耦。通过使用DAO,我们可以更好地管理数据库操作,使其独立于业务逻辑,便于测试和重构。 泛型DAO是DAO模式的...