【面试】【Hibernate常见问题总结】【02】

【常见面试问题总结目录>>>】

031 hibernate中一对多配置文件返回的是什么？

　　hibernate中一对多配置文件会相应的映射为两张表，并且它们之间的关系是一对多的。
例如：一个student和classes表的关系 。一个学生只能是一个班的,一个班可以有多个学生。

032 Hibernate与spring的联系

　　hibernate中的一些对象可以给Spring来管理,让Spring容器来创建hibernate中一些对象实例化。例如：SessionFactory，HibernateTemplate等。
Hibernate本来是对数据库的一些操作,放在DAO层,而Spring给业务层的方法定义了事务,业务层调用DAO层的方法,很好的将Hibernate的操作也加入到事务中来了。

033 Hibernate自带的分页机制是什么？如果不使用Hibernate自带的分页，则采用什么方式分页？

　　1、hibernate自带的分页机制：获得Session对象后，从Session中获得Query对象。用Query.setFirstResult()：设置要显示的第一行数据,
Query.setMaxResults()：设置要显示的最后一行数据。
　　2、不使用hibernate自带的分页,可采用sql语句分页，
如：5:为每页显示的记录,2为当前页： select * top 5 from table where tabId not in (select tabId top (2-1)*5 from table);

034 什么是Hibernate的并发机制？怎么去处理并发问题？

　　Hibernate并发机制：
　　a、Hibernate的Session对象是非线程安全的,对于单个请求,单个会话,单个的工作单元(即单个事务,单个线程),它通常只使用一次,然后就丢弃。
如果一个Session 实例允许共享的话，那些支持并发运行的,例如Http request,session beans将会导致出现资源争用。
如果在Http Session中有hibernate的Session的话,就可能会出现同步访问Http Session。只要用户足够快的点击浏览器的“刷新”,就会导致两个并发运行的线程使用同一个Session。
　　b、多个事务并发访问同一块资源,可能会引发第一类丢失更新，脏读，幻读，不可重复读，第二类丢失更新一系列的问题。
解决方案：设置事务隔离级别。
　　　　Serializable：串行化。隔离级别最高
　　　　Repeatable Read：可重复读
　　　　Read Committed：已提交数据读
　　　　Read Uncommitted：未提交数据读。隔离级别最差
　　设置锁：乐观锁和悲观锁。
　　　　乐观锁：使用版本号或时间戳来检测更新丢失,在的映射中设置 optimistic-lock=”all”可以在没有版本或者时间戳属性映射的情况下实现 版本检查，此时Hibernate将比较一行记录的每个字段的状态 行级悲观锁：Hibernate总是使用数据库的锁定机制，从不在内存中锁定对象！只要为JDBC连接指定一下隔 离级别，然后让数据库去搞定一切就够了。类LockMode 定义了Hibernate所需的不同的锁定级别：LockMode.UPGRADE,LockMode.UPGRADE_NOWAIT,LockMode.READ;

035 Hibernate与jdbc的联系

　　hibernate是jdbc的轻量级封装，包括jdbc的与数据库的连接（用hibernate.property的配置文件实现当然本质是封装了jdbc的forname），和查询，删除等代码，都用面向对象的思想用代码联系起来，hibernate通过hbm 配置文件把po类的字段和数据库的字段关联起来比如数据库的id,在po类中就是pravite Long id; public Long getId() ;public setId(Long id);
　　然后hql语句也是面向对象的，它的查询语句不是查询数据库而是查询类的,这些实现的魔法就是xml文件，其实hibernate=封装的jdbc+xml文件

036 hibernate拒绝连接、服务器崩溃的原因？最少写5个

　　1. db没有打开
　　2. 网络连接可能出了问题
　　3. 连接配置错了
　　4. 驱动的driver，url是否都写对了
　　5. LIB下加入相应驱动，数据连接代码是否有误
　　6. 数据库配置可能有问题
　　7. 当前联接太多了，服务器都有访问人数限制的
　　8. 服务器的相应端口没有开，即它不提供相应的服务

037 hibernate有哪些缓存，分别怎么使用?

