Hibernate用法：查询，更新，删除

seawavenews

浏览: 231554 次
性别:
来自: 杭州

最近访客更多访客>>

songhait

OldLearnSheep

theanswerli

newpear8794

博主相关

博客

微博

相册

留言

关于我

文章分类

全部博客 (209)

社区版块

存档分类

Hibernate D语言 DAO SQL log4j

一、基本数据查询

使用Hibernate进行数据查询是一件简单的事，Java程序设计人员可以使用对象操作的方式来进行数据查询，查询时使用一种类似SQL的HQL（Hibernate Query Language）来设定查询的条件，与SQL不同的是，HQL是具备对象导向的继承、多型等特性的语言。

　

直接使用范例来看看如何使用Hibernate进行数据库查询，在这之前，请先照之前介绍过的主题在数据库中新增几笔数据：

在Hibernate中新增资料

　

查询数据时，我们所使用的是Session的find()方法，并在当中指定HQL设定查询条件，查询的结果会装载在List对象中传回，您所需要的是将它们一一取出，一个最简单的例子如下：

AbstractDao.java


import java.util.List;
import org.eimhe.HibernateSessionFactory;
import org.eimhe.util.DataAccessLayerException;
import org.hibernate.Hibernate;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
public abstract class AbstractDao {
 private Session session;
 private Transaction tx;
 
 protected void saveOrUpdate(Object obj){
  try{
   startOperation();
   session.saveOrUpdate(obj);
   tx.commit();
  }catch(HibernateException e){
   handleException(e);
  }finally{
   session.close();
  }
 }
 protected void delete(Object obj){
  try{
   startOperation();
   session.delete(obj);
   tx.commit();
  }catch(HibernateException e){
   handleException(e);
  }finally{
   session.close();
  }
 }
 
 protected Object find(Class clazz,Long id){
  Object obj=null;
  try{
   startOperation();
   obj=session.get(clazz, id);
   if(!Hibernate.isInitialized(clazz)){
    Hibernate.initialize(clazz);
   }
   tx.commit();
  }catch(HibernateException e){
   handleException(e);
  }finally{
   session.close();
  }
  return obj;
 }
 protected List findById(Class clazz){
  return null;
 }
 protected List findAll(Class clazz){
  List objects=null;
  try{
   startOperation();
   Query query=session.createQuery("from "+clazz.getName());
   objects=query.list();
   tx.commit();
  }catch(HibernateException e){
   handleException(e);
  }finally{
   session.close();
  }
  return objects;
 }
 protected void handleException(HibernateException e) throws DataAccessLayerException{
  if(tx!=null){
   tx.rollback();
  }
  throw new DataAccessLayerException(e);
 }
 protected void startOperation() throws HibernateException{
  session=HibernateSessionFactory.getSession();
  tx=session.beginTransaction();
 }
}

2.操作封装成Dao，DayMachineInfoDao.java

package org.eimhe.dao;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
import org.eimhe.HibernateSessionFactory;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
public class DayMachineInfoDao extends AbstractDao {
 private Session session;
 private Transaction tx;
 
