精华内容
下载资源
问答
  • Hibernate持久化对象状态

    千次阅读 2013-07-22 09:36:55
    1、 hibernate持久化对象分为三种状态  transient(瞬时态、临时态) : 没有持久化标识 OID 、未与Session关联  persistent(持久态):存在持久化标识OID 、与Session关联(在事务提交 和 Session关闭...

    持久化对象 PO =  POJO + xml映射 

    1、 hibernate 将持久化对象分为三种状态

             transient(瞬时态、临时态) : 没有持久化标识 OID 、未与Session关联

             persistent(持久态):存在持久化标识OID 、与Session关联(在事务提交 和 Session关闭之前)

             detached  (脱管态、离线态) : 存在持久化标识OID ,未与Session关联


    2 、持久化对象三种状态转换


             1) 瞬时态对象:  new Book() 获得

                       瞬时 -- 持久  save()  saveOrUpdate()

                       瞬时 -- 脱管  book.setId(1) ; 为瞬时对象设置OID

             2) 持久态对象:  get() / load()  、 Query、 Criteria  从数据库查询

                       持久 -- 瞬时  delete()

                       持久 -- 脱管  close() 、evict() 、clear()

             3) 脱管态对象  无法直接获得

                       脱管 -- 瞬时  book.setId(null); 移除对象OID

                       脱管 -- 持久  update() 、saveOrUpdate() 、 lock() 过时

    3 Session缓存(一级缓存)      

    Hibernate框架中提供两级缓存 SessionFactory级别的缓存、Session级别的缓存

             SessionFactory 级别的缓存 ---- 二级缓存 (外置,需要引入第三方插件)

             Session 级别缓存 ----- 一级缓存 (内置,直接使用 )

    l  在 Session 接口的实现中包含一系列的 Java 集合, 这些 Java 集合构成了 Session 缓存. 只要 Session 实例没有结束生命周期, 存放在它缓存中的对象也不会结束生命周期

    l  当session的save()方法持久化一个对象时,该对象被载入缓存,以后即使程序中不再引用该对象,只要缓存不清空,该对象仍然处于生命周期中。当试图get()、 load()对象时,会判断缓存中是否存在该对象,有则返回,此时不查询数据库。没有再查询数据库

    l  Session 能够在某些时间点, 按照缓存中对象的变化来执行相关的 SQL 语句, 来同步更新数据库, 这一过程被称为刷出缓存(flush)

    默认情况下 Session 在以下时间点刷出缓存

    a           当应用程序调用 Transaction commit()方法的时, 该方法先刷出缓存(session.flush()),    然后在向数据库提交事务(tx.commit())

    b           当应用程序执行一些查询操作时,如果缓存中持久化对象的属性已经发生了变化,会先         刷出缓存,以保证查询结果能够反映持久化对象的最新状态

    c           调用 Session 的 flush() 方法

    hibernate快照

             当session加载了customer对象后,会为customer对象的值类型的属性复制一份快照。当刷出缓存时,     通过比较对象的当前属性和快照,来判断对象的哪些属性发生了变化

    案例: 编程证明一级缓存是存在的

                       Session session =HibernateUtils.openSession();

                       Transaction transaction =session.beginTransaction();

                       // 所有持久态对象 都会被放入一级缓存

                       Book book = (Book)session.get(Book.class, 1); // 持久态 放入缓存

                       System.out.println(book);

                       // 再次执行查询 --- 直接使用一级缓存中数据(控制台上的查询语句仍是只有一句)

                       Book book2 = (Book)session.get(Book.class, 1);

                       System.out.println(book2);

                       transaction.commit();

                       session.close();

    案例 : 快照和缓存存储原理 ,测试快照自动 flush数据

                       Session session =HibernateUtils.openSession();

                       Transaction transaction =session.beginTransaction();

                       // 先将图书查询出

                       Book book = (Book)session.get(Book.class, 1);// 持久态

                       book.setPrice(200d); // 修改一级缓存对象数据

                       // 不调用update ,是否可以更新(有transaction.commit()就有flush操作,就能更新)

                       transaction.commit(); // 如果 不flush ,数据不会改变

                       session.close();

     

    一级缓存常见操作  flush 、evict 、clear 、refresh

             * flush 比较缓存数据和快照数据是否一致,如果改变,将缓存数据更新到数据库(快照也更新,不会      清除缓存数据)

             * clear 会清除所有一级缓存数据(所有持久对象都会变为脱管对象)

             * evict 清除指定对象的一级缓存数据(被清除的对象,由持久变为脱管)

             * refresh  使用数据库中数据去覆盖缓存和快照的数据

     

    一级缓存的flush 模式  FlushMode


             * 通过session.setFlushMode 设置一级缓存刷出时间点

             * 默认FlushModel.AUTO  在 Transaction.commit  Query查询  session.flush  执行数据flush

             刷出session.flush > Transaction.commit > Query 查询

             * COMMIT  会在 session.flush和 Transaction、commit

             * MANUAL  只会在session.flush时 执行数据flush

             如果 使用MANUAL 必须 调用session.flush 才会将缓存数据更新到数据库,transaction的commit 不        会flush数据

    ALWAYS和AUTO的区别

             当hibernate缓存中的对象被改动之后,会被标记为脏数据(即与数据库不同步了)。当 session设置为         FlushMode.AUTO时,hibernate在进行查询的时候会判断缓存中的数据是否为脏数据,是则刷数据库,     不是则不刷,而always是直接刷新,不进行任何判断。很显然auto比always要高效得多

     

    4、 持久化对象的操作

             1) save 方法  瞬时态对象 转换 持久态对象

             如果采用数据库主键自增策略,执行save方法时,第一时间将insert语句发送到数据库,获得生成id ,  保存瞬时对象中,成为持久对象。持久化对象 OID 不能随意修改

             2) update 方法 将脱管变为持久

              将数据更新到数据库, 放入一级缓存

              如果脱管数据和数据库是一样的,执行update就没有意义,但是update任然会执行。如果设置select-before-update 属性,就会在修改之前先查询

    *<classname="cn.itcast.domain.Book" table="book"catalog="hibernate3day2" select-before-update="true">

              如果更新脱管对象OID 在数据库不存在,就会发生如下异常 

              * org.hibernate.StaleObjectStateException: Row was updated or deleted byanother transaction (or unsaved-value mapping was incorrect):[cn.itcast.domain.Book#3]

              如果 更新脱管对象时,一级缓存中已经存在相同OID的持久对象, 会发生异常

              * org.hibernate.NonUniqueObjectException: a different object with thesame identifier value was already associated with the session:[cn.itcast.domain.Book#2]

             3) saveOrUpdate

                       如果操作目标对象,没有OID (OIDnull OID为设置unsaved-value),执行save

                       如果操作目标对象,存在OID ,执行update

             例:在Book.hbm.xml设置 <id name="id" unsaved-value="1000"> ,如果操作Book OID1000,框架会认为Book对象是一个瞬时对象       

        4) get 、load

             get 立即执行SQL语句,返回目标对象

             load 默认采用延迟加载机制,返回目标类子类对象 (代理对象),不会立即执行SQL语句,会在访问对象内除了id之外属性时执行SQL

             如果OID在目标数据库不存在,get立即执行返回 nullload 返回代理对象,访问对象的值时,抛出异常 ObjectNotFoundException

             5) delete 删除

             可以删除一个脱管对象或者一个持久对象的,对于单表操作删除脱管对象和持久对象无区别,对于多表操作有外键处理区别

                       * 原理:先将脱管对象转换为持久对象再删除

                                                            注:被删除对象不要再使用  

    展开全文
  • Hibernate持久化对象

    2013-12-29 16:31:00
    Hibernate对象状态:(1),瞬时(Transient)状态瞬时状态对象值由new操作符创建,且尚未与Hibernate Session关联的对象(即该对象尚未被Session对象的save()、update()等...持久化对象可能是刚刚刚被保存的(save(...

    Hibernate对象状态:
    (1),瞬时(Transient)状态
    瞬时状态对象值由new操作符创建,且尚未与Hibernate Session关联的对象(即该对象尚未被Session对象的save()、update()等方法持久化到数据库中去)
    (2),持久(Persistent)状态
    持久状态对象指与数据库表中的某一条记录相对应,已经获取持久化标志符的对象。持久化对象可能是刚刚刚被保存的(save()方法)或者刚刚被加载的(load()方法),无论哪一种情况,它仍存在于相关联的session作用范围内,也就是Session仍然可以对持久对象进行操作。
    (3),脱管(Detached)状态
    脱管状态指在Session作用范围之外的持久对象,与持久对象关联的Session被关闭之后,对象由持久状态变为脱管状态,脱管状态仍然可以被继续修改,如果重新关联到某个新的Session上,会再次转变为持久对象,同时所有修改将被持久化到数据库

    Cat.java

    class Cat
    {
    private Long id;
    private Date birthdate;
    private Color color;
    private char sex;
    private float weight;
    
    }

     

    Session方法介绍
    1,save()方法,功能是使瞬时状态持久化。
    2,load() 和get()方法,根据某个对象的持久化标志符来获取该对象
      Cat cat=(Cat)session.load(Cat.class.new Long(1));
      Cat cat1 = new Cat();//
      session.load(cat,new Long(1));
    3,update()方法
      使脱管对象持久化。
    4,savaOrUpdate()方法

      既能保存瞬时对象又可更新/重新关联脱管对象。

    5,delete()方法

      从数据库中删除与对象相对应的记录。

      session.delete(cat);

    Session的缓存

      可以理解为一个Hibernate应用中处于持久状态对象的集合,类似于计算机体系结构中的Cache。当Session的load()方法试图从数据库中加载某个对象时,Session首先会判断在缓存中是否已经存在这个对象了,(判断的标准是持久化标志符),如存在就不需要再到数据库中进行检索。

    Sssion的缓存清空是指将缓存内的持久化对象进行清除,持久对象在 缓存清空之后编结束其生命周期,一般在调用Session的close() 、clear()方法进行缓存的清空。

    Session的缓存清理是指每隔一段时间,Session执行一些必需的SQL语句将内存中的对象的状态同步到JDBC连接中,一般默认在调用org.hibernate.Transaction.commit()方法、Session的flush()方法以及执行某些查询时,进行缓存的清理。

    Transaction的commit()方法会首先调用fulsh方法,然后将事务提交。

    持久化对象的级联操作

    cascase这个属性的设置来实现Hibernate中的级联操作。如班级和学生,如果一个班级被删除,与之关联的所有学生对象也删除。

    Hibernate的缓存 

    分为Session的缓存和SessionFactory的缓存。Session的缓存是内置的无法被卸载,通常被称为Hibernate的一级缓存,SessionFactory的缓存分为内置和外置,SessionFactory的内置缓存和Session的缓存在实现方式上比较相似,SessionFactory对象的一些结婚属性包含的数据,存放了映射元素和预定义的SQL语句,其中映射元数据时映射文件中数据的拷贝,预定义SQL语句是在Hibernate初始化阶段根据映射元数据推导出来的。

    SessionFactory的外置缓存是一个可配置的插件,在默认情况下不启用这个插件,也被称为Hibernate的二级缓存。存储的介质可以是内存或者硬盘。

    持久化层的缓存的范围

    从缓存访问主题的角度来讲,一般会有三类角色会对缓存内的数据进行访问:事务、进程、集群。

    事务是原子的,进程可以有多个事务构成,这些事务可以并发访问数据对象。集群是由一个或多个机器的进程构成,数据对象将被复制到集群环境中的每个进程节点。

    持久化层的缓存的并发访问策略

    在进程范围或集群范围的缓存(二级缓存),会出现并发问题,设定以下四种类型的并发访问策略。每一种策略对应一种事务隔离级别:

    *事务型:“可重复读”的事务隔离级别。在受管理环境中适用。防止脏读和不可重复读这类的并发问题。

    *读写型:“读已提交数据”的事务隔离级别,在非集群环境中使用,对于经常被读但很少修改的数据,可以采用这种隔离类型。防止脏读。

    *非严格读写型:不保证缓存与数据库中数据的一致性。

    *只读型:对于从来不修改的数据。

     

     

     

    转载于:https://www.cnblogs.com/happinessqi/p/3496515.html

    展开全文
  • 现在有一个从数据库取出来的持久化对象,对象内包含了好多其他持久化对象的集合 我想把这个持久化对象及里面其他的对象全部深复制,然后再插入到数据库中,怎样实现好。。。
  • 关于如何手动创建HibernateHibernate初了解已经介绍了,接下来了解持久化对象和一级缓存。 Hibernate的持久化类有三种状态: 1、Transient瞬时态:持久化对象没有唯一标识OID,没有纳入Session的管理。 2、...

    关于如何手动创建Hibernate,Hibernate初了解已经介绍了,接下来了解持久化对象和一级缓存。

    Hibernate的持久化类有三种状态:

    1、Transient瞬时态:持久化对象没有唯一标识OID,没有纳入Session的管理。

      2、Persistent持久态:持久化对象有唯一标识OID,已经纳入到Session的管理,另外,持久化具有自动更新数据库的特点

      3、Detached脱管态:持久化对象有唯一标识OID,没有纳入到Session管理。

    下面给出一段代码来区分这三种状态:

     1 // 区分持久化对象的三种状态:
     2 public void demo1(){
     3     // 1.创建Session
     4     Session session = HibernateUtils.openSession();
     5     // 2.开启事务
     6     Transaction tx = session.beginTransaction();
     7     
     8     // 向数据库中保存一本图书:
     9     Book book = new Book();    // 瞬时态:没有唯一标识OID,没有与session关联.
    10     book.setName("Hiernate开发");
    11     book.setAuthor("孙XX");
    12     book.setPrice(65d);
    13     
    14     session.save(book); // 持久态:有唯一标识OID,与session关联.
    15     
    16     // 3.事务提交
    17     tx.commit();
    18     // 4.释放资源
    19     session.close();
    20     
    21     book.setName("Struts2开发"); // 脱管态:有唯一的标识,没有与session关联.
    22 }

    另外,三种状态对象的转换如下:

    瞬时态:
    	获得:
    	Book book = new Book();
    
    	瞬时--->持久
    	* save(book);
    	* save()/saveOrUpdate();
    	瞬时--->脱管
    	* book.setId(1);
    持久态:
    	获得:
    	Book book = (Book)session.get(Book.class,1);
    	* get()/load()/find()/iterate();
    
    	持久--->瞬时:
    	* delete(book);
    	* 特殊状态:删除态.(被删除的对象,不建议去使用.)
    
    	持久--->脱管:
    	* session.close();
    	* close()/clear()/evict();
    脱管态:
    	获得:
    	Book book = new Book();
    	book.setId(1);
    
    	脱管--->持久:
    	* session.update();
    	* update()/saveOrUpdate()/lock()
    
    	脱管--->瞬时:
    	* book.setId(null);
    

    上面我们提到了持久化对象具有自动更新数据库的特点,其根本原因是依赖于hibernate的一级缓存。

    在hibernate中,分成两个基本的缓存:

    一级缓存和二级缓存,其实还有个缓存,名为查询缓存,也有书籍把其命名为三级缓存,下面我就先介绍一级缓存。

    一级缓存:Session级别的缓存,一级缓存与session的生命周期一致,是自带的,不可卸载。

    至于缓存的好处,无非提高效率。

    演示:

     1 // 证明一级缓存的存在
     2 public void demo3(){
     3     // 1.创建Session
     4     Session session = HibernateUtils.openSession();
     5     // 2.开启事务
     6     Transaction tx = session.beginTransaction();        
     7     
     8     // save方法可以向一级缓存中存放数据的.
     9     /*Book book = new Book();
    10     book.setName("JQuery开发");
    11     book.setAuthor("张XX");
    12     book.setPrice(45d);
    13     
    14     Integer id = (Integer) session.save(book);
    15     
    16     Book book2 = (Book) session.get(Book.class, id); 
    17     
    18     System.out.println(book2);*/
    19     
    20     // 分别用get执行两次查询.
    21     Book book1 = (Book) session.get(Book.class, 1);// 马上发生SQL去查询
    22     System.out.println(book1);
    23     
    24     Book book2 = (Book) session.get(Book.class, 1);// 不发生SQL,因为使用一级缓存的数据
    25     System.out.println(book2);
    26     
    27     // 3.提交事务
    28     tx.commit();
    29     // 4.关闭资源
    30     session.close();

    当session加载了customer对象后,会为customer对象的值类型的属性复制一份快照,也就是在一级缓存中的快照区copy一份相同的数据。

    当刷出缓存时,通过比较对象的当前属性和快照,来判断对象的哪些属性发生了变化,如果数据一致,不更新,如果数据不一致,自动更新数据库。

    在hibernate中,我们可以通过一些方法来管理一级缓存:

    一级缓存是与session的生命周期相关的.session生命周期结束,一级缓存销毁了.

    clear()            :清空一级缓存中所有的对象.
    evict(Object obj)  :清空一级缓存中某个对象.
    flush()            :刷出缓存.
    refresh(Object obj):将快照区的数据重新覆盖了一级缓存的数据.

     另外,关于一级缓存的刷出时机

    FlushMode:
    * ALWAYS	    :每次查询的时候都会刷出.手动调用flush.事务提交的时候.
    * AUTO		    :默认值.有些查询会刷出.手动调用flush.事务提交的时候.
    * COMMIT	    :在事务提交的时候,手动调用flush的时候.
    * MANUAL	    :只有在手动调用flush才会刷出.
    

     严格程度:MANUAL > COMMIT > AUTO > ALWAYS

     

    转载于:https://www.cnblogs.com/lesliehe/p/8021814.html

    展开全文
  • Hibernate持久化对象修改id重新保存的办法——Hibernate学习记录二 2017年11月10日 20:16:48 筱光 阅读数:1122 版权声明:本文为博主原创文章,未经博主允许不得转载。 ...

    Hibernate持久化对象修改id重新保存的办法——Hibernate学习记录二

    版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/womeng2009/article/details/78502912

    昨天在工作中遇到一个特殊的场景,点击修改,对一条发布状态的记录进行复制,并生成一个草稿版本,也就是同一条记录的不同状态,也就出现需要从数据库get之后把id置空重新保存,这里出现一个问题,但Hibernate的持久化对象是无法对id进行修改操作的,需要重新new一个全新的对象存储才可以,但Java中的机制,如果采用new Object()并赋值的的方式并不是真的产生一个新的对象,而是引用赋值,即传递内存地址,学过C语言的很容易理解。

    要实现这种需求,就要复制出一个全新的对象,Java提供了一种解决办法——对象克隆。

    对象克隆的方法:

    实体类实现Cloneable接口,然后在实体类中重写clone()方法,以User类为例,如下所示:

    1. package com.domain;
    2.  
    3. /**
    4. * Created by Jiro.Chen on 2017/11/6.
    5. */
    6. public class User implements Cloneable {
    7. private String id;
    8. private String name;
    9. private Integer age;
    10. private String address;
    11.  
    12. public String getId() {
    13. return id;
    14. }
    15.  
    16. public void setId(String id) {
    17. this.id = id;
    18. }
    19.  
    20. public String getName() {
    21. return name;
    22. }
    23.  
    24. public void setName(String name) {
    25. this.name = name;
    26. }
    27.  
    28. public Integer getAge() {
    29. return age;
    30. }
    31.  
    32. public void setAge(Integer age) {
    33. this.age = age;
    34. }
    35.  
    36. public String getAddress() {
    37. return address;
    38. }
    39.  
    40. public void setAddress(String address) {
    41. this.address = address;
    42. }
    43.  
    44. public boolean equals(Object o) {
    45. if (this == o) return true;
    46. if (o == null || getClass() != o.getClass()) return false;
    47.  
    48. User user = (User) o;
    49.  
    50. if (id != null ? !id.equals(user.id) : user.id != null) return false;
    51. if (name != null ? !name.equals(user.name) : user.name != null) return false;
    52. if (age != null ? !age.equals(user.age) : user.age != null) return false;
    53. if (address != null ? !address.equals(user.address) : user.address != null) return false;
    54.  
    55. return true;
    56. }
    57.  
    58. public int hashCode() {
    59. int result = id != null ? id.hashCode() : 0;
    60. result = 31 * result + (name != null ? name.hashCode() : 0);
    61. result = 31 * result + (age != null ? age.hashCode() : 0);
    62. result = 31 * result + (address != null ? address.hashCode() : 0);
    63. return result;
    64. }
    65.  
    66. @Override
    67. public Object clone(){
    68. User user = null;
    69. try {
    70. user = (User) super.clone();
    71. } catch (CloneNotSupportedException e){
    72. e.printStackTrace();
    73. }
    74. return user;
    75. }
    76. }

    这样使用的时候,User user1 =  new User();    User user2 = user1.clone();即可将user1的所有属性值复制给user2,但他们是两个对象,而不是同一个对象的引用。之后可以进行id的修改,然后用Hibernate进行保存,生成一条新的记录。

    转载于:https://www.cnblogs.com/libin6505/p/10224595.html

    展开全文
  • 点击修改,对一条发布状态的记录进行复制,并生成一个草稿版本,也就是同一条记录的不同状态,也就出现需要从数据库get之后把id置空重新保存,这里出现一个问题,但Hibernate持久化对象是无法对id进行修改操作的,...
  • Hibernate操作持久化对象

    千次阅读 2016-09-20 10:51:56
    一、什么是[对象]持久化?  Java对象的状态可分为3类,如下图,即瞬时状态,持久化持久化状态。    简单说,在使用new关键字创建出一个对象时,就是瞬时状态;使用JDBC完成数据在持久和瞬时状态的转化;存储...
  • 一,持久化类  1,含义:一个Java类和数据库表建立了映射关系,那么这个类就是持久化类。  2,书写规范:  a,具有无参构造方法。因为Hibernate底层需要使用反射机制生成类的实例。  b,具有私有属性,并对...
  • 1,持久化对象 Hibernate是一个纯粹的ORM框架,通过Hibernate的支持,程序开发者只需要管理对象的状态,无须理会底层数据库系统细节。相对于常见的JDBC持久层方案中需要手工管理SQL语句,Hibernate采用完全面向...
  • 最近在使用Hibernate,读了读《Hibernate3和JPA程序开发——从入门到精通》这本书,发现其中的有些章节内容写的很好,在这里把自己... 1、关于持久化对象的状态 Hibernate中的持久化对象可能处于如下几种状态下: 暂
  • hibernate加载持久化对象的两种方式——get、load

    千次阅读 热门讨论 2014-05-28 08:51:09
     在hibernate中get和load方法是根据id取得持久化对象的两种方法,但在实际使用的过程中总会把两者混淆,不知道什么情况下使用get好,什么时候使用load方法效率更高。下边详细说一下get和load的不同,有些时候为了...
  • hibernate操作持久化对象是通过session缓存来实现的。 什么是缓存? 缓存介于应用程序和永久性存储源之间,他的作用是降低应用程序直接读写永久性存储源的频率,从而提高应用的运行效率; 缓存内的数据是永久性存储...
  • 二:hibernate持久化类和对象标识符

    千次阅读 2017-07-03 21:34:54
    hibernate持久化类和对象标识符 1.1持久化类的编写规范 1.1.1什么是持久化类: Hibernate是持久层的ORM映射框架,专注于数据的持久化工作。所谓的持久化,就是将内存中的数据永久存储到关系型数据库中。那么...
  • Hibernate持久化层的ORM映射框架,专注于数据的持久化工作。 持久化:所谓的持久化就是讲内存中的数据永久保存到关系型数据库中。 持久化类:其实所谓的持久化类指的是一个Java类与数据库表建立了映射关系,那么...
  •  在hibernate中get和load方法是根据id取得持久化对象的两种方法,但在实际使用的过程中总会把两者混淆,不知道什么情况下使用get好,什么时候使用load方法效率更高。下边详细说一下get和load的不同,有些时候为了...
  • Session和EntityManager代表的是持久化上下文,持久化对象的状态与持久化上下文和底层数据库都有关系 四种状态: 1.new和transient:new出来的对象,没有数据库标识符,也没有关联上持久化上下文 2.managed...
  • 深入理解hibernate持久化和序列化

    千次阅读 2013-06-18 19:11:33
    虽然平时经常用hibernate持久化类DO,但是仅限于随手逆向工程生成相应数据库表的持久化类,然后拿来用,根本就没有深入的去了解hibernate持久化和类的序列化的具体用法原理。闲来没事查查资料,再结合在实际应用...
  • hibernate复制对象

    千次阅读 2010-10-02 19:07:00
    hibernate复制对象
  • 1、持久化类编写规范 首先,什么是持久化持久化就是将数据保存到数据库中,这样数据就被“持久化”了。那么什么是持久化类?持久化类就是与数据库表建立了映射关系的Java类。 持久化类的编写规范实际上基本等同...
  • session接口是hibernate向应用程序提供的操纵数据库  8.1java对象在jvm中的生命周期
  • 使用Hibernate完成数据持久化 -了解Hibernate的基本原理 -学会编写实体配置文件 -熟练掌握使用Hibernate进行增删改查操作 -掌握在项目中使用Hibernate 为什么使用Hibernate?  代码精简...
  • 一、什么是序列 对象的寿命通常随着生成该对象的程序的...对象通过写出描述自己状态的数值(serialVersionUID)来记录自己 ,这个过程叫对象的串行(Serialization) 。串行的主要任务是写出对象实例变量的数值以
  •  Hibernate持久化对象存在三种状态: 瞬时态 transient:(临时态) 不存在持久化标识OID,尚未与Hibernate Session关联对象,被认为是瞬时状态,失去引用将被JVM回收。特点:无持久化标识OID,未与Session关联。 ...
  • hibernate.cfg.xml文件 Hibernate中最核心的配置文件 功能: 数据库方言的配置数据库连接参数的配置数据库连接池的配置加载对象...Session缓存和持久化生命周期 Session缓存称为一级缓存 原理: 当应用程序调用Se
  • 使用Hbm2JavaTask生成代码是非常容易的,比hibernate提供的schemaExport(配置文件到数据库)的使用容易得多。真不知道作者怎么搞的,把个schemaExport写得这么难...... 1.开始前的准备 1.1 准备hibernate-2.1.6.zip...
  •  当应用通过调用Hibernate API与框架发生交互时,需要从持久化的角度关注应用对象的生命周期。持久化生命周期是Hibernate中的一个关键概念,正确地理解生命周期,可以更好地了解Hiberate的实现原理,掌握Hibernte的...
  • Hibernate框架 Hibernate框架入门: Hibernate框架介绍以及入门 ...Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,它将POJO与数据库表建立映射关系,是一个全自动的orm框架,...
  • 持久化持久化类的简介 一般当一个类有与之对应的映射文件,那么该类就是就是一个持久化类 ...原因:final修饰的类无法被继承,但是load返回的是持久化类的子类的代理对象,如果使用final修饰...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,486
精华内容 6,594
关键字:

复制hibernate持久化对象