Hibernate学习之------>Hibernate 面试中最常考察的知识点整合

  1. 云栖社区>
  2. 博客>
  3. 正文

Hibernate学习之------>Hibernate 面试中最常考察的知识点整合

欧阳鹏 2013-03-28 23:24:10 浏览529
展开阅读全文

  对于Hibernate,面试官最想知道的无非是以下总结这这十多个问题,每个问题都有详细的答案,如果都完全掌握以下的这些问题,那面试时问及Hibernate你还用怕什么呢?让自信伴随着你第一次冲刺吧!

一、简述 Hibernate 和 JDBC 的区别、优缺点?

JDBC与Hibernate在性能上相比,JDBC灵活性有优势。而Hibernate在易学性,易用性上有些优势。当用到很多复杂的多表联查和复杂的数据库操作时,JDBC有优势。
相同点:
◆两者都是JAVA的数据库操作中间件。

◆两者对于数据库进行直接操作的对象都不是线程安全的,都需要及时关闭。

◆两者都可以对数据库的更新操作进行显式的事务处理。

不同点:
◆使用的SQL语言不同:JDBC使用的是基于关系型数据库的标准SQL语言,Hibernate使用的是HQL(Hibernate query language)语言

◆操作的对象不同:JDBC操作的是数据,将数据通过SQL语句直接传送到数据库中执行,Hibernate操作的是持久化对象,由底层持久化对象的数据更新到数据库中。

◆数据状态不同:JDBC操作的数据是“瞬时”的,变量的值无法与数据库中的值保持一致,而Hibernate操作的数据是可持久的,即持久化对象的数据属性的值是可以跟数据库中的值保持一致的。

JDBC与Hibernate读取性能

1、JDBC仍然是最快的访问方式,不论是Create还是Read操作,都是JDBC快。

2、Hibernate使用uuid.hex构造主键,性能稍微有点损失,但是不大。

3、Create操作,JDBC在使用批处理的方式下速度比Hibernate快,使用批处理方式耗用JVM内存比不使用批处理方式要多得多。

4、读取数据,Hibernate的Iterator速度非常缓慢,因为他是每次next的时候才去数据库取数据,这一点从观察任务管理器的java进程占用内存的变化也可以看得很清楚,内存是几十K几十K的增加。

5、读取数据,Hibernate的List速度很快,因为他是一次性把数据取完,这一点从观察任务管理器的java进程占用内存的变化也可以看得很清楚,内存几乎是10M的10M的增加。

6、JDBC读取数据的方式和Hibernate的List方式是一样的(这跟JDBC驱动有很大关系,不同的JDBC驱动,结果会很不一样),这 从观察java进程内存变化可以判断出来,由于JDBC不需要像Hibernate那样构造一堆Cat对象实例,所以占用JVM内存要比 Hibernate的List方式大概少一半左右。

7、Hibernate的Iterator方式并非一无是处,它适合于从大的结果集中选取少量的数据,即不需要占用很多内存,又可以迅速得到结果。另外Iterator适合于使用JCS缓冲。

附加说明:实际上,不管CMP,Hibernate,JDO等等,所有的ORM都是对JDBC的封装,CMP则是一个重量级封装,JDO中度封 装,Hibernate是轻量级的封装。从理论上来说,ORM永远也不可能比JDBC性能好。就像任何高级语言的运行性能永远也不会好过汇编语言一个道 理。

对于Create和Update操作来说,由于普通的Java程序员未必会使用JDBC的Batch的功能,所以Hibernate会表现出超过JDBC的运行速度。

对于Read的操作来说,ORM普遍都会带有双层缓冲,即PrepreadStatement缓冲和ResultSet缓冲,而JDBC本身没有缓 冲机制,在使用连接池的情况下,一些连接池将会提供PrepreadStatement缓冲,有的甚至提供ResultSet缓冲,但是普遍情况 下,Java程序员一般都不会考虑到在写JDBC的时候优化缓冲,而且这样做也不太现实,所以在某些情况下,ORM会表现出超过JDBC的Read速度。

 

二、Hibernate三种状态的区分;

