Hibernate常见面试题汇总.docx

Hibernate常见面试题汇总.docx

《Hibernate常见面试题汇总.docx》由会员分享，可在线阅读，更多相关《Hibernate常见面试题汇总.docx（16页珍藏版）》请在冰豆网上搜索。

Hibernate常见面试题汇总

spring面试题

一、spring工作原理：

（有点像strucs）

Spring的哲学是在不影响Java对象的设计的情况下将Java对象加入到框架中。

我们下面来看看Spring的工作原理，看看Spring是如何做到不影响Java对象的。

　　EJB的框架采用了一种侵略性（Invasive）的方法来设计对象，它要求你在设计中加入符合EJB规范的代码。

一些轻量级的COP框架，例如Avalon，也要求对象设计时必须符合某种规范，例如Serviceable接口，这种做法是典型的Type1做法。

　　这种设计思路要求Spring采用一种动态的、灵活的方式来设计框架。

在Spring的工作原理中大量采用了反射。

首先Spring要解决的一个问题就是如何管理bean。

因为IOC的思想要求bean之间不能够直接调用，而应该采用一种被动的方式进行协作。

所以bean的管理是Spring工作原理中的核心部分。

　　反射和内省在代码的层次上思考问题，有时候能够带来出人意料的灵活性。

但它的使用有时候也是一个哲学问题，不论是在ORM设计还是在AOP设计上都出现了类似的问题-究竟是使用反射，还是使用代码生成。

　　在Spring中，处理这个问题的核心是在org.springframework.beans包中。

而其中最为核心的部分，则是BeanWrapper。

BeanWrapper，顾名思义，就是bean的包装器。

所以，它的主要工作，就是对任何一个bean，进行属性（包括内嵌属性）的设置和方法的调用。

在

　　BeanWrapper的默认实现类BeanWrapperImpl中，虽然代码较长，但完成的工作却是非常的集中的。

　　BeanWrapper的深入研究

　　我们看看这个BeanWrapper是如何发挥运作的，假设我们有两个bean：

　　publicclassCompany{　privateStringname;　privateEmployeemanagingDirector;　publicStringgetName（）{returnthis.name;　}　publicvoidsetName（Stringname）{this.name=name;　}　publicEmployeegetManagingDirector（）{returnthis.managingDirector;　}　publicvoidsetManagingDirector（EmployeemanagingDirector）{this.managingDirector=managingDirector;　}}publicclassEmployee{　privatefloatsalary;　publicfloatgetSalary（）{returnsalary;　}　publicvoidsetSalary（floatsalary）{this.salary=salary;　}}

　　然后我们使用BeanWrapper来调用这两个bean：

　　Companyc=newCompany（）;BeanWrapperbwComp=BeanWrapperImpl（c）;//settingthecompanyname...bwComp.setPropertyValue（"name","SomeCompanyInc."）;//...canalsobedonelikethis:

PropertyValuev=newPropertyValue（"name","SomeCompanyInc."）;bwComp.setPropertyValue（v）;//ok,letscreatethedirectorandtieittothecompany:

Employeejim=newEmployee（）;BeanWrapperbwJim=BeanWrapperImpl（jim）;bwJim.setPropertyValue（"name","JimStravinsky"）;bwComp.setPropertyValue（"managingDirector",jim）;//retrievingthesalaryofthemanagingDirectorthroughthecompanyFloatsalary=（Float）bwComp.getPropertyValue（"managingDirector.salary"）;

　　看起来麻烦了许多，但是这样Spring就可以使用统一的方式来管理bean的属性了。

　　Bean的制造工厂

　　有了对单个Bean的包装，还需要对多个的bean进行管理。

在spring中，把bean纳入到一个核心库中进行管理。

bean的生产有两种方法：

一种是一个bean产生多个实例，一种是一个bean只产生一个实例。

如果对设计模式熟悉的话，我们就会想到，前者可以采用Prototype，后者可以采用Singleton。

　　注意到，反射技术的使用使得我们不再像原始的工厂方法模式那样创建对象。

反射可以非常灵活的根据类的名称创建一个对象。

所以spring只使用了Prototype和Singleton这两个基本的模式。

　　Spring正是这样处理的，但是我们希望用户能够维护统一的接口，而不需要关心当前的bean到底是Prototype产生的独立的bean，还是Singleton产生的共享的bean。

所以，在org.springframework.beans.factory包中的BeanFactory定义了统一的getBean方法。

　　JDBC再封装JDBC优雅的封装了底层的数据库，但是JDBC仍然存在诸多的不变。

你需要编写大量的代码来完成CRUD操作，而且，JDBC无论是遇到什么样的问题，都抛出一个SQLException，这种做法在异常使用上被称为不完备的信息。

因为问题可能是很复杂的，也许是数据库连接的问题，也许是并发控制的问题，也许只是SQL语句出错。

没有理由用一个简单的SQLException就搞定全部的问题了，这种做法有些不负责任。

针对这两个问题，SpringFramework提出了两种解决方法：

首先，提供一个框架，把JDBC应用中的获取连接、异常处理、释放等比较通用的操作全部都集中起来，用户只需要提供特定的实现就OK了。