　　hibernate的缓存分为一级缓存和二级缓存, 一级说的是session的缓存，是hibernate内置的，不能卸载。二级说的是SessionFactory中的外置缓存，SessionFactory的内置缓存是放映射数据和sql语句的，程序不能更改，也不算二级缓存。二级缓存可以配置和更改，并且动态加载和卸载。Hibernate还为查询结果提供了一个查询缓存，它依赖于第二级缓存。
　　一级缓存的管理：
　　当应用程序调用Session的save()、update()、savaeOrUpdate()、get()或load()，以及调用查询接口的 list()、iterate()或filter()方法时，如果在Session缓存中还不存在相应的对象，Hibernate就会把该对象加入到第一级缓存中。当清理缓存时，Hibernate会根据缓存中对象的状态变化来同步更新数据库。 Session为应用程序提供了两个管理缓存的方法： evict(Object obj)：从缓存中清除参数指定的持久化对象。 clear()：清空缓存中所有持久化对象。
　　二级缓存的管理：
　　　　1) 条件查询的时候，总是发出一条select * from table_name where …. （选择所有字段）这样的SQL语句查询数据库，一次获得所有的数据对象。
　　　　2) 把获得的所有数据对象根据ID放入到第二级缓存中。
　　　　3) 当Hibernate根据ID访问数据对象的时候，首先从Session一级缓存中查；查不到，如果配置了二级缓存，那么从二级缓存中查；查不到，再查询数据库，把结果按照ID放入到缓存。
　　　　4) 删除、更新、增加数据的时候，同时更新缓存。Hibernate二级缓存策略，是针对于ID查询的缓存策略，对于条件查询则毫无作用。为此，Hibernate提供了针对条件查询的Query Cache(查询缓存)。

038 Hibernate缓存何时使用和如何使用

