Hibernate 面试中最常考察的知识点整合

对于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的实现原理

Dao
{
hashmapmap=newmap();
UsergetUser(integerid)
{
Useruser=map.get(id)
if(user==null)
{
user=session.get(id);
map.put(id,user);
}
returnuser;
}
}

Dao
{
Cachecache=null
setCache(Cachecache)
{
this.cache=cache
}

UsergetUser(intid)
{
if(cache!=null)
{
Useruser=cache.get(id);
if(user==null)
{
user=session.get(id);
cache.put(id,user);
}
returnuser;
}

returnsession.get(id);
}
}

Dao
{
    hashmap map = new map();
    User getUser(integer id)
    {
        User user = map.get(id)
        if(user == null)
        {
            user = session.get(id);
            map.put(id,user);
        }
        return user;
    }
}

Dao
{
    Cache cache = null
    setCache(Cache cache)
    {
        this.cache = cache
    }
   
    User getUser(int id)
    {
        if(cache!=null)
        {
            User user = cache.get(id);
            if(user ==null)
            {
                user = session.get(id);
                cache.put(id,user);
            }
            return user;
        }
       
        return session.get(id);
    }
}

（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来更改当前数据库中的数据，这样缓存的数据就会与数据库中的实际数据不一致。