实现的具体细节采用的是模板方法。

举个例子，在org.springframework.jdbc.object包中，MappingSqlQuery类实现了将SQL查询映射为具体的业务对象。

JavaDoc中这样写到：

ReusablequeryinwhichconcretesubclassesmustimplementtheabstractmapRow（ResultSet,int）methodtoconverteachrowoftheJDBCResultSetintoanobject.用户必须实现mapRow方法，这是典型模板方法的应用。

我们拿一个具体的例子来看看：

　　classUserQueryextendsMappingSqlQuery{　publicUserQuery（DataSourcedatasource）{super（datasource,"SELECT*FROMPUB_USER_ADDRESSWHEREUSER_ID=?

"）;declareParameter（newSqlParameter（Types.NUMERIC））;compile（）;　}　//MaparesultsetrowtoaJavaobject　protectedObjectmapRow（ResultSetrs,intrownum）throwsSQLException{Useruser=newUser（）;user.setId（rs.getLong（"USER_ID"））;user.setForename（rs.getString（"FORENAME"））;returnuser;　}　publicUserfindUser（longid）{//Usesuperclassconveniencemethodtoprovidestrongtypingreturn（User）findObject（id）;　}}

　　其次是第二个问题，最麻烦的地方应该说是需要截住JDBC的异常，然后判断异常的类型，并重新抛出异常。

错误的问题可以通过连接来获取，所以麻烦的是如何截获异常。

Spring框架采用的方法是回调，处理回调的类在SpringFramework中被称为template。

　　JdbcTemplatetemplate=newJdbcTemplate（dataSource）;finalListnames=newLinkedList（）;template.query（"SELECTUSER.NAMEFROMUSER",newRowCallbackHandler（）{　publicvoidprocessRow（ResultSetrs）throwsSQLException{names.add（rs.getString

（1））;　}}）;

　　回调函数是一个匿名类，其中也使用了模板方法，异常的处理都在父类中完成了。

　　层间松耦合

　　在开放源码界已经出现了大量的基于MVC的Web容器，但是这些容器都仅限于Web的范围，不涉及Web层次后端的连接，Spring作为一个整体性的框架，定义了一种Web层和后端业务层的连接方式，这个思路仍然疏运图MVC的范畴，但耦合更松散，不依赖于具体的集成层次。

　　publicclassGoogleSearchControllerimplementsController{　privateIGoogleSearchPortgoogle;　privateStringgoogleKey;　publicvoidsetGoogle（IGoogleSearchPortgoogle）{this.google=google;　}　publicvoidsetGoogleKey（StringgoogleKey）{this.googleKey=googleKey;　}　publicModelAndViewhandleRequest（HttpServletRequestrequest,HttpServletResponseresponse）throwsServletException,IOException{　Stringquery=request.getParameter（"query"）;　GoogleSearchResultresult=　//Googlepropertydefinitionsomitted...　//Usegooglebusinessobject　google.doGoogleSearch（this.googleKey,query,start,maxResults,filter,restrict,safeSearch,lr,ie,oe）;　returnnewModelAndView（"googleResults","result",result）;}　}

　　回调函数是一个匿名类，其中也使用了模板方法，异常的处理都在父类中完成了。

二、为什么要用spring:

AOP让开发人员可以创建非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。

使用AOP后，公共服务  （比如日志、持久性、事务等）就可以分解成方面并应用到域对象上，同时不会增加域对象的对象模型的复杂性。

IOC允许创建一个可以构造对象的应用环境，然后向这些对象传递它们的协作对象。

正如单词倒置所表明的，IOC就像反     过来的JNDI。

没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straightconstruction），每一个对象都是用    其协作对象构造的。

因此是由容器管理协作对象（collaborator）。

Spring即使一个AOP框架，也是一IOC容器。

Spring最好的地方是它有助于您替换对象。

有了Spring，只要用JavaBean属性和配置文件加入依赖性（协作对象）。

然后可以很容易地在需要时替换具有类似接口的协作对象。

三、请你谈谈SSH整合：

SSH：

Struts（表示层）+Spring（业务层）+Hibernate（持久层）

Struts：

Struts是一个表示层框架，主要作用是界面展示，接收请求，分发请求。

在MVC框架中，Struts属于VC层次，负责界面表现，负责MVC关系的分发。

（View：

沿用JSP，HTTP，Form，Tag，Resourse；Controller：

ActionServlet，struts-config.xml，Action）

Hibernate：

Hibernate是一个持久层框架，它只负责与关系数据库的操作。

Spring：

Spring是一个业务层框架，是一个整合的框架，能够很好地黏合表示层与持久层。

四、介绍一下Spring的事务管理：

事务就是对一系列的数据库操作（比如插入多条数据）进行统一的提交或回滚操作，如果插入成功，那么一起成功，如果中间有一条出现异常，那么回滚之前的所有操作。

这样可以防止出现脏数据，防止数据库数据出现问题。

开发中为了避免这种情况一般都会进行事务管理。

Spring中也有自己的事务管理机制，一般是使用TransactionMananger进行管理，可以通过Spring的注入来完成此功能。

spring提供了几个关于事务处理的类：

TransactionDefinition//事务属性定义

TranscationStatus//代表了当前的事务，可以提交，回滚。

PlatformTransactionManager这个是spring提供的用于管理事务的基础接口，其下有一个实现的抽象类AbstractPlatformTransactionManager,我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类。

一般事务定义步骤：

TransactionDefinitiontd=newTransactionDefinition（）;

TransactionStatusts=transactionManager.getTransaction（td）;

try

{//dosth

transactionMmit（ts）;

}

catch（Exceptione）{transactionManager.rollback（ts）;}

spring提供的事务管理可以分为两类：

编程式的和声明式的。

编程式的，比较灵活，但是代码量大，存在重复的代码比较多；声明式的比编程式的更灵活。

编程式主要使用transactionTemplate。

省略了部分的提交，回滚，一系列的事务对象定义，需注入事务管理对象.

voidadd（）{

transactionTemplate.execute（newTransactionCallback（）{

pulicObjectdoInTransaction（TransactionStatusts）

{//dosth}

}

}

声明式：

使用TransactionProxyFactoryBean:

PROPAGATION_REQUIREDPROPAGATION_REQUIREDPROPAGATION_REQUIRED,readOnly

围绕Poxy的动态代理能够自动的提交和回滚事务

org.springframework.transaction.interceptor.TransactionProxyFactoryBean

PROPAGATION_REQUIRED–支持当前事务，如果当前没有事务，就新建一个事务。

这是最常见的选择。

PROPAGATION_SUPPORTS–支持当前事务，如果当前没有事务，就以非事务方式执行。

PROPAGATION_MANDATORY–支持当前事务，如果当前没有事务，就抛出异常。

PROPAGATION_REQUIRES_NEW–新建事务，如果当前存在事务，把当前事务挂起。

PROPAGATION_NOT_SUPPORTED–以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

PROPAGATION_NEVER–以非事务方式执行，如果当前存在事务，则抛出异常。

PROPAGATION_NESTED–如果当前存在事务，则在嵌套事务内执行。

如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。

五、Spring里面如何配置数据库驱动？

使用”org.springframework.jdbc.datasource.DriverManagerDataSource”数据源来配置数据库驱动。

示例如下：

       org.hsqldb.jdbcDriver

       jdbc:

hsqldb:

db/appfuse

   sa

六、Spring里面applicationContext.xml文件能不能改成其他文件名？

ContextLoaderListener是一个ServletContextListener,它在你的web应用启动的时候初始化。

缺省情况下，它会在WEB-INF/applicationContext.xml文件找Spring的配置。

你可以通过定义一个元素名字为”contextConfigLocation”来改变Spring配置文件的位置。

示例如下：

   org.springframework.web.context.ContextLoaderListener   

       contextConfigLocation

       /WEB-INF/xyz.xml

七、如何在web应用里面配置spring?

在web.xml中加入如下同容,在启动web服务器时加载/WEB-INF/applicationContext.xml中的内容。

context

org.springframework.web.context.ContextLoaderServlet

1

通过如下类得到ApplicationContext实例

   WebApplicationContextUtils.getWebApplicationContext

八、Spring里面如何定义hibernatemapping？

添加hibernatemapping文件到web/WEB-INF目录下的applicationContext.xml文件里面。

示例如下：

       org/appfuse/model/User.hbm.xml

九、解释一下Dependencyinjection（DI,依赖注入）和IOC（Inversionofcontrol,控制反转）?

依赖注入DI是一个程序设计模式和架构模型，一些时候也称作控制反转，尽管在技术上来讲，依赖注入是一个IOC的特殊实现，依赖注入是指一个对象应用另外一个对象来提供一个特殊的能力，例如：

把一个数据库连接已参数的形式传到一个对象的结构方法里面而不是在那个对象内部自行创建一个连接。

控制反转和依赖注入的基本思想就是把类的依赖从类内部转化到外部以减少依赖

应用控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体，将其所依赖的对象的引用，传递给它。

也可以说，依赖被注入到对象中。

所以，控制反转是，关于一个对象如何获取他所依赖的对象的引用，这个责任的反转。

十、spring中的BeanFactory与ApplicationContext的作用有哪些？

1.BeanFactory负责读取bean配置文档，管理bean的加载，实例化，维护bean之间的依赖关系，负责bean的声明周期。

2.ApplicationContext除了提供上述BeanFactory所能提供的功能之外，还提供了更完整的框架功能：

a.国际化支持

b.资源访问：

Resourcers=ctx.getResource（”classpath:

config.properties”）,“file:

c:

/config.properties”

c.事件传递：

通过实现ApplicationContextAware接口

3.常用的获取ApplicationContext的方法：

FileSystemXmlApplicationContext：

从文件系统或者url指定的xml配置文件创建，参数为配置文件名或文件名数组

ClassPathXmlApplicationContext：

从classpath的xml配置文件创建，可以从jar包中读取配置文件

WebApplicationContextUtils：

从web应用的根目录读取配置文件