　　（一）关于hibernate缓存的问题：
　　1.1. 基本的缓存原理
　　Hibernate缓存分为二级，
　　　　第一级存放于session中称为一级缓存，默认带有且不能卸载。
　　　　第二级是由sessionFactory控制的进程级缓存。是全局共享的缓存，凡是会调用二级缓存的查询方法 都会从中受益。只有经正确的配置后二级缓存才会发挥作用。同时在进行条件查询时必须使用相应的方法才能从缓存中获取数据。比如Query.iterate()方法、load、get方法等。必须注意的是session.find方法永远是从数据库中获取数据，不会从二级缓存中获取数据，即便其中有其所需要的数据也是如此。
　　查询时使用缓存的实现过程为：首先查询一级缓存中是否具有需要的数据，如果没有，查询二级缓存，如果二级缓存中也没有，此时再执行查询数据库的工作。要注意的是：此3种方式的查询速度是依次降低的。
　　1.2. 存在的问题
　　　　1.2.1. 一级缓存的问题以及使用二级缓存的原因
　　因为Session的生命期往往很短，存在于Session内部的第一级最快缓存的生命期当然也很短，所以第一级缓存的命中率是很低的。其对系统性能的改善也是很有限的。当然，这个Session内部缓存的主要作用是保持Session内部数据状态同步。并非是hibernate为了大幅提高系统性能所提供的。
　　为了提高使用hibernate的性能，除了常规的一些需要注意的方法比如：
使用延迟加载、迫切外连接、查询过滤等以外，还需要配置hibernate的二级缓存。其对系统整体性能的改善往往具有立竿见影的效果！
　　　　1.2.2. N+1次查询的问题
　　　　　　1.2.2.1 什么时候会遇到1+N的问题？
　　　　前提：Hibernate默认表与表的关联方法是fetch=”select”，不是fetch=”join”,这都是为了懒加载而准备的。
　　　　　　1）一对多() ，在1的这方，通过1条sql查找得到了1个对象，由于关联的存在 ，那么又需要将这个对象关联的集合取出，所以合集数量是n还要发出n条sql，于是本来的1条sql查询变成了1 +n条 。
　　　　　　2）多对一 ，在多的这方，通过1条sql查询得到了n个对象，由于关联的存在,也会将这n个对象对应的1 方的对象取出， 于是本来的1条sql查询变成了1 +n条 。
　　　　　　3）iterator 查询时,一定先去缓存中找（1条sql查集合,只查出ID），在没命中时，会再按ID到库中逐一查找， 产生1+n条SQL
　　　　　　1.2.2.2 怎么解决1+N 问题？
　　　　　　1 ）lazy=true， hibernate3开始已经默认是lazy=true了；lazy=true时不会立刻查询关联对象，只有当需要关联对象（访问其属性，非id字段）时才会发生查询动作。
　　　　　　2）使用二级缓存， 二级缓存的应用将不怕1+N 问题，因为即使第一次查询很慢（未命中），以后查询直接缓存命中也是很快的。刚好又利用了1+N 。
　　　　　　3) 当然你也可以设定fetch=”join”，一次关联表全查出来，但失去了懒加载的特性。
执行条件查询时，iterate（）方法具有著名的 “n+1”次查询的问题，也就是说在第一次查询时iterate方法会执行满足条件的查询结果数再加一次（n+1）的查询。但是此问题只存在于第一次查询时，在后面执行相同查询时性能会得到极大的改善。此方法适合于查询数据量较大的业务数据。
　　　　　　但是注意：当数据量特别大时（比如流水线数据等）需要针对此持久化对象配置其具体的缓存策略，比如设置其存在于缓存中的最大记录数、缓存存在的时间等参数，以避免系统将大量的数据同时装载入内存中引起内存资源的迅速耗尽，反而降低系统的性能！！！
　　1.3. 使用hibernate二级缓存的其他注意事项：
　　　　1.3.1. 关于数据的有效性
　　　　另外，hibernate会自行维护二级缓存中的数据，以保证缓存中的数据和数据库中的真实数据的一致性！无论何时，当你调用save()、update()或 saveOrUpdate()方法传递一个对象时，或使用load()、 get()、list()、iterate() 或scroll()方法获得一个对象时, 该对象都将被加入到Session的内部缓存中。 当随后flush()方法被调用时，对象的状态会和数据库取得同步。
　　　　也就是说删除、更新、增加数据的时候，同时更新缓存。当然这也包括二级缓存！
　　　　只要是调用hibernate API执行数据库相关的工作。hibernate都会为你自动保证 缓存数据的有效性！！
　　　　但是，如果你使用了JDBC绕过hibernate直接执行对数据库的操作。此时，Hibernate不会/也不可能自行感知到数据库被进行的变化改动，也就不能再保证缓存中数据的有效性！！
　　　　这也是所有的ORM产品共同具有的问题。幸运的是，Hibernate为我们暴露了Cache的清除方法，这给我们提供了一个手动保证数据有效性的机会！！
　　　　一级缓存，二级缓存都有相应的清除方法。
　　　　其中二级缓存提供的清除方法为：
　　　　按对象class清空缓存
　　　　按对象class和对象的主键id清空缓存
　　　　清空对象的集合中的缓存数据等。
　　　　1.3.2. 适合使用的情况
　　　　并非所有的情况都适合于使用二级缓存，需要根据具体情况来决定。同时可以针对某一个持久化对象配置其具体的缓存策略。
　　　　适合于使用二级缓存的情况：
　　　　1、数据不会被第三方修改；
　　　　一般情况下，会被hibernate以外修改的数据最好不要配置二级缓存，以免引起不一致的数据。但是如果此数据因为性能的原因需要被缓存，同时又有可能被第3方比如SQL修改，也可以为其配置二级缓存。只是此时需要在sql执行修改后手动调用cache的清除方法。以保证数据的一致性
　　　　2、数据大小在可接收范围之内；
　　　　如果数据表数据量特别巨大，此时不适合于二级缓存。原因是缓存的数据量过大可能会引起内存资源紧张，反而降低性能。
　　　　如果数据表数据量特别巨大，但是经常使用的往往只是较新的那部分数据。此时，也可为其配置二级缓存。但是必须单独配置其持久化类的缓存策略，比如最大缓存数、缓存过期时间等，将这些参数降低至　　　　一个合理的范围（太高会引起内存资源紧张，太低了缓存的意义不大）。
　　　　3、数据更新频率低；
对于数据更新频率过高的数据，频繁同步缓存中数据的代价可能和 查询缓存中的数据从中获得的好处相当，坏处益处相抵消。此时缓存的意义也不大。
　　　　4、非关键数据（不是财务数据等）
　　　　财务数据等是非常重要的数据，绝对不允许出现或使用无效的数据，所以此时为了安全起见最好不要使用二级缓存。
　　　　因为此时 “正确性”的重要性远远大于 “高性能”的重要性。
　　（二）目前系统中使用hibernate缓存的建议
　　2.1. 目前情况
　　一般系统中有三种情况会绕开hibernate执行数据库操作：
　　　　1、多个应用系统同时访问一个数据库
　　　　此种情况使用hibernate二级缓存会不可避免的造成数据不一致的问题，此时要进行详细的设计。比如在设计上避免对同一数据表的同时的写入操作，
使用数据库各种级别的锁定机制等。
　　　　2、动态表相关
　　　　所谓“动态表”是指在系统运行时根据用户的操作系统自动建立的数据表。
　　　　比如“自定义表单”等属于用户自定义扩展开发性质的功能模块，因为此时数据表是运行时建立的，所以不能进行hibernate的映射。因此对它的操作只能是绕开hibernate的直接数据库JDBC操作。
　　　　如果此时动态表中的数据没有设计缓存，就不存在数据不一致的问题。
　　　　如果此时自行设计了缓存机制，则调用自己的缓存同步方法即可。
　　　　3、使用sql对hibernate持久化对象表进行批量删除时
　　　　此时执行批量删除后，缓存中会存在已被删除的数据。
　　　　分析：
　　　　当执行了第3条（sql批量删除）后，后续的查询只可能是以下三种方式：
　　　　a. session.find()方法：
　　　　根据前面的总结，find方法不会查询二级缓存的数据，而是直接查询数据库。
　　　　所以不存在数据有效性的问题。
　　　　b. 调用iterate方法执行条件查询时：
　　　　根据iterate查询方法的执行方式，其每次都会到数据库中查询满足条件的id值，然后再根据此id 到缓存中获取数据，当缓存中没有此id的数据才会执行数据库查询；
　　　　如果此记录已被sql直接删除，则iterate在执行id查询时不会将此id查询出来。所以，即便缓存中有此条记录也不会被客户获得，也就不存在不一致的情况。（此情况经过测试验证）
　　　　c. 用get或load方法按id执行查询：
　　　　客观上此时会查询得到已过期的数据。但是又因为系统中执行sql批量删除一般是针对中间关联数据表，对于中间关联表的查询一般都是采用条件查询 ,按id来查询某一条关联关系的几率很低,所以此问题也不存在!
　　　　如果某个值对象确实需要按id查询一条关联关系,同时又因为数据量大使用 了sql执行批量删除。当满足此两个条件时,为了保证按id 的查询得到正确的结果,可以使用手动清楚二级缓存中此对象的数据的方法!!(此种情况出现的可能性较小)
　　2.2. 建 议
　　　　1、建议不要使用sql直接执行数据持久化对象的数据的更新，但是可以执行批量删除。（系统中需要批量更新的地方也较少）
　　　　2、如果必须使用sql执行数据的更新，必须清空此对象的缓存数据。调用SessionFactory.evict(class)，SessionFactory.evict(class,id)等方法。
　　　　3、在批量删除数据量不大的时候可以直接采用hibernate的批量删除，这样就不存在绕开hibernate执行sql产生的缓存数据一致性的问题。
　　　　4、不推荐采用hibernate的批量删除方法来删除大批量的记录数据。原因是hibernate的批量删除会执行1条查询语句外加 满足条件的n条删除语句。而不是一次执行一条条件删除语句！！
　　　　当待删除的数据很多时会有很大的性能瓶颈！！！如果批量删除数据量较大,比如超过50条,可以采用JDBC直接删除。这样作的好处是只执行一条sql删除语句,性能会有很大的改善。同时，缓存数据同步的问题,可以采用 hibernate清除二级缓存中的相关数据的方法。
　　　　调 用
　　　　　　SessionFactory.evict(class) ;
　　　　　　SessionFactory.evict(class,id)等方法。
　　　　所以说，对于一般的应用系统开发而言（不涉及到集群，分布式数据同步问题等），因为只在中间关联表执行批量删除时调用了sql执行，同时中间关联表一般是执行条件查询不太可能执行按id查询。所以，此时可以直接执行sql删除，甚至不需要调用缓存的清除方法。这样做不会导致以后配置了二级缓存引起数据有效性的问题。
　　　　退一步说，即使以后真的调用了按id查询中间表对象的方法，也可以通过调用清除缓存的方法来解决。
　　　　3、具体的配置方法
　　　　根据我了解的很多hibernate的使用者在调用其相应方法时都迷信的相信“hibernate会自行为我们处理性能的问题”，或者“hibernate 会自动为我们的所有操作调用缓存”,实际的情况是hibernate虽然为我们提供了很好的缓存机制和扩展缓存框架的支持，但是必须经过正确的调用其才有可能发挥作用！！所以造成很多使用hibernate的系统的性能问题，实际上并不是hibernate不行或者不好，而是因为使用者没有正确的了解其使用方法造成的。相反，如果配置得当hibernate的性能表现会让你有相当“惊喜的”发现。下面我讲解具体的配置方法。
　　　　ibernate提供了二级缓存的接口：
　　　　　　net.sf.hibernate.cache.Provider,
　　　　同时提供了一个默认的 实现net.sf.hibernate.cache.HashtableCacheProvider，
　　　　也可以配置 其他的实现 比如ehcache,jbosscache等。
　　　　具体的配置位置位于hibernate.cfg.xml文件中