 public List findByYearAndMonthAndDayAndPowerPlantIdAndMachineNo(String year,String month,String day,long powerPlantId,long machineNo){
  List objects=null;
  try{
   startOperation();
   Query query=session.createQuery("from DayMachineInfo d where d.id.year="+year+" and d.id.month="+month+" and d.id.day="+day+
     " and d.id.powerPlantId="+powerPlantId+" and d.id.machineNo="+machineNo);
   objects=query.list();
   tx.commit();
  }catch(HibernateException e){
   handleException(e);
  }finally{
   session.close();
  }
  return objects;
 }
 public List findReturnPeriodIdAndTotalContractAndAdjustAndRealTotalContract(String year,String month,String day,long powerPlantId,long machineNo){
  List objects=null;
  try{
   startOperation();
   Query query=session.createQuery("select d.id.periodId,d.dayMachineContractQuantity,d.dayMachineRealtimeAdjustCapacity,"+
     " d.dayMachineContractQuantity+d.dayMachineRealtimeAdjustCapacity as realTotalContract" +
     " from DayMachineInfo d where d.id.year=:year and d.id.month=:month and d.id.day=:day"+
     " and d.id.powerPlantId=:powerPlantId and d.id.machineNo=:machineNo");
   query.setString("year", year);
   query.setString("month", month);
   query.setString("day", day);
   query.setString("powerPlantId", String.valueOf(powerPlantId));
   query.setString("machineNo", String.valueOf(machineNo));
   objects=query.list();
   tx.commit();
  }catch(HibernateException e){
   handleException(e);
  }finally{
   session.close();
  }
  return objects;
 }
 public List findReturnDayAndMonthContract(String year,String month,long powerPlantId,long machineNo){
  List objects=null;
  try{
   startOperation();
   Query query=session.createQuery("select d.id.day,sum(d.dayMachineDecomposeMonthBidQuantity) as monthContract"+     
     " from DayMachineInfo d where d.id.year=:year and d.id.month=:month"+
     " and d.id.powerPlantId=:powerPlantId and d.id.machineNo=:machineNo"+
     " group by d.id.day");
   query.setString("year", year);
   query.setString("month", month);
   query.setString("powerPlantId", String.valueOf(powerPlantId));
   query.setString("machineNo", String.valueOf(machineNo));
   objects=query.list();
   tx.commit();
  }catch(HibernateException e){
   handleException(e);
  }finally{
   session.close();
  }
  return objects;
 }
 public List findReturnDayAndYearContractAndAdjustAndRealContract(String year,String month,long powerPlantId,long machineNo){
  List objects=null;
  try{
   startOperation();
   Query query=session.createQuery("select d.id.day,sum(d.dayMachineDecomposeYearContractQuantity) as yearContract,"+ 
     " sum(d.dayMachineRealtimeAdjustCapacity) as adjust,"+
     " sum(d.dayMachineDecomposeYearContractQuantity)+sum(d.dayMachineRealtimeAdjustCapacity) as realContract"+
     " from DayMachineInfo d where d.id.year=:year and d.id.month=:month"+
     " and d.id.powerPlantId=:powerPlantId and d.id.machineNo=:machineNo"+
     " group by d.id.day");
   query.setString("year", year);
   query.setString("month", month);
   query.setString("powerPlantId", String.valueOf(powerPlantId));
   query.setString("machineNo", String.valueOf(machineNo));
   objects=query.list();
   tx.commit();
  }catch(HibernateException e){
   handleException(e);
  }finally{
   session.close();
  }
  return objects;
 }
 public List findDayMachineInfoAndYearMachineInfoReturnMonthAndDayAndYearContractAndAdjustAndRealContract(String year,String month,long powerPlantId,long machineNo){
  List objects=null;
  try{
   startOperation();
   Query query=session.createQuery("select d.id.month,d.id.day,sum(d.dayMachineDecomposeYearContractQuantity) as yearContract,"+ 
     " sum(d.dayMachineRealtimeAdjustCapacity) as adjust,"+
     " sum(d.dayMachineDecomposeYearContractQuantity)+sum(d.dayMachineRealtimeAdjustCapacity) as realContract"+
     " from DayMachineInfo d where d.id.year=:year and d.id.month<=:month"+
     " and d.id.powerPlantId=:powerPlantId and d.id.machineNo=:machineNo"+
     " group by d.id.month,d.id.day");
   query.setString("year", year);
   query.setString("month", month);
   query.setString("powerPlantId", String.valueOf(powerPlantId));
   query.setString("machineNo", String.valueOf(machineNo));
   objects=query.list();
//   tx.commit();
   
   query=session.createQuery("select '9999', '-1000',-10L,-10L,y.yearMachineBaseContractQuantity "+
     " from YearMachineInfo y "+
     " where y.id.year=:year and y.id.powerPlantId=:powerPlantId and y.id.machineNo=:machineNo");
   query.setString("year", year);
   query.setString("powerPlantId", String.valueOf(powerPlantId));
   query.setString("machineNo", String.valueOf(machineNo));
   objects.add(query.list().iterator().next());
   tx.commit();
   
  }catch(HibernateException e){
   handleException(e);
  }finally{
   session.close();
  }
  return objects;
 }
 public List findYearMachineInfoByYearAndPowerPlantIdAndMachineNo(String year,long powerPlantId,long machineNo){
  List objects=new ArrayList();
  try{
   startOperation();
   Query query=session.createQuery("select '9999', '-1000',-10L,-10L,y.yearMachineBaseContractQuantity "+
     " from YearMachineInfo y "+
     " where y.id.year=:year and y.id.powerPlantId=:powerPlantId and y.id.machineNo=:machineNo");
   query.setString("year", year);
   query.setString("powerPlantId", String.valueOf(powerPlantId));
   query.setString("machineNo", String.valueOf(machineNo));
   objects.add(query.list().iterator().next());
   tx.commit();
  }catch(HibernateException e){
   handleException(e);
  }finally{
   session.close();
  }
  return objects;
 }
  protected void startOperation() throws HibernateException{
   session=HibernateSessionFactory.getSession();
   tx=session.beginTransaction();
 }
}

