既然Hibernate 实现了对JDBC的轻量级封装，增加了可移植性，那么在CRUD操作上是否也可将起封装，增加其扩展性。答案肯定是可以的。所以就有了今天的基于泛型DAO，网上有很多是在Spring 和 Hibernate 混合框架的泛型DAO，其实就是Spring 在对 Hibernate 的Session 做了一个封装，此博文是针对以Hibernate框架的泛型DAO设计。
由于我们通常要读取hibernate.cfg.xml，创建一个session factory，在取出一个session 对其进行CRUD操作，所以，这部分代码一般可以写在static块中，但为了模块化，我们将其中写在一个单独的类HibernateUtil（官方建议）中。
package com.feytuo.education.persistence;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.tool.hbm2ddl.SchemaExport;
/**
* 获取会话HibernateUtil封装类
*
* @author YangKang
*
* @date 2014/04/27
*
* @version 1.0
*
*
*/
public class HibernateUtil {
private static SessionFactory sessionFactory = null;
/**
*
* @return 获取当前会话工厂
*/
public static SessionFactory getSessionFactory() {
if (null == sessionFactory) {
CreateSessionFactory();
}
return sessionFactory;
}
/**
* 创建会话工厂
*/
private static void CreateSessionFactory() {
// 第一步:读取Hibernate的配置文件 hibernamte.cfg.xml文件
Configuration config = new Configuration().configure();
// 第二步:创建服务注册构建器对象，通过配置对象中加载所有的配置信息
StandardServiceRegistryBuilder regbulider = new StandardServiceRegistryBuilder()
.applySettings(config.getProperties());
// 创建注册服务
ServiceRegistry sry = regbulider.build();
// 第三步:创建会话工厂
sessionFactory = config.buildSessionFactory(sry);
}
public static void createTables(){
Configuration config = new Configuration().configure();
new SchemaExport(config).create(false, true);
}
/**
* @return 获取当前会话对象
*/
public static Session getSession() {
return getSessionFactory().getCurrentSession();
}
public static void sfClose() {
getSessionFactory().close();
}
public static void sessionClear() {
getSession().clear();;
}
}
接下来设计基于泛型DAO的接口
包括常用 的CRUD操作和分页功能。
package com.feytuo.education.persistence;
import java.util.List;
/**
*
* 用hibernate框架HQL检索
*
* 对数据库中表各个表的增删查改CRUD操作接口
*
* @author YangKang
*
* @param <T>
* 泛型 ，实体类
* @param <PK>
* 泛型，实体类的主键类型
*
* @date 2014/04/25
*
* @version 1.0
*
* @revise 2014/04/30 V1.1
*
*/
public interface IBaseDAO<T, PK> {
/**
* 保存指定实体
*
* @param entity
* 实体对象
*/
public void save(T entity);
/**
* 更新指定实体
*
* @param entity
* 实体对象
*/
public void update(T entity);
/**
* 删除指定实体
*
* @param entity
* 实体对象
*
*/
public void delete(T entity);
public void saveOrUpdate(T entity);
/**
* 删除实体
*
* @param entityClass
* 实体类名
* @param id
* 实体的id
*/
public void deteleById(Class<T> entityClass, PK id);
/**
* 更新实体 可用于添加 ,修改,删除操作
*
* @param hql
* 执行的的hql语句
* @param params
* 参数,可有对象或多个对象,代替Hql中的"?"号
*/
public void execute(final String hql, final Object[] params);
/**
* 获取所有实体集合
*
* @param entityClass
* 实体类名
* @return 结果集合
*/
public List<T> query(Class<T> entityClass);
/**
* 按HQL条件查询列表
*
* @param entityClass
* 实体类名
* @param id
* 实体id
* @return 实体对象
*/
public T findById(Class<T> entityClass, PK id);
/**
* 按具体属性内容查询
*
* @param entityClass
* @param propertyName
* @param value
* @return
*/
public T findByProperty(Class<T> entityClass, String propertyName,
Object value);
/**
* 按hql条件查询列表
*
* @param hql
* 查询语句 支持连接查询和多条件查询
* @param params
* @return
*/
public List<T> findByHql(String hql, Object[] params);
/**
* 查询指定sql语句的分页数据集合
*
* @param entityClass
* @param start
* @param limit
* @return
*/
public List<T> findByPage(Class<T> entityClass, int start, int limit);
/**
* 查询指定sql语句的分页数据集合
*
* @param hql
* @param params
* @param start
* @param limit
* @return
*/
public List<T> findByPage(String hql, Object[] params, int start, int limit);
}
DAO类的实现。
package com.feytuo.education.persistence;
import java.io.Serializable;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
/**
* Hibernate 框架<br />
*
* 实体类的增删查改实现类
*
* @author YangKang
*
* @param <T>
* 实体类名
* @param <PK>
* 实体类的主键类型
*
* @date 2014/04/30
*
* @version 1.0
*
* @revise 2014/05/02 V1.1
*/
public class BaseDAO<T, PK extends Serializable> implements
IBaseDAO<T, PK> {
/**
* 添加实体
*/
@Override
public void save(T entity) {
Session session = HibernateUtil.getSession();
session.beginTransaction();
session.save(entity);
session.getTransaction().commit();
}
/**
* 更新实体
*/
@Override
public void update(T entity) {
Session session = HibernateUtil.getSession();
session.beginTransaction();
session.update(entity);
session.getTransaction().commit();
}
/**
* 更新实体
*/
@Override
public void saveOrUpdate(T entity) {
Session session = HibernateUtil.getSession();
session.beginTransaction();
session.saveOrUpdate(entity);
session.getTransaction().commit();
}
/**
* 删除实体
*/
@Override
public void delete(T entity) {
Session session = HibernateUtil.getSession();
session.beginTransaction();
session.delete(entity);
session.getTransaction().commit();
}
/**
* 按id删除实体
*/
@Override
public void deteleById(Class<T> entityClass, PK id) {
Session session = HibernateUtil.getSession();
session.beginTransaction();
session.delete(findById(entityClass, id));
session.getTransaction().commit();
}
/**
* 执行自定义的sql语句，实现其中的添加,更新,删除的方法
*/
@Override
public void execute(String hql, Object[] params) {
Session session = HibernateUtil.getSession();
session.beginTransaction();
Query query = session.createQuery(hql);
if (null != params && params.length > 0) {
for (int i = 0; i < params.length; i++) {
query.setParameter(i, params[i]);
}
}
// 执行hql语句
query.executeUpdate();
session.getTransaction().commit();
}
/**
* 获取所有实体
*/
@SuppressWarnings("unchecked")
@Override
public List<T> query(Class<T> entityClass) {
Session session = HibernateUtil.getSession();
session.beginTransaction();
String hql = "from " + entityClass.getName();
Query query = session.createQuery(hql);
List<T> list = query.list();
session.getTransaction().commit();
return list;
}
@SuppressWarnings("unchecked")
@Override
public T findByProperty(Class<T> entityClass, String propertyName,
Object value) {
String hql = "from " + entityClass.getName() + " as model where model."
+ propertyName + "=?";
Session session = HibernateUtil.getSession();
session.beginTransaction();
Query query = session.createQuery(hql);
query.setParameter(0, value);
List<T> list = query.list();
session.getTransaction().commit();
if (null != list) {
return list.get(0);
} else {
return null;
}
}
/**
* 按实体名和id获取实体
*
* @param entityClass
* @param id
* @return
*/
@SuppressWarnings("unchecked")
@Override
public T findById(Class<T> entityClass, PK id) {
Session session = HibernateUtil.getSession();
session.beginTransaction();
T entity = (T) session.get(entityClass, id);
session.getTransaction().commit();
return entity;
}
/**
* 按自定义的hql取得结果集
*/
@Override
@SuppressWarnings("unchecked")
public List<T> findByHql(String hql, Object[] params) {
Session session = HibernateUtil.getSession();
session.beginTransaction();
Query query = session.createQuery(hql);
if (null != params && params.length > 0) {
for (int i = 0; i < params.length; i++) {
query.setParameter(i, params[i]);
}
}
List<T> list = query.list();
session.getTransaction().commit();
return list;
}
/**
* 分页使用
*
* @param entityClass
* @param start
* @param limit
* @return
*/
@SuppressWarnings("unchecked")
@Override
public List<T> findByPage(String hql, Object[] params, int start, int limit) {
Session session = HibernateUtil.getSession();
session.beginTransaction();
List<T> list = null;
try {
Query query = session.createQuery(hql);
if (params != null && params.length != 0) {
for (int i = 0; i < params.length; i++) {
query.setParameter(i, params[i]);
}
}
if (limit != 0) {
query.setFirstResult(start).setMaxResults(limit);
}
list = query.list();
session.getTransaction().commit();
} catch (Exception ef) {
ef.printStackTrace();
session.getTransaction().rollback();
}
return list;
}
/**
* 分页使用
*
* @param entityClass
* @param start
* @param limit
* @return
*/
@SuppressWarnings("unchecked")
@Override
public List<T> findByPage(Class<T> entityClass, int start, int limit) {
Session session = HibernateUtil.getSession();
String hql = "select from o " + entityClass.getName() + " o";
session.beginTransaction();
Query query = session.createQuery(hql);
query.setFirstResult(start).setMaxResults(limit);
List<T> list = query.list();
session.getTransaction().commit();
return list;
}
}
我在HibernateUtil 获取Session的方法是getCurrentSession()，所以在DAO实现类里是无需close session的,若使用的是openSession()，则实现类必须要close session。至于为什么要close，这和文件一样，你懂得。
在此Hibernate 基于泛型DAO类设计完成，如还有其他的需求，可在接口中扩展。
相关推荐
【标题】"Hibernate泛型Dao"是针对Java开发中的数据持久化框架Hibernate的一个高级应用，主要目的是为了提高代码的复用性和简洁性。在传统的Hibernate使用中，针对每个实体类，我们都需要创建一个对应的Dao（Data ...
标题中的“基于Hibernate的泛型Dao框架”是指在Java开发中使用Hibernate ORM工具，并结合泛型设计模式构建的数据库访问对象（DAO）框架。这样的框架旨在提高代码复用性，减少重复工作，使得数据访问层的实现更加简洁...
Hibernate 对泛型Dao接口的实现主要通过继承泛型Dao接口，使用 Hibernate 的 Session 对象来实现数据访问。 Hibernate 对泛型Dao接口的实现的优点： 1. 简化数据访问：Hibernate 对泛型Dao接口的实现可以简化数据...
Struts2、Hibernate、Spring整合的泛型DAO （本人评价: 代码开发效率提高30% 代码出错率减少70%） 对于大多数开发人员，系统中的每个 DAO 编写几乎相同的代码到目前为止已经成为一种习惯。虽然所有人都将这种重复...
至于`Dao经典泛型.doc`文件，可能是更深入的关于Hibernate泛型DAO的文档，可能包含了如何配置Spring、如何处理复杂查询以及如何优化泛型DAO的更多细节。阅读这份文档将进一步提升你对泛型DAO的理解和应用能力。 ...
本文将深入探讨一种在SSH（Struts+Spring+Hibernate）框架中广泛应用的经典泛型DAO层实现方式，旨在展示其简洁性、高效性和灵活性。 #### 泛型DAO层：概念与优势 泛型DAO层通过利用Java的泛型机制，提供了一种类型...
本篇文章将深入探讨一个使用Spring注解和Hibernate实现的泛型DAO设计，以提高代码的复用性和可维护性。 首先，`HibernateBaseDao.java`是基础的Hibernate DAO类，它提供了对Hibernate操作的基本封装。这个类通常会...
本文将深入探讨“Spring Hibernate 泛型DAO”这一主题，以及如何通过泛型DAO实现更加高效、可复用的代码。 首先，让我们理解什么是DAO（Data Access Object）模式。DAO是一种设计模式，它的主要作用是隔离业务逻辑...
本篇将详细介绍"Hibernate泛型DAO接口，大部分通用都已包括"这一主题。 首先，让我们看看DAO的概念。DAO是软件设计模式中的一种，它的主要职责是封装对数据源的访问，以提供业务逻辑层与数据存储层之间的解耦。通过...
而泛型DAO（Data Access Object）则是基于Hibernate进一步抽象出来的一个设计模式，用于提供更通用的数据操作方法。本文档主要探讨了如何在Spring+Hibernate环境中创建和使用泛型DAO。 首先，我们来看一下泛型DAO...
例如，一个泛型DAO接口可能定义如下： ```java public interface GenericDao<T> { void save(T entity); T get(Long id); void update(T entity); void delete(T entity); } ``` 然后，对于一个名为`User`的实体...
而`Hibernate泛型DAO`则是为了减少代码重复性，提高代码复用性和可维护性的一种设计模式。本文将深入探讨`Hibernate泛型DAO`的实现及其使用方法。 首先，DAO（Data Access Object）模式是一种设计模式，它的主要...
这尤其适用于那些基于ORM（对象关系映射）框架，如Hibernate或MyBatis的项目，它们提供了与数据库交互的基础设施，我们可以直接在泛型DAO上构建。 在实际应用中，我们可能还需要考虑一些额外的细节，如事务管理、...
而泛型DAO是一个类型安全的，代码精简的设计模式（相对于传统DAO），尤其在DAO组件数量庞大的时候，代码量的减少更加明显。 泛型DAO的核心是定义一个GenericDao接口，声明基本的CRUD操作： 用hibernate作为持久化...
总结来说，"Struts2+hibernate+spring整合泛型DAO"是一种常见的Java Web开发模式，它利用三大框架的优势，结合泛型设计，提高了代码复用，降低了维护成本，使得开发者能更专注于业务逻辑，而不是基础架构。
《Hibernate泛型DAO及使用方法借鉴》 在Java开发中，特别是使用Spring+Hibernate框架时，泛型DAO（Data Access Object）是常见的设计模式，它提供了对数据库操作的一般化接口，以提高代码的重用性和可维护性。本文...
6. **泛型Dao**：在Java开发中，泛型Dao（Generic Dao）是一种设计模式，用于减少重复的数据库操作代码。通过定义一个通用的Dao接口，可以实现对不同类型的实体对象进行CRUD操作，提高了代码的复用性和可维护性。...
接下来，我们可以使用Hibernate或MyBatis等持久层框架实现这个泛型DAO。以Hibernate为例，一个简单的实现可能如下： ```java public class HibernateGenericDAO, ID extends Serializable> implements GenericDAO, ...
本文将深入探讨如何实现一个简单的Hibernate泛型DAO（数据访问对象），以提高代码的可重用性和可维护性。 首先，我们来看`AbstractHibernateGenericDao`类，这是一个抽象类，它通常会包含一些基本的CRUD（创建、...