Hibernate面试题部分汇总集合

此文档主要简绍J2EE中的hibernate面试突击问题部分集合

Hibernate常见的面试问题

Hibernate

1．Hibernate简介？

Hibernate是一个开源的对象关系映射框架，它对JDBC进行了非常轻量级的 对象封装，使得Java程序员可以随心所欲的使用面向对象编程思想来操纵数据库。

2．Hibernate工作原理？及为什么要用？

Hibernate是一个JDO工具。它的工作原理是通过文件把值对象和数据库表之间建立起一个映射关系，这样，我们只需要通过操作这些值对象和Hibernate 提供的一些基本类，就可以达到使用数据库的目的。

1）对JDBC操作提供封装,方便操作简化数据库访问的代码，使用面向对象的方式操作DAO；

2）简化DAO层的代码量ORM从关系型DB到面向对象(java)的转变 ；

3）在java代码中充斥着大量的sql语句不便于维护,但是ORM映射可以减少此类代码,便于维护 ；

3．Hibernate的优点和缺点？

⑴Hibernate的优点：

1).Hibernate使用Java反射机制，而不是字节码增强程序来实现透明性；

2).Hibernate的性能非常好，因为它是一个轻量级框架。映射的灵活性很出色；

3).它支持多种关系数据库，从一对一到多对多的各种复杂关系；

(2)Hibernate的缺点：

它限制您所使用的对象模型，如一个持久性类不能映射到多个表，其独有的 界面和可怜的市场份额也让人不安。

4．Hibernate的缓存机制？

Hibernate的缓存包括Session的缓存和SessionFactory的缓存，其中 SessionFactory的缓存又可以分为两类：内置缓存和外置缓存。Session的缓存是内置的，不能被卸载，也被称为Hibernate的第一级缓存。SessionFactory的内置缓存中存放了映射元数据和预定义SQL语句，SessionFactory的内置缓存是只读的，应用程序不能修改缓存中的映射元数据和预定义SQL语句，因此SessionFactory不需要进行内置缓存与映射文件的同步。SessionFactory的外置缓存是一个可配置的插件。在默认情况下，SessionFactory不会启用这个插

此文档主要简绍J2EE中的hibernate面试突击问题部分集合

件。SessionFactory的外置缓存也被称为Hibernate的第二级缓存。事务范围的缓存是持久化层的第一级缓存；进程范围和集群范围的缓存是持久化层的第二级缓存。Hibernate还为查询结果提供了一个查询缓存，它依赖于二级缓存。

持久化层可以提供多种范围的缓存。如果在事务范围的缓存中没有查到相应

的数据，还可以到进程范围或集群范围的缓存内查询，如果还是没有查到，那么只有到数据库中查询。事务范围的缓存是持久化层的第一级缓存，通常它是必需的；进程范围或集群范围的缓存是持久化层的第二级缓存，通常是可选的。

什么样的数据适合放到二级缓存中？

1）很少被修改的数据；

2）不是很重要的数据；

3）不会被并发访问的数据；

4）参考数据。

不适合放到二级缓存中的数据？

1）经常被修改的数据；

2）绝对重要的数据，例如：财务数据；

3）共享数据。

其它：

· 处于一级缓存中的对象永远不会过期，除非应用程序显式清空缓存或者清除 特定的对象 必须提供数据

过期策略；

· 只要应用程序通过Session接口执行保存、更新、删除、加载和查询数据库数据的操作，Hibernate就会启用第一级缓存，把数据库中的数据以对象的形式拷贝到缓存中，对于批量更新和批量删除操作，如果不希望启用第一级缓存，可以绕过Hibernate API，直接通过JDBC API来执行指操作。 用户可以在单个类或类的单个集合的粒度上配置第二级缓存。如果类的实例被经常读但很少被修 改，就可以考虑使用第二级缓存。只有为某个类或集合配置了第二级缓存，Hibernate在运行时才会把它的实例加入到第二级缓存中。

我的理解：

Hibernate中的一级缓存是出于Hibernate自身的需要而进行的一次数据缓

存，可以在Hibernate中的一般操作中起到数据缓存的作用。而通常所说的缓存 技术，实际上对应的就是Hibernate中的二级缓存，只不过在Hibernate中，已经有了Session级别的一级缓存，所以称之为二级缓存。

缓存的管理：

一级缓存的管理

此文档主要简绍J2EE中的hibernate面试突击问题部分集合

Session为应用程序提供了两个管理缓存的方法：

1>.Evict(Object obj)：从缓存中清除参数指定的持久化对象；

2>.Clear()：清空缓存中所有持久化对象。

