深入解析Java的Hibernate框架中的持久对象

一、持久对象生命周期
应用程序在使用Hibernate框架后,创建的持久对象会经历一整套生命周期来完成数据库的操作,其中主要的三个状态分别是瞬态(Transient)、持久化(Persistent)、脱管(detached)。这三种状态的转换是能够在应用程序中控制的,如下图:

为了能清楚的了解这几种状态,这里使用一个实例来查看下这几种状态下对象的不同,下面状态内的代码,具体步骤如下:
(1)创建Hibernate_session程序集,并添加像相应的jar包;
(2)配置Hibernate,添加相应的实体User类,及它的映射文件,并配置好相应的数据库连接;
User类文件的映射文件User.hbm.xml代码:

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2014-4-30 15:39:33 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping>
 <class name="com.hibernate.User">
  <id name="id">
   <generator class="uuid"/>
  </id>
  <property name="name"/>
  <property name="password"/>
  <property name="createTime"/>
  <property name="expireTime"/>
 </class>
</hibernate-mapping>

Hibernate数据库连接配置代码:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
  "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
  "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
 <session-factory>
  <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
  <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_session</property>
  <property name="hibernate.connection.username">root</property>
  <property name="hibernate.connection.password">ab12</property>
  <!-- dialect:方言,封装的底层API,类似于Runtime,将数据库转换为配置中的相应的语言 -->
  <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> 

  <mapping resource="com/hibernate/User.hbm.xml"/>
 </session-factory>
</hibernate-configuration>

(3)添加静态成员sessionfactory的公共类,用来创建一个SessionFactory及其Session对象;

package com.hibernate; 

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration; 

public class session { 

 private static SessionFactory factory; //声明静态局部变量SessionFactory,数据库镜像 

 static{
  try{
   //创建并获取配置数据库的配置文件,默认获取hibernate.cfg.xml
   Configuration cfg=new Configuration().configure();
   factory=cfg.buildSessionFactory(); //构建一个数据库镜像
  }catch(Exception e){
   e.printStackTrace(); //打印错误信息
  }
 } 

 public static Session getSession(){
  return factory.openSession(); //返回创建的session对象
 } 

 public static SessionFactory getSessionFactory(){
  return factory; //返回相应的SessionFactory
 } 

 //关闭session对象
 public static void closeSession(Session session){
  if(session != null){
   if(session.isOpen()){
    session.close();
   }
  }
 }
}

(4)添加一个Source Folder,并在该文件夹内添加名称为com.hibernate的package包,并在包中添加一个名称为SessionTest的类文件。

package com.hibernate; 

import java.util.Date; 

import junit.framework.TestCase; 

import org.hibernate.Session;
import org.hibernate.Transaction; 

public class SessionTest extends TestCase { 

}

二、状态转化方法
1、对象直接进入Persistent状态    
     
1.1 get方法
从数据库中获取一行信息,并将该信息同步到创建的对象中,该方法返回一个Object对象,如果没有查询到内容则返回null。下面的实例通过采用Session的get方法来获取一个对象,并将对象转换为实例。

public void testGet1(){
 Session session=null;
 Transaction tx = null;
 try{
  session=HibernateUtils.getSession();
  //开启事务
  tx= session.beginTransaction();
  //get加载上来的对象为持久对象
  //执行get会马上发出查询语句,如果不存在会返回null
  User user=(User)session.get(User.class,"ff80808145bc28cc0145bc28ce020002");
  System.out.println(user.getName()); 

  //persistent状态
  //persistent状态的对象,当对象的属性发生改变的时候
  //Hibernate在清理缓存(脏数据检查)的时候,会和数据库同步
  user.setName("赵柳"); 

  session.getTransaction().commit();
 }catch(Exception e){
  e.printStackTrace();
  if(tx != null){
   tx.rollback();
  }
 }finally{
  HibernateUtils.closeSession(session);
 }
}

设置断点,获取User对象。

获取到了该对象,通过强制转换后得到了一个user对象。程序中添加了setName方法,也就是说会更新数据库中的名称,执行完成后检查数据库,如下图更新结果。

1.2 load方法
功能类似于get方法,也是从数据库中获取数据并同步到对象中,该方法支持lazy是一种懒汉操作,它返回的是一个持久化的Object对象或者一个代理,所以需要进行转化。