<property name="hibernate.cache.use_query_cache">true</property> 
<property name="hibernate.cache.provider_class">net.sf.hibernate.cache.HashtableCacheProvider</property> 

　　　　很多的hibernate使用者在 配置到 这一步 就以为 完事了，
　　　　注意：其实光这样配，根本就没有使用hibernate的二级缓存。同时因为他们在使用hibernate时大多时候是马上关闭session，所以，一级缓存也没有起到任何作用。结果就是没有使用任何缓存，所有的hibernate操作都是直接操作的数据库！！性能可以想见。
　　　　正确的办法是除了以上的配置外还应该配置每一个vo对象的具体缓存策略，在影射文件中配置。例如：

<hibernate-mapping> 
    <class name="com.sobey.sbm.model.entitySystem.vo.DataTypeVO" table="dcm_datatype"> 
        <cache usage="read-write"/> 
        <id name="id" column="TYPEID" type="java.lang.Long"> 
            <generator class="sequence"/> 
        </id> 
        <property name="name" column="NAME" type="java.lang.String"/> 
        <property name="dbType" column="DBTYPE" type="java.lang.String"/> 
    </class> 
</hibernate-mapping> 

　　　　关键就是这个< cache usage=”read-write” />，其有几个选择read-only,read-write,transactional,等
　　　　然后在执行查询时 注意了 ，如果是条件查询，或者返回所有结果的查询，此时session.find()方法 　　　　不会获取缓存中的数据。只有调用query.iterate()方法时才会调缓存的数据。
　　　　同时 get 和 load方法 是都会查询缓存中的数据
　　　　对于不同的缓存框架具体的配置方法会有不同，但是大体是以上的配置（另外，对于支持事务型，以及支持集群的环境的配置我会争取在后续的文章中中 发表出来）

