hibernate基础DAO

最新推荐文章于 2025-06-01 22:05:17 发布
原创 最新推荐文章于 2025-06-01 22:05:17 发布 · 909 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#hibernate #javaEE #数据库

本文介绍了Hibernate的基础DAO接口和实现，包括如何定义baseDao接口和其实现细节，为JavaEE应用提供数据库操作支持。同时，推荐了一个学习Java的资源网站：Java知识学习网，提供Java学习资料和学习路线图。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1、baseDao接口

 

package com.cando.dao;

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

/**
 * 基础数据库操作类
 * 
 * @author
 * 
 */
public interface BaseDao<T> {

	/**
	 * 保存�?��对象
	 * 
	 * @param o
	 * @return
	 */
	public Serializable save(T o);

	/**
	 * 删除�?��对象
	 * 
	 * @param o
	 */
	public void delete(T o);

	/**
	 * 更新�?��对象
	 * 
	 * @param o
	 */
	public void update(T o);

	/**
	 * 保存或更新对�?
	 * 
	 * @param o
	 */
	public void saveOrUpdate(T o);

	/**
	 * 查询
	 * 
	 * @param hql
	 * @return
	 */
	public List<T> find(String hql);

	/**
	 * 查询集合
	 * 
	 * @param hql
	 * @param param
	 * @return
	 */
	public List<T> find(String hql, Object[] param);

	/**
	 * 查询集合
	 * 
	 * @param hql
	 * @param param
	 * @return
	 */
	public List<T> find(String hql, List<Object> param);

	/**
	 * 查询集合(带分�?
	 * 
	 * @param hql
	 * @param param
	 * @param page
	 *            查询第几�?
	 * @param rows
	 *            每页显示几条记录
	 * @return
	 */
	public List<T> find(String hql, Object[] param, Integer page, Integer rows);

	/**
	 * 查询集合(带分�?
	 * 
	 * @param hql
	 * @param param
	 * @param page
	 * @param rows
	 * @return
	 */
	public List<T> find(String hql, List<Object> param, Integer page, Integer rows);

	/**
	 * 获得�?��对象
	 * 
	 * @param c
	 *            对象类型
	 * @param id
	 * @return Object
	 */
	public T get(Class<T> c, Serializable id);

	/**
	 * 获得�?��对象
	 * 
	 * @param hql
	 * @param param
	 * @return Object
	 */
	public T get(String hql, Object[] param);

	/**
	 * 获得�?��对象
	 * 
	 * @param hql
	 * @param param
	 * @return
	 */
	public T get(String hql, List<Object> param);

	/**
	 * select count(*) from �?
	 * 
	 * @param hql
	 * @return
	 */
	public Long count(String hql);

	/**
	 * select count(*) from �?
	 * 
	 * @param hql
	 * @param param
	 * @return
	 */
	public Long count(String hql, Object[] param);

	/**
	 * select count(*) from �?
	 * 
	 * @param hql
	 * @param param
	 * @return
	 */
	public Long count(String hql, List<Object> param);

	/**
	 * 执行HQL语句
	 * 
	 * @param hql
	 * @return 响应数目
	 */
	public Integer executeHql(String hql);

	/**
	 * 执行HQL语句
	 * 
	 * @param hql
	 * @param param
	 * @return 响应数目
	 */
	public Integer executeHql(String hql, Object[] param);

	/**
	 * 执行HQL语句
	 * 
	 * @param hql
	 * @param param
	 * @return
	 */
	public Integer executeHql(String hql, List<Object> param);

}

2、baseDao实现

 

 

package com.cando.dao.impl;

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

import javax.annotation.Resource;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import com.cando.dao.BaseDao;

@Repository("baseDao")
@SuppressWarnings("all")
public class BaseDaoImpl<T> implements BaseDao<T> {

	private SessionFactory sessionFactory;

	public SessionFactory getSessionFactory() {
		return sessionFactory;
	}

	@Autowired
	public void setSessionFactory(SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;
	}

	private Session getCurrentSession() {
		return sessionFactory.getCurrentSession();
	}

	public Serializable save(T o) {
		return this.getCurrentSession().save(o);
	}

	public void delete(T o) {
		this.getCurrentSession().delete(o);
	}

	public void update(T o) {
		this.getCurrentSession().update(o);
	}

	public void saveOrUpdate(T o) {
		this.getCurrentSession().saveOrUpdate(o);
	}

	public List<T> find(String hql) {
		return this.getCurrentSession().createQuery(hql).list();
	}

	public List<T> find(String hql, Object[] param) {
		Query q = this.getCurrentSession().createQuery(hql);
		if (param != null && param.length > 0) {
			for (int i = 0; i < param.length; i++) {
				q.setParameter(i, param[i]);
			}
		}
		return q.list();
	}

