[Java面试八]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 的查询缓存

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏IT技术精选文摘

Session管理之超时设置和强制下线

5425
来自专栏Linux驱动

C-fopen,fwrite,fread,fseek笔记

FILE * fopen(const char * path,const char * mode);

2292
来自专栏码农分享

代理模式(Proxy)

转载 https://blog.csdn.net/lovelion/article/details/8228042

1252
来自专栏Java帮帮-微信公众号-技术文章全总结

Web-第二十九天 Lucene&solr使用二【悟空教程】

Solrj和图形界面操作的区别就类似于数据库中使用jdbc和mysql客户端的区别一样。

1152
来自专栏Java技术分享

高并发分布式系统中生成全局唯一Id汇总

数据在分片时,典型的是分库分表,就有一个全局ID生成的问题。 单纯的生成全局ID并不是什么难题,但是生成的ID通常要满足分片的一些要求:    1 不能有单...

3185
来自专栏V站

SQL注入基础-基于Sqli-lab平台实战

有关SQL注入的各种定义阐述已经很多,大家可自行使用搜索引擎搜索即可,小东不再赘述。

2815
来自专栏我的小碗汤

听说你还没掌握Normalizer的使用方法?

在 Elasticsearch 中处理字符串类型的数据时,如果我们想把整个字符串作为一个完整的 term 存储,我们通常会将其类型 type 设定为 keywo...

1654
来自专栏程序员的SOD蜜

消息服务框架使用案例之--大文件上传(断点续传)功能

消息服务框架使用案例之--大文件上传(断点续传)功能 一、分块上传和断点续传原理 在我们的一个产品应用中,客户需要上传大量的文件到服务器,其中不乏很大的视频文件...

8955
来自专栏拂晓风起

“class”类型重定义 || 防止头文件重复加载 || 两个类之间互相引用

1724
来自专栏java学习

Hibernate学习笔记2

定义hbm.xml映射文件和pojo类时都需要定义主键,Hibernate中定义的主键类型包括:自然主键和代理主键:

1114

扫码关注云+社区

领取腾讯云代金券