3.对上面Dao的测试，DayMachineInfoDaoTest.java：


import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
import org.eimhe.bean.DayMachineInfo;
import org.eimhe.dao.DayMachineInfoDao;
import junit.framework.TestCase;
public class DayMachineInfoDaoTest extends TestCase {
 private DayMachineInfoDao dDao=new DayMachineInfoDao();
 private DayMachineInfo dmi=new DayMachineInfo();
 protected void setUp() throws Exception {
  super.setUp();
 }
 protected void tearDown() throws Exception {
  super.tearDown();
 }
 public void testFindByYearAndMonthAndDayAndPowerPlantIdAndMachineNo() {
  List list=new ArrayList();
  list=dDao.findByYearAndMonthAndDayAndPowerPlantIdAndMachineNo("2006", "12", "23", (long)32, (long)1);
  Iterator it=list.iterator();
  while(it.hasNext()){
   dmi=(DayMachineInfo) it.next();
   System.out.print(dmi.getDayMachineContractQuantity());
   System.out.println(it.next().toString());
  }
 }
 public void testFindReturnPeriodIdAndTotalContractAndAdjustAndRealTotalContract(){
  List list=new ArrayList();
  list=dDao.findReturnPeriodIdAndTotalContractAndAdjustAndRealTotalContract("2004", "10", "1", 32, 1);
  Iterator it=list.iterator();
  Double subtotalContract=0d;
  Long subtotalAdjust=0L;
  Double subtotalRealContract=0d;
  while(it.hasNext()){
   Object[] pair= (Object[]) it.next();
   Long periodId=(Long) pair[0];
   Double totalContract=(Double) pair[1];
   Long adjust=(Long) pair[2];
   Double realTotalContract=(Double) pair[3];
   subtotalContract+=totalContract;
   subtotalAdjust+=adjust;
   subtotalRealContract+=realTotalContract;
   System.out.print("|  "+periodId+"\t|  ");
   System.out.print(totalContract+"\t|  ");
   System.out.print(adjust+"\t|  ");
   System.out.print(realTotalContract+"\t|  ");
   System.out.println("");
  }
  System.out.print("|  "+1000+"\t|  ");
  System.out.print(subtotalContract+"\t|  ");
  System.out.print(subtotalAdjust+"\t|  ");
  System.out.print(subtotalRealContract+"\t|  ");
  System.out.println("");
 }
 public void testFindReturnDayAndMonthContract(){
  List list=new ArrayList();
  list=dDao.findReturnDayAndMonthContract("2004", "10",32, 1);
  Iterator it=list.iterator();
  Double subtotalMonthContract=0D;
  while(it.hasNext()){
   Object[] pair=(Object[]) it.next();
   String day=(String) pair[0];
   Double monthContract=(Double) pair[1];
   subtotalMonthContract+=monthContract;
   System.out.print("|  "+day+"\t|  ");
   System.out.print(monthContract+"\t|  ");
   System.out.println("");
  }
  System.out.print("|  "+1000+"\t|  ");
  System.out.print(subtotalMonthContract+"\t|  ");
  System.out.println("");
  
 }
 public void testFindReturnDayAndYearContractAndAdjustAndRealContract(){
  List list=new ArrayList();
  list=dDao.findReturnDayAndYearContractAndAdjustAndRealContract("2004", "10", 32, 1);
  Iterator it=list.iterator();
  long subYearContract=0L;
  long subAdjust=0L;
  long subRealContract=0L;
  while(it.hasNext()){
   Object[] pair=(Object[]) it.next();
   String day=(String) pair[0];
   Long yearContract=(Long)pair[1];
   Long adjust=(Long)pair[2];
   Long realContract=(Long)pair[3];
   if(yearContract==null)yearContract=0L;
   if(adjust==null)adjust=0L;
   if(realContract==null)realContract=0L;
   subYearContract+=yearContract;
   subAdjust+=adjust;
   subRealContract+=realContract;
   System.out.print("|  "+day+"\t|  ");
   System.out.print(yearContract+"\t|  ");
   System.out.print(adjust+"\t|  ");
   System.out.print(realContract+"\t|  ");
   System.out.println("");
  }
  System.out.print("|  "+1000+"\t|  ");
  System.out.print(subYearContract+"\t|  ");
  System.out.print(subAdjust+"\t|  ");
  System.out.print(subRealContract+"\t|  ");
  System.out.println("");
 }
 public void testFindDayMachineInfoAndYearMachineInfoReturnMonthAndDayAndYearContractAndAdjustAndRealContract(){
  List list=new ArrayList();
  list=dDao.findDayMachineInfoAndYearMachineInfoReturnMonthAndDayAndYearContractAndAdjustAndRealContract("2006", "12", 32, 1);
  Iterator it=list.iterator();
  while(it.hasNext()){
   Object[] pair=(Object[]) it.next();
    String month=(String) pair[0];
    String day=(String) pair[1];
    Long yearContract=(Long) pair[2];
    Long adjust=(Long) pair[3];
    Double realContract=(Double) pair[4];
    System.out.print("|  "+month+"\t|  ");
    System.out.print(day+"\t|  ");
    System.out.print(yearContract+"\t|  ");
    System.out.print(adjust+"\t|  ");
    System.out.print(realContract+"\t|  ");
    System.out.println("");
  }
 }
 public void testFindYearMachineInfoByYearAndPowerPlantIdAndMachineNo(){
  List list=new ArrayList();
  list=dDao.findYearMachineInfoByYearAndPowerPlantIdAndMachineNo("2005", 32,1);
  Iterator it=list.iterator();
//  while(it.hasNext()){
//   
//   Double yyy=(Double) it.next();
//   System.out.print(yyy);
//  }
  while(it.hasNext()){
   Object[] pair=(Object[]) it.next();
    String month=(String) pair[0];
    String day=(String) pair[1];
    Long yearContract=(Long) pair[2];
    Long adjust=(Long) pair[3];
    Double realContract=(Double) pair[4];
    System.out.print("|  "+month+"\t|  ");
    System.out.print(day+"\t|  ");
    System.out.print(yearContract+"\t|  ");
    System.out.print(adjust+"\t|  ");
    System.out.print(realContract+"\t|  ");
    System.out.println("");
  }
 }
}

