Hibernate



1、什么是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;

2、update和saveOrUpdate的区别？

update()和saveOrUpdate()是用来对跨Session的PO进行状态管理的。 
update()方法操作的对象必须是持久化了的对象。也就是说，如果此对象在数据库中不存在的话，就不能使用update()方法。 
saveOrUpdate()方法操作的对象既可以使持久化了的，也可以使没有持久化的对象。如果是持久化了的对象调用saveOrUpdate()则会 更新数据库中的对象；如果是未持久化的对象使用此方法,则save到数据库中。

3、hibernate的三种状态之间如何转换

当对象由瞬时状态(Transient)一save()时，就变成了持久化状态； 
当我们在Session里存储对象的时候，实际是在Session的Map里存了一份， 也就是它的缓存里放了一份，然后，又到数据库里存了一份，在缓存里这一份叫持久对象(Persistent)。 Session 一 Close()了,它的缓存也都关闭了,整个Session也就失效了,这个时候，这个对象变成了游离状态(Detached)，但数据库中还是存在的。 
当游离状态(Detached)update()时，又变为了持久状态(Persistent)。 
当持久状态(Persistent)delete()时，又变为了瞬时状态(Transient), 此时，数据库中没有与之对应的记录。

4、比较hibernate的三种检索策略优缺点

1立即检索； 
优点： 对应用程序完全透明，不管对象处于持久化状态，还是游离状态，应用程序都可以方便的从一个对象导航到与它关联的对象； 
缺点： 1.select语句太多；2.可能会加载应用程序不需要访问的对象白白浪费许多内存空间； 
2延迟检索： 
优点： 由应用程序决定需要加载哪些对象，可以避免可执行多余的select语句，以及避免加载应用程序不需要访问的对象。因此能提高检索性能，并且能节省内存空间； 
缺点： 应用程序如果希望访问游离状态代理类实例，必须保证他在持久化状态时已经被初始化； 
3 迫切左外连接检索 
优点： 1对应用程序完全透明，不管对象处于持久化状态，还是游离状态，应用程序都可以方便地冲一个对象导航到与它关联的对象。2使用了外连接，select语句数目少； 
缺点： 1 可能会加载应用程序不需要访问的对象，白白浪费许多内存空间；2复杂的数据库表连接也会影响检索性能；

5、如何在控制台看到hibernate生成并执行的sql

在定义数据库和数据库属性的文件applicationConfig.xml里面，把hibernate.show_sql 设置为true 
这样生成的SQL就会在控制台出现了 
注意：这样做会加重系统的负担，不利于性能调优

6、hibernate都支持哪些缓存策略

Read-only: 这种策略适用于那些频繁读取却不会更新的数据，这是目前为止最简单和最有效的缓存策略 
* Read/write:这种策略适用于需要被更新的数据，比read-only更耗费资源，在非JTA环境下，每个事务需要在session.close和session.disconnect()被调用 
* Nonstrict read/write: 这种策略不保障两个同时进行的事务会修改同一块数据，这种策略适用于那些经常读取但是极少更新的数据 
* Transactional: 这种策略是完全事务化得缓存策略，可以用在JTA环境下

7、hibernate里面的sorted collection 和ordered collection有什么区别

sorted collection是在内存中通过Java比较器进行排序的 
ordered collection是在数据库中通过order by进行排序的

8、Hibernate工作原理及为什么要用？

1.读取并解析配置文件 
2.读取并解析映射信息，创建SessionFactory 
3.打开Sesssion 
4.创建事务Transation 
5.持久化操作 
6.提交事务 
7.关闭Session 
8.关闭SesstionFactory

为什么要用： 
1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。

1. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作

2. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。

3. hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。

10、Hibernate是如何延迟加载?

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

11、Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系)

类与类之间的关系主要体现在表与表之间的关系进行操作，它们都是对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many、

12、说下Hibernate的缓存机制

1. 内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存

2. 二级缓存： 
   a) 应用及缓存 
   b) 分布式缓存 
   条件：数据不会被第三方修改、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非关键数据 
   c) 第三方缓存的实现

13、Hibernate的查询方式

Sql、Criteria,objectcomposition 
Hql： 
1、 属性查询 
2、 参数查询、命名参数查询 
3、 关联查询 
4、 分页查询 
5、 统计函数

14、如何优化Hibernate？

1.使用双向一对多关联，不使用单向一对多 
2.灵活使用单向一对多关联 
3.不用一对一，用多对一取代 
4.配置对象缓存，不使用集合缓存 
5.一对多集合使用Bag,多对多集合使用Set 
6. 继承类使用显式多态 
7. 表字段要少，表关联不要怕多，有二级缓存撑腰