二级缓存的管理：

Hibernate的二级缓存策略的一般过程如下：

1) 条件查询的时候，总是发出一条select * from table_name where …. （选择 所有字段）这样的SQL语句查询数据库，一次获得所有的数据对象。

2) 把获得的所有数据对象根据ID放入到第二级缓存中。

3) 当Hibernate根据ID访问数据对象的时候，首先从Session一级缓存中查； 查不到，如果配置了二级缓存，那么从二级缓存中查；查不到，再查询数据库，把结果按照ID放入到缓存。

4) 删除、更新、增加数据的时候，同时更新缓存。此外，Hibernate的二级缓存策略，只是针对于ID查询的缓存策略，对于条件查询则毫无作用。为此，

Hibernate提供了针对条件查询的Query Cache（查询缓存）。

常用的缓存插件：

Hibernate的二级缓存是一个插件，下面是几种常用的缓存插件：

· EhCache：可作为进程范围的缓存，存放数据的物理介质可以是内存或硬 盘，对Hibernate的查询缓存提供了支持。

· OSCache：可作为进程范围的缓存，存放数据的物理介质可以是内存或硬 盘，提供了丰富的缓存数据过期策略，对Hibernate的查询缓存提供了支持。 · SwarmCache：可作为群集范围内的缓存，但不支持Hibernate的查询缓存。 · JBossCache：可作为群集范围内的缓存，支持事务型并发访问策略，对Hibernate的查询缓存提供了支持。

5.Hibernate是如何实现延迟加载的？

Hibernate对象关系映射提供延迟的与非延迟的对象初始化。

非延迟加载在读取一个对象的时候会将与这个对象所有相关的其他对象一

起读取出来。这有时会导致成百select语句在读取对象的时候执行。这个问题有时出现在使用双向关系的时候，经常会导致整个数据库都在初始化的阶段被读 出来了。

一个明显的解决方法是使用Hibernate提供的延迟加载机制。这种初始化策

略只在一个对象调用它的一对多或多对多关系时才将关系对象读取出来。这个过程对开发者来说是透明的，而且只进行了很少的数据库操作请求，因此会得到比

此文档主要简绍J2EE中的hibernate面试突击问题部分集合

较明显的性能提升。 这项技术的一个缺陷是延迟加载技术要求一个Hibernate会话要在对象使用

的时候一直开着。这会成为通过使用DAO模式将持久层抽象出来时的一个主要问题。为了将持久化机制完全地抽象出来，所有的数据库逻辑，包括打开或关闭会话，都不能在应用层出现。最常见的是，一些实现了简单接口的DAO实现类将数据库逻辑完全封装起来了。一种快速但是笨拙的解决方法是放弃DAO模式，将数据库连接逻辑加到应用层中来。这可能对一些小的应用程序有效，但是在大的系 统中，这是一个严重的设计缺陷，妨碍了系统的可扩展性。

幸运的是，Spring框架为Hibernate延迟加载与DAO模式的整合提供了一种

方便的解决方法。对那些不熟悉Spring与Hibernate集成使用的人，我不会在这里讨论过多的细节，但是我建议你去了解Hibernate与Spring集成的数据访问。以一个Web应用为例，Spring提供了OpenSessionInViewFilter和OpenSessionInViewInterceptor。我们可以随意选择一个类来实现相同的功能。两种方法唯一的不同就在于interceptor在Spring容器中运行并被配置在web应用的上下文中，而Filter在Spring之前运行并被配置在web.xml中。不管用哪个，他们都在请求将当前会话与当前（数据库）线程绑定时打开Hibernate会话。一旦已绑定到线程，这个打开了的Hibernate会话可以在DAO实现类中透明地使用。这个会话会为延迟加载数据库中值对象的视图保持打开状态。一旦这个逻辑视图完成了，Hibernate会话会在Filter的doFilter方法或者Interceptor的 postHandle方法中被关闭。

6．Hibernate有几种查询方式？

· Session的get()和load()查询；

· HQL查询；

· Query查询；

· Criteria查询；

· 本地SQL语句查询（Native SQl）。

7．Hibernate的性能优化？

⑴在运行的情况下使用最新版本的Hibernate发行版，如hibernate3中经过优 化的批量处理机制，代理机制、属性的延迟加载支持等；

⑵指定合理的缓存策略，通过系统压力测试得到最佳的缓存性能；

⑶采用合理的Session管理机制，避免无谓的数据库开销和临时对象的反复创建；

⑷尽量使用延迟加载特性，以避免系统资源的无谓消耗；

⑸设定合理的批处理参数(batch_size)；

