`
seawavenews
  • 浏览: 230223 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
文章分类
社区版块
存档分类
最新评论

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

HibernateD语言DAOSQLlog4j 
阅读更多

一、基本数据查询

使用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有详细的说明。


 

分享到：
| hibernate查询总结
评论
发表评论

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

相关推荐

    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&lt;User&gt; cq = cb.createQuery(User.class); Root&lt;User&gt; 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实例，一次应用只需要一个...

Magicbox
Global site tag (gtag.js) - Google Analytics