参考了以前项目的一些代码，以及结合自己封装的泛型，重构，封装了hibernate，自己管理session，提供增删改差，包括查询，分页以及相关辅助功能，个人觉得封装得比较彻底，自己也喜欢这种调用方式，希望路过的能多给意见
package com.micon.base.dao;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import javax.annotation.Resource;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.springframework.stereotype.Repository;
import com.micon.base.bean.Page;
//import com.ghca.bsm.util.ClassSEQUtil;
@Repository
public class Dao{
@Resource
private SessionFactory sessionFactory;
public Session getSession(){
return sessionFactory.getCurrentSession();
// return sessionFactory.openSession()
}
/**
* 获得单个实体
*
* @param clazz 实体类型
* @param params 参数列表
* @return 单个实体
*/
public <T> T get(Class<T> clazz, List<Criterion> params) {
return get(clazz, params.toArray(new Criterion[0]));
}
/**
* 获得单个实体
*
* @param clazz 实体类型
* @param params 参数列表
* @return 单个实体
*/
public <T> T get(Class<T> clazz, Criterion... params) {
Session session =getSession();
// session.enableFilter("STATE_FILTER");
Criteria criteria = session.createCriteria(clazz);
// criteria.add(Restrictions.gt("state", 0));
if (params != null) {
for (Criterion param : params) {
criteria.add(param);
}
}
criteria.setMaxResults(1);
List<T> list = criteria.list();
if (list.size() > 0) {
return list.get(0);
} else {
return null;
}
}
/**
* HQL查询单条结果
*
*/
public <T> T get(String hql, HashMap<String, Object> paramMap) {
Session session =getSession();
// session.enableFilter("STATE_FILTER");
Query query = session.createQuery(hql);
if (paramMap != null) {
for (Entry<String, Object> entry : paramMap.entrySet()) {
query.setParameter(entry.getKey(), entry.getValue());
}
}
query.setMaxResults(1);
List<T> list = query.list();
if (list.size() > 0) {
return list.get(0);
} else {
return null;
}
}
/**
* 获得单个实体个数
*
* @param clazz 实体类型
* @param params 参数列表
* @return 实体个数
*/
public <T> Integer getSize(Class<T> clazz, List<Criterion> params) {
Session session = getSession();
// session.enableFilter("STATE_FILTER");
Criteria criteria = session.createCriteria(clazz);
// criteria.add(Restrictions.gt("state", 0));
if (params != null) {
for (Criterion param : params) {
criteria.add(param);
}
}
criteria.setProjection(Projections.count("id"));
Object obj = criteria.uniqueResult();
if (obj instanceof Long) {
return ((Long) obj).intValue();
} else if (obj instanceof Integer) {
return (Integer) obj;
} else {
return 0;
}
}
public <T> Integer getSize(Class<T> clazz) {
return getSize(clazz, null);
}
/**
* 根据hql查询记录数
* @param hql
* @return
*/
// public Integer getSize(String hql){
// Integer size = 0;
// StringBuffer hqlSb = new StringBuffer();
// hqlSb.append("select count(1) from ");
// hqlSb.append("(");
// hqlSb.append(hql);
// hqlSb.append(")");
// List<Object> sizeList = gets(hqlSb.toString());
// if(sizeList.size() > 0){
// size = Integer.parseInt(sizeList.get(0).toString());
// }
// return size;
// }
/**
*
* @param <T>
* @param clazz
* @param params
* @param start
* @param maxsize
* @return
*/
public <T> List<T> gets(Class<T> clazz, List<Criterion> params,
Page page) {
return gets(clazz,params,page,null);
}
public <T> List<T> gets(Class<T> clazz, Order order) {
return gets(clazz, null, null, order);
}
/**
* 根据条件执行查询
* @param <T>
* @param clazz
* @param params
* @param start
* @param maxsize
* @param order
* @return
*/
public <T> List<T> gets(Class<T> clazz, List<Criterion> params,
Page page,Order order) {
Session session = getSession();
// session.enableFilter("STATE_FILTER");
Criteria criteria = session.createCriteria(clazz);
// criteria.add(Restrictions.gt("state", 0));
if(order!=null){
criteria.addOrder(order);
}
if (params != null) {
for (Criterion param : params) {
criteria.add(param);
}
}
if (page != null){
page.setTotalCount(getSize(clazz, params));
criteria.setFirstResult((page.getPageNumber()-1)*page.getPageSize());
criteria.setMaxResults(page.getPageSize());
}
return criteria.list();
}
public <T> List<T> gets(Class<T> clazz, List<Criterion> params) {
return gets(clazz, params, null, null);
}
public <T> List<T> gets(Class<T> clazz, List<Criterion> params, Order order) {
return gets(clazz, params, null, order);
}
public <T> List<T> gets(Class<T> clazz) {
return gets(clazz, null, null, null);
}
public <T> List<T> gets(Class<T> clazz, Page page) {
return gets(clazz, null,page);
}
public <T> T get(Class<T> clazz, Integer id) {
Session session = getSession();
// session.enableFilter("STATE_FILTER");
return (T) session.get(clazz, id);
}
public <T> void deleteObject(Class<T> clazz, Integer id) {
Session session = getSession();
T t = (T) session.get(clazz, id);
session.delete(t);
}
public <T> void deleteObject(T t) {
Session session = getSession();
session.delete(t);
}
public <T> List<T> gets(String hql) {
return gets(hql, null, null);
}
public <T> List<T> gets(String hql, Map<String, Object> paramMap) {
return gets(hql, paramMap, null);
}
public <T> List<T> gets(String hql, Map<String, Object> paramMap,
Page page) {
Session session = getSession();
Query query = session.createQuery(hql);
if (paramMap != null) {
for (Entry<String, Object> entry : paramMap.entrySet()) {
query.setParameter(entry.getKey(), entry.getValue());
}
}
if (page != null){
query.setFirstResult((page.getPageNumber()-1)*page.getPageSize());
query.setMaxResults(page.getPageSize());
}
return query.list();
}
public Object get(String hql, Map<String, Object> paramMap){
Session session = getSession();
Query query = session.createQuery(hql);
if (paramMap != null) {
for (Entry<String, Object> entry : paramMap.entrySet()) {
query.setParameter(entry.getKey(), entry.getValue());
}
}
return query.uniqueResult();
}
/**
*
* 重写save方法 根据oracle函数生成id 将id的生成方式转换为数据库函数的方式验证
* @param t
* @throws Exception
* 修改时间 2012/7/12
*/
public void saveObject(Object t) throws Exception {
// 获得当前对象的id ，if id =null 生成id
// 否成直接保存
// Object IdVal = ClassSEQUtil.getIdValue(t);
// if (IdVal == null) {
// String tableName = ClassSEQUtil.getTableName(t);
// int id = ClassSEQUtil.getId(tableName, this.getSession());
// ClassSEQUtil.setIdValue(t, id);
// }
getSession().save(t);
}
public void updateObject(Object t) {
getSession().update(t);
}
/**
* 执行原生SQL
*/
public void executeSqlUpdate(String sql) {
executeSqlUpdate(sql, null);
}
/**
* 执行原生SQL
*/
public void executeSqlUpdate(String sql, Map<String, Object> paramMap) {
Session session = getSession();
SQLQuery sqlQuery = session.createSQLQuery(sql);
if (paramMap != null) {
for (Entry<String, Object> entry : paramMap.entrySet()) {
sqlQuery.setParameter(entry.getKey(), entry.getValue());
}
}
sqlQuery.executeUpdate();
}
/**
* 用原生SQL更新对象
*
*/
public List querySql(String sql, Map<String, Object> paramMap){
return querySql(sql,paramMap,null);
}
public List querySql(String sql,Page page) {
return querySql(sql, null,page);
}
public List querySql(String sql, Map<String, Object> paramMap,Page page) {
Session session = getSession();
SQLQuery sqlQuery = session.createSQLQuery(sql);
if (paramMap != null) {
for (Entry<String, Object> entry : paramMap.entrySet()) {
sqlQuery.setParameter(entry.getKey(), entry.getValue());
}
}
if(page != null){
sqlQuery.setFirstResult((page.getPageNumber()-1)*page.getPageSize());
sqlQuery.setMaxResults(page.getPageSize());
}
return sqlQuery.list();
}
public List querySql(String sql) {
return querySql(sql,null,null);
}
}
希望路过的大牛给点意见，不慎感激，呵呵，多多指教哈
相关推荐
本文将详细介绍如何进行Hibernate环境搭建，以及如何进行基本操作的封装，我们将以MySQL开源数据库作为数据存储后端。 一、Hibernate环境搭建 1. **安装MySQL数据库**: 首先，你需要在本地或者服务器上安装MySQL...
在实际应用中，我们通常会将`SessionFactory`和`Session`的管理封装到DAO（Data Access Object）层，以便于业务逻辑层调用。同时，为了优化性能，Hibernate还提供了二级缓存，可以通过配置将频繁访问的数据存储在...
标题“使用Hibernate封装方法”暗示我们将讨论如何在项目中通过封装Hibernate操作，以提高代码的复用性和可读性。通常，我们会在DAO（数据访问对象）层进行这些封装，将数据库的CRUD（创建、读取、更新、删除）操作...
本资料包"Java封装hibernate操作数据库.rar"主要涉及了如何使用Hibernate进行数据库操作，并通过DAO(Data Access Object)层的封装来实现更加高效、简洁的代码结构。 首先，让我们深入了解Hibernate。Hibernate是一...
3. **封装Hibernate DAO**： - **SessionFactory的创建与管理**：通常在应用启动时初始化SessionFactory，然后在整个应用生命周期内复用。这可以减少数据库连接的开销。 - **Session的使用**：每个数据库操作都应...
本文将深入探讨如何使用Hibernate将本地SQL查询的结果封装成对象。 首先，本地SQL查询（Native SQL）是指直接在Hibernate中使用原生的SQL语句进行查询，而不是使用HQL（Hibernate Query Language）。这允许开发者...
然而，在实际开发中，我们往往需要根据项目需求对其进行定制，例如添加事务管理、异常处理、日志记录等功能，这就涉及到了对`Session`的封装。 在提供的`HibernateSessionWrapper.java`文件中，我们可以预期它实现...
在代码中，我们看到`SessionFactory.currentSession()`用于获取当前的`Session`实例，这意味着该应用可能使用了某种会话管理策略，如基于Spring的事务管理。 2. **Session**: `Session`是与数据库交互的主要接口，...
这就是"封装Hibernate统一操作接口"的目的。 一、 Hibernate概述 Hibernate是一个开源的ORM框架，它将Java对象与关系数据库中的记录进行映射，从而避免了传统的JDBC编程的繁琐。通过Hibernate，开发者可以使用面向...
- `HibernateTemplate`是Spring提供的一个便捷工具，它封装了`Session`的常用操作，如查询、保存、更新和删除，简化了编码，同时也支持事务管理。 - 使用`HibernateTemplate`可以避免直接操作`Session`，减少可能...
1. **事务管理**：HibernateTemplate自动管理Hibernate Session和Transaction，确保在事务边界内的操作原子性和一致性。无需手动开启和关闭Session，也不用关心事务的回滚和提交。 2. **异常转换**：它将Hibernate...
这个“Struts+Hibernate超市管理系统”是一个典型的MVC（Model-View-Controller）架构示例，它展示了如何将这两个框架有效地整合在一起，为超市管理提供一套完整的解决方案。 首先，Struts是一个基于MVC设计模式的...
【标题】：Hibernate入门实例——基于HibernateUtil的数据库操作封装 在Java开发中，Hibernate作为一个强大的对象关系映射（ORM）框架，极大地简化了数据库操作。本实例将深入浅出地介绍如何使用Hibernate进行基本...
**基于Struts2+Hibernate4的学生管理系统** 在Java Web开发领域，Struts2和Hibernate4是两个非常重要的框架。Struts2是一个强大的MVC（Model-View-Controller）框架，而Hibernate4则是一个对象关系映射（ORM）工具...
Hibernate的Session接口提供了事务管理和缓存机制，提升了数据操作的性能和一致性。 在文件上传下载功能方面，Struts2提供了文件上传插件，使得用户可以方便地上传文件到服务器，而下载功能则可以通过生成HTTP响应...
本文将深入探讨如何在Hibernate中进行分页查询的封装，并提供相关的源码和工具使用方法。 首先，我们需要了解Hibernate中的Criteria查询，这是实现分页查询的一种方式。Criteria API允许我们以面向对象的方式构建...
DAO层使用Hibernate提供的API与数据库交互，例如Session对象用于开始和结束数据库事务，Query或Criteria API用于执行查询，实体类（如Student）代表数据库中的表。 系统可能包含以下主要组件： 1. `struts.xml`：...
源码解析可能会揭示`Session`内部的事务管理、缓存机制以及如何封装JDBC操作。 其次，`SessionFactory`的创建过程也是一个重要的知识点。`SessionFactory`是Hibernate的工厂类，用于创建`Session`实例。它的创建...
在Java开发中，Hibernate是一个非常重要的对象关系映射（ORM）框架，它允许开发者使用面向对象的方式来操作数据库，极大地...在实际项目中，结合Hibernate的其他功能，如缓存、事务管理等，可以进一步提升开发效率。
本项目"basic-hibernate"专注于封装Hibernate4，以实现高效、便捷的数据库访问。下面，我们将深入探讨如何利用这个项目进行数据库访问，并了解相关的技术要点。 首先，我们来看看项目的构建方式。项目采用Maven作为...