此文档主要简绍J2EE中的hibernate面试突击问题部分集合

⑹如果可能，使用UUID作为主键生成器；

⑺如果可能，使用基于Version的乐观锁策略替代悲观锁；

⑻开发过程中，打开Hibernate的SQL日志文件(hibernate.show_sql)，通过观 察Hibernate生成的SQL

语句进一步了解其实现原理，从而指定更好的实现策略；

⑼数据库本身的优化也起着至关重要的作用，合理的索引、缓存和数据分区策略 都会对持久层性能带来客观提升。

8．Hibernate中的update（）和saveOrUpdate（）的区别？

Hibernate中的对象状态有3种，分别为：

· 未被持久化的值对象（Value Object，VO）；

· 已经被持久化的持久化对象（Persistent Object，PO）；

· 曾经被持久化过，但现在已经和Session分离，以VO的身份在运行。

首先，我们来说说何时用update()；

· 如果你的PO不需要跨Session，即打开一个Session之后，对其进行操作，之后关闭，再也不会用到了，此时不需要用update()方法，此时Hibernate会自动检测到PO已经被修改过，会向数据库发送一条Update语句；如下代码： Foo foo=sess.load(Foo.class,id);;

foo.setXXX(xxx); mit();

· 如果你的PO需要跨Session操作，在第一个Session关闭后，你还想把

已经于第一个Session分离的PO当做VO来用，并将修改更新到数据库中，那么 此时就需要Update()方法；也就是说，当数据是持久化对象时，不需要使用update方法，当数据不是持久化状态的时候，必须使用update方法，告诉数据库要更新数据；然后，我们谈谈saveOrUpdate()；

如果业务层传过来的是一个已经持久化过的PO对象，那么Hibernate就会

根据这个方法更新该对象，如果传递过来的是一个VO对象，那么Hibernate就 会save这个对象。

9．Hibernate中的load（）和get（）的区别？

最重要的区别：如果未能发现符合条件的记录，Hibernate get方法返回null，而load方法会抛出一个ObjectNotFoundException。

1. 对于Hibernate get方法，Hibernate会确认一下该id对应的数据是否

存在，首先在session缓存中查找，然后在二级缓存中查找，还没有就查询数据库，数据库中没有就返回null。

此文档主要简绍J2EE中的hibernate面试突击问题部分集合

2. Hibernate load方法加载实体对象的时候，根据映射文件上类级别的lazy

属性的配置(默认为true)，分情况讨论：

(1)若为true,则首先在Session缓存中查找，看看该id对应的对象是否存

在，不存在则使用延迟加载，返回实体的代理类对象(该代理类为 实体类的子 类，由CGLIB动态生成)。等到具体使用该对象(除获

取OID以外)的时候，再查询二级缓存和数据库，若仍没发现符合条件的记录，则会抛出一个ObjectNotFoundException。

(2)若为false,就跟Hibernate get方法查找顺序一样，只是最终若没发现

符合条件的记录，则会抛出一个ObjectNotFoundException。

注释：此文出自/qqabc20082006@126/blog/static/2292852520106249825542/

Hibernate常用的接口和类

Configuration接口

|- Configuration接口的作用是对Hibernate进行配置，以及对它进行启动。在Hibernate的启动过程中，Configuration类的实例首先定位映射文档的位置，读取这些配置，然后创建一个SessionFactory对象。

SessionFactory 接口

|- 这里用到了一个设计模式――工厂模式，用户程序从工厂类SessionFactory中取得Session的实例.SessionFactory并不是轻量级的，一个项目通常只需要一个 SessionFactory就够了，但是当你的项目要操作多个数据库时，那你必须为每个数据库指定一个SessionFactory。

SessionFactory在Hibernate中实际起到了一个缓冲区的作用，它缓冲了Hibernate自动生成的SQL语句和一些其它的映射数据，还缓冲了一些将来有可能重复利用的数据。

Session接口

|- Session接口对于Hibernate 开发人员来说是一个最重要的接口。然而在Hibernate中，实例化的Session是一个轻量级的类，创建和销毁它都不会占用很多资源。这在实际项目中确实很重要，因为在客户程序中，可能会不断地创建以及销毁Session对象，如果Session的开销太大，会给系统带来不良影响。但值得注意的是 Session对象是非线程安全的，因此在你的设计中，最好是一个线程只创建一个Session对象。

Hibernate使用Session来存取，它是持久化管理器接口，代表与数据库

此文档主要简绍J2EE中的hibernate面试突击问题部分集合