对于Hibernate,它的对象有三种状态,transient、persistent、detached
◆transient:瞬态或者自由态(new Data("没关联到Session前"),该po的实例和session没有关联,该po的实例处于transient)
◆persistent:持久化状态(和数据库中记录相射的Po实例,即数据库表中有条记录是对应于这个对象的。它的状态是persistent, 通过get和load等得到的对象都是persistent)
◆detached:脱管状态或者游离态
(1)当通过get或load方法得到的po对象它们都处于persistent,但如果执行delete(po)时(但还没执行事务),该 po状态就处于detached, (表示和session脱离关联),因delete而变成游离态可以通过save或saveOrUpdate()变成持久态
(2)当一个session执行close()或clear()、evict()之后,session缓存中的persistent的po对象也变成detached,此时持久对象会变成脱管对象,此时该对象虽然具有数据库识别值,但它已不在HIbernate持久层的管理之下。

 

三、hibernate中的update()和saveOrUpdate()的区别?

(1)update() 更新,没有主键会报错的,saveOrUpdate() 保存或更新, 没有主键就执行插入。
(2)Update:是对暂态(transient )或是只是脱管(detached)的更新操作,对于暂态对象的更新操作通常不产生效果,对于脱 管对象是做了同步的操作,即数据库的数据发生变化并且对象状态也成为托管对象
 SaveOrUpdate : 也是对暂态(transient )或是只是脱管(detached)的进行操作,至于是插入还是更新,则要根据(identifier)id 中指定的一些具体条件来分析,如果对象没有持久化标识(identifier)属性,对其调用save() ,否则update() 这个对象 。
(3)如果该po对象已经在本session中持久化了,在本session中执行saveOrUpdate(po)不做任何事
如果savaOrUpdate(给定id的新po)与另一个与本session关联的po对象拥有相同的持久化标识(identifier),抛出一个NonUniqueObjectException异常 :a different object with the same identifier value was already associated with the session。

 

四、Hibernate.update()和merge()区别?

前面说过update,基本merge和update一样。但如果session中存在相同持久化标识(identifier)的实例,用用户给出的对象覆盖session已有的持久实例
(1)当我们使用update的时候,执行完成后,会抛出异常
(2)但当我们使用merge的时候,把处理自由态的po对象A的属性copy到session当中处于持久态的po的属性中,执行完成后原来是持久状态还是持久态,而我们提供的A还是自由态。

 

五、Hibernate update和flush区别?

Hibernate update操作的是在自由态或脱管状态(因session的关闭而处于脱管状态)的对象,而flush是操作的在持久状态的对象。

默认情况下,一个持久状态的对象的改动(包含set容器)是不需要update的,只要你更改了对象的值,等待Hibernate flush就自动更新或保存到数据库了。
(1) 调用某些查询的和手动flush(),session的关闭、SessionFactory关闭结合。get()一个对象,把对象的属性进行改变,把资源关闭。
(2)transaction commit的时候(包含了flush) 。

 

六、Hibernate session的load()和get()的区别?

1:如果你使用load方法,hibernate认为该id对应的对象(数据库记录)在数据库中是一定存在的,所以它可以放心的使用,它可以放心的使用代理来延迟加载该对象。在用到对象中的其他属性数据时才查询数据库,但是万一数据库中不存在该记录,那没办法,只能抛异常,所说的load方法抛异常是指在使用该对象的数据时,数据库中不存在该数据时抛异常,而不是在创建这个对象时。由于session中的缓存对于hibernate来说是个相当廉价的资源,所以在load时会先查一下session缓存看看该id对应的对象是否存在,不存在则创建代理。所以如果你知道该id在数据库中一定有对应记录存在就可以使用load方法来实现延迟加载。 对于get方法,hibernate会确认一下该id对应的数据是否存在,首先在session缓存中查找,然后在二级缓存中查找,还没有就查数据库,数据库中没有就返回null(网上有很多误解以为get就马上去数据库查找根本不先查session那是不正确的,不想信你就去做下试验便知)。