public void testLoad1(){
 Session session=null;
 try{
  session=HibernateUtils.getSession();
  //不会马上查询语句,因为load支持lazy(延迟加载/懒加载)
  //什么教lazy?只有真正使用这个对象的时候,再创建,对于Hibernate来说
  //才真正发出查询语句,主要为了提高性能,lazy是Hibernate中非常重要的特性
  //Hibernate的lazy是如何实现的?采用代理对象实现,代理对象主要采用的是CGLIB库生成的
  //而不是JDK的动态代理,因为JDK的动态代理只能对实现了借口的类生成代理,CGLIB可以对类生成
  //代理,它采用的是继承方式
  User user=(User)session.load(User.class,"8a1b653745bcc7b50145bcc7b7140001");
  System.out.println(user.getName()); 

  //persistent状态
  //persistent状态的对象,当对象的属性发生改变的时候
  //Hibernate在清理缓存(脏数据检查)的时候,会和数据库同步
  user.setName("zhaoliu"); 

  session.getTransaction().commit();
 }catch(Exception e){
  e.printStackTrace();
 }finally{
  HibernateUtils.closeSession(session);
 }
}

查询获取该User对象如下图:

分析上图,获取的User对象并不完整,或者说并没有常见一个User对象,更是一种代理,它使用了CGLIB来预加载对象,只有在使用该对象时才真正创建。
1.3 Get Vs load
get和load方法很重要,在面试Hibernate时经常会考到,下面对比下两者。
相同点:

(1)功能相同,将关系数据转化为对象;
(2)使用方法相同,同样需要制定两个参数
不同点:

(1)load方法支持lazy操作,预加载对象,在使用时才创建,get是直接将关系数据转化为对象;
(2)load加载对象如果不存在会抛出objectNotFoundException异常,get如果没有获取数据会返回null。

2、手动构造detached对象
想要获取对象还有另外一种方法,它区别于get与load方法,是一种手动获取的方法,首先常见一个对象,然后通过制定id的方式获取该对象的数据,方法如下:

public void testUer(){
  Session session=null;
  try{ 

    session=HibernateUtils.getSession();
    session.beginTransaction(); 

    //手动构造detached对象
    User user=new User();
    user.setId("8a1b653745bcc7b50145bcc7b7140001"); 

    //persistent状态
    //persistent状态的对象,当对象的属性发生改变的时候
    //Hibernate在清理缓存(脏数据检查)的时候,会和数据库同步
    session.getTransaction().commit();
  }catch(Exception e){
    e.printStackTrace();
  }finally{
    HibernateUtils.closeSession(session);
  }
}

查看获取的结果图:

分析结果图,代码中使用了setId方法为该对象制定了id号,在制定id号后就能够对该对象进行操作,在事务提交后同步到数据库中,采用了手动指定,手动指定了对象的信息。
2.1 Delete方法
删除数据库中指定的对象,在删除前必须将对象转化到Persistent状态,可以使用get、load或者手动的方法指定对象,使用方法如下代码:

session=HibernateUtils.getSession();
session.beginTransaction();
User user=(User)session.load(User.class,"8a1b653745bcc6d50145bcc6d67a0001");
//建议采用此种方式删除,先加载再删除
session.delete(user);

2.2 Update

更新数据,该方法会修改数据库中的数据。在使用的时候会出现量中情况,更新数据库某个字段值或者更新数据库的整行值
2.2.1  更新某个字段值
如果只想要更新某个字段的值,在update前,需要使用load或者get方法使对象转化为persistent状态代码如下:

//获取session对象
session=HibernateUtils.getSession();
//开启事务
session.beginTransaction();
//或者可以使用另外的方法开启
//session.getTransaction().begin(); 

//加载获取User对象
//方法一:使用load方法
//User user=(User)session.load(User.class, "8a1b653745bcc7b50145bcc7b7140001");
//方法二:手动获取
User user=new User();
user.setId("8a1b653745bcc7b50145bcc7b7140001"); 

//更新姓名
user.setName("zhangsan");
session.update(user);
session.getTransaction().commit();

2.2.2 更新整行                       
想要更新整行的数据,可以采用手动将状态转换到detached状态,手动指定对象的id值,代码如下:

//获取session对象
session=HibernateUtils.getSession();
//开启事务
session.beginTransaction();
//或者可以使用另外的方法开启
//session.getTransaction().begin(); 

//手动获取
User user=new User();
user.setId("8a1b653745bcc7b50145bcc7b7140001"); 

//更新姓名
user.setName("zhangsan");
session.update(user);
session.getTransaction().commit();

查看更新结果:

分析更新结果,它其实更新了数据库的整行数据,这种更新操作有太多的不确定因素,不建议使用。