15、Hibernate有哪几种查询数据的方式

3种：hql、条件查询QBC(QueryBy Criteria)、原生sql （通过createSQLQuery建立）

16、谈谈Hibernate中inverse的作用

inverse属性默认是false,就是说关系的两端都来维护关系。 
比如Student和Teacher是多对多关系，用一个中间表TeacherStudent维护。Gp)i 
如果Student这边inverse=”true”, 那么关系由另一端Teacher维护，就是说当插入Student时，不会操作TeacherStudent表（中间表）。只有Teacher插入或删除时才会触发对中间表的操作。所以两边都inverse=”true”是不对的，会导致任何操作都不触发对中间表的影响；当两边都inverse=”false”或默认时，会导致在中间表中插入两次关系。

17、Detached Object（游离对象）有什么好处

Detached Object（游离对象）可以传递到任何层直到表现层而不是用任何DTO(DataTransfer Objects). 然后你还可以重新把游离对象赋给另外一个Session.

18、JDBC hibernate 和 ibatis 的区别

jdbc:手动 
手动写sql 
delete、insert、update要将对象的值一个一个取出传到sql中,不能直接传入一个对象。 
select:返回的是一个resultset，要从ResultSet中一行一行、一个字段一个字段的取出，然后封装到一个对象中，不直接返回一个对象。 
ibatis的特点:半自动化 
sql要手动写 
delete、insert、update:直接传入一个对象 
select:直接返回一个对象 
hibernate:全自动 
不写sql,自动封装 
delete、insert、update:直接传入一个对象 
select:直接返回一个对象

19、在数据库中条件查询速度很慢的时候,如何优化?

1.建索引 
2.减少表之间的关联 
3.优化sql，尽量让sql很快定位数据，不要让sql做全表查询，应该走索引,把数据量大的表排在前面 
4.简化查询字段，没用的字段不要，已经对返回结果的控制，尽量返回少量数据

20、什么是SessionFactory,她是线程安全么？

SessionFactory 是Hibrenate单例数据存储和线程安全的，以至于可以多线程同时访问。一个SessionFactory 在启动的时候只能建立一次。SessionFactory应该包装各种单例以至于它能很简单的在一个应用代码中储存.

21、Hibernate的五个核心接口

Configuration 接口：配置Hibernate，根据其启动hibernate，创建 
SessionFactory 对象； 
SessionFactory 接口：初始化Hibernate，充当数据存储源的代理，创建 
session 对象，sessionFactory 是线程安全的，意味着它的同一个实例可以被应 
用的多个线程共享，是重量级、二级缓存； 
Session 接口：负责保存、更新、删除、加载和查询对象，是线程不安全的， 
避免多个线程共享同一个session，是轻量级、一级缓存； 
Transaction 接口：管理事务； 
Query 和Criteria 接口：执行数据库的查询。

1.Hibernate session接口的get和load方法有何异同？ 
答： 其实它们也没有什么不同的， 作用其实都是一样的，但是有一定的区别，get是每次都会从数据库取数据以保证数据的可靠性，而load会返回proxy，相当于是一个存根，它的值会去hibernate中的session的二级缓存里去找，如果找不到目则会laxy load一下,简单来说，用get的时候，当为空的时候不会抛出异常，反之load会抛. 

2.在持久化层，对象分为哪些状态？分别列出来. 
答:瞬时态(Transient)、持久态(Persistent)、脱管态(Detached)。 
瞬时态(Transient) 
是对象是创建时，瞬时对象在内存孤立存在，它是携带信息的载体，不和数据库的数据有任何关联关系，在Hibernate中，可通过session的save()或 saveOrUpdate()方法将瞬时对象与数据库相关联，并将数据对应的插入数据库中，此时该瞬时对象转变成持久化对象。 
持久态(Persistent) 
是该对象在数据库中已有对应的记录，并拥有一个持久化标识，如果是用hibernate的delete()方法，对应的持久对象就变成瞬时对象，因数据库中的对应数据已被删除，该对象不再与数据库的记录关联。 
    当一个session执行close()或clear()、evict()之后，持久对象变成脱管对象，此时持久对象会变成脱管对象，此时该对象虽然具有数据库识别值，但它已不在hibernate持久层的管理之下。 
  持久对象具有如下特点： 
     1. 和session实例关联； 
     2. 在数据库中有与之关联的记录。 