2、“get()永远只返回实体类”,但实际上这是不正确的,get方法如果在session缓存中找到了该id对应的对象,如果刚好该对象前面是被代理过的,如被load方法使用过,或者被其他关联对象延迟加载过,那么返回的还是原先的代理对象,而不是实体类对象,如果该代理对象还没有加载实体数据(就是id以外的其他属性数据),那么它会查询二级缓存或者数据库来加载数据,但是返回的还是代理对象,只不过已经加载了实体数据。

3、再注重说明get方法首先查询session缓存,没有的话查询二级缓存,最后查询数据库;反而load方法创建时首先查询session缓存,没有就创建代理,实际使用数据时才查询二级缓存和数据库。

总之对于get和load的根本区别,一句话,hibernate对于load方法认为该数据在数据库中一定存在,可以放心的使用代理来延迟加载,如果在使用过程中发现了问题,只能抛异常;而对于get方法,hibernate一定要获取到真实的数据,否则返回null。

 

七、Hibernate List和Iterator方式的比较

(1)、List方式是1次性把所有的数据全部取到内存中,构造一个超大的结果集,主要的时间开销是这一步,这一步的时间开销要远远超过JDBC和 Iterator方式下构造结果集的时间开销,并且内存开销也很惊人;而对结果集的遍历操作,速度则是非常的惊人(经过测试,30万记录的内 存遍历不到100ms,由于这一步不受JDBC影响,因此结果可信)。因此,List方式适合于对结果集进行反复多次操作的情况,例如分页显示,往后往前 遍历,跳到第一行,跳到最后一行等等。

(2)、Iterator方式只取记录id到内存中,并没有把所有数据取到内存中,因此构造结果集的时间开销很小,比JDBC和List方式都要少,并且内 存开销也小很多。而对结果集的遍历的操作的时候,Iterator仍然要访问数据库,所有主要的时间开销都花在这里。因此,Iterator方式适合于只 对结果集进行1次遍历操作的情况,并且Iterator方式特别适合于从超大结果集中取少量数据,这种情况Iterator性能非常好。

 

八、hibernate的inverse属性的作用?

在Hibernate中,术语inverse是反转的意思,在关联关系中,inverse="false"为主控方,由主控方负责维护对象的关联关系。
inverse 决定是否把对对象中集合的改动反映到数据库中,所以inverse只对集合起作用,也就是只对one-to-many或many-to-many有效(因 为只有这两种关联关系包含集合,而one-to-one和many-to-one只含有关系对方的一个引用,注意一般只在双向关联时才有需要设置inverse)。
(1)、一对多:
通常会在的one一方放弃对多的关系的维护,这样效率会高起来(如老师记住每位学生是件困难的事情,效率是很低的,所以干脆就不记了,这关系由学生来维护,学生记住一位老师是很容易)
 所以应该在一方的设置 inverse=true ,多的一方设置 inverse=false(多的一方也可以不设置inverse属性,因为默认值是false),这说明关联关系由多的一方来维护。
如果要一方维护关系,就会使在插入或是删除"一"方时去update"多"方的每一个与这个"一"的对象有关系的对象。
而如果让"多"方面维护关系时就不会有update操作,因为关系就是在多方的对象中的,直指插入或是删除多方对象就行了。
显然这样做的话,会减少很多操作,提高了效率。
注:单向one-to-many关联关系中,不可以设置inverse="true",因为被控方的映射文件中没有主控方的信息。

(2)、多对多: 属性在独立表中。inverse属性的默认值为false。在多对多关联关系中,关系的两端 inverse不能都设为false,即默认的情况是不对的,如果都设为false,在做插入操作时会导致在关系表中插入两次关系。也不能都设为 true,如果都设为true,任何操作都不会触发对关系表的操作。因此在任意一方设置inverse=true,另一方inverse=false。

 

九、hibernate的cascade属性的作用?

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

 

 

十、各种关联关系下的lazy懒加载区别?