之间的一次操作。然而为了操作持久化数据，首先要获得SessionFactory对象，SessionFactory负责一个数据库，是Session的工厂，对于一个XML配置文件，SessionFactory对象Configuration对象负责创建。这里的net.sf.hibernate.cfg.Configuration的一个实例代表了应用程序中所有的Java类到关系数据库的映射的集合，这些映射是从一些XML映射文件中编译得到的。可以得到一个 Configuration的实例，直接实例化即可，当所有的映射都被Configuration解析之后，应用程序为了得到Session实例，必须先得到它的工厂，这些工厂应该是应用程序的所有线程所共享的。当然Hibernate并不禁

止程序实例化多个SessionFactory，这在使用不止一个数据库时候就很有用。

Transaction 接口

|- Transaction接口是一个可选的API，你可以选择不使用这个接口，取而代之的是Hibernate的设计者自己写的底层事务处理代码。 Transaction接口是对实际事务实现的一个抽象，这些实现包括JDBC的事务、JTA中的UserTransaction、甚至可以是CORBA 事务。之所以这样设计是能让开发者能够使用一个统一事务的操作界面，使得自己的项目可以在不同的环境和容器之间方便地移值。

Query和Criteria接口

|- Query接口让你方便地对数据库及持久对象进行查询，它可以有两种表达方式：HQL语言或本地数据库的SQL语句。Query经常被用来绑定查询参数、限制查询记录数量，并最终执行查询操作。

Criteria接口与Query接口非常类似，它允许你创建并执行面向对象的标

准化查询。值得注意的是Query接口也是轻量级的，它不能在Session之外使用。

Callback 接口

当一些有用的事件发生时――例如持久对象的载入、存储、删除时，Callback接口会通知Hibernate去接收一个通知消息。一般而言，Callback接口在用户程序中并不是必须的，但你要在你的项目中创建审计日志时，你可能会用到它。

本文来自CSDN博客，转载请标明出处：/dengqiong080704/archive/2008/07/06/2616050.aspx

此文档主要简绍J2EE中的hibernate面试突击问题部分集合

Hibernate管理Session对象的方式有哪

些?

尽管让程序自主管理Session对象的生命周期也是可行的，但是在实际Java 应用中，把管理Session对象的生命周期交给Hibernate，可以简化 Java应用的程序代码和软件架构。

Hibernate 自身提供了 3 种管理Session对象生命周期的方式：

(1)Session对象的生命周期与本地线程绑定。

(2)Session对象的生命周期与 JTA事务绑定。

(3)Hibernate委托程序管理 Session对象的生命周期。

它包含了业务逻辑代码，创建 SessionFactory 对象的代码、管理 Session 对 象的代码，以及执行数据库事务的代码。对于复杂的软件应用，需要细分 BusinessService类的功能，建立精粒度的对象模型。精粒度的对象模型把功能逐步分解为多个模块，然后分配给多个类来协作完成。精粒度的对象模型可以减少重复代码，而且能提高每个类的独立性，有利于软件的维护和可重用。 本节将进一步细分 BusinessService类的功能，并且由多个类来分担 BusinessService类的功能：

● HibernateUtil类：实用类，负责创建一个应用范围内的 SessionFactory 对象，它的 getSessionFactory()静态方法返回这个 SessionFactory 对象。它的getCurrentSession()静态方法返回当前的 Session对象。 ● Monkey类：持久化类，代表猴子。

● MonkeyDAo. 类：封装了通过 Hibernate API来访问数据库，进行查询及 更新 Monkey对象的代码。不负责声明数据库事务。DAO(DataAccess Object) 表示数据访问对象。

● BusinessService 类：负责处理投票业务，通过 MonkeyDAO 类来查询及 更新 Monkey对象，数据库事务的声明由 BusinessService类来完成。 SessionFactory对象是重量级对象，在一个Java应用中，对于一个数据库存储

此文档主要简绍J2EE中的hibernate面试突击问题部分集合

源，只需要创建一个代表该存储源的 SessionFactory对象，它被整个Java应 用共享。

MonkeyDAO 类封装了与 Monkey 对象有关的访问数据库的代码，参见例程 16-2。MonkeyDAO类通过 HibernateUtil类的 getCurrentSession()方法来得到 当前的Session对象。MonkeyDAO类的 getById()及 update()方法既不用管理 Session，也不用声明事务。

package my pack;