2.3 save方法

插入数据。在执行save方法时会调用数据库的insert语句,向数据库中添加新的一行。save后的对象会转化为持久态,在此状态下的对象能够再次更新对象,在最后提交事务时会同更改更新到数据库。如下:

public void testSave2(){
  Session session=null;
  Transaction tx = null;
  try{
    session=HibernateUtils.getSession();
    //开启事务
    tx= session.beginTransaction(); 

    //Transient状态
    User user=new User();
    user.setName("zhangsi");
    user.setPassword("123");
    user.setCreateTime(new Date());
    user.setExpireTime(new Date()); 

    //persistent状态
    //persistent状态的对象,当对象的属性发生改变的时候
    //Hibernate在清理缓存(脏数据检查)的时候,会和数据库同步
    session.save(user);
    user.setName("lisi"); 

    tx.commit(); 

  }catch(Exception e){
    e.printStackTrace();
    if(tx != null){
      tx.rollback();
    }
  }finally{
    HibernateUtils.closeSession(session);
  } 

  //detached状态
}

查看上例运行结果视图:

分析结果:session在提交事务的时候其实做了两部的操作,结合代码中的更新过程,首先是新增了一个User对象,之后执行了save操作,它会调用insert语句,然后在代码中做了一个setName的操作,重新修改了名称,但这时还没有同步到数据库中而是在内存中,这时就会有两种状态,我们称此时的数据位脏数据,最后提交事务的时候更新到数据库中。

(0)