039 写出一个sql语句体现hibernate中一对多的关系

　　hibernate.cfg.xml文件的作用
　　该配置文件主要用来描述数据库连接的相关信息，以及该应用中关心映射文件所在的位置，和一些其他的设置，该文件一般放在项目的根目录下。
　　hibernate中的继承关系按照数据库的表结构来分的话有那几种？
　　1.所有类在一张表中，通过添加一个鉴别字段来区分子类。
　　2.每个子类一张表，父类的字段被分配到每个表中。
　　3.每个类一张表，包括父类和子类，通过父类和子类的ID来体现继承关系

040 hibernate中常见的关联关系有那3种？那种事最常见的

　　一对一
　　一对多
　　多对多
　　一对多最常见

041 hibernate中的cascade属性的作用:

　　级联操作

042 hql中能否使用max(),sum(),sount()等组函数？

　　能

043 hql中能否使用Group by?

　　能

044 hql中加select和不加select的区别

　　加select你可以返回的是一个对象中的某一个属性，也可以是一个对象的全部属性。不加select返回的是对象的全部属性
Hql中query.uniqueResult()和query.list()的区别？
前者指返回一个对象，后者返回一个list集合

045 简述一下qbc

　　qbc(query by criteria)封装了sql语句的动态拼接，对查询提供了更加面向对象的功能接口

046 请解释为什么SessionFactory一般以单例方式使用

　　SessionFactory是一个大型对象，而且线程安全。在一个程序中只需要一个。

047 请解释说明hibernate配置文件中dialect属性的确切含义

　　数据库方言：多种数据库拥有不同的语言语法，通过设置dialect指定所用的数据库，并生成对应语法和语言的sql语句。

048 请解释Hibernate3.2主键的生成方式中，native和identity方式的区别。

　　Native主键生成方式会根据不同的底层数据库自动选择　　
　　Identity、Sequence、Hilo主键生成方式
　　Identity当时根据底层数据库，来支持自动增长，不同的数据库用不同的主键增长方式