脱管态(Detached) 
当与某持久对象关联的session被关闭后，该持久对象转变为脱管对象。当脱管对象被重新关联到session上时，并再次转变成持久对象。 
       脱管对象拥有数据库的识别值，可通过update()、saveOrUpdate()等方法，转变成持久对象。 
       脱管对象具有如下特点： 
  1.本质上与瞬时对象相同，在没有任何变量引用它时，JVM会在适当的时候将它回收； 
2. 比瞬时对象多了一个数据库记录标识值。 
3.lock和update区别 
答: update是把一个已经更改过的脱管状态的对象变成持久状态 
lock是把一个没有更改过的脱管状态的对象变成持久状态(针对的是因Session的关闭 而处于脱管状态的po对象(2)，不能针对因delete而处于脱管状态的po对象) 
对应更改一个记录的内容，两个的操作不同： 
update的操作步骤是： 
(1)属性改动后的脱管的对象的修改->调用update 
lock的操作步骤是： 
(2)调用lock把未修改的对象从脱管状态变成持久状态-->更改持久状态的对象的内容-->等待flush或者手动flush 
4.save 和update区别 
答： save是把一个对象做为一个新的数据保存, update则是把一个脱管状态的对象或自由态对象（一定要和一个记录对应）更新到数据库，其实一个是保存一个是更新，一看都知道是有什么区别了。 
5.update 和saveOrUpdate区别 
答：这个是比较好理解的，顾名思义，saveOrUpdate基本上就是合成了save和update,而update只是update;引用hibernate reference中的一段话来解释他们的使用场合和区别 
通常下面的场景会使用update()或saveOrUpdate()： 
程序在第一个session中加载对象,接着把session关闭 
该对象被传递到表现层 
对象发生了一些改动 
该对象被返回到业务逻辑层最终到持久层 
程序创建第二session调用第二个session的update()方法持久这些改动 
saveOrUpdate(po)做下面的事: 
如果该po对象已经在本session中持久化了，在本session中执行saveOrUpdate不做任何事 
如果savaOrUpdate(新po)与另一个与本session关联的po对象拥有相同的持久化标识(identifier)，抛出一个异常 
org.hibernate.NonUniqueObjectException: a different object with the same identifier value was already associated with the session: [org.itfuture.www.po.Xtyhb#5] 
saveOrUpdate如果对象没有持久化标识(identifier)属性，对其调用save() ，否则update() 这个对象      
6.flush和update区别 
答：这两个的区别好理解update操作的是在自由态或脱管状态(因session的关闭而处于脱管状态)的对象//updateSQL 
而flush是操作的在持久状态的对象。 
默认情况下，一个持久状态的对象的改动（包含set容器）是不需要update的，只要你更改了对象的值，等待hibernate flush就自动更新或保存到数据库了。hibernate flush发生在以下几种情况中： 
1， 调用某些查询的和手动flush(),session的关闭、SessionFactory关闭结合 
get()一个对象，把对象的属性进行改变,把资源关闭。 
2，transaction commit的时候（包含了flush） 
先写得这里了，

 

 

 

 

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)乐观锁

答案：

(1)A,B,C (2)B,C (3)A (4)D (5)A,B,C,D,F (6)C (7)B (8)A,C,D (9)D (10)F (11)C (12)C (13)B,D (14)C (15)B

 

 

 

 

 

　(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) B) C) D)<:property>

　　(4)元素有一个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();

　　Customerc1=(Customer)session.load(Customer.class,newLong(1));

　　Customerc2=(Customer)session.load(Customer.class,newLong(1));

　　System.out.println(c1c2);

　　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

　　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

　　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集合采用延迟检索策略，编译或运行以下程序，会出现什么情况（单选）

　　tx = session.beginTransaction();