相关推荐

  • Java的Hibernate框架中的组合映射学习教程

    一.组合映射 组合是关联关系的一种特殊情况,是关联关系耦合度最高的一种关系,组合的主对象和子对象拥有相同的生命周期,主对像消亡的话子对象也会消亡.这里使用雇主和用户作为示例,用户和雇主都拥有联系方式属性,如果这里站在对象角度思考的话,常常会把对象模型绘制成为组合的方式,抽象出来一个共同的联系方式类,然后两种人分别包含相应的联系方式对象即可,向应的对象模型时它的对象示例如下图所示: 组合对象模型在生成相应的关系模型后会把对应的子类包含到主表中,所以对应的表结构会将相应的属性生成到对应的表中,相应的

  • Java的Hibernate框架中复合主键映射的创建和使用教程

    复合主键映射需要在映射配置文件中使用<composite-id>标签,该标签是指将一个类指定为相应的复合主键,它的name属性需要指定类文件中定义的属性值,并在该标签中添加<key-property>子标签. Note:想要使用复合映射必须要将复合主键放到一个类中,也就是讲复合主键属性和其它属性分到两个类中,并将复合主键的类实现接口Serializable,该接口隶属于java.io. 复合主键的映射关系的主键是由多个列复合而成的,对应到数据表中相当的简单,如下图: 1.类文件 这

  • Java的Hibernate框架结合MySQL的入门学习教程

    零.关于Hibernate Hibernate是冬眠的意思,它是指动物的冬眠,但是本文讨论的Hibernate却与冬眠毫无关系,而是接下来要讨论的SSH2框架中的一员.Hibernate是一个开源的项目,它是一个对象关系模型的框架,并且对JDBC进行了非常轻量级的封装,程序员在开发时可以使用对象编程思维进行开发. 下载地址:http://hibernate.org/orm/downloads/ Note:轻量级和重量级的区别,轻量级的框架包较小,并且使用较简单,而且测试容易,开发效率高:重量级框

  • Java的Hibernate框架中的基本映射用法讲解

    Hibernate进行了分类整合发现其实Hibernate分为三大部分:核心对象.映射.HQL,这三大部分开发过程中最常使用,前几篇讨论了核心对象及对象之间的转换方法,接下来讨论Hibernate的映射使用方法.   Hibernate一个重要的功能就是映射,它能够在对象模型和关系模型之间转换,是面向对象编程思想提倡使用的,使用映射程序开发人员只需要关心对象模型中代码的编写.对象和关系数据库之间的映射通常是由XML文档来定义的.这个映射文档被设计为易读的,并且可以手动修改.这种映射关系我总结为下

  • Java的Hibernate框架中一对多的单向和双向关联映射

    一.一对多单向关联映射 一对多关系的对象模型在日常生活中也经常看到,就拿学生和班级来说,一个班级里有多个学生,所以班级和学生的关系是一对多的关系,映射到对象模型中,如下图: 对象模型说明了这种一对多的关系是由一的一端来维护的,那么映射成关系模型就是一个班级字段下面会有多个学生,这样就形成了一对多的关系,通过班级能够查询获得学生信息,对应的关系模型如下图: 1.基本配置 有了对象模型接下来就让它们映射为对应的关系代码,在进行关系映射时需要在一的一端添加<one-to-many>标签,另外还需要在

  • 浅析Java的Hibernate框架中的继承关系设计

    这次我们来说一下hibernate的层次设计,层次设计也就是实体之间的继承关系的设计.  也许这样比较抽象,我们直接看例子.  1)我们先看一下普通的做法  直接上代码:三个实类如下: public class TItem implements Serializable{ //省略Get/Set方法 private int id; private String manufacture; private String name; } public class TBook extends TItem

  • java Hibernate save()与persist()区别

    Hibernate 之所以提供与save()功能几乎完全类似的persist()方法,一方面是为了照顾JPA的用法习惯.另一方面,save()和 persist()方法还有一个区别:使用 save() 方法保存持久化对象时,该方法返回该持久化对象的标识属性值(即对应记录的主键值):但使用 persist() 方法来保存持久化对象时,该方法没有任何返回值.因为 save() 方法需要立即返回持久化对象的标识属性,所以程序执行 save() 会立即将持久化对象对应的数据插入数据库:而 persist

  • Java Hibernate中使用HQL语句进行数据库查询的要点解析

    一.实体对象查询 实体对象查询是hql查询的基础,作为一种对象查询语言,在查询操作时和sql不同,查询字符串中的内容要使用类名和类的属性名来代替.这种查询方法相对简单,只要有SQL功底,使用hql是很简单的,但是有一些问题需要注意,就是查询获取数据不是目的,需要考虑的是如何编写出高效的查询语句,这才是讨论的重点. 1.N+1问题 (1)什么是N+1问题 在刚听到这个名词时疑惑可能是有的,以前根本就没有听过N+1问题,那么它是指什么呢?N+1指的是一张表中有N条数据,那么在获取这N条数据时会产生N

  • Java的Hibernate框架中的继承映射学习教程

    一.继承映射 继承是面向对象很重要的特性,它实现了代码的服用,在关系模型中同样也有继承关系,这种继承关系其实可以看做是一种枚举关系,一种类型中可以枚举出很多子类型,这些子类型和父对象形成了继承关系,能够对其进行枚举的大部分都可以看做是一种继承映射,所以这种枚举关系可以看做是继承映射,例如动物就是一种抽象类,它是其它动物猪.猫等的父类,它们之间就是一种继承关系,如下图: 这种继承映射在转化为关系模型后会生成一张表,那么这张表是如何区分这两种类型的呢?用的是关系字段,需要在表中添加类型字段,使用关键

  • Java的Hibernate框架中的双向主键关联与双向外键关联

    一.双向主键关联 双向的主键关联其实是单向一对一主键关联的一种特殊情况,只不过要在关联对象的两端的映射文件中都要进行<one-to-one>的配置,另外还要在主映射的主键一端采用foreign外键关联属性. 这里同样使用Person和IdCard来讨论,一个人对应着一个唯一的身份证,而且一个身份证也唯一映射着一个人,所以这就产生了双向的关联关系,Person的主键同样也是IdCard的主键,分别是主键的同时也是外键,这种关联关系成为双向一对一映射,表现到关系模型中可如下图: 图中的两个表采用了

  • 详解Java的Hibernate框架中的Interceptor和Collection

    Interceptor 讲到Interceptor,相信熟悉struts2的童鞋肯定不会陌生了,struts2可以自定义拦截器进行自己想要的一系列相关的工作.而这里我们说的Interceptor也是差不多相似的功能.  废话不说,直接来代码:  下面这个是MyInterceptor类,它实现了Interceptor接口: public String onPrepareStatement(String arg0) { return arg0; } public boolean onSave(Obj

  • 简介Java的Hibernate框架中的Session和持久化类

    Session Session对象用于获取与数据库的物理连接. Session对象是重量轻,设计了一个互动是需要与数据库每次被实例化.持久化对象被保存,并通过一个Session对象中检索. 会话中的对象不应该保持开放很长一段时间,因为他们通常不被线程安全的,他们应该被创建并根据需要摧毁他们.这次会议的主要功能是提供创建,读取和删除操作映射的实体类的实例.实例中可能存在以下三种状态之一在给定时间点: 短暂性: 持久化类的未与会话相关联,并在数据库中没有代表性,没有标识值的新实例被Hibernate

随机推荐