Hibernate总结以及在面试中的一些问题.

 

1.为什么要使用Hibernate开发你的项目呢?Hibernate的开发流程是怎么样的?

为什么要使用
①.对JDBC访问数据库的代码做了封装,大大简化了数据访问层繁琐的重复性代码。 
②.Hibernate 是一个基于JDBC的主流持久化框架,是一个优秀的ORM 实现。他很大程度的简化DAO层的编码工作 
③.hibernate 的性能非常好,因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库,从一对一到多对多的各种复杂关系。
开发流程
 

2.什么是延迟加载?

    延迟加载机制是为了避免一些无谓的性能开销而提出来的,所谓延迟加载就是当在真正需要数据的时候,才真正执行数据加载操作。在Hibernate中提供了对实体对象的延迟加载以及对集合的延迟加载,另外在Hibernate3中还提供了对属性的延迟加载。

3.说一下hibernate的缓存机制

A:hibernate一级缓存 
(1)hibernate支持两个级别的缓存,默认只支持一级缓存; 
(2)每个Session内部自带一个一级缓存; 
(3)某个Session被关闭时,其对应的一级缓存自动清除; 
B:hibernate二级缓存 
(1) 二级缓存独立于session,默认不开启;

4.Hibernate的查询方式有哪些?

本地SQL查询、Criteria、Hql

5.如何优化Hibernate?

1.使用双向一对多关联,不使用单向一对多
2.灵活使用单向一对多关联
3.不用一对一,用多对一取代
4.配置对象缓存,不使用集合缓存
5.一对多集合使用Bag,多对多集合使用Set
6. 继承类使用显式多态
7. 表字段要少,表关联不要怕多,有二级缓存撑腰 

6.Hibernate中GET和LOAD的区别?

    请注意如果没有匹配的数据库记录,load()方法可能抛出无法恢复的异常(unrecoverable exception)。 如果类的映射使用了代理(proxy),load()方法会返回一个未初始化的代理,直到你调用该代理的某方法时才会去访问数据库。若你希望在某对象中创建一个指向另一个对象的关联,又不想在从数据库中装载该对象时同时装载相关联的那个对象,那么这种操作方式就用得上的了。 如果为相应类映射关系设置了batch-size, 那么使用这种操作方式允许多个对象被一批装载(因为返回的是代理,无需从数据库中抓取所有对象的数据)。 如果你不确定是否有匹配的行存在,应该使用 get()方法,它会立刻访问数据库,如果没有对应的行,会返回null。
    session.get 方法, 查询立即执行 , 返回Customer类对象
    session.load 方法,默认采用延迟加载数据方式,不会立即查询,返回 Customer类子类对象 (动态生成代理对象)
* 如果 PO类使用final修饰,load无法创建代理对象,返回目标对象本身 (load效果和 get效果 相同 ) 

7.说说在 hibernate中使用Integer做映射和使用int做映射之间有什么差别?

Integer code和int code的区别: 
Integer是对象.      code=null;   对象可以为空.    
int 是普通类型,     不可能=null.        
根据你的数据库code是可以空的,故应该映射成Integer.       
你没理由hbm.xml里写 Integer,类里却写int

8.SQL和HQL有什么区别?

sql 面向数据库表查询 
hql 面向对象查询 
  
hql:from 后面跟的 类名+类对象 where 后 用 对象的属性做条件 
sql:from 后面跟的是表名  where 后 用表中字段做条件 
查询 
在Hibernate中使用查询时,一般使用Hql查询语句。 
HQL(Hibernate Query Language),即Hibernate的查询语言跟SQL非常相像。不过HQL与SQL的最根本的区别,就是它是面向对象的。 
  
使用HQL时需要注意以下几点: 
1.大小写敏感 
因为HQL是面向对象的,而对象类的名称和属性都是大小写敏感的,所以HQL是大小写敏感的。
HQL语句:from Cat as cat where cat.id > 1;与from Cat as cat where cat.ID > 1;是不一样的,这点与SQL不同。
2.from子句 
from Cat,该句返回Cat对象实例,开发人员也可以给其加上别名,eg. from Cat as cat,对于多表查询的情况,可参考如下:
from Cat as cat, Dog as dog
其它方面都与SQL类似,在此不再赘述。

9.Hibernate的分页查询