　　Customercustomer=(Customer)session.get(Customer.class,newLong(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)乐观锁

　　答案：

　　(1)A,B,C (2)B,C (3)A (4)D (5)A,B,C,D,F (6)C (7)B (8)A,C,D(9)D(10)F (11)C (12)C (13)B,D (14)C (15)B

　　您正在阅读： 十五道关于Hibernate的面试题

　　编辑推荐

　　hibernate面试题

　　hibernate入门教程系列(二)Hibernate关系映射(上)

　　结合MYSQL数据库一个Hibernate的简单教程

 

 

 

 

一．简答题 1．请说出Hibernate中持久化对象的生命周期以及各种状态直接的区别，并描述相互之间是如何转换的。 Hibernate中持久化对象的生命周期有临时态、持久态和游离态三种。 处于临时态的对象主键值为空，并且未与session关联，数据未保存到数据库中 处于持久态的对象与session关联起来，持久化后对象中的数据被保存到数据库中，并且主键值按照.hbm.xml文件中配置的生成方式生成相应的值 处于游离态的对象脱离了session的管理，是持久化后的一种状态，主键值按照.hbm.xml文件中配置的生成方式生成相应的值 当new一个新的对象时，该对象处于临时态 当该对象被当作session的参数使用的时候，该对象处于持久态 事务提交，session关闭后，该对象处于游离态 2．hibernate与数据库连接的实现?并解释了一下,例如文件是通过流来实现的!hibernate与数据库连接是通过什么实现的? Hibernate与数据库的连接是通过JDBC实现的 3．spring和hibernate的事务管理方式有什么不同？ hibernate的事务管

 

 

 

 

2．hibernate与数据库连接的实现?并解释了一下,例如文件是通过流来实现的!hibernate与数据库连接是通过什么实现的? Hibernate与数据库的连接是通过JDBC实现的 3．spring和hibernate的事务管理方式有什么不同？ hibernate的事务管理方式仅仅就是托管给JDBC（如果用JTA那么就是JTA），而JDBC的一切行为包括事务是基于一个connection的，那么hibernate委托给JDBC的事务也就是基于一个session。JTA与JDBC事务不同在于可以跨连接。 spring也是调用hibernate中事务管理的API。hibernate的事务管理，一般是编程性的。而委托给spring之后，可以使用声明式的，也就是可以在XML之中配置哪些需要进行事务管理 4．用hibernate的session时要注意几点 1.在更新数据时,要用open() 2.使用完之后,要close(),这样连接池会回收该连接。 5．说说在hibernate中使用Integer做映射和使用int做映射之间有什么差别 使用int做映射，hibernate会自动把int类型转换为Integer类型，以便统一以对象方式处理数据。使用Integer就无须转换。 在从数据库中取数据的时候，如果是用Integer做的映射，则要求PO对象中对应的类型也必须为Integer类型，使用的时候需要转换为int。如果是int型，则无须转换。 6．一个网站应用，请设计一个持久化类User，他可能有多张会员卡号、需要多个email地址（数量不定）作为其身份验证的方式 设计三个类。User类、会员卡类和email类。User类与会员卡类和email类之间是一对多的关系 7．请简单评价该设计的优劣：身份证号码作为一个person表的主键 一个表的主键值设计最好不要采用具有业务含义的字段。理由有二 （1）．具有业务含义的字段的长度不固定 （2）．具有业务含义的字段的取值范围不定。可能是纯数字，也可能是纯字符，或者是数字和字符的混合情况。 上述两个方面一但发生变动将不利于业务层的处理。 8．Hibernate如何获取指定主键id的某对象，请举例，并进行可能的优劣比较 三种方式：get()，load()和find() Get()和load()是先在缓存中查找对象，如果找不到再去数据库中查询； Find()是无论何时都在数据库中查询对象。 三者比较起来Get()和load()的性能稍好一点。 二．问答题 1．请说出Hibernate中的映射关系有几种，分别是什么，如何配置 Hibernate中的映射关系有一对一、一对多、多对多三种。 一对一关系比较简单，只需在主控方（由谁想得到谁，前者即是主控方）定义。配置如下： 简单模式： 完整模式： 一对多关系分为单向一对多关系和双向一对多关系。 单向一对多关系只需在“一”方进行配置，双向一对多需要在关联双方均加以配置。配置如下： 单向一对多： 双向一对多： 一的一方： 多的一方： 被动方的记录由Hibernate负责读取，之后存放在主控方指定的Collection类型属性中。 多对多关联：由于多对多关联的性能不佳，在设计中应避免大量使用。应根据情况，采取延迟加载机制来避免无谓的性能开销。配置如下： 2．请描述对象建模时的继承关系在Hibernate中有几种映射方式，如何映射 一共有三种： 每颗类继承树使用一张表，配置如下： 三个类对应的字段都在一个数据表里表示。subtype字段标识存储的是哪个子类，与xml文件中的 对应。 每个子类各一张表，配置如下： 每个具体类各一张表，配置如下： 3．请描述Hibernate中的缓存机制 缓存是介于应用程序和物理数据源之间，其作用是为了降低应用程序对物理数据源访问的频次，从而提高了应用的运行性能。缓存内的数据是对物理数据源中的数据的复制，应用程序在运行时从缓存读写数据，在特定的时刻或事件会同步缓存和物理数据源的数据。 缓存的介质一般是内存，所以读写速度很快。但如果缓存中存放的数据量非常大时，也会用硬盘作为缓存介质。缓存的实现不仅仅要考虑存储的介质，还要考虑到管理缓存的并发访问和缓存数据的生命周期。 Hibernate的缓存包括Session的缓存和SessionFactory的缓存，其中SessionFactory的缓存又可以分为两类：内置缓存和外置缓存。Session的缓存是内置的，不能被卸载，也被称为Hibernate的第一级缓存。Session的缓存是指Session的一些集合属性包含的数据。SessionFactory的内置缓存中存放了映射元数据和预定义SQL语句，映射元数据是映射文件中数据的拷贝，而预定义SQL语句是在Hibernate初始化阶段根据映射元数据推导出来，SessionFactory的内置缓存是只读的，应用程序不能修改缓存中的映射元数据和预定义SQL语句，因此SessionFactory不需要进行内置缓存与映射文件的同步。SessionFactory的外置缓存是一个可配置的插件。在默认情况下，SessionFactory不会启用这个插件。外置缓存的数据是数据库数据的拷贝，外置缓存的介质可以是内存或者硬盘。SessionFactory的外置缓存也被称为Hibernate的第二级缓存。 Hibernate的这两级缓存都位于持久化层，存放的都是数据库数据的拷贝，那么它们之间的区别是什么呢？为了理解二者的区别，需要深入理解持久化层的缓存的两个特性：缓存的范围和缓存的并发访问策略。 持久化层的缓存的范围 缓存的范围决定了缓存的生命周期以及可以被谁访问。缓存的范围分为三类。 1 事务范围：缓存只能被当前事务访问。缓存的生命周期依赖于事务的生命周期，当事务结束时，缓存也就结束生命周期。在此范围下，缓存的介质是内存。事务可以是数据库事务或者应用事务，每个事务都有独自的缓存，缓存内的数据通常采用相互关联的的对象形式。 2 进程范围：缓存被进程内的所有事务共享。这些事务有可能是并发访问缓存，因此必须对缓存采取必要的事务隔离机制。缓存的生命周期依赖于进程的生命周期，进程结束时，缓存也就结束了生命周期。进程范围的缓存可能会存放大量的数据，所以存放的介质可以是内存或硬盘。缓存内的数据既可以是相互关联的对象形式也可以是对象的松散数据形式。松散的对象数据形式有点类似于对象的序列化数据，但是对象分解为松散的算法比对象序列化的算法要求更快。 3 集群范围：在集群环境中，缓存被一个机器或者多个机器的进程共享。缓存中的数据被复制到集群环境中的每个进程节点，进程间通过远程通信来保证缓存中的数据的一致性，缓存中的数据通常采用对象的松散数据形式。 对大多数应用来说，应该慎重地考虑是否需要使用集群范围的缓存，因为访问的速度不一定会比直接访问数据库数据的速度快多少。 持久化层可以提供多种范围的缓存。如果在事务范围的缓存中没有查到相应的数据，还可以到进程范围或集群范围的缓存内查询，如果还是没有查到，那么只有到数据库中查询。事务范围的缓存是持久化层的第一级缓存，通常它是必需的；进程范围或集群范围的缓存是持久化层的第二级缓存，通常是可选的。 持久化层的缓存的并发访问策略 当多个并发的事务同时访问持久化层的缓存的相同数据时，会引起并发问题，必须采用必要的事务隔离措施。 在进程范围或集群范围的缓存，即第二级缓存，会出现并发问题。因此可以设定以下四种类型的并发访问策略，每一种策略对应一种事务隔离级别。 事务型：仅仅在受管理环境中适用。它提供了Repeatable Read事务隔离级别。对于经常被读但很少修改的数据，可以采用这种隔离类型，因为它可以防止脏读和不可重复读这类的并发问题。 读写型：提供了Read Committed事务隔离级别。仅仅在非集群的环境中适用。对于经常被读但很少修改的数据，可以采用这种隔离类型，因为它可以防止脏读这类的并发问题。 非严格读写型：不保证缓存与数据库中数据的一致性。如果存在两个事务同时访问缓存中相同数据的可能，必须为该数据配置一个很短的数据过期时间，从而尽量避免脏读。对于极少被修改，并且允许偶尔脏读的数据，可以采用这种并发访问策略。 只读型：对于从来不会修改的数据，如参考数据，可以使用这种并发访问策略。 事务型并发访问策略是事务隔离级别最高，只读型的隔离级别最低。事务隔离级别越高，并发性能就越低。 什么样的数据适合存放到第二级缓存中？ 1、很少被修改的数据 2、不是很重要的数据，允许出现偶尔并发的数据 3、不会被并发访问的数据 4、参考数据 不适合存放到第二级缓存的数据？ 1、经常被修改的数据 2、财务数据，绝对不允许出现并发 3、与其他应用共享的数据。 Hibernate的二级缓存 如前所述，Hibernate提供了两级缓存，第一级是Session的缓存。由于Session对象的生命周期通常对应一个数据库事务或者一个应用事务，因此它的缓存是事务范围的缓存。第一级缓存是必需的，不允许而且事实上也无法卸除。在第一级缓存中，持久化类的每个实例都具有唯一的OID。 第二级缓存是一个可插拔的的缓存插件，它是由SessionFactory负责管理。由于SessionFactory对象的生命周期和应用程序的整个过程对应，因此第二级缓存是进程范围或者集群范围的缓存。这个缓存中存放的对象的松散数据。第二级对象有可能出现并发问题，因此需要采用适当的并发访问策略，该策略为被缓存的数据提供了事务隔离级别。缓存适配器用于把具体的缓存实现软件与Hibernate集成。第二级缓存是可选的，可以在每个类或每个集合的粒度上配置第二级缓存。 Hibernate的二级缓存策略的一般过程如下： 1) 条件查询的时候，总是发出一条select * from table_name where …. （选择所有字段）这样的SQL语句查询数据库，一次获得所有的数据对象。 2) 把获得的所有数据对象根据ID放入到第二级缓存中。 3) 当Hibernate根据ID访问数据对象的时候，首先从Session一级缓存中查；查不到，如果配置了二级缓存，那么从二级缓存中查；查不到，再查询数据库，把结果按照ID放入到缓存。 4) 删除、更新、增加数据的时候，同时更新缓存。 Hibernate的二级缓存策略，是针对于ID查询的缓存策略，对于条件查询则毫无作用。为此，Hibernate提供了针对条件查询的Query缓存。 Hibernate的Query缓存策略的过程如下： 1) Hibernate首先根据这些信息组成一个Query Key，Query Key包括条件查询的请求一般信息：SQL, SQL需要的参数，记录范围（起始位置rowStart，最大记录个数maxRows)，等。 2) Hibernate根据这个Query Key到Query缓存中查找对应的结果列表。如果存在，那么返回这个结果列表；如果不存在，查询数据库，获取结果列表，把整个结果列表根据Query Key放入到Query缓存中。 3) Query Key中的SQL涉及到一些表名，如果这些表的任何数据发生修改、删除、增加等操作，这些相关的Query Key都要从缓存中清空。

 

 

 

