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映射配置
编写规则

①必须提供无参数public构造器
②所有属性private，提供public的getter和setter方法
③必须提供标识属性，与数据表中主键对应，例如Customer类 id属性
④PO类属性应尽量使用基本数据类型的包装类型(区分空值) 例如int---Integer long---Long
⑤不要用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中的配置:

#hibernate.transaction.factory_class net.sf.hibernate.transaction.JTATransactionFactory
#hibernate.transaction.factory_class net.sf.hibernate.transaction.JDBCTransactionFactory

如果你什么都不配置，默认情况下使用JDBCTransaction，如果你配置为：

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

#hibernate.transaction.factory_class net.sf.hibernate.transaction.JTATransactionFactory
#hibernate.transaction.factory_class net.sf.hibernate.transaction.JDBCTransactionFactory

在下面的分析中我会给出原因。

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

Session session = sf.openSession();
Transaction tx = session.beginTransactioin();
...
session.flush();
tx.commit();
session.close();

这是默认的情况，当你在代码中使用Hibernate的Transaction的时候实际上就是JDBCTransaction。那么JDBCTransaction究竟是什么东西呢？来看看源代码就清楚了：

Hibernate2.0.3源代码中的类

net.sf.hibernate.transaction.JDBCTransaction:
public void begin() throws HibernateException {
...
if (toggleAutoCommit) session.connection().setAutoCommit(false);
...
}

这是启动Transaction的方法，看到 connection().setAutoCommit(false) 了吗？是不是很熟悉？

再来看

public void commit() throws HibernateException {
...
try {
if ( session.getFlushMode()!=FlushMode.NEVER ) session.flush();
try {
session.connection().commit();
committed = true;
}
...
toggleAutoCommit();
}

这是提交方法，看到connection().commit() 了吗？下面就不用我多说了，这个类代码非常简单易懂，通过阅读使我们明白Hibernate的Transaction都在干了些什么？我现在把用 Hibernate写的例子翻译成JDBC，大家就一目了然了：

Connection conn = ...; <--- session = sf.openSession();
conn.setAutoCommit(false); <--- tx = session.beginTransactioin();
... <--- ...
conn.commit(); <--- tx.commit(); (对应左边的两句)
conn.setAutoCommit(true);
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 的查询缓存