例如:从数据库中的第20000条数据开始查后面100条记录 
Query q = session.createQuery("from Cat as c");;    
q.setMaxResults(100);;    
List l = q.list();; 
q.setFirstResult(20000);;  

10.Hibernate中Java对象的状态以及对应的特征有哪些?

持久化对象的三种状态 
    持久化对象PO和OID 
PO=POJO + hbm映射配置 
    编写规则 
  1. ①必须提供无参数public构造器
  2. ②所有属性private,提供public的getter和setter方法
  3. ③必须提供标识属性,与数据表中主键对应,例如Customer类 id属性
  4. ④PO类属性应尽量使用基本数据类型的包装类型(区分空值)  例如int---Integer  long---Long
  5. ⑤不要用final修饰(将无法生成代理对象进行优化)
OID 指与数据表中主键对应 PO类中属性,例如 Customer类 id属性
    Hibernate框架使用OID来区分不同PO对象 
        * 例如内存中有两个PO对象,只要具有相同 OID, Hibernate认为同一个对象 
    * Hibernate 不允许缓存同样OID的两个不同对象
     
①瞬时态(临时态、自由态):不存在持久化标识OID,尚未与Hibernate Session关联对象,被认为处于瞬时态,失去引用将被JVM回收 
②持久态:存在持久化标识OID,与当前session有关联,并且相关联的session没有关闭 ,并且事务未提交 
③脱管态(离线态、游离态):存在持久化标识OID,但没有与当前session关联,脱管状态改变hibernate不能检测到
 
    区分三种状态:判断对象是否有OID,判断对象是否与session关联(被一级缓存引用) 
// 获得Session
Session session =HibernateUtils.openSession();
// 开启事务
Transaction transaction = session.beginTransaction();
 
Book book =newBook();// 瞬时态(没有OID,未与Session关联)
book.setName("hibernate精通");
book.setPrice(56d);
 
session.save(book);// 持久态(具有OID,与Session关联)
 
// 提交事务,关闭Session
transaction.commit();
session.close();
 
System.out.println(book.getId());// 脱管态(具有 OID,与Session断开关联)
持久化对象状态转换
     
    ①瞬时态对象:通过new获得 
        瞬时----->持久    save、saveOrUpdate(都是session)
        瞬时----->脱管    book.setId(1) 为瞬时对象设置OID 
 
    ②持久态对象:通过get/load 、Query查询获得
持久----->瞬时    delete  (被删除持久化对象 不建议再次使用 )
持久----->脱管    evict(清除一级缓存中某一个对象)、close(关闭Session,清除一级缓存)、clear(清除一级缓存所有对象 )
 
    ③脱管态对象 无法直接获得
脱管----->瞬时    book.setId(null); 删除对象OID
脱管----->持久    update、saveOrUpdate、 lock(过时)

11.Hibernate中怎样处理事务?

Hibernate是对JDBC的轻量级对象封装,Hibernate本身是不具备Transaction 处理功能的,Hibernate的Transaction实际上是底层的JDBC Transaction的封装,或者是JTA Transaction的封装,下面我们详细的分析: 
Hibernate可以配置为JDBCTransaction或者是JTATransaction,这取决于你在hibernate.properties中的配置: 

  1. #hibernate.transaction.factory_class net.sf.hibernate.transaction.JTATransactionFactory
  2. #hibernate.transaction.factory_class net.sf.hibernate.transaction.JDBCTransactionFactory
如果你什么都不配置,默认情况下使用JDBCTransaction,如果你配置为:

hibernate.transaction.factory_class net.sf.hibernate.transaction.JTATransactionFactory 
将使用JTATransaction,不管你准备让Hibernate使用JDBCTransaction,还是JTATransaction,我的忠告就是什么都不配,将让它保持默认状态,如下:  

  1. #hibernate.transaction.factory_class net.sf.hibernate.transaction.JTATransactionFactory
  2. #hibernate.transaction.factory_class net.sf.hibernate.transaction.JDBCTransactionFactory
在下面的分析中我会给出原因。

一、JDBC Transaction 
看看使用JDBC Transaction的时候我们的代码例子: 

  1. Session session = sf.openSession();
  2. Transaction tx = session.beginTransactioin();
  3. ...
  4. session.flush();
  5. tx.commit();
  6. session.close();