hibernate面试题

 

    1.在数据库中条件查询速度很慢的时候,如何优化?

    1.建索引
    2.减少表之间的关联
    3.优化sql，尽量让sql很快定位数据，不要让sql做全表查询，应该走索引,把数据量大的表排在前面
    4.简化查询字段，没用的字段不要，已经对返回结果的控制，尽量返回少量数据

    [2.在hibernate中进行多表查询,每个表中各取几个字段,也就是说查询出来的结果集并没有一个实体类与之对应,如何解决这个问题?

    解决方案一，按照Object[]数据取出数据，然后自己组bean

    解决方案二，对每个表的bean写构造函数，比如表一要查出field1,field2两个字段，那么有一个构造函数就是Bean(type1 filed1,type2 field2) ，然后在hql里面就可以直接生成这个bean了。具体怎么用请看相关文档，我说的不是很清楚。

    session.load()和session.get()的区别

    Session.load/get方法均可以根据指定的实体类和id从数据库读取记录，并返回与之对应的实体对象。其区别在于：

    如果未能发现符合条件的记录，get方法返回null，而load方法会抛出一个ObjectNotFoundException。
    Load方法可返回实体的代理类实例，而get方法永远直接返回实体类。

    load方法可以充分利用内部缓存和二级缓存中的现有数据，而get方法则仅仅在内部缓存中进行数据查找，如没有发现对应数据，将越过二级缓存，直接调用SQL完成数据读取。

    Session在加载实体对象时，将经过的过程：

    首先，Hibernate中维持了两级缓存。第一级缓存由Session实例维护，其中保持了Session当前所有关联实体的数据，也称为内部缓存。而第二级缓存则存在于SessionFactory层次，由当前所有由本SessionFactory构造的Session实例共享。出于性能考虑，避免无谓的数据库访问，Session在调用数据库查询功能之前，会先在缓存中进行查询。首先在第一级缓存中，通过实体类型和id进行查找，如果第一级缓存查找命中，且数据状态合法，则直接返回。

    之后，Session会在当前“NonExists”记录中进行查找，如果“NonExists”记录中存在同样的查询条件，则返回null。“NonExists”记录了当前Session实例在之前所有查询操作中，未能查询到有效数据的查询条件（相当于一个查询黑名单列表）。如此一来，如果Session中一个无效的查询条件重复出现，即可迅速作出判断，从而获得最佳的性能表现。

    对于load方法而言，如果内部缓存中未发现有效数据，则查询第二级缓存，如果第二级缓存命中，则返回。
    如在缓存中未发现有效数据，则发起数据库查询操作（Select SQL），如经过查询未发现对应记录，则将此次查询的信息在“NonExists”中加以记录，并返回null。

    根据映射配置和Select SQL得到的ResultSet，创建对应的数据对象。
    将其数据对象纳入当前Session实体管理容器（一级缓存）。

    执行Interceptor.onLoad方法（如果有对应的Interceptor）。

    将数据对象纳入二级缓存。

    如果数据对象实现了LifeCycle接口，则调用数据对象的onLoad方法。
    返回数据对象。

   Hibernate的主键生成机制

    1) assigned

    主键由外部程序负责生成，无需Hibernate参与。

    2) hilo

    通过hi/lo 算法实现的主键生成机制，需要额外的数据库表保存主键生成历史状态。

    3) seqhilo

    与hilo 类似，通过hi/lo 算法实现的主键生成机制，只是主键历史状态保存在Sequence中，适用于支持Sequence的数据库，如Oracle。

    4) increment

    主键按数值顺序递增。此方式的实现机制为在当前应用实例中维持一个变量，以保存着当前的最大值，之后每次需要生成主键的时候将此值加1作为主键。这种方式可能产生的问题是：如果当前有多个实例访问同一个数据库，那么由于各个实例各自维护主键状态，不同实例可能生成同样的主键，从而造成主键重复异常。因此，如果同一数据库有多个实例访问，此方式必须避免使用。

    5) identity

    采用数据库提供的主键生成机制。如DB2、SQL Server、MySQL中的主键生成机制。

    6) sequence

    采用数据库提供的sequence 机制生成主键。如Oralce 中的Sequence。

    7) native

    由Hibernate根据底层数据库自行判断采用identity、hilo、sequence其中一种作为主键生成方式。

    8) uuid.hex

    由Hibernate基于128 位唯一值产生算法生成16 进制数值（编码后以长度32 的字符串表示）作为主键。

    9) uuid.string

    与uuid.hex 类似，只是生成的主键未进行编码（长度16）。在某些数据库中可能出现问题（如PostgreSQL）。

    10) foreign

    使用外部表的字段作为主键。一般而言，利用uuid.hex方式生成主键将提供最好的性能和数据库平台适应性。
    这10中生成OID标识符的方法,increment 比较常用,把标识符生成的权力交给Hibernate处理.但是当同时多个 Hibernate应用操作同一个数据库,甚至同一张表的时候.就推荐使用identity 依赖底层数据库实现,但是数据库必须支持自动增长,当然针对不同的数据库选择不同的方法.如果你不能确定你使用的数据库具体支持什么的情况下.可以选择用native 让Hibernate来帮选择identity,sequence,或hilo.
    另外由于常用的数据库，如Oracle、DB2、SQLServer、MySql 等，都提供了易用的主键生成机制（Auto-Increase 字段或者Sequence）。我们可以在数据库提供的主键生成机制上，采用generator-class=native的主键生成方式。
    不过值得注意的是，一些数据库提供的主键生成机制在效率上未必最佳，大量并发insert数据时可能会引起表之间的互锁。数据库提供的主键生成机制，往往是通过在一个内部表中保存当前主键状态（如对于自增型主键而言，此内部表中就维护着当前的最大值和递增量），之后每次插入数据会读取这个最大值，然后加上递增量作为新记录的主键，之后再把这个新的最大值更新回内部表中，这样，一次Insert操作可能导致数据库内部多次表读写操作，同时伴随的还有数据的加锁解锁操作，这对性能产生了较大影响。因此，对于并发Insert要求较高的系统，推荐采用uuid.hex 作为主键生成机制。

 

 

 Struts，Spring，Hibernate面试题总结 收藏

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