049 请简要的描述一下使用Hibernate进行大批量更新的经验

　　直接使用hibernate API 进行批量更新和批量删除都不推荐，而直接通过JDBC API执行相关的SQL语句或调用相关的存储过程是最佳的方式。

050 请简要的描述一下使用Hibernate二级高速缓存的经验

　　1．Hibernate3的二级缓存和session级别的缓存一样都只对实体对象做缓存，不对属性级别的查询做缓存；二级缓存的生命周期和sessionFactory的生命周期是一样的，sessionFactory可以管理二级缓存；
　　2．sessionFactory级别的缓存，需要手动配置；所有的session可以共享sessionFactory 级别的缓存；（一般把一些不经常变化的实体对象放到sessionFactory级别的缓存中，适合放不经常变化的实体对象。）
　　3．Hiberante3二级缓存的配置和使用方法如下：
　　必须把ehcache.jar包导入，然后到Hibernate3.2的etc文件下把ehcache.xml复制到工程src目录下（ehcache.xml里边的参数里边有详细英文说明）；
　　说明：ehcache.jar是第三方法的缓存产品，hiberante只是把它做了集成，还有好多第三方hibernate集成的缓存产品，相关说明请查阅hiberante3开发手册；ehcache是不支持分布应用的，如果有分布式需求，请换成支持分布式的二级缓存产品，hiberate3开发手册都有相头说明。配置方法都类似）；
　　4．Hibernate3的二级缓存默认是开起的，也可以指定开起。

051 Hibernate的延迟加载怎么看？

　　当Hibernate查询数据的时候，数据并没有存在于内存中，当数据真正对数据操作时，才存在于内存中，就实现了延迟加载，他节省了服务器内存的开销，从而提升了服务器的性能。

052 hibernate的sessionFactory

　　是管理session的一个工厂，由sessionFactory的相关方法返回session对象，而不是平常的new关键字创建session，它的另一个好处就是，你只管要session而不用管它是如何产生的。这样在效率和安全性是比较好的。

053 什么事O/RM?

　　对象关心映射是一种为了解决面向对象与关心数据库互不匹配的技术。简单的说，orm是通过使用描述对象和数据库之间映射的元数据，将java程序中的对象自动持久化到关系数据库中，本质上就是将数据从一种形式转换到另一种形式。

054 在o/rm中java中的类名，属性，对象分别转换为数据库中的什么？

　　类名–表名
　　属性–字段
　　对象–记录

055 LockMode类表示的几种锁定模式

锁定模式	描述
LockMode.NONE	如果缓存中存在对象,直接返回该对象的引用,否则通过select语句到数据库中加载该对象,默认值.
LockMode.READ	不管缓存中是否存在对象,总是通过select语句到数据库中加载该对象,如果映射文件中设置了版本元素,就执行版本检查,比较缓存中的对象是否和数据库中对象版本一致
LockMode.UPGRADE	不管缓存中是否存在对象,总是通过select语句到数据库中加载该对象,如果映射文件中设置了版本元素,就执行版本检查,比较缓存中的对象是否和数据库中对象的版本一致,如果数据库系统支持悲观锁(如Oracle/MySQL),就执行select…for update语句,如果不支持(如Sybase),执行普通select语句
LockMode.UPGRADE_NOWAIT	和LockMode.UPGRADE具有同样功能,此外,对于Oracle等支持update nowait的数据库,执行select…for update nowait语句,nowait表明如果执行该select语句的事务不能立即获得悲观锁,那么不会等待其它事务释放锁,而是立刻抛出锁定异常
LockMode.WRITE	保存对象时会自动使用这种锁定模式,仅供Hibernate内部使用,应用程序中不应该使用它
LockMode.FORCE	强制更新数据库中对象的版本属性,从而表明当前事务已经更新了这个对象

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

　　1) 很少被修改的数据
　　2) 不是很重要的数据，允许出现偶尔并发的数据
　　3) 不会被并发访问的数据
　　4) 参考数据,指的是供应用参考的常量数据，它的实例数目有限，它的实例会被许多其他类的实例引用，实例极少或者从来不会被修改。

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

　　1) 经常被修改的数据
　　2) 财务数据，绝对不允许出现并发
　　3) 与其他应用共享的数据。

Hibernate笔试题

(1)一般情况下，关系数据模型与对象模型之间有哪些匹配关系（多选）