这是默认的情况,当你在代码中使用Hibernate的Transaction的时候实际上就是JDBCTransaction。那么JDBCTransaction究竟是什么东西呢?来看看源代码就清楚了:

Hibernate2.0.3源代码中的类 

  1. net.sf.hibernate.transaction.JDBCTransaction:
  2. public void begin() throws HibernateException {
  3.     ...
  4.     if (toggleAutoCommit) session.connection().setAutoCommit(false);
  5.     ...
  6. }
这是启动Transaction的方法,看到 connection().setAutoCommit(false) 了吗?是不是很熟悉?

再来看 

  1. public void commit() throws HibernateException {
  2.     ...
  3.     try {
  4.         if ( session.getFlushMode()!=FlushMode.NEVER ) session.flush();
  5.     try {
  6.         session.connection().commit();
  7.         committed = true;
  8.     }
  9.     ...
  10.     toggleAutoCommit();
  11. }
这是提交方法,看到connection().commit() 了吗?下面就不用我多说了,这个类代码非常简单易懂,通过阅读使我们明白Hibernate的Transaction都在干了些什么?我现在把用 Hibernate写的例子翻译成JDBC,大家就一目了然了:
  1. Connection conn = ...; <--- session = sf.openSession();
  2. conn.setAutoCommit(false); <--- tx = session.beginTransactioin();
  3. ... <--- ...
  4. conn.commit(); <--- tx.commit(); (对应左边的两句)
  5. conn.setAutoCommit(true);
  6. conn.close(); <--- session.close();
    看明白了吧,Hibernate的JDBCTransaction根本就是conn.commit而已,根本毫无神秘可言,只不过在Hibernate中, Session打开的时候,就会自动conn.setAutoCommit(false),不像一般的JDBC,默认都是true,所以你最后不写 commit也没有关系,由于Hibernate已经把AutoCommit给关掉了,所以用Hibernate的时候,你在程序中不写 Transaction的话,数据库根本就没有反应。

12.简单的介绍一下Hibernate的核心API?

1.Configuration
    用于加载hibernate配置
    ①加载核心属性配置hibernate.properties和hibernate.cfg.xml
//方式一:去src 读取 hibernate.properties 属性配置文件
Configuration cfg =newConfiguration(); 
//方式二:去src读取 hibernate.cfg.xml  
Configuration cfg =newConfiguration().configure(); 
 Configuration cfg =newConfiguration().configure("自定义xml文件");去src 加载指定文件 
 
    ②手动加载hbm映射配置,持久化类与数据表的映射关系(*.hbm.xml 文件)
如果没有对PO类进行hbm映射,会报错 :
org.hibernate.MappingException:Unknown entity: cn.itcast.domain.Customer 
        那么我们可以手动加载其映射文件:
//方式一:
configuration.addResource("cn/itcast/domain/Customer.hbm.xml");加载hbm文件 
//方式二:
configuration.addClass(Customer.class);加载Class,自动搜索hbm映射文件
    * 如果使用 hibernate.cfg.xml配置,将映射配置xml中 <mapping resource="cn/itcast/domain/Customer.hbm.xml"/>
 
2.SessionFactory
    ①保存了当前的数据库配置信息和所有映射关系以及预定义的SQL语句这个对象是线程安全的
//预定义SQL语句
<sql-queryname="login">
    <![CDATA[select * from user where username= ? and password =?]]>
</sql-query>
3.Session
    代表hibernate操作会话对象,相当于Connection 
session是一个单线程对象,线程不安全(在方法内部定义和使用Session,不会出现线程问题)
* 每个线程方法调用栈,是线程私有的
session 进行PO(Persistent Object)对象常见持久化操作, 存在一级缓存
    常用API
save 完成插入
update 完成修改
delete完成删除
get/load 根据主键字段查询
createQuery、 createSQLQuery 创建查询对象Query接收HQL,SQLQuery接收SQL
createCriteria()  面向对象条件查询
4.Transaction 事务操作
commit 提交
rollback 回滚
 
    如果没有开启事务,那么每个Session的操作,都相当于一个独立的事务
* 事务是否提交
//默认false 
<property name="hibernate.connection.autocommit">false</property> 事务不提交
<propertyname="hibernate.connection.autocommit">true</property> 事务提交
5.Query
    session.createQuery()获得
面向对象查询,操作类,操作属性
接收参数 HQL语句
开发代码步骤
    获得HibernateSession对象
    编写HQL语句
    调用session.createQuery 创建查询对象
    如果HQL语句包含参数,则调用Query的setXXX设置参数
    调用Query对象的list()或uniqueResult()方法执行查询
6.Criteria 接口(QBC查询 Query By Criteria )
  主要为了解决多条件查询问题,以面向对象的方式添加条件,无需拼接HQL语句 

13.update与saveOrUpdate有什么区别?

save() 方法很显然是执行保存操作的,如果是对一个新的刚new出来的对象进行保存,自然要使用这个方法了,数据库中没有这个对象。 
update() 如果是对一个已经存在的托管对象进行更新那么肯定是要使用update()方法了,数据中有这个对象。 
saveOrUpdate() 这个方法是更新或者插入,有主键就执行更新,如果没有主键就执行插入。【此方法慎用】
    在Hibernate中saveOrUpdate()方法在执行的时候,先会去session中去找存不存在指定的字段,如果存在直接update,否则save,这个时候问题就发生了。 
    有两张表,表A和表B,这两张表的主键都是一样的,例如都是MASTER_ID,同时对应的BO里面属性都是masterID,现在要执行的操作是,以 MASTER_ID为条件将表A中的数据查询出来,然后将部分值插入到表B中,然后再更新表B,在查询表A后,session中已经存在masterID 了,这个时候再去对表B进行savaOrUpdate的时候,Hibernate会发现session中已经存在masterID了,所以执行的就是 update,但是实际上表B中根本不存在masterID这个值,当你执行完查询数据库的时候会发现没有插入数据,像这种情况,就得先用 masterID对表B进行查询,当返回的BO为NULL时,new一个新BO然后再进行插入,这个时候用到的就是createbo了。

14.Hibernate的inverse属性的作用?

1.明确inverse和cascade的作用  
inverse 决定是否把对对象中集合的改动反映到数据库中,所以inverse只对集合起作用,也就是只对one-to-many或many-to-many有效(因为只有这两种关联关系包含集合,而one-to-one和many-to-one只含有关系对方的一个引用)。 
cascade决定是否把对对象的改动反映到数据库中,所以cascade对所有的关联关系都起作用(因为关联关系就是指对象之间的关联关系)。

2.inverse属性 :inverse所描述的是对象之间关联关系的维护方式。 
inverse只存在于集合标记的元素中 。Hibernate提供的集合元素包括<set/> <map/> <list/> <array /> <bag /> 
Inverse属性的作用是:是否将对集合对象的修改反映到数据库中。 inverse属性的默认值为false,表示对集合对象的修改会被反映到数据库中;inverse=false 的为主动方,由主动方负责维护关联关系。  inverse=”true” 表示对集合对象的修改不会被反映到数据库中。为了维持两个实体类(表)的关系,而添加的一些属性,该属性可能在两个实体类(表)或者在一个独立的表里面,这个要看这双方直接的对应关系了: 这里的维护指的是当主控放进行增删改查操作时,会同时对关联关系进行对应的更新。 
   一对多: 该属性在多的一方。应该在一方的设置 inverse=true ,多的一方设置 inverse=false(多的一方也可以不设置inverse属性,因为默认值是false),这说明关联关系由多的一方来维护。如果要一方维护关 系,就会使在插入或是删除"一"方时去update"多"方的每一个与这个"一"的对象有关系的对象。而如果让"多"方面维护关系时就不会有update 操作,因为关系就是在多方的对象中的,直指插入或是删除多方对象就行了。显然这样做的话,会减少很多操作,提高了效率。
注:单向one-to-many关联关系中,不可以设置inverse="true",因为被控方的映射文件中没有主控方的信息。 
   多对多: 属性在独立表中。inverse属性的默认值为false。在多对多关联关系中,关系的两端 inverse不能都设为false,即默认的情况是不对的,如果都设为false,在做插入操作时会导致在关系表中插入两次关系。也不能都设为 true,如果都设为true,任何操作都不会触发对关系表的操作。因此在任意一方设置inverse=true,另一方inverse=false。 
   一对一: 其实是一对多的一个特例,inverse 的设置也是一样的,主要还是看关联关系的属性在哪一方,这一方的inverse=false。 
   多对一: 也就是一对多的反过来,没什么区别。

3.cascade属性 
级联操作:指当主控方执行某项操作时,是否要对被关联方也执行相同的操作。 
cascade属性的作用是描述关联对象进行操作时的级联特性。因此,只有涉及到关系的元素才有cascade属性。具有cascade属性的标记包括<many-to-one /> <one-to-one /> <any /> <set /><bag /> <idbag /> <list /> <array /> 
注意:<one-to-many />和 <many-to-many />是用在集合标记内部的,所以是不需要cascade属性的。 

4.inverse和cascade的区别 
作用的范围不同: 
    Inverse是设置在集合元素中的。 
    Cascade对于所有涉及到关联的元素都有效。 
    <many-to-one/><ont-to-many/>没有inverse属性,但有cascade属性 
执行的策略不同 
    Inverse 会首先判断集合的变化情况,然后针对变化执行相应的处理。 
    Cascade 是直接对集合中每个元素执行相应的处理 
执行的时机不同 
    Inverse是在执行SQL语句之前判断是否要执行该SQL语句 
    Cascade则在主控方发生操作时用来判断是否要进行级联操作 
执行的目标不同 
    Inverse对于<ont-to-many>和<many-to-many>处理方式不相同。 
    对于<ont-to-many>,inverse所处理的是对被关联表进行修改操作。 
    对于<many-to-many>,inverse所处理的则是中间关联表 
    Cascade不会区分这两种关系的差别,所做的操作都是针对被关联的对象。 
总结:  
<one-to-many> 
    <one-to-many>中,建议inverse=”true”,由“many”方来进行关联关系的维护 
    <many-to-many>中,只设置其中一方inverse=”false”,或双方都不设置 
    Cascade,通常情况下都不会使用。特别是删除,一定要慎重。 
操作建议:
    一般对many-to-one和many-to-many不设置级联,这要看业务逻辑的需要;对one-to-one和one-to-many设置级联。 
    many-to-many关联关系中,一端设置inverse=”false”,另一端设置为inverse=”true”。在one-to-many关联关系中,设置inverse=”true”,由多端来维护关系表
 

Hibernate一级缓存相关问题

1.Session中的一级缓存
    Hibernate框架共有两级缓存, 一级缓存(Session级别缓存)、二级缓存(SessionFactory级别缓存)
    在Session接口的实现中包含一系列的 Java 集合, 这些 Java 集合构成了 Session 缓存.  持久化对象保存Session一级缓存中(一级缓存引用持久化对象地址),只要 Session 实例没有结束生命周期, 存放在它缓存中的对象也不会结束生命周期
    Hibernate Session接口的实现类SessionImpl类(查看源码,右击session,选择Open Type Hierarchy) ,里面有2个重要的字段:
*private transient ActionQueue actionQueue;                       ----行动队列(标记数据活动)
*private transient StatefulPersistenceContext persistenceContext;----持久化上下文 
    当session的save()方法持久化一个对象时,该对象被载入缓存,以后即使程序中不再引用该对象,只要缓存不清空,该对象仍然处于生命周期中。当试图get()、 load()对象时,会判断缓存中是否存在该对象,有则返回,此时不查询数据库。没有再查询数据库
    Session 能够在某些时间点, 按照缓存中对象的变化来执行相关的 SQL 语句, 来同步更新数据库, 这一过程被称为刷出缓存(flush)
        *  Transaction的commit()
        *  应用程序执行一些查询操作时
        *  调用Session的flush()方法
 
    ①验证一级缓存的存在
Book book =(Book) session.get(Book.class,1);// 第一次查询,缓存中没有
System.out.println(book);
 
Book book2 =(Book) session.get(Book.class,1);// 因为第一次查询,对象已经被放入1级缓存,不会查询数据
System.out.println(book2);
 
*生成一条SQL语句,返回同一个对象,第一次查询生成SQL,查询对象,将对象放入一级缓存,第二次查询,直接从一级缓存获得
    
 
 
    ②测试Hibernate快照 (深入理解一级缓存内存结构原理)
    hibernate 向一级缓存放入数据时,同时保存快照数据(数据库备份),当修改一级缓存数据,在flush操作时,对比缓存和快照,如果不一致,自动更新(将缓存的内容同步到数据库,更新快照)
 
*  快照区使用,在Session 保存一份与数据库相同的数据,在session的flush时, 通过快照区比较得知一级缓存数据是否改变,如果改变执行对应操作(update)
/**
* 测试快照区的使用
  */
@Test
publicvoid demo3(){
    // 获得Session
Session session =HibernateUtils.openSession();
// 开启事务
Transaction transaction = session.beginTransaction();
 
// 查询id 为1 的图书对象
Book book =(Book) session.get(Book.class,1);// 第一次查询,将对象加入一级缓存
System.out.println(book);
 
book.setName("深入浅出Hibernate技术");// 修改书名(一级缓存被修改,自动update)
 
// 没有手动执行update,因为快照区原因,自动更新
 
// 提交事务,关闭Session
transaction.commit();
session.close();
}
    使用Debug模式进行截图说明:
    我们重点关注session中的2个属性actionQueue和persistenceContext
 
    大白话解析:
        **当执行get后,缓存里面有数据了,活动队列没有发生变化,说明没有需要提交到数据的内容,而PersistenceContext里面有内容了。
            我们说,持久化上下文里面存放的是一个Map,它的键为一级缓存对象,值为快照(它是一级缓存对象的一个副本)。 
        **当执行setName后,一级缓存里面的数据发生了改变,在缓存flush时,会对比缓存和快照,如果不一致,那么会将缓存中的内容同步到数据库,并更新快照!
 
*  Hibernate中 持久态 对象具有自动更新数据库能力 (持久态对象 才保存在 Session中,才有快照 )
 
2.一级缓存常见操作
    所有操作需要使用断点调试才能看得比较清楚!
    1)flush : 修改一级缓存数据针对内存操作,需要在session执行flush操作时,将缓存变化同步到数据库
     * 只有在缓存数据与快照区不同时,生成update语句
    2)clear : 清除所有对象 一级缓存
    3)evict : 清除一级缓存指定对象
    4)refresh :重新查询数据库,更新快照和一级缓存