	public List<T> find(String hql, List<Object> param) {
		Query q = this.getCurrentSession().createQuery(hql);
		if (param != null && param.size() > 0) {
			for (int i = 0; i < param.size(); i++) {
				q.setParameter(i, param.get(i));
			}
		}
		return q.list();
	}

	public List<T> find(String hql, Object[] param, Integer page, Integer rows) {
		if (page == null || page < 1) {
			page = 1;
		}
		if (rows == null || rows < 1) {
			rows = 10;
		}
		Query q = this.getCurrentSession().createQuery(hql);
		if (param != null && param.length > 0) {
			for (int i = 0; i < param.length; i++) {
				q.setParameter(i, param[i]);
			}
		}
		return q.setFirstResult((page - 1) * rows).setMaxResults(rows).list();
	}

	public List<T> find(String hql, List<Object> param, Integer page, Integer rows) {
		if (page == null || page < 1) {
			page = 1;
		}
		if (rows == null || rows < 1) {
			rows = 10;
		}
		Query q = this.getCurrentSession().createQuery(hql);
		if (param != null && param.size() > 0) {
			for (int i = 0; i < param.size(); i++) {
				q.setParameter(i, param.get(i));
			}
		}
		return q.setFirstResult((page - 1) * rows).setMaxResults(rows).list();
	}

	public T get(Class<T> c, Serializable id) {
		return (T) this.getCurrentSession().get(c, id);
	}

	public T get(String hql, Object[] param) {
		List<T> l = this.find(hql, param);
		if (l != null && l.size() > 0) {
			return l.get(0);
		} else {
			return null;
		}
	}

	public T get(String hql, List<Object> param) {
		List<T> l = this.find(hql, param);
		if (l != null && l.size() > 0) {
			return l.get(0);
		} else {
			return null;
		}
	}

	public Long count(String hql) {
		return (Long) this.getCurrentSession().createQuery(hql).uniqueResult();
	}

	public Long count(String hql, Object[] param) {
		Query q = this.getCurrentSession().createQuery(hql);
		if (param != null && param.length > 0) {
			for (int i = 0; i < param.length; i++) {
				q.setParameter(i, param[i]);
			}
		}
		return (Long) q.uniqueResult();
	}

	public Long count(String hql, List<Object> param) {
		Query q = this.getCurrentSession().createQuery(hql);
		if (param != null && param.size() > 0) {
			for (int i = 0; i < param.size(); i++) {
				q.setParameter(i, param.get(i));
			}
		}
		return (Long) q.uniqueResult();
	}

	public Integer executeHql(String hql) {
		return this.getCurrentSession().createQuery(hql).executeUpdate();
	}

	public Integer executeHql(String hql, Object[] param) {
		Query q = this.getCurrentSession().createQuery(hql);
		if (param != null && param.length > 0) {
			for (int i = 0; i < param.length; i++) {
				q.setParameter(i, param[i]);
			}
		}
		return q.executeUpdate();
	}

	public Integer executeHql(String hql, List<Object> param) {
		Query q = this.getCurrentSession().createQuery(hql);
		if (param != null && param.size() > 0) {
			for (int i = 0; i < param.size(); i++) {
				q.setParameter(i, param.get(i));
			}
		}
		return q.executeUpdate();
	}

}

推荐大家一个Java的学习网站：Java知识学习网,Java资料下载，Java学习路线图，网址：https://www.java1010.com

 

 

 

 

 

 