　　A)表对应类
　　B)记录对应对象
　　C)表的字段对应类的属性
　　D)表之间的参考关系对应类之间的依赖关系

(2)以下关于SessionFactory的说法哪些正确？（多选）

　　A)对于每个数据库事务，应该创建一个SessionFactory对象
　　B)一个SessionFactory对象对应一个数据库存储源。
　　C)SessionFactory是重量级的对象，不应该随意创建。如果系统中只有一个数据库存储源，只需要创建一个。
　　D)SessionFactory的load()方法用于加载持久化对象

(3)Customer类中有一个Set类型的orders属性，用来存放Order订单对象，在Customer.hbm.xml文件中，用哪个元素映射orders属性？

　　A)< set >
　　B)< one-to-many >
　　C)< many-to-one >
　　D)< property >

(4)< set >元素有一个cascade属性，如果希望Hibernate级联保存集合中的对象，casecade属性应该取什么值？（单选）

　　A)none
　　B)save
　　C)delete
　　D)save-update

(5)以下哪些属于Session的方法？

　　A)load()
　　B)save()
　　C)delete()
　　D)update()
　　E)open()
　　F)close()

(6)以下程序的打印结果是什么？（单选）

　　tx = session.beginTransaction();
　　Customer c1=(Customer)session.load(Customer.class,new Long(1));
　　Customer c2=(Customer)session.load(Customer.class,new Long(1));
　　System.out.println(c1==c2);
　　tx.commit();
　　session.close();
　　A)运行出错，抛出异常
　　B)打印false
　　C)打印true

(7)以下程序代码对Customer的name属性修改了两次：

　　tx = session.beginTransaction();
　　Customer customer=(Customer)session.load(Customer.class,new Long(1));
　　customer.setName(\”Jack\”);
　　customer.setName(\”Mike\”);
　　tx.commit();
　　执行以上程序，Hibernate需要向数据库提交几条update语句？（单选）
　　A)0
　　B)1
　　C)2
　　D)3

(8)在持久化层，对象分为哪些状态？（多选）

　　A)临时状态
　　B)独立状态
　　C)游离状态
　　D)持久化状态

(9)对于以下程序，Customer对象在第几行变为持久化状态？（单选）

　　Customer customer=new Customer(); //line1
　　customer.setName(\”Tom\”); //line2
　　Session session1=sessionFactory.openSession(); //line3
　　Transaction tx1 = session1.beginTransaction(); //line4
　　session1.save(customer); //line4
　　tx1.commit(); //line5
　　session1.close(); //line6
　　A) line1
　　B)line2
　　C)line3
　　D)line4
　　E)line5
　　F)line6
　　

(10)对于以下程序，Customer对象在第几行变为游离状态？（单选）

　　Customer customer=new Customer(); //line1
　　customer.setName(\”Tom\”); //line2
　　Session session1=sessionFactory.openSession(); //line3
　　Transaction tx1 = session1.beginTransaction(); //line4
　　session1.save(customer); //line4
　　tx1.commit(); //line5
　　session1.close(); //line6
　　A)line1
　　B)line2
　　C)line3
　　D)line4
　　E)line5
　　F)line6

(11)以下哪一种检索策略利用了外连结查询？（单选）

　　A)立即检索
　　B)延迟检索
　　C)迫切左外连结检索

(12)假设对Customer类的orders集合采用延迟检索策略，编译或运行以下程序，会出现什么情况（单选）

　　Session session=sessionFactory.openSession();
　　tx = session.beginTransaction();
　　Customer customer=(Customer)session.get(Customer.class,new Long(1));
　　tx.commit();
　　session.close();
　　Iterator orderIterator=customer.getOrders().iterator();
　　A) 编译出错
　　B)编译通过，并正常运行
　　C)编译通过，但运行时抛出异常

(13)关于HQL与SQL，以下哪些说法正确？（多选）

　　A)HQL与SQL没什么差别
　　B)HQL面向对象，而SQL操纵关系数据库
　　C)在HQL与SQL中，都包含select,insert,update,delete语句
　　D)HQL仅用于查询数据，不支持insert,update和delete语句

(14)事务隔离级别是由谁实现的？（单选）

　　A)Java应用程序
　　B)Hibernate
　　C)数据库系统
　　D)JDBC驱动程序

(15)悲观锁与乐观锁，哪个具有较好的并发性能？（单选）

　　A)悲观锁
　　B)乐观锁