@Test
// Session 对于 一级缓存操作
publicvoid demo4(){
// 获得Session
Session session =HibernateUtils.openSession();
// 开启事务
Transaction transaction = session.beginTransaction();
 
// 查询id 为1 的图书对象
Book book =(Book) session.get(Book.class,1);// 第一次查询,将对象加入一级缓存
System.out.println(book);
 
// book.setPrice(80d); // 修改一级缓存数据
// 将缓存内容同步到数据库
// session.flush();
 
// 清除一级缓存所有数据
// session.clear();
 
// 清除一级缓存中 指定对象
// session.evict(book);
 
book.setPrice(30d);// 一级缓存改变
session.refresh(book);// 用数据库内容 覆盖快照区和一级缓存
 
// 提交事务,关闭Session
transaction.commit();
session.close();
}
 
3.一级缓存刷出时间点设置 (FlushMode)
ALWAYS :在每次查询时,session都会flush  (不要求 )
AUTO   : 在有些查询时,session会flush  (默认)  ---------- 查询、commit 、session.flush
COMMIT : 在事务提交时,session会flush   ------- commit 、session.flush
MANUAL :只有手动调用  session.flush 才会刷出  ----  session.flush
 
刷出条件(时间点严格程度 )
MANUAL > COMMIT> AUTO> ALWAYS
@Test
// 理解 FlushMode作用
publicvoid demo5(){
// 获得Session
Session session =HibernateUtils.openSession();
 
// 设置 flushMode
session.setFlushMode(FlushMode.MANUAL);
 
// 开启事务
Transaction transaction = session.beginTransaction();
 
// 查询id 为1 的图书对象
Book book =(Book) session.get(Book.class,1);// 第一次查询,将对象加入一级缓存
System.out.println(book);
 
book.setPrice(1000d);// 修改价格
 
session.createQuery("from Book").list();// 查询所有图书 (AUTO 级别 flush)
 
// 提交事务,关闭Session
transaction.commit();// (COMMIT 级别 flush)
 
// session.flush(); // MANUAL 级别 flush
 
session.close();
}
 
