完整版hibernate面试题.docx
《完整版hibernate面试题.docx》由会员分享，可在线阅读，更多相关《完整版hibernate面试题.docx（18页珍藏版）》请在冰豆网上搜索。
完整版hibernate面试题
1.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,objectcomptosition
Hql：
1、属性查询
2、参数查询、命名参数查询
3、关联查询
4、分页查询
5、统计函数
6．如何优化Hibernate？
1.使用双向一对多关联，不使用单向一对多
2.灵活使用单向一对多关联
3.不用一对一，用多对一取代
4.配置对象缓存，不使用集合缓存
5.一对多集合使用Bag,多对多集合使用Set
6.继承类使用显式多态
7.表字段要少，表关联不要怕多，有二级缓存撑腰
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
答案二：
hibernate工作原理：
1、通过Configuration（）.configure（）;读取并解析hibernate.cfg.xml配置文件。
2、由hibernate.cfg.xml中的读取解析映射信息。
3、通过config.buildSessionFactory（）;//得到sessionFactory。
4、sessionFactory.openSession（）;//得到session。
5、session.beginTransaction（）;//开启事务。
6、persistentoperate;
6、session.getTransaction（）.commit（）;//提交事务
7、关闭session;
8、关闭sessionFactory;
hibernate优点：
1、封装了jdbc，简化了很多重复性代码。
2、简化了DAO层编码工作，使开发更对象化了。
3、移植性好，支持各种数据库，如果换个数据库只要在配置文件中变换配置就可以了，不用改变hibernate代码。
4、支持透明持久化，因为hibernate操作的是纯粹的（pojo）java类，没有实现任何接口，没有侵入性。
所以说它是一个轻量级框架。
hibernate延迟加载：
get不支持延迟加载，load支持延迟加载。
1、hibernate2对实体对象和集合实现了延迟加载
2、hibernate3对提供了属性的延迟加载功能
hibernate延迟加载就是当使用session.load（User.class,1）或者session.createQuery（）查询对象或者属性的时候
这个对象或者属性并没有在内存中，只有当程序操作数据的时候，才会存在内存中，这样就实现延迟加载，节省了内存的开销，从而提高了服务器的性能。
Hibernate的缓存机制
一级缓存：
session级的缓存也叫事务级的缓存，只缓存实体，生命周期和session一致。
不能对其进行管理。
不用显示的调用。
二级缓存：
sessionFactory缓存，也叫进程级的缓存，使用第3方插件实现的，也值缓存实体，生命周期和sessionFactory一致，可以进行管理。
首先配置第3放插件，我们用的是EHCache，在hibernate.cfg.xml文件中加入
true
在映射中也要显示的调用，
二级缓存之查询缓存：
对普通属性进行缓存。
如果关联的表发生了修改，那么查询缓存的生命周期也结束了。
在程序中必须手动启用查询缓存：
query.setCacheable（true）;
优化Hibernate
1、使用一对多的双向关联，尽量从多的一端维护。
2、不要使用一对一，尽量使用多对一。
3、配置对象缓存，不要使用集合缓存。
4、表字段要少，表关联不要怕多，有二级缓存撑腰。
（1）一般情况下，关系数据模型与对象模型之间有哪些匹配关系（多选）
A）表对应类B）记录对应对象C）表的字段对应类的属性
（2）以下关于SessionFactory的说法哪些正确？
（多选）
）一个SessionFactory对象对应一个数据库存储源。
C）SessionFactory是重量级的对象，不应该随意创建。
如果系统中只有一个数据库存储源，只需要创建一个
（3）Customer类中有一个Set类型的orders属性，用来存放Order订单对象，在Customer.hbm.xml文件中，用哪个元素映射orders属性？
A）B）C）D）<:
property>
（4）元素有一个cascade属性，如果希望Hibernate级联保存集合中的对象，casecade属性应该取什么值？
（单选）
）save-update
（5）以下哪些属于Session的方法？
A）load（）B）save（）C）delete（）D）update（）E）open（）F）close（）
（6）以下程序的打印结果是什么？
（单选）
1.tx = session.beginTransaction（）;
2.Customer c1=（Customer）session.load（Customer.class,new Long
（1））;
3.Customer c2=（Customer）session.load（Customer.class,new Long
（1））;
4.System.out.println（c1==c2）;
mit（）;
6.session.close（）;
打印true
（7）以下程序代码对Customer的name属性修改了两次：
1.tx = session.beginTransaction（）;
2.Customer customer=（Customer）session.load（Customer.class,
3.new Long
（1））;
4.customer.setName（\"Jack\"）;
5.customer.setName（\"Mike\"）;
mit（）;
执行以上程序，Hibernate需要向数据库提交几条update语句？
（单选）
B，1
（8）在持久化层，对象分为哪些状态？
（多选）
A）临时状态C）游离状态D）持久化状态
（9）对于以下程序，Customer对象在第几行变为持久化状态？
（单选）
1.Customer customer=new Customer（）; //line1
2.customer.setName（\"Tom\"）; //line2
3.Session session1=sessionFactory.openSession（）; //line3
4.Transaction tx1 = session1.beginTransaction（）; //line4
5.session1.save（customer）; //line4
mit（）; //line5
7.session1.close（）; //line6
A）line1B）line2C）line3D）line4E）line5F）line6
（10）对于以下程序，Customer对象在第几行变为游离状态？
（单选）
1.Customer customer=new Customer（）; //line1
2.customer.setName（\"Tom\"）; //line2
3.Session session1=sessionFactory.openSession（）; //line3
4.Transaction tx1 = session1.beginTransaction（）; //line4
5.session1.save（customer）; //line4
mit（）; //line5
7.session1.close（）; //line6
）line6
（11）以下哪一种检索策略利用了外连结查询？
（单选）
A）立即检索B）延迟检索C）迫切左外连结检索
（12）假设对Customer类的orders集合采用延迟检索策略，编译或运行以下程序，会出现什么情况（单选）
1.Session session=sessionFactory.openSession（）;
2.tx = session.beginTransaction（）;
3.Customer customer=（Customer）session.get（Customer.class,new Long
（1））;
mit（）;
5.session.close（）;
6.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）HibernateC）数据库系统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对象的三种状态是什么？
瞬时态（Transient）、持久态（Persistent）、脱管态（Detached）。
处于持久态的对象也称为PO（PersistenceObject），瞬时对象和脱管对象也称为VO（ValueObject）。
瞬时态
由new命令开辟内存空间的java对象，
eg.Personperson=newPerson（”amigo”,“女”）;
如果没有变量对该对象进行引用，它将被java虚拟机回收。
瞬时对象在内存孤立存在，它是携带信息的载体，不和数据库的数据有任何关联关系，在Hibernate中，可通过session的save（）或saveOrUpdate（）方法将瞬时对象与数据库相关联，并将数据对应的插入数据库中，此时该瞬时对象转变成持久化对象。
持久态
处于该状态的对象在数据库中具有对应的记录，并拥有一个持久化标识。
如果是用hibernate的delete（）方法，对应的持久对象就变成瞬时对象，因数据库中的对应数据已被删除，该对象不再与数据库的记录关联。
当一个session执行close（）或clear（）、evict（）之后，持久对象变成脱管对象，此时持久对象会变成脱管对象，此时该对象虽然具有数据库识别值，但它已不在HIbernate持久层的管理之下。
持久对象具有如下特点：
1.和session实例关联；
2.在数据库中有与之关联的记录。
脱管态
当与某持久对象关联的session被关闭后，该持久对象转变为脱管对象。
当脱管对象被重新关联到session上时，并再次转变成持久对象。
脱管对象拥有数据库的识别值，可通过update（）、saveOrUpdate（）等方法，转变成持久对象。
脱管对象具有如下特点：
1.本质上与瞬时对象相同，在没有任何变量引用它时，JVM会在适当的时候将它回收；
2. 比瞬时对象多了一个数据库记录标识值。
DetachedObject（游离对象）有什么好处？
DetachedObject（游离对象）可以传递到任何层直到表现层而不是用任何DTO（DataTransferObjects）.然后你还可以重新把游离对象赋给另外一个Session.
jdbc、hibernate、ibatis的区别？
jdbc:
手动
手动写sql
delete、insert、update要将对象的值一个一个取出传到sql中,不能直接传入一个对象。
select:
返回的是一个resultset，要从ResultSet中一行一行、一个字段一个字段的取出，然后封装到一个对象中，不直接返回一个对象。
ibatis的特点:
半自动化
sql要手动写
delete、insert、update:
直接传入一个对象
select:
直接返回一个对象
hibernate:
全自动
不写sql,自动封装
delete、insert、update:
直接传入一个对象
select:
直接返回一个对象
Hibernate如何实现数据表映射的继承关系？
1、两个表，子类重复父类的属性。
2、一个表，子类父类共用一个表
3、两个表，子类引用父类的主键，享用公共的字段或属性。
批量删除
Queryquery=session.createQuery（”update”或”delete”）;
query.executeUpdate（）;
Hibernate中Query对象的使用
1个或多个属性查询:
Queryquery=session.createQuery（”selectcustomername,customeridfromCustomer”）
Listl=query.list（）;
For（inti=0;i{
Obejct[]object=（Object[]）l.get（i）;
Object[0] object[1]
}
}
分组:
“selectcount（*）,productnamefromProductgroupbyproductnameorderbyproductname”
取值与属性一样
配置的查询,在*.hbm.xml中
[CDATA[
fromProductwhereproductid=:
productid
]]>
Queryquery=session.getNamedQuery（sql）;
联接1
”fromCustomerascustomerjoinfetchcustomer.buySet”：
将多的放到buySet属性中，得出的结是Customer有一个，Buy有多个
联接2
“fromCustomerascustomerjoincustomer.buySet”:
得出的对象,customer与buy是1对1
子查询:
”fromCustomerascustomerwhere（selectcount（*）fromcustomer.buySet）>1″
Hibernate中Criteria和DetachedCriteria的作用是什么？
Criteriac=session.createCriteria（Customer.class）;
//设置条件
c.add（Expression.ge（“字段名”,”值对象”））
ge:
>=
gt:
>
le:
<=
lt:
<
eq:
=
//排序
c.addOrder（Order.asc（“字段名”））
//分页
c.setFirstResult
（1）//从第2行开始提取
c.setMaxResults（5）//返回5行
DetachedCriteria产生时不需要session
DetachedCriteriadc=DetachedCriteria.forClass（Customer.class）
Criteriac=Dc.getExecutableCriteria（session）
Hibernate中数据表映射关系主要有什么类型？
one-to-many
inverse:
主控方，外键的关系有谁控制
inverse=false是主控方，外键是由它控制的
inverse=true是被控方，外键与它没关系
要想实现主控方的控制必须将被控方作为主控方的属性
cascade:
级联
主表增从表增
主表修从表修
主表删从表删
lazy:
延迟
lazy=false：
一下将所有的内容取出，不延时（常用）
lazy=true：
取出部分内容，其余内容动态去取
通过get可以取出对方的所有内容
hibernate的核心类是什么，它们的相互关系是什么?
重要的方法是什么?
Configuration
SessionFactory
Session如下方法
Save
load
Update
Delete
Queryq=CreateQuery（“fromCustomerwherecustomerName=:
customerName”）
beginTransaction
close
Transaction
Commit（）
在myeclipse加入hibernate环境的全过程是什么?
1.Db-browers加入配置连接
2.新建工程
3.加入hibernate环境，指定*.hbm.xml及HibernateSessionFactory文件所在的位置
详细内容参见以前写的hibernate的第一个小例子
面试中常出现的两个Hibernate面试题及解答
1.在数据库中条件查询速度很慢的时候,如何优化?
1.建索引
2.减少表之间的关联
3.优化sql，尽量让sql很快定位数据，不要让sql做全表查询，应该走索引,把数据量大的表排在前面
4.简化查询字段，没用的字段不要，已经对返回结果的控制，尽量返回少量数据
[2.在hibernate中进行多表查询,每个表中各取几个字段,也就是说查询出来的结果集并没有一个实体类与之对应,如何解决这个问题?
解决方案一，按照Object[]数据取出数据，然后自己组bean
解决方案二，对每个表的bean写构造函数，比如表一要查出field1,field2两个字段，那么有一个构造函数就是Bean（type1filed1,type2field2），然后在hql里面就可以直接生成这个bean了。
具体怎么用请看相关文档，我说的不是很清楚。
session.load（）和session.get（）的区别
Session.load/get方法均可以根据指定的实体类和id从数据库读取记录，并返回与之对应的实体对象。
其区别在于：
如果未能发现符合条件的记录，get方法返回null，而load方法会抛出一个ObjectNotFoundException。
Load方法可返回实体的代理类实例，而
升级会员 