接口
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扮演着重要的角色,它使得DAO层对所有实体类的操作变得统一和规范。 首先,让我们详细了解一下Struts2。Struts2是基于拦截器的MVC框架,它提供了强大的动作映射、结果...
标题和描述中指出的文档《Struts+Spring+Hibernate开发实例.pdf》包含了关于这三个流行的Java开源框架结合使用的示例代码和相关知识点。Struts负责视图与控制器部分,Spring负责业务逻辑层及依赖注入,Hibernate负责...
本文将深入探讨“Spring Hibernate 泛型DAO”这一主题,以及如何通过泛型DAO实现更加高效、可复用的代码。 首先,让我们理解什么是DAO(Data Access Object)模式。DAO是一种设计模式,它的主要作用是隔离业务逻辑...
至于`Dao经典泛型.doc`文件,可能是更深入的关于Hibernate泛型DAO的文档,可能包含了如何配置Spring、如何处理复杂查询以及如何优化泛型DAO的更多细节。阅读这份文档将进一步提升你对泛型DAO的理解和应用能力。 ...
【内容】在使用Hibernate泛型Dao时,首先需要定义一个基类,比如`AbstractGenericDao<T>`,其中T代表泛型类型,对应你要操作的实体类。这个基类会包含一些通用的CRUD(Create, Read, Update, Delete)方法,如`save...
描述中提到的“剥离出来的泛型Hibernate”可能是指从一个大型项目中抽取出来的一个独立组件,这个组件专注于泛型DAO的实现,以便在其他项目中复用。博文链接指向的ITEYE博客文章可能详细解释了如何实现这样的泛型DAO...
泛型DAO(Data Access Object)是一种设计模式,用于抽象数据访问层的操作,提供通用的CRUD(Create, Read, Update, Delete)方法。通过泛型,DAO可以适用于多种类型的实体,降低了代码重复。例如,一个BaseDAO接口...
本文档主要探讨了如何在Spring+Hibernate环境中创建和使用泛型DAO。 首先,我们来看一下泛型DAO接口的定义。在`com.th.huz`包下,定义了一个名为`GenericDao`的接口,它有两个泛型参数:`T`代表要操作的实体类,`PK...
Struts2、Hibernate、Spring整合的泛型DAO (本人评价: 代码开发效率提高30% 代码出错率减少70%) 对于大多数开发人员,系统中的每个 DAO 编写几乎相同的代码到目前为止已经成为一种习惯。虽然所有人都将这种重复...
而`Hibernate泛型DAO`则是为了减少代码重复性,提高代码复用性和可维护性的一种设计模式。本文将深入探讨`Hibernate泛型DAO`的实现及其使用方法。 首先,DAO(Data Access Object)模式是一种设计模式,它的主要...
《Hibernate泛型DAO及使用方法借鉴》 在Java开发中,特别是使用Spring+Hibernate框架时,泛型DAO(Data Access Object)是常见的设计模式,它提供了对数据库操作的一般化接口,以提高代码的重用性和可维护性。本文...
在标题和描述中提到的"Spring+Hibernate实现)Hibernate公用类",实际上是指创建一个泛化的DAO接口(EntityDao)和它的实现类(EntityDaoImpl)。这样的设计模式可以避免为每个数据模型(如User、News、Company)都...
DAO泛型是Spring框架中一个重要的优化手段,它允许我们在编写DAO层代码时使用泛型,以提高代码的复用性和类型安全性。通过定义泛型接口或抽象类,我们可以创建一个通用的DAO模板,将具体的数据库操作与实体类的类型...
Struts2、Hibernate、Spring整合的泛型DAO (本人评价: 代码开发效率提高30% 代码出错率减少70%) 对于大多数开发人员,系统中的每个 DAO 编写几乎相同的代码到目前为止已经成为一种习惯。虽然所有人都将这种重复...
综上所述,"spring3.1+hibernate4+jpa Dao"的集成是一个高效、灵活的企业级应用开发架构,它结合了Spring的IoC和AOP能力、Hibernate的ORM功能以及JPA的标准接口,通过泛型DAO实现和事务管理,为开发者提供了强大的...
本文将深入探讨一种在SSH(Struts+Spring+Hibernate)框架中广泛应用的经典泛型DAO层实现方式,旨在展示其简洁性、高效性和灵活性。 #### 泛型DAO层:概念与优势 泛型DAO层通过利用Java的泛型机制,提供了一种类型...
1. 创建一个泛型的DAO接口,定义分页查询的方法,参数可能包括实体类的类型、查询条件、当前页数和每页大小。 2. 实现DAO接口,使用Hibernate的Session和Query对象进行分页查询,并返回结果集。 3. 在Service层中,...
泛型dao 即:不写重复的dao 。这个技术 能让 dao层 和 service层 不写一行代码。外国都用这个泛型DAO了 中国还是一个类一个dao的写,我生气就写了这个文章了。 在本文中,我将为您展示如何避免再三地重复 DAO 代码
具体来说,可以利用Spring AOP和动态代理技术,实现一个通用的DAO基类或接口,该基类或接口能够自动为不同的实体类生成相应的DAO实例。这种方式不仅减少了代码量,还提高了系统的可扩展性和维护性。 #### 4. 实现...
本篇文章将深入探讨一个使用Spring注解和Hibernate实现的泛型DAO设计,以提高代码的复用性和可维护性。 首先,`HibernateBaseDao.java`是基础的Hibernate DAO类,它提供了对Hibernate操作的基本封装。这个类通常会...