public c1ass MonkeyDAO (

pub1ic Monkey get By Id (long id) (

return (Mon key ) Hibernate Util . get CurrentS ession ( )

. get (Monkey . class , new Long (id) );

public void update (Monkey monkey) (

HibernateUtil. getCurrentSession()·saveOrUpdate(monkey)i)

Hibernate 到底如何管理 Session对 Java应用是透明的。无论是那种管理方 式，MonkeyDAO 类都不必自己创建 Session 对象，只需调用 HibernateUtil 类的getCurrentSession()方法，就能获得当前的 Session对象。而HibernateUtil类的getCurrentSession()方法实际上是调用 SessionFactory对象的

getCurrentSession()方法，来获得当前的 Session对象。由此可见，Hibernate 内部封装了管理 Session对象的生命周期的实现细节。当 Java 应用改变

Hibernate 的 Session 管理方式时，无须修改 Monkey 类、MonkeyDAO 类和 HibernateUtil 类的源代码，只需修改 Hibernate 的配置文件及

BusinessService 类就行了。 在 Hibernate 的配置文件中，hibernate.current-sessioncontext-class属性用于指定 Session管理方式，可选值包括：

●thread：Session对象的生命周期与本地线程绑定。

●jta：Session对象的生命周期与 JTA 事务绑定。

●managed：Hibernate委托程序来管理 Session对象的生命周期。

此文档主要简绍J2EE中的hibernate面试突击问题部分集合

本文固定链接: /tansuanyinliaohui/452.html

Hibernate中的Cache管理

一级Cache：

Session实现了第一级Hibernate Cache，它属于事务级数据缓冲。一旦事务结束，这个Cache也随之失效。一个Session的生命周期对应一个数据库事务或一个程序事务。

Session-cache保证了一个Session中两次请求同一个对象时，取得的对象是同一个JAVA实例，有时它可以避免不必要的数据冲突。

另外，它还能为另一些重要的性能提供保证：

1：在对一个对象进行自我循环引用时， 不至于产生堆栈溢出。

2：当数据库事务结束时，对于同一个数据库行，不会产生数据冲突，因为对于数据库中的一行，最多只有一个对象来表示它。

3：一个事务中可能会有很多个处理单元，在每一个处理单元中做的操作都会立即被另外的处理单元得知。

我们不用刻意去打开Session-cache，它总是被打开并且不能被关闭。当使用save（），update（）或saveOrUpdate（）来保存数据更改，或通过load（），find（），list（）等方法来得到对象时，对象就会被加入到Session-cache. 如果要同步很多数据对象，就需要有效地管理Cache，可以用Session的evict（）方法从一级Cache中移除对象。

Session session = HibernateUtil.currentSession();

Transaction tx = session.beginTransaction();

for(int i = 0 ; i <100000 ; i++){

Student stu = new Student();

session.save(stu);

}

mit();

session.close（）；

在保存50000个或更多对象时，程序可能会抛出OutOfMemoryException异常，因为 Hibernate Cache在一级缓存了新加入的所有对象。内存溢出。要解决这全问题就需要把JDBC批处理数量设置为一个合理的数值（一般是10～

20）。

在 Hibernate Cache的配置文件中可以加入以下属性：

<property name="hibernate.jdbc.batch_size"> 20 </property>

然后我们在程序中一定时刻就提交并更新Session的Hibernate Cache： Session session = HibernateUtil.currentSession();

Transaction tx = session.beginTransaction();

for(int i = 0 ; i <100000 ; i++){

Student stu = new Student();

此文档主要简绍J2EE中的hibernate面试突击问题部分集合

session.save(stu);

if(i%20 == 0) { //每保存完20个对象后，进行如下操作

session.flush();//这个会提交更新

session.clear();//清除Cache,释放内存

}

}|||

二级Cache

二级Cache是SessionFactory范围内的缓存，所有的Session共享同一个二级Cache.在二级Cache中保存持久性实例的散装形式的数据。二级Cache的内部如何实现并不重要，重要的是采用哪种正确的缓存策略，以及采用哪个Cache提供器。持久化不同的数据需要不同的 Cache策略，比如一些因素将影响到Cache策略的选择：数据的读/写比例，数据表是否能被其他的应用程序扬访问等。对于一些读/写比例高的数据可以打开它的缓存，允许这些数据进入二级缓存容器有利于系统性能的优化；而对于能被其它应用程序访问的数据对象，最好将此对象的二级Cache选项关闭。

设置Hibernate Cache的二级需要分两步进行：首先确认使用什么数据并发策略，然后配置缓存过期时间并设置Hibernate Cache提供器。

有4种内置的Hibernate数据并发冲突策略，代表数据库隔离级别：

1：事务（Transaction）仅在受管理的环境中可用。它保证可重读的事务隔离级别，可以对读/写比例高，很少更新的数据采用该策略。

2：读写（read-write）使用时间戳机制维护读写提交事务隔离级别。可以对读/写比例高，很少更新的数据采用该策略。

3：非严格读写（notstrict-read-write）不保证Cache和数据库之间的数据库的一致性。使用此策略时，应该设置足够的缓存过期时间，否则可能从缓存中读出脏数据。当一些数据极少改变，并且当这些数据和数据库有一部份不量影响不大时，可以使用此策略。

4：只读（read-only）当确保数据永不改变时，可以使用此策略。

我们确定了Hibernate Cache策略后，就要挑选一个高效的Cache提供器，它将作为插件被Hibernate调用。Hibernate允许使用下述几种缓存插件：EhCache：可以在JVM中作为一个简单进程范围内的缓存，它可以把缓存的数据放入内存或磁盘，并支持Hibernate中可选用的查询缓存。

OpenSymphony OSCache：和EhCache相似，并且提供了丰富的缓存过期策略。

◆SwarmCache：可作为集群范围的缓存，但不支持查询缓存。

◆JBossCache：可作为集群范围的缓冲，但不支持查询缓存。

在Hibernate中使用EhCache

EhCache是一个纯JAVA程序，可以在Hibernate中作为一个插件引入。在Hibernate中使用EhCache需要在Hibernate的配置文件中设置

<propery name="hibernate.cache.provider_class">

org.hibernate.cache.EhCacheProvider

</property>

此文档主要简绍J2EE中的hibernate面试突击问题部分集合

<ehcache>

<diskStore path="c:““cache"/> //设置cache.data文件存放位置

<defaultCache

maxElementsInMemory="10000" //缓存中允许创建的最大对象数 eternal="false" //缓存中对象是否为永久的

timeToIdleSeconds="120"//缓存数据钝化时间(即对象在它过期前的空闲时间)

timeToLiveSeconds="120"//缓存数据生存时间(即对象在它过期前的生存时间)

overflowToDisk="true"

/>

<cache name="Student" //用户自定义的Cache配置

maxElementsInMemory="10000"

eternal="false"

timeToIdleSeconds="300"

timeToLiveSeconds="600"

overflowToDisk="true"

/>

</ehcache>

此外我们还需要在持久化类的映射文件中进行配置。例如，Group（班级）和Student（学生）是一对多的关系，它们对应的数据表分别是 t_group和t_student.现在要把Student类的数据进行二级缓存，这需要在二个映射文件中都对二级缓存进行配置。

在Group.hbm.xml中如下，在其<set></set>中添加

此文来源于：www. (考试吧)

Hibernate延迟加载机制

延迟加载：

延迟加载机制是为了避免一些无谓的性能开销而提出来的，所谓延迟加载就是当在真正需要数据的时候，才真正执行数据加载操作。在Hibernate中提供了对实体对象的延迟加载以及对集合的延迟加载，另外在Hibernate3中还提供了对属性的延迟加载。下面我们就分别介绍这些种类的延迟加载的细节。

A、实体对象的延迟加载：

此文档主要简绍J2EE中的hibernate面试突击问题部分集合

如果想对实体对象使用延迟加载，必须要在实体的映射配置文件中进行相应的配置，如下所示：

<hibernate-mapping>

<class name=”er” table=”user” lazy=”true”>

……

</class>

</hibernate-mapping>

通过将class的lazy属性设置为true，来开启实体的延迟加载特性。如果我们运行下面的代码：

User user=(User)session.load(User.class,”1”);（1）

System.out.println(user.getName());（2）

当运行到(1)处时，Hibernate并没有发起对数据的查询，如果我们此时通过一些调试工具(比如JBuilder2005的Debug工具)，观察此时user对象的内存快照，我们会惊奇的发现，此时返回的可能是User$EnhancerByCGLIB$$bede8986类型的对象，而且其属性为null,这是怎么回事？还记得前面我曾讲过session.load()方法，会返回实体对象的代理类对象，这里所返回的对象类型就是User对象的代理类对象。在Hibernate中通过使用CGLIB,来实现动态构造一个目标对象的代理类对象，并且在代理类对象中包含目标对象的所有属性和方法，而且所有属性均被赋值为null。通过调试器显示的内存快照，我们可以看出此时真正的User对象，是包含在代理对象的CGLIB$CALBACK_0.target属性中，当代码运行到（2）处时，此时调用user.getName()方法，这时通过CGLIB赋予的回调机制，实际上调用

此文档主要简绍J2EE中的hibernate面试突击问题部分集合

CGLIB$CALBACK_0.getName()方法，当调用该方法时，Hibernate会首先检查CGLIB$CALBACK_0.target属性是否为null，如果不为空，则调用目标对象的 getName方法，如果为空，则会发起数据库查询，生成类似这样的SQL语句：select * from user where id=’1’;来查询数据，并构造目标对象，并且将它赋值到CGLIB$CALBACK_0.target属性中。

这样，通过一个中间代理对象，Hibernate实现了实体的延迟加载，只有当用户真正发起获得实体对象属性的动作时，才真正会发起数据库查询操作。所以实体的延迟加载是用通过中间代理类完成的，所以只有session.load()方法才会利用实体延迟加载，因为只有session.load()方法才会返回实体类的代理类对象。

B、集合类型的延迟加载：

在 Hibernate的延迟加载机制中，针对集合类型的应用，意义是最为重大的，因为这有可能使性能得到大幅度的提高，为此Hibernate进行了大量的努力，其中包括对JDK Collection的独立实现，我们在一对多关联中，定义的用来容纳关联对象的Set集合，并不是java.util.Set类型或其子类型，而是 net.sf.hibernate.collection.Set类型，通过使用自定义集合类的实现，Hibernate实现了集合类型的延迟加载。为了对集合类型使用延迟加载，我们必须如下配置我们的实体类的关于关联的部分：

<hibernate-mapping>

<class name=”er” table=”user”>

…..

此文档主要简绍J2EE中的hibernate面试突击问题部分集合

<set name=”addresses” table=”address” lazy=”true” inverse=”true”> <key column=”user_id”/>

<one-to-many class=”com.neusoft.entity.Arrderss”/>

</set>

</class>

</hibernate-mapping>

通过将<set>元素的lazy属性设置为true来开启集合类型的延迟加载特性。我们看下面的代码：

User user=(User)session.load(User.class,”1”);

Collection addset=user.getAddresses(); (1)

Iterator it=addset.iterator(); (2)

while(it.hasNext()){

Address address=(Address)it.next();

System.out.println(address.getAddress());

}

当程序执行到(1)处时，这时并不会发起对关联数据的查询来加载关联数据，只有运行到(2)处时，真正的数据读取操作才会开始，这时Hibernate会根据缓存中符合条件的数据索引，来查找符合条件的实体对象。

这里我们引入了一个全新的概念——数据索引，下面我们首先将接一下什么是数据索引。在 Hibernate中对集合类型进行缓存时，是分两部分进行缓存的，首先缓存集合中所有实体的id列表，然后缓存实体对象，这些实体对象的id列表，就是所谓的数据索引。当查找数据索引时，如果没有找到对应的数据索引，这时

此文档主要简绍J2EE中的hibernate面试突击问题部分集合

就会一条select SQL的执行，获得符合条件的数据，并构造实体对象集合和数据索引，然后返回实体对象的集合，并且将实体对象和数据索引纳入Hibernate的缓存之中。另一方面，如果找到对应的数据索引，则从数据索引中取出 id列表，然后根据id在缓存中查找对应的实体，如果找到就从缓存中返回，如果没有找到，在发起select SQL查询。在这里我们看出了另外一个问题，这个问题可能会对性能产生影响，这就是集合类型的缓存策略。如果我们如下配置集合类型： <hibernate-mapping>

<class name=”er” table=”user”>

…..

<set name=”addresses” table=”address” lazy=”true” inverse=”true”> <cache usage=”read-only”/>

<key column=”user_id”/>

<one-to-many class=”com.neusoft.entity.Arrderss”/>

</set>

</class>

</hibernate-mapping>

这里我们应用了<cache usage=”read-only”/>配置，如果采用这种策略来配置集合类型，Hibernate将只会对数据索引进行缓存，而不会对集合中的实体对象进行缓存。如上配置我们运行下面的代码：

User user=(User)session.load(User.class,”1”);

Collection addset=user.getAddresses();

Iterator it=addset.iterator();

此文档主要简绍J2EE中的hibernate面试突击问题部分集合

while(it.hasNext()){

Address address=(Address)it.next();

System.out.println(address.getAddress());

}

System.out.println(“Second query……”);

User user2=(User)session.load(User.class,”1”);

Collection it2=user2.getAddresses();

while(it2.hasNext()){

Address address2=(Address)it2.next();

System.out.println(address2.getAddress());

}

运行这段代码，会得到类似下面的输出：

Select * from user where id=’1’;

Select * from address where user_id=’1’;

Tianjin

Dalian

Second query……

Select * from address where id=’1’;

Select * from address where id=’2’;

Tianjin

Dalian

我们看到，当第二次执行查询时，执行了两条对address表的查询操作，为什么

此文档主要简绍J2EE中的hibernate面试突击问题部分集合

会这样？这是因为当第一次加载实体后，根据集合类型缓存策略的配置，只对集合数据索引进行了缓存，而并没有对集合中的实体对象进行缓存，所以在第二次再次加载实体时，Hibernate找到了对应实体的数据索引，但是根据数据索引，却无法在缓存中找到对应的实体，所以Hibernate根据找到的数据索引发起了两条select SQL的查询操作，这里造成了对性能的浪费，怎样才能避免这种情况呢？我们必须对集合类型中的实体也指定缓存策略，所以我们要如下对集合类型进行配置：

<hibernate-mapping>

<class name=”er” table=”user”>

…..

<set name=”addresses” table=”address” lazy=”true” inverse=”true”> <cache usage=”read-write”/>

<key column=”user_id”/>

<one-to-many class=”com.neusoft.entity.Arrderss”/>

</set>

</class>

</hibernate-mapping>

此时Hibernate会对集合类型中的实体也进行缓存，如果根据这个配置再次运行上面的代码，将会得到类似如下的输出：

Select * from user where id=’1’;

Select * from address where user_id=’1’;

Tianjin

此文档主要简绍J2EE中的hibernate面试突击问题部分集合

Dalian

Second query……

Tianjin

Dalian

这时将不会再有根据数据索引进行查询的SQL语句，因为此时可以直接从缓存中获得集合类型中存放的实体对象。

C、属性延迟加载：

在Hibernate3中，引入了一种新的特性——属性的延迟加载，这个机制又为获取高性能查询提供了有力的工具。在前面我们讲大数据对象读取时，在User对象中有一个resume字段，该字段是一个java.sql.Clob类型，包含了用户的简历信息，当我们加载该对象时，我们不得不每一次都要加载这个字段，而不论我们是否真的需要它，而且这种大数据对象的读取本身会带来很大的性能开销。在Hibernate2中，我们只有通过我们前面讲过的面性能的粒度细分，来分解User类，来解决这个问题（请参照那一节的论述），但是在Hibernate3中，我们可以通过属性延迟加载机制，来使我们获得只有当我们真正需要操作这个字段时，才去读取这个字段数据的能力，为此我们必须如下配置我们的实体类：

<hibernate-mapping>

<class name=”er” table=”user”>

……

<property name=”resume” type=”java.sql.Clob” column=”resume”

此文档主要简绍J2EE中的hibernate面试突击问题部分集合

lazy=”true”/>

</class>

</hibernate-mapping>

通过对<property>元素的lazy属性设置true来开启属性的延迟加载，在Hibernate3中为了实现属性的延迟加载，使用了类增强器来对实体类的Class文件进行强化处理，通过增强器的增强，将CGLIB的回调机制逻辑，加入实体类，这里我们可以看出属性的延迟加载，还是通过CGLIB来实现的。CGLIB是 Apache的一个开源工程，这个类库可以操纵java类的字节码，根据字节码来动态构造符合要求的类对象。根据上面的配置我们运行下面的代码：

String sql=”from User user where =’zx’ ”;

Query query=session.createQuery(sql); (1)

List list=query.list();

for(int i=0;i<list.size();i++){

User user=(User)list.get(i);

System.out.println(user.getName());

System.out.println(user.getResume()); (2)

}

当执行到(1)处时，会生成类似如下的SQL语句：

Select id,age,name from user where name=’zx’;

这时Hibernate会检索User实体中所有非延迟加载属性对应的字段数据，当执行到(2)处时，会生成类似如下的SQL语句：

Select resume from user where id=’1’;

此文档主要简绍J2EE中的hibernate面试突击问题部分集合

这时会发起对resume字段数据真正的读取操作。

此文 出自：/michaellee/archive/2009/11/24/303432.html

Java程序员基础32问经典

JAVA程序员面试32问

第一，谈谈final, finally, finalize的区别。

第二，Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?

第三，Static Nested Class 和 Inner Class的不同，说得越多越好(面试题有的很笼统)。

第四，&和&&的区别。

第五，HashMap和Hashtable的区别。

第六，Collection 和 Collections的区别。

第七，什么时候用assert。

第八，GC是什么? 为什么要有GC?

第九，String s = new String("xyz");创建了几个String Object?

第十，Math.round(11.5)等於多少? Math.round(-11.5)等於多少?

第十一，short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?

第十二，sleep() 和 wait() 有什么区别?

第十三，Java有没有goto?

第十四，数组有没有length()这个方法? String有没有length()这个方法?

本文来源：https://www.bwwdw.com/article/hszm.html