Java源代码一个简单的通用DAO实现（基于hibernate）
07-24
Java源代码 一个简单的通用DAO实现 （基于hibernate）面向应用层按POJO类缓存hibernate的session对象.使用举例： DAO dao = DAOFactory.getDAO(POJO.class);//获得一个全局类单例的DAO实例 dao.save(pojo); 你也可以生成一个不被DAOFactory（工厂）缓存的即用即弃的DAO实例: DAO dao = DAOFactory.getInstance(POJO.class);
Hibernate的DAO实现
ZWeb-Blog
04-24 1万+
10.7  Hibernate的DAO实现DAO对象是模块化的数据库访问组件，DAO对象通常包括：对持久化类的基本CRUD操作（插入、查询、更新、删除）操作。Spring对Hibernate的DAO实现提供了良好的支持。主要有如下两种方式的DAO实现：q      继承HibernateDaoSupport的实现DAOq      基于Hibernate3.0实现DAO不管采用哪一种实
ajax关键知识点之Spring整合Hibernate的DAO层开发解析
最新发布
2301_78506709的博客
06-01 603
本文解析了Spring整合Hibernate实现DAO层开发的关键技术。DAO层作为"数据库翻译官"，隔离业务逻辑与数据访问，提升系统可维护性。Spring通过HibernateDaoSupport简化操作，LocalSessionFactoryBean管理SessionFactory配置。文章详细介绍了DAO接口与实现类的设计模式，以及N-1和1-N关联中延迟加载的优化策略，强调通过合理配置lazy属性平衡性能。整个方案采用面向接口编程，使数据持久层具有更好的移植性，适用于轻量级Jav
HibernateDAO.java
百威
03-26 126
[code="java"] import java.util.List; /** * 使用Hibernate实现DAO的基础类 包括持久化操作的一些基础方法 * * @author Administrator * */ public class HibernateDAO { /** * 保存对象信息到数据库 * @param obj 需要持久化的对象 ...
hibernateDao
yaoyaoyue的专栏
06-21 226
package com.csair.gme.conf.dao.impl; import java.sql.Connection; import java.sql.ResultSet; import java.sql.ResultSetMetaData; import java.sql.SQLException; import java.sql.Statement; import...
详细介绍 Hibernate 泛型 DAO 及其使用方法
热门推荐
阿铮的箩筐
03-31 3万+
  编写Spring+Hibernate框架下的应用，总是离不了编写一个通用的泛型GenericHibernateDao。查阅了网上不少的GenericHibernateDao实现，归纳整理为如下实现，供后续编码参考。 首先定义接口泛型DAO接口 GenericDaopackage com.th.huz;import java.io.Serializable;import ja
Hibernate泛型Dao
10-18
在实际应用中，还需要理解JDBC（Java Database Connectivity）的基础知识，因为Hibernate是在JDBC之上建立的。此外，了解SQL语言也是必要的，虽然Hibernate可以自动生成SQL，但在某些复杂查询场景下，可能需要手动...
JPA(hibernate) Dao 和 DaoSupport
04-13
在Spring框架中，`DaoSupport`是一个抽象类，为DAO实现提供了一些基础支持，比如初始化和关闭数据库资源。继承自`DaoSupport`的DAO类可以利用其提供的便利方法，如`getJdbcTemplate()`或`getHibernateTemplate()`，...
Hibernate基础学习：了解 Hibernate 框架和DAO模式
Hibernate基础学习 Hibernate 是一个面向 Java 环境的对象/关系数据库映射工具，即 ORM（Object-RelationMapping 对象-关系映射）工具。它对 JDBCAPI 进行了封装，负责 Java 对象的持久化，在分层的软件架构中它...
Hibernate封装dao层
08-31
2. **Hibernate基础**： Hibernate通过映射XML文件或者注解，将Java对象与数据库表关联，使得我们可以以对象操作的方式来处理数据库。其主要组件包括：SessionFactory（会话工厂）、Session（数据库会话）、...
Hibernate通用Dao设计。
05-29
- 针对特殊需求，可以在通用DAO的基础上，为特定实体类创建特定的DAO，添加特定的方法。 - 结合MyBatis或其他ORM工具，实现混合使用，根据场景选择最合适的访问方式。 综上所述，Hibernate通用DAO设计的核心在于...
hibernate通用dao
11-08
简单的hibernate通用dao,包括基本的CRUD.hibernate版本为3版本.
HibernateDao 通用
09-15
HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用
Hibernate_通用DAO模式，一个写好的dao层
08-18
这个是不同类型的表单通用的dao模式，简洁明了，注释清楚，可移植性很强
Hibernate之DAO
ZhangVeni的博客
03-14 738
使用eclipse 安装Hibernate tools 然后利用数据表逆向生成POJO类的方法网上有很多，请读者自习搜索学习。但里面很多只生成了POJO 类和一些文档，对DAO类却鲜有人问津，本着科学探索的精神（主要是不想自己写DAO），研究一下Hibernate Tools（以下简写成HT）自动生成的DAO 类。
hibernate 基础dao类实现
wal812834184的专栏
06-04 5585
<br />import java.io.Serializable;<br />import java.lang.reflect.InvocationTargetException;<br />import java.math.BigInteger;<br />import java.util.ArrayList;<br />import java.util.List;<br />import java.util.regex.Matcher;<br />import java.util.regex.Patt
Hibernate dao 层
胡汉三
05-05 4994
欢迎技术交流。 QQ：138986722 接口——IDao： package com.boxun.crm.dao; import java.util.List; import org.hibernate.HibernateException; import org.hibernate.Session; /** * DAO接口 * 该类只是提供一个公用接口，以便HQL查询与SQL查
hibernate_Dao及序列化
子龙修仙的博客
06-30 390
1. Dao 定义一个dao的接口，在service中可以通过注解直接使用：@Autowiredprivate IUserDataOptionDao optionDao;spring会自动去找接口的实现类，并创建相应的对象。但是，如果此接口有多个实现类呢？如：@Repositorypublic class UserDataOptionDaoImpl implements IUserDataOpti...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值