原理：

1.         读取并解析配置文件

2.         读取并解析映射信息，创建SessionFactory

3.         打开Sesssion

4.         创建事务Transation

5.         持久化操作

6.         提交事务

7.         关闭Session

8.         关闭SesstionFactory

 

为什么要用：

 

1.    对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。

2.    Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作

3.    hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。

4.    hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。

 

2．   Hibernate是如何延迟加载?

1.         Hibernate2延迟加载实现：a)实体对象  b)集合（Collection）

2.         Hibernate3 提供了属性的延迟加载功能

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

3．   Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系)

类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many、

4．   说下Hibernate的缓存机制

1.         内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存

2.         二级缓存：

a)         应用及缓存

b)        分布式缓存

条件：数据不会被第三方修改、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非              关键数据

c)  第三方缓存的实现

5．   Hibernate的查询方式

Sql、Criteria,object comptosition

Hql：

1、  属性查询

2、  参数查询、命名参数查询

3、  关联查询

4、  分页查询

5、  统计函数

 

6．   如何优化Hibernate？

1.         使用双向一对多关联，不使用单向一对多

2.         灵活使用单向一对多关联

3.         不用一对一，用多对一取代

4.         配置对象缓存，不使用集合缓存

5.         一对多集合使用Bag,多对多集合使用Set