4.session持久化对象操作方法
    1) save 将数据保存到数据库 , 将瞬时对象转换持久对象 
持久化对象,不允许随便修改 OID
 
    2) update 更新数据 ,主要用于脱管对象的更新(持久对象,可以根据快照自动更新 ), 将脱管对象转换持久对象        
@Test
// 脱管对象更新
publicvoid demo6(){
// 获得Session
Session session =HibernateUtils.openSession();
// 开启事务
Transaction transaction = session.beginTransaction();
 
Book book =newBook();// 瞬时
book.setId(1);// 脱管
book.setName("java入门");
book.setPrice(40d);
 
session.update(book);// 持久
 
session.flush();
 
// book.setPrice(50d);
 
// 提交事务,关闭Session
transaction.commit();
session.close();
}
        问题一: 调用update,默认直接生成update语句,如果数据没有改变,不希望生成update
    在hbm文件 <class>元素 添加 select-before-update="true"
<classname="cn.itcast.domain.firstcache.Book"table="book"catalog="hibernate3day2"select-before-update="true">
问题二: 当update,脱管对象变为持久对象, 一级缓存不允许出现相同OID 两个持久对象
@Test
// 一级缓存 存在两个相同OID 持久态对象 报错
publicvoid demo7(){
// 获得Session
Session session =HibernateUtils.openSession();
// 开启事务
Transaction transaction = session.beginTransaction();
 
// 查询
// Book b = (Book) session.get(Book.class, 1); // 持久
 
Book book =newBook();// 瞬时
book.setId(1);// 脱管
book.setName("java入门");
book.setPrice(50d);
session.update(book);// 持久
 
// 提交事务,关闭Session
transaction.commit();
session.close();
}
    org.hibernate.NonUniqueObjectException: a different object with the same identifier value was already associated with the session: [cn.itcast.domain.firstcache.Book#1]
问题三: 脱管对象 OID 在数据表中不存在,update时,发生异常
    org.hibernate.StaleObjectStateException: Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect): [cn.itcast.domain.firstcache.Book#20]
 
    3) saveOrUpdate , 如果参数是一个瞬时对象执行save, 如果参数是一个脱管对象执行update, 如果参数是持久对象直接返回