1、one-to-one懒加载
 一对一的懒加载并不常用,因为懒加载的目的是为了减少与数据库的交互,从而提高执行效率,而在一对一关系中,主表中的每一条数据只对应从表的一条数据库,就算都查询也不会增加多少交互的成本,而且主表不能有contrained=true,所以主表是不能懒加载的。但是从表可以有。
    实现此种懒加载必须在从对象这边同时满足三个条件:
    1、lazy!=false(lazy的属性有三个选项分别为:no-proxy、false和proxy)
    2、Constrained = true ;
    3、fetch=select。

 注:当fetch设置为join时,懒加载就会失效。因为fetch的作用是抓取方式,他有两个值分别为select和join,默认值为select。即在设为join时,他会直接将从表信息以join方式查询到而不是再次使用select查询,这样导致了懒加载的失效。

2、one-to-many懒加载
    与one-to-one关联不同,对one-to-many而言,主表的每一条属性都会对应从表的多条数据,这个时候懒加载就显得非常有效了。比如一个部门里面有多个员工,如果没有懒加载,每查询这个部门的时候都会查询出多个员工,这会大大增加与数据库交互的成本。所以Hbernate默认的是加入懒加载的。这就是查询集合属性的时候返回的是一个PersistentIndexed*类型对象的原因。该对象其实就是一个代理对象。当然,可以在映射文件中通过将lazy属性设为假来禁用。
  Hibernate默认对one-to-many就是使用的懒加载,但用户也可以取消懒加载操作:
     一:设置lazy=”false”;
     二:设置fetch=”join”.

实现此种懒加载必须在从对象这边同时满足两个条件:
   1、lazy!=false(lazy的属性有三个选项分别为:no-proxy、false和proxy)
    2、fetch=select。

3、many-to-one懒加载

此关联关系的懒加载和one-to-one的懒加载一样都是可要可不要的,因为对执行效率的提高都不是非常明显。虽然多对一与一对一关系方式相同,但是在Hibernate中多对一时,默认是进行懒加载的。另外有一点需要注意的是懒加载并不会区分集合属性里面是否有值,即使是没有值,他依然会使用懒加载。

实现此种懒加载必须在从对象这边同时满足两个条件
   1、lazy!=false(lazy的属性有三个选项分别为:no-proxy、false和proxy)
    2、fetch=select

4、many-to-many懒加载

此关联关系的懒加载和one-to-many的懒加载一样对程序的执行效率的提高都是非常明显的。
   实现此种懒加载必须在从对象这边同时满足两个条件:
     1、lazy!=false(lazy的属性有三个选项分别为:no-proxy、false和proxy)
     2、fetch=select

能够懒加载的对象都是被改过的代理对象,当相应的对象没有关闭时,访问这些懒加载对象的属性(getId和getClass除外)Hibernate会初始化这些代理,或用hibernate.initalize(proxy)来初始化代理对象;当关闭session后在访问懒加载的对象就会出现异常。

 

 

 

十一、hibernate中lazy的使用中的区别?

Lazy的有效期:只有在session打开的时候才有效;session关闭后lazy就没效了。

lazy策略可以用在:

◆ <class>标签上:可以取值true/false

◆<property>标签上,可以取值true/false,这个特性需要类增强

◆<set>/<list>等集合上,可以取值为true/false/extra

◆<one-to-one>/<many-to-one>等标签上,可以取值false/proxy/no-proxy

6.1 get和load的区别:

◆get不支持延迟加载,而load支持。

◆当查询特定的数据库中不存在的数据时,get会返回null,而load则抛出异常。

6.2 类(Class)的延迟加载:

◆设置<class>标签中的lazy="true",或是保持默认(即不配置lazy属性)

◆ 如果lazy的属性值为true,那么在使用load方法加载数据时,只有确实用到数据的时候才会发出sql语句;这样有可能减少系统的开销。
  注意:在class标签上配置的lazy属性不会影响到关联对象!!!

 

十二、iBatis与Hibernate有什么不同?

相同点:屏蔽jdbc api的底层访问细节,使用我们不用与jdbc api打交道,就可以访问数据。
jdbc api编程流程固定,还将sql语句与java代码混杂在了一起,经常需要拼凑sql语句,细节很繁琐。
ibatis的好处:屏蔽jdbc api的底层访问细节;将sql语句与java代码进行分离;提供了将结果集自动封装称为实体对象和对象的集合的功能,queryForList返回对象集合,用queryForObject返回单个对象;提供了自动将实体对象的属性传递给sql语句的参数。

