Hibernate 的 Dao 简写

最新推荐文章于 2019-07-19 22:55:38 发布
最新推荐文章于 2019-07-19 22:55:38 发布
阅读量88 收藏 1
点赞数
分类专栏： hibernate 文章标签： Spring Hibernate DAO SSH
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxinpeng/article/details/83647908
版权

Spring 为了简写SSH中的DAO层，提供了HibernateDaoSupport类。让我们基本上可以一句话就可以完成对数据库的一个原子操作（增，删，改，查）。代码写久之后就发现，每个类中都有代码相似度达90%的（增，删，改，查）的5个方法。（查是两个方法）。既然代码中只是 类名不同而已。想到用泛型抽象。另外，HibernateDaoSupport对分页的支持不是很好，现重新书写一下。代码如下：

 

DAO  的接口：

 

/**
 * 使用泛型编写 Dao中的增删改查。
 * 
 * @author Administrator
 * 
 * @param <T>
 */
public interface EntityDao<T> {
	/**
	 * 保存对象。
	 * @param o 要保存的对象
	 * @return 返回保存的状态
	 */
	Integer save(T o);
	/**
	 * 更新对象。
	 * @param o 要更新的对象
	 * @return  返回更新的状态
	 */
	Integer update(T o);
	/**
	 * 删除对象。
	 * @param o 要删除的对象
	 * @return  返回删除的状态
	 */
	Integer delete(T o); 
	/**
	 * 根据ID查询对象。
	 * @param id 要查询对象的ID
	 * @return	  返回查询的对象。
	 */
	T get(Integer id);
	/**
	 * 根据HQL查询对象
	 * @param HQL  要查询的HQL语句
	 * @return     返回查询的对象。
	 */
	List<T> find();
	
}

 DAO 的实现类：

 

