`
zyongking
  • 浏览: 58780 次
  • 性别: Icon_minigender_1
  • 来自: 湖北
社区版块
存档分类
最新评论

Hibernate的通用dao

    博客分类:
  • j2ee
阅读更多

Hibernate+spring通用的dao.
首先定义一个SimpleDao接口,里面的方法如下:

/*
 * 
 * @author zyong
 *
 * @date 2009-9-19 下午11:02:34
 *
 * @action 一个简单公共的hibernate通用dao实现类
 */
package com.wind.dao;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Map;

import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.LockMode;
import org.hibernate.criterion.DetachedCriteria;

/**
 * 
 * @author zyong
 * 
 * @action 一个通用的Hibernate的dao接口<br>
 *         数据访问层里面的每一个接口都应该继承这个接口<br>
 *         而不用重写里面的方法
 */
public interface SimpleDao<E extends Serializable, PK extends Serializable> {

	/**
	 * 
	 * 该枚举类型用于,getStackValue方法中的Stack枚举
	 * 
	 */
	enum Stack {
		MAX, MIN, AVG, SUM;
	}

	/**
	 * 
	 * @param id
	 *            根据主键查询一个实体
	 * @return 一个实体对象
	 */
	E get(PK id);

	/**
	 * 
	 * @param id
	 *            根据主键查询一个实体
	 * @param lock
	 *            加锁实体
	 * @return 一个实体对象
	 */
	E get(PK id, LockMode lock);

	/**
	 * 使用数据库函数
	 * 
	 * @param criteria
	 *            一个DetacherCriteria对象
	 * @param propertyName
	 *            实体类属性名
	 * @param stackName
	 *            Stack枚举类型中的任意一个
	 * @return 一行一列数据库
	 */
	Object getStackValue(DetachedCriteria criteria, String propertyName,
			String stackName);

	/**
	 * 查询数据库对应的记录数
	 * 
	 * @param criteria
	 *            一个DetachedCriteria对象
	 * @return 记录数
	 */
	Integer getRowCount(DetachedCriteria criteria);

	/**
	 * 
	 * @param id
	 *            根据主键加裁一个实体对象
	 * @return 一个实体对象
	 */
	E load(PK id);

	/**
	 * 
	 * @param id
	 *            根据主键加裁实体
	 * @param lock
	 *            加锁实体
	 * @return 一个实体对象
	 */
	E load(PK id, LockMode lock);

	/**
	 * 
	 * @return 加裁所有对象
	 */
	List<E> loadAll();

	/**
	 * 
	 * @param entity
	 *            保存一个实体
	 * @throws HibernateException
	 *             抛出Exception异常
	 */
	void save(E entity) throws HibernateException;

	/**
	 * 
	 * @param entity
	 *            删除一个实体
	 * @throws HibernateException
	 *             抛出异常
	 */
	void delete(E entity) throws HibernateException;

	/**
	 * 
	 * @param entity
	 *            删除一个实体
	 * @param lock
	 *            加锁实体
	 * @throws HibernateException
	 *             抛出异常
	 */
	void delete(E entity, LockMode lock) throws HibernateException;

	/**
	 * 
	 * @param entitys
	 *            删除多个实体
	 * @throws HibernateException
	 *             抛出异常
	 */
	void delete(Collection<E> entitys) throws HibernateException;

	/**
	 * 
	 * @param entity
	 *            修改一个实体
	 * @throws HibernateException
	 *             抛出异常
	 */
	void update(E entity) throws HibernateException;

	/**
	 * 
	 * @param entity
	 *            修改一个实体
	 * @param lock
	 *            加锁实体
	 * @throws HibernateException
	 *             抛出异常
	 */
	void update(E entity, LockMode lock) throws HibernateException;

	/**
	 * 
	 * @param entity
	 *            当实体在数据库不在在与之对应记录时,则保存实体,在在实体,则更新实体
	 * @throws HibernateException
	 *             抛出异常
	 */
	void saveOrUpdate(E entity) throws HibernateException;

	/**
	 * 
	 * @param entitys
	 *            保存多个实体
	 * @throws HibernateException
	 *             抛出异常
	 */
	void saveOrUpdate(Collection<E> entitys) throws HibernateException;

	/*---------------------------利用hql,sql对数据库进行操作--------------------------------*/

	/**
	 * 
	 * @param hql
	 *            使用hql语句进行数据库增删改操作
	 * @return 受影响行的记录数
	 */
	Integer bulkUpdate(String hql);

	/**
	 * 
	 * @param hql
	 *            使用hql语句进行数据库增删改操作
	 * @param params
	 *            hql语句参数
	 * @return 受影响行的记录数
	 */
	Integer bulkUpdate(String hql, Object... values);

	/**
	 * 
	 * @param hql
	 *            使用hql语句,检索数据
	 * @return 一个list集合
	 */
	List<E> find(String hql);

	/**
	 * 
	 * @param hql
	 *            使用hql语句,检索数据
	 * @param params
	 *            hql语句参数
	 * @return 一个list集合
	 */
	List<E> find(String hql, Object... values);

	/**
	 * 
	 * @param queryName
	 *            使用命名的hql语句进行查询
	 * @return 一个list集合
	 */
	List<E> findByNamedQuery(String queryName);

	/**
	 * 
	 * @param queryName
	 *            使用带参数的命名hql语句进行查询
	 * @param values
	 *            参数集合
	 * @return 一个list集合
	 */
	List<E> findByNamedQuery(String queryName, Object... values);

	/**
	 * 
	 * @param queryName
	 *            使用带参数的命名hql语句进行查询
	 * @param params
	 *            参数集合<br>
	 *            Map的键为参数名称即paramName<br>
	 *            Map的值则为values
	 * @return 一个list集合
	 */
	List<E> findByNamedParam(String queryName, Map<String, Object> params);

	/**
	 * 
	 * @param queryName
	 *            使用带参数的命名hql语句进行查询
	 * @param params
	 *            参数集合<br>
	 *            Map的键为参数名称即paramName<br>
	 *            Map的值则为values
	 * @return 一个list集合
	 */
	List<E> findByNamedQueryAndNamedParam(String queryName,
			Map<String, Object> params);

	/**
	 * 
	 * @param criteria
	 *            使用指定的检索标准来检索数
	 * @return 一个list集合
	 */
	List<E> findByCriteria(DetachedCriteria criteria);

	/**
	 * 
	 * @param criteria
	 *            使用指定的检索标准来分页检索数据
	 * @param firstResult
	 *            开始条数
	 * @param maxResults
	 *            返回记录数
	 * @return 一个list集合
	 */
	List<E> findByCriteria(DetachedCriteria criteria, Integer firstResult,
			Integer maxResults);

	/**
	 * 加锁指定的实体
	 * 
	 * @param entity
	 *            实体对象
	 * 
	 * @param lock
	 *            加锁
	 */
	void lock(E entity, LockMode lock) throws HibernateException;

	/**
	 * 强制立即更新到数据库,否则需要事务提交后,才会提交到数据库
	 */
	void flush() throws HibernateException;

	/**
	 * 
	 * @return 根据SimpleDao泛型类型,创建一个与会话无关的检索对象
	 */
	DetachedCriteria createDetachedCriteria();

	/**
	 * 
	 * @param c
	 *            为一个实体类型
	 * @return 根据指定的类型创建一个与会话无关的检索对象
	 */
	DetachedCriteria createDetachedCriteria(Class<? extends Serializable> c);

	/**
	 * 
	 * @return 创建与会话绑定的检索标准对象
	 */
	Criteria createCriteria();

}

 

SimpleDaoImpl为一个SimpleDao的实现类.代码如下:

/*
 * 
 * @author zyong
 *
 * @date 2009-9-19 下午11:02:34
 *
 * @action 一个简单公共的hibernate通用dao实现类
 */
package com.wind.dao.impl;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Collection;
import java.util.List;
import java.util.Map;

import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.LockMode;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Projections;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import com.wind.dao.SimpleDao;

/**
 * 
 * @author zyong
 * 
 * @action 一个公共的Hibernate通用dao实现类<br>
 *         数据库访问层,每一个实现类都应该来继承该类<br>
 *         不应该重写里面的方法,需要相应的方法,直接到数据访问层每个类对应的接口中添加
 */
public abstract class SimpleDaoImpl<E extends Serializable, PK extends Serializable>
		extends HibernateDaoSupport implements SimpleDao<E, PK> {

	/**
	 * 为E对应的实例类型
	 */
	private Class<?> entityClass;

	/**
	 * 获取E实例类的类型
	 */
	public SimpleDaoImpl() {
		Class<?> c = this.getClass();
		Type t = c.getGenericSuperclass();
		if (t instanceof ParameterizedType) {
			this.entityClass = (Class<?>) ((ParameterizedType) t)
					.getActualTypeArguments()[0];
		}
	}

	@SuppressWarnings("unchecked")
	public E get(PK id) {
		return (E) this.getHibernateTemplate().get(this.entityClass, id);
	}

	@SuppressWarnings("unchecked")
	public E get(PK id, LockMode lock) {
		E entity = (E) this.getHibernateTemplate().get(this.entityClass, id,
				lock);
		if (entity != null) {
			this.flush();// 如果实体不为null,立即刷新,否则锁不会生效
		}
		return entity;
	}

	public Object getStackValue(DetachedCriteria criteria, String propertyName,
			Stack value) {
		switch (value) {
		case MAX:
			criteria.setProjection(Projections.max(propertyName));
			break;
		case MIN:
			criteria.setProjection(Projections.min(propertyName));
			break;
		case AVG:
			criteria.setProjection(Projections.avg(propertyName));
			break;
		default:
			criteria.setProjection(Projections.sum(propertyName));
			break;
		}
		return this.findByCriteria(criteria, 0, 1).get(0);
	}

	public Integer getRowCount(DetachedCriteria criteria) {
		criteria.setProjection(Projections.rowCount());
		return (Integer) this.findByCriteria(criteria, 0, 1).get(0);
	}

	@SuppressWarnings("unchecked")
	public E load(PK id) {
		return (E) this.getHibernateTemplate().load(this.entityClass, id);
	}

	@SuppressWarnings("unchecked")
	public E load(PK id, LockMode lock) {
		E entity = (E) this.getHibernateTemplate().load(this.entityClass, id,
				lock);
		if (entity != null) {
			this.flush();// 如果实体不为null,立即刷新,否则锁不会生效
		}
		return entity;
	}

	@SuppressWarnings("unchecked")
	public List<E> loadAll() {
		return this.getHibernateTemplate().loadAll(entityClass);
	}

	@SuppressWarnings("unchecked")
	public List<E> find(String hql) {
		return this.getHibernateTemplate().find(hql);
	}

	@SuppressWarnings("unchecked")
	public List<E> find(String hql, Object... values) {
		return this.getHibernateTemplate().find(hql, values);
	}

	@SuppressWarnings("unchecked")
	public List<E> findByNamedQuery(String queryName, Object... values) {
		return this.getHibernateTemplate().findByNamedQuery(queryName, values);
	}

	@SuppressWarnings("unchecked")
	public List<E> findByNamedQuery(String queryName) {
		return this.getHibernateTemplate().findByNamedQuery(queryName);
	}

	@SuppressWarnings("unchecked")
	public List<E> findByNamedQueryAndNamedParam(String queryName,
			Map<String, Object> params) {
		return this.getHibernateTemplate().findByNamedQueryAndNamedParam(
				queryName, (String[]) params.keySet().toArray(),
				params.values().toArray());
	}

	@SuppressWarnings("unchecked")
	public List<E> findByNamedParam(String queryName, Map<String, Object> params) {
		return this.getHibernateTemplate()
				.findByNamedParam(queryName,
						(String[]) params.keySet().toArray(),
						params.values().toArray());
	}

	@SuppressWarnings("unchecked")
	public List<E> findByCriteria(DetachedCriteria criteria) {
		return this.getHibernateTemplate().findByCriteria(criteria);
	}

	@SuppressWarnings("unchecked")
	public List<E> findByCriteria(DetachedCriteria criteria,
			Integer firstResult, Integer maxResults) {
		return this.getHibernateTemplate().findByCriteria(criteria,
				firstResult, maxResults);
	}

	public void save(E entity) throws HibernateException {
		this.getHibernateTemplate().save(entity);
	}

	public void saveOrUpdate(E entity) throws HibernateException {
		this.getHibernateTemplate().saveOrUpdate(entity);
	}

	public void saveOrUpdate(Collection<E> entitys) throws HibernateException {
		this.getHibernateTemplate().saveOrUpdateAll(entitys);
	}

	public void delete(E entity) throws HibernateException {
		this.getHibernateTemplate().delete(entity);
	}

	public void delete(E entity, LockMode lock) throws HibernateException {
		this.getHibernateTemplate().delete(entity, lock);
		this.flush();// 如果实体不为null,立即刷新,否则锁不会生效
	}

	public void delete(Collection<E> entitys) throws HibernateException {
		this.getHibernateTemplate().deleteAll(entitys);
	}

	public void update(E entity) throws HibernateException {
		this.getHibernateTemplate().update(entity);
	}

	public void update(E entity, LockMode lock) throws HibernateException {
		this.getHibernateTemplate().update(entity, lock);
		this.flush();// 如果实体不为null,立即刷新,否则锁不会生效
	}

	public Integer bulkUpdate(String hql) {
		return this.getHibernateTemplate().bulkUpdate(hql);
	}

	public Integer bulkUpdate(String hql, Object... values) {
		return this.getHibernateTemplate().bulkUpdate(hql, values);
	}

	public void flush() throws HibernateException {
		this.getHibernateTemplate().flush();
	}

	public void lock(E entity, LockMode lock) throws HibernateException {
		this.getHibernateTemplate().lock(entity, lock);
	}

	public DetachedCriteria createDetachedCriteria() {
		return DetachedCriteria.forClass(this.entityClass);
	}

	public DetachedCriteria createDetachedCriteria(
			Class<? extends Serializable> c) {
		return DetachedCriteria.forClass(c);
	}

	public Criteria createCriteria() {
		return this.createDetachedCriteria().getExecutableCriteria(
				this.getSession());
	}

}

 

 

数据访问层里面的每一个接口都继承SimpleDao接口,每一个接口的实现类都继承SimpleDaoImpl类.

  • dao.zip (3.5 KB)
  • 下载次数: 476
分享到:
评论

相关推荐

    Hibernate通用Dao

    通用dao,简单全面,所有dao都可以继承这个dao.

    Hibernate通用Dao设计。

    综上所述,Hibernate通用DAO设计的核心在于抽象出共性的数据库操作,并通过泛型和继承等面向对象设计原则,达到代码复用的目的。这样不仅可以降低开发难度,还能提升系统的可维护性,对于大型项目尤其重要。通过学习...

    hibernate通用dao

    **hibernate通用DAO(Data Access Object)**是软件开发中的一个重要概念,它主要用于数据库操作的抽象,使得业务逻辑层可以无需关注具体的SQL语句,从而实现数据访问的解耦。在Java EE应用中,Hibernate作为一款...

    hibernate spring通用dao

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

    本人写的Hibernate超级通用DAO

    《深入浅出Hibernate通用DAO设计与实践》 在软件开发中,数据访问对象(DAO)是用于处理数据库操作的重要组件,它可以将业务逻辑与数据访问层进行解耦,提高代码的可复用性和可维护性。本文将围绕“Hibernate超级...

    hibernate4 通用dao,service

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

    Hibernate 原生通用DAO

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

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

    本资源“Hibernate_通用DAO模式”提供了一种适用于不同类型表单的DAO实现,基于SSH(Struts2、Spring、Hibernate)框架,特别强调简洁、易懂和高可移植性。 首先,SSH框架是Java Web开发中的经典组合,Struts2负责...

    HibernateDao 通用

    HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao ...

    Hibernate封装dao层

    为了进一步提高代码的复用性,可以使用泛型来创建通用的DAO接口和实现。例如,`BaseDao&lt;T&gt;`,其中T代表实体类类型,这样就可以在不改变基本结构的情况下,为不同的实体类创建DAO。 6. **查询方法**: - 使用HQL...

    hibernate不是泛型的通用DAo1

    "hibernate不是泛型的通用DAo1"这个标题暗示了我们讨论的是一种非泛型化的DAO实现,可能是因为开发者想要避免强制继承和泛型模板。 在描述中提到,开发者在网上寻找的大多数DAO实现都是泛型的,需要继承来使用。...

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

    本篇将详细介绍"Hibernate泛型DAO接口,大部分通用都已包括"这一主题。 首先,让我们看看DAO的概念。DAO是软件设计模式中的一种,它的主要职责是封装对数据源的访问,以提供业务逻辑层与数据存储层之间的解耦。通过...

    HibernateDao.java

    - **设计模式**:考虑使用模板方法模式或者策略模式,将通用的数据库操作抽象出来,使得`HibernateDao.java`更具有复用性和灵活性。 总结,`HibernateDao.java`是Hibernate框架在实际项目中的重要实现,它封装了...

    Hibernate泛型Dao

    【标题】"Hibernate泛型Dao"是针对Java开发中的数据持久化框架Hibernate的一个高级应用,主要目的是为了提高代码的复用性和简洁性。在传统的Hibernate使用中,针对每个实体类,我们都需要创建一个对应的Dao(Data ...

    hibernate 通用接口架构

    "hibernate 通用接口架构"是指利用Hibernate框架,通过设计DAO(Data Access Object)层的接口来实现业务逻辑与数据访问的解耦,从而提高代码的可复用性和可维护性。 首先,我们来理解DAO层的作用。DAO层作为业务...

    Haha.Hibernate SprintSideExt 通用HibernateDAO

    Haha.Hibernate SprintSideExt 通用HibernateDAO 文章资源 详见:http://blog.csdn.net/lijun7788/article/details/6658847

    java ssh通用DAO另类实现示例

    总结:这个另类的Java SSH通用DAO实现利用了动态代理和Hibernate的特性,降低了代码复杂度,提高了代码复用性。它使得DAO层的维护变得更加简单,同时保持了良好的封装性和扩展性。在实际项目中,这样的设计可以显著...

    vc生成hibernate的dao类

    3. **模板定制**: 创建或编辑DAO类模板,模板中应包含通用的数据库操作方法,如save(), get(), update(), delete()等。 4. **代码生成工具**: 使用VC6.0中的插件或独立的代码生成工具,根据模板和实体类信息,自动...

Global site tag (gtag.js) - Google Analytics