Hibernate是一个全自动的orm映射工具,它可以自动生成sql语句,ibatis需要我们自己在xml配置文件中写sql语句,hibernate要比ibatis功能负责和强大很多。因为hibernate自动生成sql语句,我们无法控制该语句,我们就无法去写特定的高效率的sql。对于一些不太复杂的sql查询,hibernate可以很好帮我们完成,但是,对于特别复杂的查询,hibernate就很难适应了,这时候用ibatis就是不错的选择,因为ibatis还是由我们自己写sql语句。

 

 

十三、介绍一下Hibernate的二级缓存

 

按照以下思路来回答:(1)首先说清楚什么是缓存,(2)再说有了hibernate的Session就是一级缓存,即有了一级缓存,为什么还要有二级缓存,(3)最后再说如何配置Hibernate的二级缓存。
(1)缓存就是把以前从数据库中查询出来和使用过的对象保存在内存中(一个数据结构中),这个数据结构通常是或类似Hashmap,当以后要使用某个对象时,先查询缓存中是否有这个对象,如果有则使用缓存中的对象,如果没有则去查询数据库,并将查询出来的对象保存在缓存中,以便下次使用。下面是缓存的伪代码:
引出hibernate的第二级缓存,用下面的伪代码分析了Cache的实现原理

Java代码  收藏代码
  1. Dao  
  2. {  
  3.     hashmap map = new map();  
  4.     User getUser(integer id)  
  5.     {  
  6.         User user = map.get(id)  
  7.         if(user == null)  
  8.         {  
  9.             user = session.get(id);  
  10.             map.put(id,user);  
  11.         }  
  12.         return user;  
  13.     }  
  14. }  
  15.   
  16. Dao  
  17. {  
  18.     Cache cache = null  
  19.     setCache(Cache cache)  
  20.     {  
  21.         this.cache = cache  
  22.     }  
  23.      
  24.     User getUser(int id)  
  25.     {  
  26.         if(cache!=null)  
  27.         {  
  28.             User user = cache.get(id);  
  29.             if(user ==null)  
  30.             {  
  31.                 user = session.get(id);  
  32.                 cache.put(id,user);  
  33.             }  
  34.             return user;  
  35.         }  
  36.          
  37.         return session.get(id);  
  38.     }  
  39. }  

 
(2)Hibernate的Session就是一种缓存,我们通常将之称为Hibernate的一级缓存,当想使用session从数据库中查询出一个对象时,Session也是先从自己内部查看是否存在这个对象,存在则直接返回,不存在才去访问数据库,并将查询的结果保存在自己内部。由于Session代表一次会话过程,一个Session与一个数据库连接相关连,所以Session最好不要长时间保持打开,通常仅用于一个事务当中,在事务结束时就应关闭。并且Session是线程不安全的,被多个线程共享时容易出现问题。通常只有那种全局意义上的缓存才是真正的缓存应用,才有较大的缓存价值,因此,Hibernate的Session这一级缓存的缓存作用并不明显,应用价值不大。Hibernate的二级缓存就是要为Hibernate配置一种全局缓存,让多个线程和多个事务都可以共享这个缓存。我们希望的是一个人使用过,其他人也可以使用,session没有这种效果。
(3)二级缓存是独立于Hibernate的软件部件,属于第三方的产品,多个厂商和组织都提供有缓存产品,例如,EHCache和OSCache等等。在Hibernate中使用二级缓存,首先就要在hibernate.cfg.xml配置文件中配置使用哪个厂家的缓存产品,接着需要配置该缓存产品自己的配置文件,最后要配置Hibernate中的哪些实体对象要纳入到二级缓存的管理中。明白了二级缓存原理和有了这个思路后,很容易配置起Hibernate的二级缓存。扩展知识:一个SessionFactory可以关联一个二级缓存,也即一个二级缓存只能负责缓存一个数据库中的数据,当使用Hibernate 的二级缓存后,注意不要有其他的应用或SessionFactory来更改当前数据库中的数据,这样缓存的数据就会与数据库中的实际数据不一致。

网友评论

登录后评论
0/500
评论
欧阳鹏
+ 关注