6.         继承类使用显式多态

7.         表字段要少，表关联不要怕多，有二级缓存撑腰

 

7．   Struts工作机制？为什么要使用Struts？

工作机制：

Struts的工作流程:

  在web应用启动时就会加载初始化ActionServlet,ActionServlet从

  struts-config.xml文件中读取配置信息,把它们存放到各种配置对象

  当ActionServlet接收到一个客户请求时,将执行如下流程.

    -(1)检索和用户请求匹配的ActionMapping实例,如果不存在,就返回请求路径无效信息;

    -(2)如果ActionForm实例不存在,就创建一个ActionForm对象,把客户提交的表单数据保存到ActionForm          对象中;

    -(3)根据配置信息决定是否需要表单验证.如果需要验证,就调用ActionForm的validate()方法;

    -(4)如果ActionForm的validate()方法返回null或返回一个不包含ActionMessage的ActuibErrors对象,                就表示表单验证成功;

    -(5)ActionServlet根据ActionMapping所包含的映射信息决定将请求转发给哪个Action,如果相应的                    Action实例不存在,就先创建这个实例,然后调用Action的execute()方法;

    -(6)Action的execute()方法返回一个ActionForward对象,ActionServlet在把客户请求转发给                               ActionForward对象指向的JSP组件;

    -(7)ActionForward对象指向JSP组件生成动态网页,返回给客户;