判断对象是瞬时对象 : OID为null , 在hbm文件中为 <id>元素指定 unsaved-value属性,如果PO对象OID为 unsaved-value 也是瞬时对象
<id name="id" unsaved-value="-1">  如果对象 OID为-1 也是瞬时对象,此时执行的是save操作
@Test
// PO对象,OID为 hbm文件 配置 unsaved-value 也是瞬时对象, saveOrUpdate 执行 save操作
publicvoid demo8(){
// 获得Session
Session session =HibernateUtils.openSession();
// 开启事务
Transaction transaction = session.beginTransaction();
 
Book book =newBook();// 瞬时
book.setId(-1);// 存在OID , -1是unsaved-value 也是瞬时
book.setName("xxx");
book.setPrice(100d);
 
session.saveOrUpdate(book);
 
// 提交事务,关闭Session
transaction.commit();
session.close();
}
 
    4) get/load
        如果查询OID不存在, get方法返回 null , load 方法返回代理对象 (代理对象初始化时抛出 ObjectNotFoundException )
 
    5) delete 方法既可以删除一个脱管对象, 也可以删除一个持久化对象
        **如果删除脱管,先将脱管对象 与 Session 关联,然后再删除
**执行delete,先删除一级缓存数据,在session.flush 操作时,删除数据表中数据
 

