Hibernate(JAVA)面试题

Hibernate（JAVA）面试题

Hibernate (JAVA)面试题

一、简述Hibernate作用？

O/R Mapping(对象关系映射)

将工作量降低95%

二、简述核心配置文件及作用？

：数据库的连接、批量处理、加载二级缓存驱动、显示sql

*.：将一个表与类相映射、二级缓存的方式

三、简述核心接口、类组成及作用？

类:

Configuration：读取及*..文件

接口:

SessionFactory:产生具体的session

Session:做具体的操作

save

update

saveOrUpdate:有主键修改，没主键增加

delete

load

Transaction ：事务处理

Transaction trans=ransaction();

/doc/,mit();

ck();

Query:执行查询

//hql，类及属性是对象

Query query=Query("from Customer where

customerid=:aa")

ing("aa","aa")

List list=();

Validator:在做之前进行拦截,在处理之前进行校验

Lifecycle:拦截器，可以增加、修改、查询等之前触发，但其让数据类与hibernate 的藕合度增加，一般不用。

public class Users implements Validator,Lifecycle

{

}

interceptor:拦截器,其比Lifecycle更加的优秀,不用每个数据类去实现一些接口，而是在产生session时将其注入到session中。其可以增加、修改、查询等之前触发，但其中的session不可以重用，可以用上一个session的connection，不用管事务，因为事务已被前一个session实现。

四、简述关联组成及作用？

one-to-many:

get/set方法:

一方通过get方法可以取出另一方，另一方也可以通过get方法取出对方，所以在one这边有一个Set属性可以得到所有的many,many这边有一个One类型的属性可以取出one

inverse:主控方，维护外键值，说明外键列由谁来控制，要想维护外键列的值必须将被控方作为主控方的属性，主控方一般在many方。

inverse=false 是主控方，外键是由它控制的

inverse=true 是被控方，外键与它没关系

cascade:级联，要想实现级联必须将从对象作为主对象的属性。

主表增从表增

主表修从表修

主表删从表删

lazy:延迟

lazy=false：不但取当前对象，还取其关联的所有内容

lazy=true：只取当前对象不取关联对象的属性，当真正用到对方属性时才执行sql加载相应的值

五、简述批量删除？

Query query=Query("update"或"delete");

eUpdate();

不同步缓存

六、简述Tomcat连接池作用及实现步骤？

在容器中预先产生了n个连接实例,客户端不用重新实例化，可以直接取,用完后还可以放回去。

步骤：

1、将sql-server三个包拷贝到C:tomcat-6lib下目录下

2、修改C:/tomcat-6/conf/为以下内容

<=""

"

auth="Container"

maxidle="30"

p=""

bdsfid="121"

maxwait="10000"

password=""

driverclassname="verDrivermaxactive="100"

name="jdbc/sqlserver"

type="urce" username="sa">

url="jdbc:microsoft:sqlserver://localhost:1433;databaseName=pubs;selectMethod=cursor"/>

3、jdbc测试代码

Context initCtx = new InitialContext();

//进入连接池环境

Context envCtx = (Context)("java:comp/env");

//得到一个连接池

ds = (DataSource)("jdbc/sa");

//得到连接

Connection conn = nection();

4、hibernate通过连接池实现连接

java:comp/env/jdbc/sa

true

name="dialect">verDialect

5、spring调用tomcat中的连接池

java:comp/env/jdbc/name

七、简述hibernate中的主键生成机制？

1、Assigned:手动给定

2、identity:sqlserver、db2、mySql的自动增加

3、sequence:oracle的序列

4、native:自动选择identity、sequence，不用手动给定

5、:Hibernate基于128位唯一值产生算法生成16 进制数值

八、简述数据库开发的过程？

外模型

以客户为中心，客户可以看懂。

概念模型

以外模型作为输入，适应开发的进一步细化，是外模型全集

注意事项:

符合需求

速度

冗余

开发的难度

内模型

数据库

九、简述e-r图设计的过程？

找实体

拉关系

写属性

十、简述三级范式？

主键

完全依赖于主键

不出现传递依赖

十一. 简述对象的三大状态？

自由(transient)

与session无关

持久(persistent)

由session来管理

在持久状态中通过get方法取出对方

游离(detached)

被session抛弃

十二、简述没有锁会存在的问题？

1、脏读:一个事务处理的数据是另一个事务没有提交的数据

2、覆盖更新:一个事务将另一个事务的修改覆盖了。

3、不可重复读:一个事务两个相同的sql读取出来的内容不一样。

4、幻想读:同一个事务第一次读有，第二次读没有。

十三、简述锁的分类？

1、读未提交:可以读取未提交的数据，不可以防止脏读、覆盖更新。

2、读已提交（数据库默认的处理方式）:读取的数据是已提交的，在提交之前当前行的版本与数据库的版本比较，若小于数据库的版本报错回退。

乐观锁:一个游标读取一批数据后不加锁，另一个事务可以更新游标中的数据，但游标所在事务更新另一事务更新过的行时，报错，回退。

系统运行效率快。

悲观锁:一个游标读取一批数据后加锁，另一个事务不可以更新游标中的数据，但游标所在事务的更新一定成功。

系统运行效率慢。

3、可重复读:将上一个sql取的数据临时存储，保证同一个事务内下一个sql与上一个sql取的数据一样。

4、串行化:一个事对表进行select、update、delete、insert时全表加锁，另一个事只可以select不可update、delete、insert。运行速度最慢。

十四、简述hibbernate的缓存？

1、事务级(一级缓存session):当前事务结束缓存结束。

2、应用级(二级缓存SessionFactory):所有session共享同一个SessionFactory的数据。要人为让SesionFactory是单例模式。

3、集群(有多个应用服务器):每一台主机有一个SessionFactory,一个服务器的数据发生改变要通知其它所有服务器同步缓存数据或删除缓存数据，如果删除，下次取时再从数据库中取。集群级缓存要慎用，因为有主机之间有通信，要有socket连接，要同步数据增加网络流通量及系统开销。

十五、简述利用缓存的原则？

1、数据量在可接收的范围内

2、更新或并发更新少

3、重复查询且使用率高的数据

十六、简述缓存的实现步骤？

1、hibernate提供了支持缓存的接口，通过修改设置缓存。

2、将拷入工程

3、要src的根目录下加入说明缓存。

3、在中加入两个属性

a、说明提供二级缓存驱动类

b、说明query也支持缓存

eProvider

true

4、在具体的中说明当前类使用二级缓存

5、在执行query之前设置其支持二级缓存

heable(true);

十七、简述list使用缓存的特点？

sql只执行一次，直接查询o/r mapping后返回结果,要想重用缓存，hql必须相同，如果相同，相应行的主键在缓存中就直接取，如果没有根据主键值在数据库中找，而不是重新执行整个sql。

十八、简述iterator使用缓存的特点？

先执行一次sql取出所有主键，再根据主键值查找缓存，若有直接取出，若没有根据主键在数据库中查相应的对象并进行o/rMapping。对于没缓存的sql，其sql要执行"

行数+1"次。对于有缓存的行，执行效率高。综上:第一次查询用list方法，第二查询用iterator方法。

十九、简述数据查找的过程？

首先在一级缓存中中找，若没有找到就在二级缓存中，若还是没有找到就产生sql 在数据据库中找。

二十、简述缓存的特点？

load、get、insert、update、delete都会自动同步缓存，但eUpdate()不更缓存，但如果批量更新时exeucuteUpdate执行效率很高。

一个对象通过get或的方法查询放到一级缓存或二级缓存中时，不能用update直接更新，只通通过set方法更新。

evict:清除缓存。

二十一、简述load与get方法的区别？

相同点:3.2版本

先从一级缓存找，如果没在二级缓存中找的。

load:

如果没有找到报ObjectNotFoundException

返回的是一个代理

如果当前数据类的接口返回的应是接口

如果当前数据类没有接口，通过CGLIB返回类似接口的引用。

get

如果没有找开返回null

如果得到是一个真实的对象

二十二、简述hibernate常见优化策略？

1、用最新版本的hibernate

2、制定合理的缓存策略

用二级缓存，缓存的原则。

3、采用合理的session管理机制

一个线程个session,线程结束session结束。

4、尽量使用延迟加载

many

大文本、大文件

5、设定合理的批处理参数(batch-size)

fetch_size:每次从数据库中取出记录条数一般设置为30、50、100。

OracleJDBC驱动默认的Fetch Size=15,设置Fetch Size为：30、50性能会明显提升。

batch_size:

在进行插入、更新、删除时执行多少个sql后将sql提交到数据库中hibernate中的配置如下:

key="t">9Dialect

false

50

6、如有可能，选用uuid作为主键生成器

7、如有可能，选用基于version的乐观锁替代悲观锁

非观锁:

1）、Query query1=Query("select * from

Customer for update");

2）、Query query1=Query("select * from

Customer");

kMode("Customer",E);

乐观锁

optimistic-lock="version/none"

/>

8、开发过程中，打开hibernate的SQl日志输出(_sql=true)，通过观察hibernate生成的sql语句进一步了解其实现原理，从而指事实上更好的实现策略。

二十三、简述hql？

1、criteria：可以不用写hql就可查询数据库中的内容

Criteria cri=Criteria();

--加入查询的条件

(("age",30));

--加入排序

er(("sex"));

--分页

stRow(0);

ResultRows(2);

2、取一个属性

List sexes=Quyer("select sex from Customer");

for(String sex:sexes)

{

}

3、取多个属性

List

for(Object[] field:fields)

{

field[0];

field[1];

field[2];

}

4、将多个属构造成一个对象

List customers=Quyer("select new

fields=Quyer("select

customerName,age,sex from Customer");

Customer(customerName,age,sex) from Customer");

for(Customer customer:customers)

{

tomerName();

}

5、查询的sql来自于配置文件

--在*.文件中配置hql

<[!CDATA[

FROM Customer where customerName=:customerName

]]>

Query query=edQuery("myHql");

ing("customerName","a1");

();

6、order by及group by

List fields=Query("

select count(sex),customerName from Customer

group by customerName order by customerName").list();

for(Object[] field:fields)

{

Long count=(Long)fields[0];

String customerName=(String)fields[1];

}

7、关联

1、没有fetch

1、通用的sql

a、在where条件中关联

select c.*,b.* from customer c,buy b

where erName=erName;

b、在from子句中关联

select c.*,b.* from customer c join buy b

on erName=erName;

2、hibernate的实现

1、没有fetch的实现

List results=Query("from Customer as

customer inner join ");

for(Object[] result:results)

{

Customer customer=(Customer)result[0];

Buy buy=(Buy)result[1];

}

2、有fetch的实现

二十四、简述数据加载方式？

即时加载:加载不但加载当前对象还加载其关联对象属性

延迟加载:加载时只加载当前对象，不加载关联对象，只有真正用关联对象的属性时才加载。

预先加载:针对关联，一个sql加载多个对象。

批量加载:设置bach-size及fetch-size参数

二十五、如何实现继承？

1、一个类一张表

2、子类与父类是同一张表，在表中多加入一个字段说明是子类还是父类

1）、表

create table user2

(

userName varchar(20) primary key,

pwd varchar(20),

guessRemark varchar(20),

adminRemark varchar(20),

DISCRIMINATOR_USERTYPE varchar(30)

)

2）、三个类的实现,Guess及Admin继承于user2

3）、具体配置

4）、特点:查询父类时会查询所有的子类

3、三个类三张表，子类对应的表共享父类的字段

1）、sql

drop table guest3;

drop table admin3;

drop table user3;

create table user3

(

USERID varchar(32) primary key,

username varchar (30),

pwd varchar(20)

);

create table guest3

(

USERID varchar(32) primary key,

guest_remark varchar(20),

constraint guest3_fk foreign

user3(userID) );

create table admin3

(

USERID varchar(32) primary key,

admin_remark varchar(20),

constraint admin3_fk foreign

user3(userID) );

2）、配置

二十六、简述many-to-many？

例子：

create table power

key(userID)

references

references

key(userID)

(

powerID int primary key,

powerName varchar(20)

);

create table role

(

roleID int primary key,

roleName varchar(20)

);

create table rolepower

(

powerID int foreign key references power(powerID),

roleID int foreign key references power(powerID)

);

--power

--powerID是rolepower的外键列

--roleID是rolepower的外键列

--清楚当前power的主键值

select * from Role where rowID in

(

select roleID

from rolepower where powerID=当前power的主键值

);

--role

select * from Power where powerID in

(select 中间的外键powerID from rolepower where 中间的外键roleID=role表的主键(roleId))