`
XmKevinChen
  • 浏览: 86100 次
  • 性别: Icon_minigender_1
  • 来自: 厦门
社区版块
存档分类
最新评论

Spring+Hibernate的泛型DAO类

    博客分类:
  • J2EE
阅读更多

接口

package org.kevin.prototype.common.dao;

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

import org.hibernate.LockMode;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Order;

/**
 * 基础dao接口
 *
 * @author kevin
 *
 * @param <T>
 *            Entity
 * @param <PK>
 *            Primary Key
 */
public interface IGenericDao<T extends Serializable, PK extends Serializable> {

	/**
	 * 通过主键获取实体
	 *
	 * @param id
	 * @return T entity
	 */
	T get(PK id);

	/**
	 * 通过主键获得实体并加锁
	 *
	 * @param id
	 * @param mode
	 * @return
	 */
	T getWithLock(PK id, LockMode mode);

	/**
	 * 通过主键获得实体
	 *
	 * @param id
	 * @return
	 */
	T load(PK id);

	/**
	 * 通过主键获得实体并加锁
	 *
	 * @param id
	 * @param mode
	 * @return
	 */
	T loadWithLock(PK id, LockMode mode);

	/**
	 * 保存实体
	 *
	 * @param entity
	 * @return
	 */
	T save(T entity);

	/**
	 * 更新实体
	 *
	 * @param entity
	 * @return
	 */
	T update(T entity);

	/**
	 * 删除实体
	 *
	 * @param entity
	 */
	void delete(T entity);

	/**
	 * 强制立即更新缓存到数据库
	 */
	void flush();

	/**
	 * 获得全部实体
	 *
	 * @return
	 */
	List<T> findAll();

	/**
	 * 根据例子,获取实体
	 *
	 * @param exampleEntity
	 * @return
	 */
	List<T> findByExample(T exampleEntity);

	/**
	 * 根据例子,获取实体
	 *
	 * @param exampleEntity
	 * @param excludeProperty
	 * @return
	 */
	List<T> findByExample(T exampleEntity, String[] excludeProperty);

	List<T> findLikeEntity(T entity, String[] propertyNames);

	@SuppressWarnings("unchecked")
	List findByHQL(String hql);

	List<T> findByCriteria(int firstResult, int maxResults, Order order,
			Criterion... criterions);

	List<T> findByCriteria(Criterion... criterions);

}

 

实现类:

package org.kevin.prototype.common.dao.impl;

import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.ParameterizedType;
import java.sql.SQLException;
import java.util.List;

import org.apache.commons.beanutils.PropertyUtils;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.LockMode;
import org.hibernate.Session;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Example;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.kevin.prototype.common.dao.IGenericDao;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

public abstract class GenericDaoImpl<T extends Serializable, PK extends Serializable, DaoImpl extends IGenericDao<T, PK>>
		extends HibernateDaoSupport implements IGenericDao<T, PK> {

	private Class<T> clazz;

	@SuppressWarnings("unchecked")
	public GenericDaoImpl() {
		this.clazz = (Class<T>) ((ParameterizedType) getClass()
				.getGenericSuperclass()).getActualTypeArguments()[0];
	}

	public Class<T> getClazz() {
		return clazz;
	}

	public void delete(T entity) {
		getHibernateTemplate().delete(entity);
	}

	public void flush() {
		getHibernateTemplate().flush();
	}

	@SuppressWarnings("unchecked")
	public T get(PK id) {
		return (T) getHibernateTemplate().get(getClazz(), id);
	}

	@SuppressWarnings("unchecked")
	public T getWithLock(PK id, LockMode mode) {
		return (T) getHibernateTemplate().get(getClazz(), id, mode);

	}

	@SuppressWarnings("unchecked")
	public T load(final PK id) {
		return (T) getHibernateTemplate().load(getClazz(), id);
	}

	@SuppressWarnings("unchecked")
	public T loadWithLock(PK id, LockMode mode) {
		return (T) getHibernateTemplate().load(getClazz(), id, mode);
	}

	public T save(T entity) {
		getHibernateTemplate().save(entity);
		return entity;
	}

	public T update(T entity) {
		getHibernateTemplate().update(entity);
		return entity;
	}

	public List<T> findAll() {
		return findByCriteria();
	}

	@SuppressWarnings("unchecked")
	public List<T> findByExample(T exampleEntity) {
		return getHibernateTemplate().findByExample(exampleEntity);
	}

	@SuppressWarnings("unchecked")
	public List<T> findByExample(T exampleEntity, String[] excludeProperty) {
		DetachedCriteria criteria = DetachedCriteria.forClass(getClazz());
		Example example = Example.create(exampleEntity);
		for (String exclude : excludeProperty) {
			example.excludeProperty(exclude);
		}
		criteria.add(example);
		return getHibernateTemplate().findByCriteria(criteria);
	}

	@SuppressWarnings("unchecked")
	public List<T> findLikeEntity(T entity, String[] propertyNames) {
		DetachedCriteria criteria = DetachedCriteria.forClass(getClazz());
		for (String property : propertyNames) {
			try {
				Object value = PropertyUtils.getProperty(entity, property);
				if (value instanceof String) {
					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 (IllegalAccessException e) {
				e.printStackTrace();
			} catch (InvocationTargetException e) {
				e.printStackTrace();
			} catch (NoSuchMethodException e) {
				e.printStackTrace();
			}
		}
		return getHibernateTemplate().findByCriteria(criteria);
	}

	@SuppressWarnings("unchecked")
	public List findByHQL(String hql) {
		return getHibernateTemplate().find(hql);
	}

	@SuppressWarnings("unchecked")
	public List<T> findByCriteria(final int firstResult, final int maxResults,
			final Order order, final Criterion... criterions) {
		return (List<T>) getHibernateTemplate().execute(
				new HibernateCallback() {

					public List<T> doInHibernate(Session session)
							throws HibernateException, SQLException {
						Criteria criteria = session.createCriteria(getClazz());
						for (Criterion c : criterions) {
							criteria.add(c);
						}
						if (order != null) {
							criteria.addOrder(order);
						}

						criteria.setFirstResult(firstResult);
						criteria.setMaxResults(maxResults);

						return criteria.list();
					}
				});
	}

	@SuppressWarnings("unchecked")
	public List<T> findByCriteria(Criterion... criterions) {
		DetachedCriteria criteria = DetachedCriteria.forClass(getClazz());
		for (Criterion c: criterions) {
			criteria.add(c);
		}
		return getHibernateTemplate().findByCriteria(criteria);
	}

}
 
分享到:
评论

相关推荐

    Struts2+hibernate+spring整合泛型DAO

    在Struts2+Hibernate+Spring的集成中,泛型DAO扮演着重要的角色,它使得DAO层对所有实体类的操作变得统一和规范。 首先,让我们详细了解一下Struts2。Struts2是基于拦截器的MVC框架,它提供了强大的动作映射、结果...

    Struts+Spring+Hibernate开发实例.pdf

    标题和描述中指出的文档《Struts+Spring+Hibernate开发实例.pdf》包含了关于这三个流行的Java开源框架结合使用的示例代码和相关知识点。Struts负责视图与控制器部分,Spring负责业务逻辑层及依赖注入,Hibernate负责...

    spring hibernate 泛型DAO

    本文将深入探讨“Spring Hibernate 泛型DAO”这一主题,以及如何通过泛型DAO实现更加高效、可复用的代码。 首先,让我们理解什么是DAO(Data Access Object)模式。DAO是一种设计模式,它的主要作用是隔离业务逻辑...

    Hibernate泛型DAO(结合spring模板支持)

    至于`Dao经典泛型.doc`文件,可能是更深入的关于Hibernate泛型DAO的文档,可能包含了如何配置Spring、如何处理复杂查询以及如何优化泛型DAO的更多细节。阅读这份文档将进一步提升你对泛型DAO的理解和应用能力。 ...

    Hibernate泛型Dao

    【内容】在使用Hibernate泛型Dao时,首先需要定义一个基类,比如`AbstractGenericDao&lt;T&gt;`,其中T代表泛型类型,对应你要操作的实体类。这个基类会包含一些通用的CRUD(Create, Read, Update, Delete)方法,如`save...

    再发一个基于Hibernate+Spring 泛型GenericDao 的工程源码.

    描述中提到的“剥离出来的泛型Hibernate”可能是指从一个大型项目中抽取出来的一个独立组件,这个组件专注于泛型DAO的实现,以便在其他项目中复用。博文链接指向的ITEYE博客文章可能详细解释了如何实现这样的泛型DAO...

    SSH2全注解整合(spring2.5+hibernate3.3+struts2.1+泛型DAO+proxool连接池)

    泛型DAO(Data Access Object)是一种设计模式,用于抽象数据访问层的操作,提供通用的CRUD(Create, Read, Update, Delete)方法。通过泛型,DAO可以适用于多种类型的实体,降低了代码重复。例如,一个BaseDAO接口...

    Hibernate泛型DAO及使用方法.doc

    本文档主要探讨了如何在Spring+Hibernate环境中创建和使用泛型DAO。 首先,我们来看一下泛型DAO接口的定义。在`com.th.huz`包下,定义了一个名为`GenericDao`的接口,它有两个泛型参数:`T`代表要操作的实体类,`PK...

    泛型dao 泛型dao 泛型dao

    Struts2、Hibernate、Spring整合的泛型DAO (本人评价: 代码开发效率提高30% 代码出错率减少70%) 对于大多数开发人员,系统中的每个 DAO 编写几乎相同的代码到目前为止已经成为一种习惯。虽然所有人都将这种重复...

    Hibernate泛型DAO及使用方法

    而`Hibernate泛型DAO`则是为了减少代码重复性,提高代码复用性和可维护性的一种设计模式。本文将深入探讨`Hibernate泛型DAO`的实现及其使用方法。 首先,DAO(Data Access Object)模式是一种设计模式,它的主要...

    Hibernate泛型DAO及使用方法借鉴.pdf

    《Hibernate泛型DAO及使用方法借鉴》 在Java开发中,特别是使用Spring+Hibernate框架时,泛型DAO(Data Access Object)是常见的设计模式,它提供了对数据库操作的一般化接口,以提高代码的重用性和可维护性。本文...

    Spring+Hibernate实现)Hibernate公用类

    在标题和描述中提到的"Spring+Hibernate实现)Hibernate公用类",实际上是指创建一个泛化的DAO接口(EntityDao)和它的实现类(EntityDaoImpl)。这样的设计模式可以避免为每个数据模型(如User、News、Company)都...

    ssh2 + dao泛型

    DAO泛型是Spring框架中一个重要的优化手段,它允许我们在编写DAO层代码时使用泛型,以提高代码的复用性和类型安全性。通过定义泛型接口或抽象类,我们可以创建一个通用的DAO模板,将具体的数据库操作与实体类的类型...

    虚拟数据层 Struts2、Hibernate、Spring整合的泛型DAO Version 2010.9.27

    Struts2、Hibernate、Spring整合的泛型DAO (本人评价: 代码开发效率提高30% 代码出错率减少70%) 对于大多数开发人员,系统中的每个 DAO 编写几乎相同的代码到目前为止已经成为一种习惯。虽然所有人都将这种重复...

    spring3.1+hibernate4+Jpa Dao

    综上所述,"spring3.1+hibernate4+jpa Dao"的集成是一个高效、灵活的企业级应用开发架构,它结合了Spring的IoC和AOP能力、Hibernate的ORM功能以及JPA的标准接口,通过泛型DAO实现和事务管理,为开发者提供了强大的...

    经典泛型dao层代码,非常好用简易

    本文将深入探讨一种在SSH(Struts+Spring+Hibernate)框架中广泛应用的经典泛型DAO层实现方式,旨在展示其简洁性、高效性和灵活性。 #### 泛型DAO层:概念与优势 泛型DAO层通过利用Java的泛型机制,提供了一种类型...

    struts+spring+hibernate通用分页方法

    1. 创建一个泛型的DAO接口,定义分页查询的方法,参数可能包括实体类的类型、查询条件、当前页数和每页大小。 2. 实现DAO接口,使用Hibernate的Session和Query对象进行分页查询,并返回结果集。 3. 在Service层中,...

    虚拟数据层:Struts2、Hibernate、Spring整合的泛型DAO 代码

    泛型dao 即:不写重复的dao 。这个技术 能让 dao层 和 service层 不写一行代码。外国都用这个泛型DAO了 中国还是一个类一个dao的写,我生气就写了这个文章了。 在本文中,我将为您展示如何避免再三地重复 DAO 代码

    Struts+Spring+Hibernate框架技术在Web开发中的研究与应用

    具体来说,可以利用Spring AOP和动态代理技术,实现一个通用的DAO基类或接口,该基类或接口能够自动为不同的实体类生成相应的DAO实例。这种方式不仅减少了代码量,还提高了系统的可扩展性和维护性。 #### 4. 实现...

    大家看看我设计的泛型DAO(使用Spring的Anotation和Hibernate)

    本篇文章将深入探讨一个使用Spring注解和Hibernate实现的泛型DAO设计,以提高代码的复用性和可维护性。 首先,`HibernateBaseDao.java`是基础的Hibernate DAO类,它提供了对Hibernate操作的基本封装。这个类通常会...

Global site tag (gtag.js) - Google Analytics