为什么要用：

JSP、Servlet、JavaBean技术的出现给我们构建强大的企业应用系统提供了可能。但用这些技术构建的系统非常的繁乱，所以在此之上，我们需要一个规则、一个把这些技术组织起来的规则，这就是框架，Struts便应运而生。

基于Struts开发的应用由3类组件构成：控制器组件、模型组件、视图组件

8．   Struts的validate框架是如何验证的？

在struts配置文件中配置具体的错误提示，再在FormBean中的validate()方法具体调用。

9．   说下Struts的设计模式

MVC模式:  web应用程序启动时就会加载并初始化ActionServler。用户提交表单时，一个配置好的ActionForm对象被创建，并被填入表单相应的数据，ActionServler根据Struts-config.xml文件配置好的设置决定是否需要表单验证，如果需要就调用ActionForm的Validate（）验证后选择将请求发送到哪个Action，如果Action不存在，ActionServlet会先创建这个对象，然后调用Action的execute（）方法。Execute（）从ActionForm对象中获取数据，完成业务逻辑，返回一个ActionForward对象，ActionServlet再把客户请求转发给ActionForward对象指定的jsp组件，ActionForward对象指定的jsp生成动态的网页，返回给客户。

单例模式

Factory(工厂模式)：

定义一个基类===》实现基类方法（子类通过不同的方法）===》定义一个工厂类（生成子类实例）

===》开发人员调用基类方法

Proxy(代理模式)

10．  spring工作机制及为什么要用?

 

1.spring mvc请所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责负责对请求进行真正的处理工作。

2.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller.

3.DispatcherServlet请请求提交到目标Controller

4.Controller进行业务逻辑处理后，会返回一个ModelAndView

5.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象

6.视图对象负责渲染返回给客户端。

为什么用：

{AOP 让开发人员可以创建非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。使用 AOP 后，公共服务 （比如日志、持久性、事务等）就可以分解成方面并应用到域对象上，同时不会增加域对象的对象模型的复杂性。

IOC允许创建一个可以构造对象的应用环境，然后向这些对象传递它们的协作对象。正如单词 倒置 所表明的，IOC 就像反过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction），每一个对象都是用    其协作对象构造的。因此是由容器管理协作对象（collaborator）。

Spring即使一个AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring，只要用 JavaBean 属性和配置文件加入依赖性（协作对象）。然后可以很容易地在需要时替换具有类似接口的协作对象。}