@SuppressWarnings({ "unchecked", "hiding" })
public class EntityDaoSupport<T> extends MyHibernateDaoSupport implements
		EntityDao<T> {
	// 泛型的Class
	private Class<T> entityClass;

	// 根据反射得到泛型的class.
	public EntityDaoSupport() {
		entityClass = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
	}

	@Override
	public  Integer delete(T o) {
		this.getHibernateTemplate().delete(o);
		return 1;
	}

	@Override
	public  List<T> find() {
		List<T> list = this.getHibernateTemplate().find("from " + entityClass.getName());
		if (list != null && list.size() > 0) {
			return list;
		}
		return null;
	}
	@Override
	public  T get(Integer id) {
		T o = (T) this.getHibernateTemplate().get(entityClass, id);
		return o;
	}
	@Override
	public  Integer save(T o) {
		Serializable result=this.getHibernateTemplate().save(o);
		if(result!=null){
			return 1;
		}
		return 0;
	}

	@Override
	public  Integer update(T o) {
		this.getHibernateTemplate().saveOrUpdate(o);
		return 1;
	}
	/**
	 * 根据给定的HQL查询。
	 * @param HQL  要查询的HQL语句
	 * @return	      返回查询对象的集合。
	 */
	public T get(String HQL) {
		List<T>list=this.getHibernateTemplate().find(HQL);
		if(list!=null && list.size()>0){
			return list.get(0);
		}
		return null;
	}
	/**
	 * 查询所有的对象。
	 * @return 返回查询对象的集合。
	 */
	public List<T> find(String HQL) {
		List<T> list = this.getHibernateTemplate().find(HQL);
		if (list != null && list.size() > 0) {
			return list;
		}
		return null;
	}
	/**
	 * 根据给定的HQL语句及参数查询。
	 * @param HQL  要查询的HQL语句
	 * @param arg  需要带入的参数
	 * @return     返回查询对象的集合。
	 */
	public List<T> find(String HQL, Object arg) {
		List<T> list = this.getHibernateTemplate().find(HQL,arg);
		if (list != null && list.size() > 0) {
			return list;
		}
		return null;
	}
	/**
	 * 根据给定的HQL语句及参数查询。
	 * @param HQL  要查询的HQL语句
	 * @param args 需要带入的参数数组
	 * @return 返回查询对象的集合。
	 */
	public List<T> find(String HQL, Object... args) {
		List<T> list = this.getHibernateTemplate().find(HQL,args);
		if (list != null && list.size() > 0) {
			return list;
		}
		return null;
	}
	/**
	 * 根据HQL查询对象
	 * @param HQL  要查询的HQL语句
	 * @param arg  需要带入的参数
	 * @return     返回查询的对象。
	 */
	public T get(String HQL, Object arg) {
		List<T>list=this.getHibernateTemplate().find(HQL,arg);
		if(list!=null && list.size()>0){
			return list.get(0);
		}
		return null;
	}
	/**
	 * 根据HQL查询对象
	 * @param HQL  要查询的HQL语句
	 * @param args 需要带入的参数（数组）
	 * @return     返回查询的对象。
	 */
	public T get(String HQL, Object... args) {
		List<T>list=this.getHibernateTemplate().find(HQL,args);
		if(list!=null && list.size()>0){
			return list.get(0);
		}
		return null;
	}
	/**
	 * 执行HQL语句，执行执行Insert,Delete,Update 动作。
	 * @param HQL  要执行的HQL语句
	 * @return	      返回执行的状态
	 */
	public Integer execute(final String HQL) {
		return this.getHibernateTemplate().execute(new HibernateCallback<Integer>() {
			@Override
			public Integer doInHibernate(Session session) throws HibernateException,SQLException {
				Query query=session.createQuery(HQL);
				prepareQuery(query);
				return query.executeUpdate();
			}
		});
	}
	
	/**
	 * 执行HQL语句，执行执行Insert,Delete,Update 动作。
	 * @param HQL  要执行的HQL语句
	 * @param arg  带入的参数
	 * @return     返回执行的状态
	 */
	public Integer execute(final String HQL,final Object arg) {
		return this.getHibernateTemplate().execute(new HibernateCallback<Integer>() {
			@Override
			public Integer doInHibernate(Session session) throws HibernateException,SQLException {
				Query query=session.createQuery(HQL);
				prepareQuery(query);
				if(arg!=null){
					query.setParameter(0, arg);
				}
				return query.executeUpdate();
			}
		});
	}

	/**
	 * 执行HQL语句，执行执行Insert,Delete,Update 动作。
	 * @param HQL  要执行的HQL语句
	 * @param args 带入的参数数组
	 * @return     返回执行的状态
	 */
	public Integer execute(final String HQL, final Object... args) {
		return this.getHibernateTemplate().execute(new HibernateCallback<Integer>() {
			@Override
			public Integer doInHibernate(Session session) throws HibernateException,SQLException {
				Query query=session.createQuery(HQL);
				prepareQuery(query);
				if (args != null) {
					for (int i = 0; i < args.length; i++) {
						query.setParameter(i, args[i]);
					}
				}
				return query.executeUpdate();
			}
		});
	}

	/**
	 * 根据给定的HQL语句查询聚合函数(count,sum,max,min,avg..)返回结果
	 * @param HQL  要查询的HQL语句
	 * @return     返回查询的条数
	 */
	public Integer findAgg(String HQL) {
		List<Object>list=this.getHibernateTemplate().find(HQL);
		if(list!=null && list.size()>0){
			Object object=list.get(0);
			if(object!=null){
				return Integer.parseInt(object.toString());
			}
		}
		return 0;
	}
	 
	/**
	 * 根据给定的HQL语句查询聚合函数(count,sum,max,min,avg..)返回结果
	 * @param HQL  要查询的HQL语句
	 * @param arg  带入的参数
	 * @return     返回查询的条数
	 */
	public Integer findAgg(String HQL, Object arg) {
		List<Object>list=this.getHibernateTemplate().find(HQL,arg);
		if(list!=null && list.size()>0){
			Object object=list.get(0);
			if(object!=null){
				return Integer.parseInt(object.toString());
			}
		}
		return 0;
	}

	/**
	 * 根据给定的HQL语句查询聚合函数(count,sum,max,min,avg..)返回结果
	 * @param HQL  要查询的HQL语句
	 * @param args 带入的参数(数组)
	 * @return     返回查询的条数
	 */
	public Integer findAgg(String HQL, Object... args) {
		List<Object>list=this.getHibernateTemplate().find(HQL,args);
		if(list!=null && list.size()>0){
			Object object=list.get(0);
			if(object!=null){
				return Integer.parseInt(object.toString());
			}
		}
		return 0;
	}
	/**
	 * 分页查询
	 * @param HQL           要查询的HQL语句
	 * @param maxResults	最大显示的行数
	 * @param firstResult	查询开始的行数
	 * @return              返回查询的集合
	 */
	public List<T> find(final String HQL, final Integer maxResults, final Integer firstResult) {
		return this.getHibernateTemplate().executeWithNativeSession(new HibernateCallback<List<T>>() {
			@Override
			public List<T> doInHibernate(Session session)throws HibernateException, SQLException {
				Query query=session.createQuery(HQL);
				prepareQuery(query);
				query.setMaxResults(maxResults);
				query.setFirstResult(firstResult);
				List<T>list=query.list();
				if(list!=null && list.size()>0){
					return list;
				}
				return null;
			}
		});
	}
	
	/**
	 * 分页查询
	 * @param HQL          要查询的HQL语句
	 * @param maxResults   最大显示的行数
	 * @param firstResult  查询开始的行数
	 * @param arg          带入的参数
	 * @return             返回查询的集合
	 */
	public List<T> find(final String HQL, final Integer maxResults, final Integer firstResult,
			final Object arg) {
		return this.getHibernateTemplate().executeWithNativeSession(new HibernateCallback<List<T>>() {
			@Override
			public List<T> doInHibernate(Session session)throws HibernateException, SQLException {
				Query query=session.createQuery(HQL);
				prepareQuery(query);
				query.setMaxResults(maxResults);
				query.setFirstResult(firstResult);
				if(arg!=null){
					query.setParameter(0, arg);
				}
				List<T>list=query.list();
				if(list!=null && list.size()>0){
					return list;
				}
				return null;
			}
		});
	}

	/**
	 * 分页查询
	 * @param HQL          要查询的HQL语句
	 * @param maxResults   最大显示的行数
	 * @param firstResult  查询开始的行数
	 * @param args         带入的参数（数组）
	 * @return             返回查询的集合
	 */
	public List<T> find(final String HQL, final Integer maxResults, final Integer firstResult,
			final Object... args) {
		return this.getHibernateTemplate().executeWithNativeSession(new HibernateCallback<List<T>>() {
			@Override
			public List<T> doInHibernate(Session session)throws HibernateException, SQLException {
				Query query=session.createQuery(HQL);
				prepareQuery(query);
				query.setMaxResults(maxResults);
				query.setFirstResult(firstResult);
				if(args!=null){
					for(int i=0;i<args.length;i++){
						query.setParameter(i, args[i]);
					}
				}
				List<T>list=query.list();
				if(list!=null && list.size()>0){
					return list;
				}
				return null;
			}
		});
	}

	/**
	 * Prepare the given Query object, applying cache settings and/or
	 * a transaction timeout.
	 * @param queryObject the Query object to prepare
	 * @see #setCacheQueries
	 * @see #setQueryCacheRegion
	 * @see SessionFactoryUtils#applyTransactionTimeout
	 */
	protected void prepareQuery(Query queryObject) {
		HibernateTemplate hibernateTemplate=this.getHibernateTemplate();
		if (hibernateTemplate.isCacheQueries()) {
			queryObject.setCacheable(true);
			if (hibernateTemplate.getQueryCacheRegion() != null) {
				queryObject.setCacheRegion(hibernateTemplate.getQueryCacheRegion());
			}
		}
		if (hibernateTemplate.getFetchSize() > 0) {
			queryObject.setFetchSize(hibernateTemplate.getFetchSize());
		}
		if (hibernateTemplate.getMaxResults() > 0) {
			queryObject.setMaxResults(hibernateTemplate.getMaxResults());
		}
		SessionFactoryUtils.applyTransactionTimeout(queryObject, getSessionFactory());
	}

	/**
	 * 执行SQL语句
	 * @param sql 要执行的sql语句
	 * @return    返回执行的状态
	 */
	public Integer executeSql(final String sql) {
		return this.getHibernateTemplate().execute(new HibernateCallback<Integer>() {
			@Override
			public Integer doInHibernate(Session session) throws HibernateException,SQLException {
				SQLQuery sqlQuery=session.createSQLQuery(sql);
				prepareQuery(sqlQuery);
				return sqlQuery.executeUpdate();
			}
		});
	}

}

 使用

 

