`
465272694
  • 浏览: 52380 次
  • 性别: Icon_minigender_1
  • 来自: 广州
社区版块
存档分类
最新评论

Hibernate基本DAO功能的封装

阅读更多
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&lt;Object&gt;
     */
    @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&lt;Object&gt;
//		 */
//		@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层"就是将Hibernate的功能整合到DAO设计模式中,以实现更加高效、规范的数据库操作。 1. **DAO设计模式**: DAO模式是软件设计模式的一种,它的核心思想是创建一个独立于具体数据库操作的对象,...

    JPA(hibernate) Dao 和 DaoSupport

    综上所述,`JPA(hibernate) Dao 和 DaoSupport`涉及到Java持久化技术,主要关注如何通过面向对象的方式操作数据库,以及如何设计和使用DAO层来封装数据访问逻辑。在实际项目中,我们还需要了解如何使用Spring Data ...

    hibernate封装.pdf

    在提供的代码片段中,我们可以看到一个`HibernateDao`类,它是对Hibernate的一些基本操作进行了封装,包括获取、删除等方法。下面将详细解释这些知识点。 1. **SessionFactory**: `SessionFactory`是Hibernate的...

    HibernateDao.java

    `HibernateDao.java`是Hibernate框架中一个常见的数据访问对象(DAO,Data Access Object)类,它的主要职责是封装对数据库的操作,提供一套面向对象的接口,使得业务逻辑层可以无需关心底层SQL语句,直接通过对象...

    hibernate环境搭建基本操作封装

    本文将详细介绍如何进行Hibernate环境搭建,以及如何进行基本操作的封装,我们将以MySQL开源数据库作为数据存储后端。 一、Hibernate环境搭建 1. **安装MySQL数据库**: 首先,你需要在本地或者服务器上安装MySQL...

    HibernateDao 通用

    在实际开发中,HibernateDao通常包含以下功能: 1. 实现通用的CRUD操作,如增删改查。 2. 提供事务处理,确保数据一致性。 3. 支持动态SQL,允许根据条件生成不同的查询语句。 4. 可以封装分页、排序等复杂查询逻辑...

    Hibernate 原生通用DAO

    **Hibernate原生通用DAO**是基于Hibernate框架设计的一种简化数据访问操作的方式,它模仿了Spring框架中的`HibernateTemplate`类,旨在提供一个简单易用的DAO(Data Access Object)层,方便开发人员进行数据库操作...

    hibernate+dao实例

    通常,开发者会创建一个基类,比如HibernateDAO,提供通用的方法,然后为每个特定的数据模型创建继承自该基类的DAO实现。 在标签中,“源码”意味着讨论可能涉及到了具体的代码实现,而“工具”可能指的是Hibernate...

    Hibernate_通用DAO模式,一个写好的dao层

    在Java Web开发中,DAO(Data Access Object)模式是一种常用的设计模式,用于封装对数据库的操作,使得业务逻辑层与数据访问层分离,提高代码的可重用性和可维护性。本资源“Hibernate_通用DAO模式”提供了一种适用...

    简单封装 HibernateTemplate 各项功能

    GenericHibernateDao 继承 HibernateDao,简单封装 HibernateTemplate 各项功能,简化基于Hibernate Dao 的编写。

    HibernateDAO的写法

    HibernateDAO(Data Access Object)主要负责数据库的读写操作,它封装了对Hibernate Session的操作,降低了业务层与数据库的直接交互,提高了代码的可维护性和可测试性。DAO设计模式是将数据库操作隔离出来,使得...

    SpringSide的Hibernate封装

    总的来说,SpringSide的Hibernate封装是面向实际开发需求的一套解决方案,它不仅简化了DAO层的编写,也提升了代码质量,降低了维护成本,是Spring和Hibernate集成项目中的一个优秀实践。对于开发者来说,理解并熟练...

    Hibernate通用Dao设计。

    在传统的Java应用程序中,DAO(Data Access Object)层是用于封装数据库访问逻辑的地方,它隔离了业务逻辑与数据存储之间的耦合。Hibernate的出现使得我们可以将SQL语句转换为对Java对象的操作,降低了直接操作...

    Hibernate的通用dao

    通用DAO(Data Access Object)是一种设计模式,用于封装对数据库的操作,提供一套可重用的接口,以简化数据访问层的开发工作。本篇将深入探讨Hibernate中的通用DAO实现及其相关知识点。 **一、Hibernate简介** ...

    使用hibernate封装方法

    标题“使用Hibernate封装方法”暗示我们将讨论如何在项目中通过封装Hibernate操作,以提高代码的复用性和可读性。通常,我们会在DAO(数据访问对象)层进行这些封装,将数据库的CRUD(创建、读取、更新、删除)操作...

    hibernate4 通用dao,service

    标题中的“hibernate4 通用dao,service”指的是在Java开发中使用Hibernate框架实现的通用数据访问对象(DAO)和业务服务层(Service)。Hibernate是一个流行的对象关系映射(ORM)工具,它允许开发者使用面向对象的...

    使用代理实现Hibernate Dao层自动事务

    Dao层是应用与数据库之间的一层抽象,它封装了对数据库的所有操作,使得业务逻辑层可以专注于业务处理,而不必关心具体的SQL语句或者数据库连接管理。在Hibernate中,Dao层通常包含了一些对Hibernate Session的操作...

    hibenate 对DAO的封装

    本主题主要探讨的是如何使用泛型和反射技术来实现Hibernate对DAO的封装,从而创建一个通用的DAO模板,减少开发者重复编写CRUD(Create、Read、Update、Delete)操作的工作。 首先,我们需要理解DAO(Data Access ...

    Hibernate泛型DAO及使用方法

    首先,DAO(Data Access Object)模式是一种设计模式,它的主要作用是封装数据库访问的逻辑,使得业务层与数据访问层解耦。泛型DAO是DAO模式的一种改进,通过使用Java泛型,我们可以创建一个适用于任何类型的DAO接口...

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

    DAO是软件设计模式中的一种,它的主要职责是封装对数据源的访问,以提供业务逻辑层与数据存储层之间的解耦。通过使用DAO,我们可以更好地管理数据库操作,使其独立于业务逻辑,便于测试和重构。 泛型DAO是DAO模式的...

Global site tag (gtag.js) - Google Analytics