二、更新和删除数据

如果您是在同一个Session中取出数据并想要马上进行更新，则只要先查询并取出对象，透过setXXX()方法设定好新的值，然后呼叫session.flush()即可在同一个Session中更新指定的数据，例如：

HibernateTest.java

这个程序会显示数据表中的所有数据，并将数据表中的第一笔数据更新，一个执行的结果如下：

如果您开启了一个Session，从数据表中取出数据显示到使用者接口上，之后关闭Session，当使用者在接口上操作完毕并按下储存时，这时您要重新开启一个Session，使用update()方法将对象中的数据更新至对应的数据表中，一个例子如下：

HibernateTest.java

这个程序执行的结果范例如下，您可以看看实际上执行了哪些SQL：

一个执行的结果范例如下：

log4j

Hibernate对于数据的更新、删除等动作，是依赖id值来判定，如果您已知id值，则可以使用load()方法来加载资料。这边我们先介绍的是一些简单的查询动作，将来有机会的话，再介绍一些进阶的查询，如果您想要先认识一些HQL，可以看看参考手册的第11章，当中对于HQL有详细的说明。

分享到：

Oracle sqlsplus | hibernate查询总结

2007-04-10 17:33

浏览 1834

评论(0)

查看更多

评论

发表评论

 您还没有登录,请您登录后再发表评论

相关推荐

org.hibernate.HibernateException: No Hibernate Session bound to thread

然而，在使用 Hibernate 进行数据库操作时，经常会遇到 "No Hibernate Session bound to thread" 的错误信息。本文将详细介绍该错误的解决方案。错误原因 "No Hibernate Session bound to thread" 错误信息通常是...

hibernate02：session对象、hql查询、在线查询也叫对象查询、离线查询

`Session`提供了在数据库中保存、更新和删除对象的方法，同时也负责加载或检索对象。它具有事务管理功能，并且实现了对数据库的脏检查（dirty-checking）和缓存机制。创建`Session`对象时通常通过`SessionFactory`，...

Hibernate案例：办公自动系统

通过XML配置文件或注解，Hibernate能够将Java对象与数据库表进行映射，实现对象的创建、查询、更新和删除操作。 2. Hibernate 的核心组件： - Session：它是与数据库交互的主要接口，负责对象的持久化操作，如保存...

操作Hibernate类：增加,删除,修改及查询.pdf

它同样在事务中执行，但使用HQL来删除指定ID的记录，避免了先查询再删除的步骤，提高了效率。 5. **模糊查询（Fuzzy Query）** - 示例代码中没有具体展示模糊查询，但通常可以使用HQL或Criteria API来实现。例如，...

day36-hibernate检索和优化 02-Hibernate检索方式：简单查询及别名查询