DAO 接口：

 

public interface UserDao extends EntityDao<Admin>{

	Admin find(String userName);
	
	Admin find(String userName,String userPass);
	
}

 DAO的实现类：

 

public class UserDaoHibernate extends EntityDaoSupport<Admin> implements UserDao {
	
	public Admin find(String userName) {
		final String HQL="from Admin where userName=?";
		return super.find(HQL,userName);
	}
	
	public Admin find(String userName, String userPass) {
		final String HQL="from Admin where userName=? and userPass=?";
		return super.find(HQL,new String[]{userName,userPass});
	}
}
 

这样以来，则可以在实际开发时写DAO层就不要每次都去写5大方法了。但在Service层中是可以正确调用的这5大方法的。

注：HibernateDaoSupport 使用的是Spring3.0版本。

wxinpeng
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于Hibernate编写DAO
张浩BIT的博客
11-12 2752
上一篇介绍了如何在ssh环境中配置Hibernate框架，本篇介绍如何基于Hibernate框架编写DAO 1. Hibernate框架相关接口 Hibernate体系结构如图所示，下面介绍Hibernate体系结构中常用的类 SessionFactory 配置对象被用于创造一个 SessionFactory 对象，使用提供的配置文件
Hibernate中的DAO模式
01-06
利用Hibernate技术实现DAO模式；利用存储过程封装SQL语句实现分页
Hibernate之DAO
ZhangVeni的博客
03-14 667
使用eclipse 安装Hibernate tools 然后利用数据表逆向生成POJO类的方法网上有很多，请读者自习搜索学习。但里面很多只生成了POJO 类和一些文档，对DAO类却鲜有人问津，本着科学探索的精神（主要是不想自己写DAO），研究一下Hibernate Tools（以下简写成HT）自动生成的DAO 类。
Hibernate 的 Dao 简写
訫誶
04-09 82
[size=medium][color=brown]Hibernate 的 Dao 简写[/color] [/size] Spring 为了简写SSH中的DAO层，提供了HibernateDaoSupport类。让我们基本上可以一句话就可以完成对数据库的一个原子操作（增，删，改，查）。 代码写久之后就发现，每个类中都有代码相似度达90%的（增，删，改，查）的5个方法。（查是两个方法）。 既然...
hibernate简述
大哥的叔的博客
02-11 1万+
软件三层架构： 浏览器 表示层 业务逻辑层 持久化层 数据库 hibernate是一款工作在持久化层的大型的、开源的ORM框架 持久化： 1狭义：将数据从“不可掉电（内存）”的设备上，保存在“可以掉电（硬盘）”的设备上 2广义：与数据库有关的一切操作都可以归纳到持久化范围内。      create：保存。将数据保存在数据表中。对应SQL的insert       retri...
自动生成DAO源代码
07-18
首先，DAO是Data Access Object的缩写，它是业务逻辑层和持久化层之间的桥梁，负责处理与数据库的交互，如查询、插入、更新和删除等操作。DAO的设计目标是将数据访问逻辑与业务逻辑分离，使得系统更易于测试和维护。...
spring_aop.rar_spring-dao
09-21
AOP是Aspect Oriented Programming的缩写，它是一种编程范式，主要目的是将那些关注点与核心业务逻辑分离，如日志、事务管理、性能监控等。在Spring框架中，AOP通过动态代理实现，允许我们在不修改源代码的情况下，...
Hibernate3.2.2
03-30
Hibernate 3.2.2版本也可以与其他库如Spring Framework集成，实现更高级别的功能，如声明式事务管理、DAO（Data Access Object）模式的简化等。 **7. 性能优化** - **缓存机制**：Hibernate支持一级缓存（Session...
hibernate3.0 jar包
03-31
2. **数据访问对象（DAO）**：Hibernate提供了Session接口，它是DAO层的主要接口，用于执行CRUD（创建、读取、更新、删除）操作。例如，通过`Session.save()`方法可以将对象保存到数据库，`Session.get()`用于获取...
Hibernate配置源码
06-23
【压缩包子文件的文件名称列表】"sprh"可能是项目源代码的简写，具体包含了论坛系统的各个组件，如实体类、配置文件、DAO、Service、Controller等，以及可能的测试代码和日志文件。通过分析这些源代码，可以深入理解...
Hibernate&&Spring中的缩写英文术语
qq_15340387的博客
07-21 781
ORM：Object/Relation Mapping——对象/关系数据库映射 。 POJO：Plain Ordinary Java Object——普通、传统的java对象 PO：Persistent Object——持久化对象 PO=POJO+XML映射文件 OOA：Object-Oriented Analysis——面对对象分析 OOD：Objec
Hibernate的DAO实现
热门推荐
ZWeb-Blog
04-24 1万+
10.7  Hibernate的DAO实现DAO对象是模块化的数据库访问组件，DAO对象通常包括：对持久化类的基本CRUD操作（插入、查询、更新、删除）操作。Spring对Hibernate的DAO实现提供了良好的支持。主要有如下两种方式的DAO实现：q      继承HibernateDaoSupport的实现DAOq      基于Hibernate3.0实现DAO不管采用哪一种实
详细介绍 Hibernate 泛型 DAO 及其使用方法
心有猛虎,细嗅蔷薇
03-13 1460
编写spring+hibernate框架下的应用，总是离不了编写一个通用的泛型GenericHibernateDao。查阅了网上不少的GenericHibernateDao实现，归纳整理为如下实现，供后续编码参考。  首先定义接口泛型DAO接口 GenericDao package com.th.huz; import java.io.Serializable; import 
HibernateDAO: 通用DAO,基于Hibernate的DAO实现
yhf
05-10 4073
对于后端开发者来说，经常跟数据库打交道，hibernate mybatis是常用是的持久化层，mybatis简单、灵活，易上手，但要写大量的sql；Hibernate太复杂，但对基于对象的操作则方便些，但是对于复杂的查询也是比较麻烦。但在实际项目中，大部分语句是比较简单的，只有部分会比较复杂些，但若简单的语句写多了也是麻烦。此DAO层正是由此而来，基于Hibernate开发，解决小sql的问...
Hibernate 通用的Dao及其实现类
夏沐的博客
07-19 1150
BaseDao.java接口： package com.crm.dao; import java.io.Serializable; import java.util.List; import org.hibernate.criterion.DetachedCriteria; /** * 通用的DAO的接口 * @author jt * */ public interface Ba...
hibernate的dao层通用设计
小哥的博客
07-26 2697
hibernate的dao层通用设计，hibernate作为一款优秀的数据库持久化框架，在现实的运用中是非常广泛的。它的出现让不熟悉sql语法的程序员能开发数据库连接层成为一种可能，但是理想与现实永远是有差距的。开发过程中如果只使用hql进行操作，并且表之间的关联配置很复杂的话，这将成为一种噩梦。还好我们伟大的hibernate支持原生的sql操作，这也大大的增加了hibernate的灵活性。下面我们探讨一下hibernate的dao
手把手教你如何自定义DAO框架（重量级干货）
Cs_hnu_scw的博客
11-10 1246
描述：本篇博客，主要是对于目前实际web项目开发中，对于数据库操作的一些基本方法的封装，通过这样的方式，可以使得开发更加简单，减少代码量，也便于维护和阅读。其中，主要是讲解了三种不同情况的封装方法，都是自身实际开发过程中，进行积累的，当然，还有很多不足之处，但是基本够项目的基本开发。 一：非框架的DAO层封装 其中包含的知识点： 1：连接池 2：数据源 3：反射 4：数据库元数据对象
K-means聚类.py ACM比赛常用算法k-means算法
最新发布
07-14
K-means聚类.py ACM比赛常用算法k-means算法
java 自动生成dao action service iml
10-20
在Java中，我们可以使用MyBatis、Hibernate等框架自动生成DAO，这样可以避免手动编写大量的数据库操作代码，提高开发效率。DAO的主要作用是封装对数据库的增删改查等操作，同时也可以处理事务。 其次，Action是控制...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值