Hibernate二级缓存相关问题

1.二级缓存的相关介绍

缓存好处: 将数据库或者硬盘数据,保存在内存中,减少数据库查询次数,减少硬盘交互,提高检索效率

    hibernate 共有两个级别的缓存

        * 一级缓存,保存Session中, 事务范围的缓存

        * 二级缓存,保存SessionFactory ,进程范围的缓存

    SessionFacoty 两部分缓存

    内置 :Hibernate 自带的, 不可卸载. 通常在 Hibernate 的初始化阶段, Hibernate 会把映射元数据和预定义的 SQL 语句放到SessionFactory 的缓存中, 映射元数据是映射文件中数据的复制, 而预定义 SQL 语句时 Hibernate 根据映射元数据推到出来的. 该内置缓存是只读的.

 

    外置 :一个可配置的缓存插件. 在默认情况下, SessionFactory 不会启用这个缓存插件. 外置缓存中的数据是数据库数据的复制, 外置缓存的物理介质可以是内存或硬盘,必须引入第三方缓存插件才能使用。

 
2.二级缓存的内部结构以及存储特点
Hibernate二级缓存分为:   
    * 类缓存区域
    * 集合缓存区域 
    * 更新时间戳区域 
    * 查询缓存区域
 
 
类缓存区数据存储特点
* 从二级缓存区返回数据每次地址都是不同的(散装数据 )。每次查询二级缓存,都是将散装数据构造为一个新的对象 
 