3. **批处理**：批量插入、更新或删除操作可以显著提高效率。 4. **预编译SQL**：使用HQL或Criteria的预编译功能，可以减少SQL解析的时间。 5. **结果集映射优化**：避免使用“select *”，只选择需要的字段，减少...

精通Hibernate：Java对象持久化技术详解.pdf

Session则负责执行CRUD（创建、读取、更新、删除）操作，是事务处理的基本单位。Query接口提供了对HQL（Hibernate查询语言）和Criteria API的支持，使得数据库查询更加灵活和强大。此外，本书还会深入到Hibernate...

Hibernate：用户注册、查询用户信息、用户删除、用户修改功能.zip

5. CRUD操作：使用Session对象进行创建（save()或saveOrUpdate()）、查询（load()、get()或createQuery()）、删除（delete()）和更新（update()）操作。 6. 事务管理：由于数据库操作涉及数据的一致性，因此需要使用...

Hibernate 用法实例

本篇内容将通过丰富的实例来深入探讨Hibernate的核心概念和技术，帮助读者从入门到精通，掌握其所有主要用法。** ### 一、Hibernate 概述 Hibernate 提供了一种在Java应用程序中管理关系数据库模型的机制。它通过...

在Hibernate中处理批量更新和批量删除

本文将深入探讨在Hibernate中处理批量更新和批量删除的策略，以及如何优化这些操作，以提高数据库操作的效率。 ### 批量更新的常规方法在Hibernate中，最直观的批量更新方式是通过循环遍历查询结果集，并对每个...

Hibernate javaclient 查询,更新小例子

标题和描述提及的是"Hibernate javaclient 查询,更新小例子"，这意味着我们将探讨使用Hibernate作为Java客户端库进行数据查询和更新的基本操作。Hibernate是一个强大的对象关系映射（ORM）框架，它允许开发者用面向...

在Hibernate应用中处理批量更新和批量删除

本文将深入探讨在Hibernate应用中处理批量更新和批量删除的最佳实践，以及如何避免常见的性能陷阱。 ### 一、批量更新的基本概念批量更新是指对数据库中的多条记录进行一次性更新操作，相较于单条记录更新，批量...

Hibernate3.1_学习源码

其中重点配置方法和Hibernate中普遍采用的方法链编程的使用。还需注意可以将组合主键构建成一个实体，这样在编程时更加直观。 05 05Hibernate_EntityLayerDesign : 实体层的设计，演示两种情况： 1) 数据库表：一张...

Hibernate的高级查询

以下是如何使用Criteria API查询所有未删除的用户： ```java CriteriaBuilder cb = session.getCriteriaBuilder(); CriteriaQuery<User> cq = cb.createQuery(User.class); Root<User> root = cq.from(User....

hibernate 源码直接导入Eclipse

- 创建测试用例：为了更好地理解Hibernate的功能，可以创建一些测试用例，模拟数据库操作，如保存、查询、更新和删除对象，观察源码的执行流程。 - 调试源码：使用Eclipse的调试工具，设置断点，观察变量值的变化...

hibernate+struts实现数据库查询的例子

通过配置文件和注解，Hibernate可以自动将Java对象映射到数据库表，实现对象的保存、更新、删除和查询。在这个例子中，Hibernate可能会被用来定义实体类，配置映射文件，并编写SQL查询语句，以便从数据库中检索数据...

hibernate 模糊查询分页

它提供了保存、更新、删除对象以及执行查询的能力。当我们想要实现模糊查询时，可以利用`Criteria` API或者`HQL`（Hibernate Query Language）来完成。例如，如果我们要查询一个名为`User`的实体类中所有名字包含...

Hibernate Part 2：单表CRUD

对于更复杂的查询，如条件查询、分页查询等，可以使用HQL（Hibernate Query Language）或者JPA的`@NamedQuery`。HQL是面向对象的查询语言，与SQL类似但针对对象模型。例如，查找用户名为"test"的用户： ```java ...

hibernate:java持久化对象详解01

- Session：它是Hibernate的核心接口，负责管理对象的生命周期，包括创建、加载、更新和删除对象。 - Transaction：在Hibernate中，事务是数据库操作的基本单元，用于确保数据的一致性和完整性。 - Entity：持久...

hibernate-lib。rar

- Session：是Hibernate的主要工作单元，负责与数据库进行交互，提供了持久化对象的创建、查询、更新和删除等操作。 - SessionFactory：是Hibernate的配置中心，负责创建Session实例，一次应用只需要一个...

最近访客 更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论

Hibernate用法：查询，更新，删除

评论

发表评论

相关推荐

最近访客更多访客>>