集合缓存区
 
如果注释掉 Order类缓存,orders 集合无法缓存 
* 集合缓存区数据缓存依赖类缓存区数据缓存

 

** 一级缓存的操作会同步到二级缓存

更新时间戳区域

作用:记录数据最后更新时间,确保缓存数据是有效的

    Hibernate 提供了和查询相关的缓存区域:

    **时间戳缓存区域: org.hibernate.cahce.UpdateTimestampCache 
    时间戳缓存区域存放了对于查询结果相关的表进行插入, 更新或删除操作的时间戳.  Hibernate 通过时间戳缓存区域来判断被缓存的查询结果是否过期, 其运行过程如下: 
    T1 时刻执行查询操作, 把查询结果存放在 QueryCache 区域, 记录该区域的时间戳为 T1 
    T2 时刻对查询结果相关的表进行更新操作, Hibernate 把 T2 时刻存放在 UpdateTimestampCache 区域. 
    T3 时刻执行查询结果前, 先比较 QueryCache 区域的时间戳和 UpdateTimestampCache 区域的时间戳, 若 T2 >T1, 那么就丢弃原先存放在 QueryCache 区域的查询结果, 重新到数据库中查询数据, 再把结果存放到 QueryCache 区域; 若 T2 < T1, 直接从 QueryCache 中获得查询结果。
 
**更新时间戳区域,记录数据最后更新时间,在使用二级缓存时,比较缓存时间t1 与更新时间 t2 , 如果 t2 > t1 丢弃原来缓存数据,重新查询缓存
查询缓存
    有人称查询缓存 为hibernate 第三级缓存

* 二级缓存缓存数据都是类对象数据,数据都是缓存在 "类缓存区域" ,二级缓存缓存PO类对象,条件(key)是id

    查询缓存适用场合: 

        **应用程序运行时经常使用查询语句

        **很少对与查询语句检索到的数据进行插入, 删除和更新操作

    如果查询条件不是id查询, 缓存数据不是PO类完整对象 =====> 不适合使用二级缓存

查询缓存: 缓存的是查询数据结果, key是查询生成SQL语句  , 查询缓存比二级缓存功能更加强大

 
适用查询缓存的步骤
    1)配置二级缓存(查询缓存依赖二级缓存)

    2)启用查询缓存 hibernate.cfg.xml

 

<property name="hibernate.cache.use_query_cache">true</property>
    3)必须在程序中指定使用查询缓存

 

query.setCacheable(true);
 
3.二级缓存的并发策略

    transactional : 提供Repeatable Read事务隔离级别,缓存支持事务,发生异常的时候,缓存也能够回滚

    read-write    : 提供Read Committed事务隔离级别,更新缓存的时候会锁定缓存中的数据

    nonstrict-read-write :导致脏读, 很少使用

    read-only     : 数据不允许修改,只能查询

* 很少被修改,不是很重要,允许偶尔的并发问题, 适合放入二级缓存。考虑因素(二级缓存的监控【后面学习】,它是是否采用二级缓存主要参考指标)

4.Hibernate支持哪些二级缓存技术? 
    *  EHCache  (主要学习,支持本地缓存,支持分布式缓存)
        可作为进程范围内的缓存, 存放数据的物理介质可以是内存或硬盘, 对 Hibernate 的查询缓存提供了支持。 
    *  OSCache 
        可作为进程范围内的缓存, 存放数据的物理介质可以是内存或硬盘, 提供了丰富的缓存数据过期策略, 对 Hibernate 的查询缓存提供了支持 
    *  SwarmCache 
        可作为集群范围内的缓存, 但不支持 Hibernate 的查询缓存 
    *  JBossCache 
        可作为集群范围内的缓存, 支持 Hibernate 的查询缓存