Java框架面试题总结

当客户端向浏览器发送HTTP请求时，所有浏览器请求都被提交给ActionServlet处理。如果用户提交表单，则会将表单中的数据放入到ActionForm中。ActionServlet根据struts_config.xml文件中预先配置好的设置选择将请求转发到哪个action对象，action对象从actionForm对象中获取数据，但后调用业务逻辑组件，完成业务功能。

2. Struts的工作流程分解

Web应用如果采用struts框架,在web应用启动时就会加载并初始化ActionServlet,ActionServlet从struts_config.xml文件中读取配置信息,基本执行步骤如下:

(1) 所有浏览器请求都被提交给ActionServlet处理

(2) ActionServlet根据struts_config.xml文件中预先配置好的设置,选择应该将请求转发到哪个action对象.

(3) 当用户提交表单时,一个配置好的ActionForm对象将被创建,并被填入表单中的相当数据.

(4) Action对象从ActionForm对象中获取数据.

(5) Action对象调用业务逻辑组件完成业务功能.

3. Struts控制器组件的组成. 和控制器的主要功能

Struts控制器组件主要包括:

ActionServlet组件:充当Struts框架的中央控制器.

RequestRrocessor组件:充当每个子应用模块的请求处理器.

Action组件:负责处理一项具体的业务.

Struts控制器组件主要完成以下任务:

l 接受用户请求.

l 根据用户请求,调用合适的模型组件来执行相应的业务逻辑.

l 获取业务逻辑执行结果.

l 根据当前状态以及业务逻辑执行结果,选择合适的视图组件返回给用户.

4. Struts中的几个关键对象的作用(说说几个关键对象的作用)

ActionServlet类控制导航流.

ActionServlet根据URI来决定哪个Action类被用于处理请求,Action可以校验输入,并访问业务层以便从数据库检索信息.

Action需要知道页面提交了哪些内容,所以由ActionServlet根据请求URI来决定将请求参数绑定到哪个ActionForm中并传入Action.

Action在完成业务逻辑后,返回一个ActionForward对象,ActionServlet根据ActionForward对象中的路径来调用页面完成响应.

Struts将这些信息绑定在一个ActionMapping对象中,一个ActionMapping对应一个请求URI,当请求路径到达的时候,ActionServlet就会查询ActionMapping对象,ActionMapping对象将告诉ActionServlet哪个Action类会被调用,哪个ActionForm类被用于传递页面数据以及哪些ActionForward将被用于转向.

有关Action,ActionForm,ActionForward等信息,通过struts-config.xml配置文件来定义.

5. Struts工作流程图(用例图)

注: Servlet 容器在启动时,或者用户首次请求ActionServlet时加载ActionServlet类.

6. 说说MVC设计模式和它的优点

MVC是一种设计模式,.它强制性的把应用程序的输入,处理和输出分开.MVC把应用程序分成三个核心模块:模型(Model),视图(View)和控制器(Controller).他们分别处理不同的任务.

视图是用户看到并与之交互的界面.视图向用户显示相关的数据,并能接受用户的输入数据,但是它不进行任何实际的业务处理.

模型是应用程序的主体部分.模型表示业务数据和业务逻辑.一个模型能为多个视图提供数据.由于同一个模型可以被多个视图重用,所以提高了应用的重用性.

控制器接受用户的输入并调用模型和视图去完成任务.

MVC的处理逻辑如下:

首先控制器接受用户请求,并决定应该调用哪个模型来进行处理,然后模型根据用户请求进行相应的业务逻辑处理,并返回数据. 最后控制器调用相应的视图来格式化模型返回的诗句,并通过视图呈现给用户.

MVC的优点:

(1) 在MVC设计模式中,模型响应用户请求并返回响应数据,视图负责格式化数据并把它们呈现给用户,业务逻辑和表示层分离,同一个模型可以被不同的视图重用,所以大大提高了代码的可重用性.

(2) MVC的三个模块相互独立,改变其中的一个不会影响其他两个,所以根据这种设计思想能构造良好的松耦合的构件.

(3) 控制器可以用来连接不同的模型和视图去完成用户的需求,也可以为构造应用程序提供强有力的手段.给定一些可重用的模型和视图,控制器可以根据用户的需求选择适当的模型进行处理,然后选择适当的视图将结果显示给用户.

7. 说说struts是如何实现MVC的 ?

Struts采用JSP作为MVC的视图, 控制器由ActionServlet和Action类来实现. 控制器负责视图和模型之间的交互. 模型由实现业务逻辑的JavaBean或EJB组件构成,

然后说说Struts的工作流程.

8. Struts优点与缺点

   Struts是开源软件，使开发者能更深入的了解其内部实现机制。
   Struts 优点：业界"标准"（很多成功案例），学习资源丰富。
   Struts的优点主要集中体现在两个方面：Taglib和页面导航。
          a、利用Struts提供的taglib可以大大节约开发时间。
          b、维护扩展比较方便。通过一个配置文件，即可把握整个系统各部分之间的联系，这对于后期的维护有着莫大的好处。
          c、表现与逻辑分离
          d、表单验证解决了请求数据的验证问题，增强了系统健壮性。
          e、便于团队开发

Struts缺点：a、大量的使用标签，对于初学者难度较大。
b、ActionForms使用不便、无法进行单元测试（StrutsTestCase只能用于集成）

9 . strust的Action是不是线程安全的？如果不是有什么方式可以保证Action的线程安

全？如果是，说明原因

不是. 为了确保action的线程安全, 最好的办法就是不要在action里定义实列变量.

10. Tiles框架是什么？

Tiles框架为创建Web页面提供了一种模板机制，它能将网页的布局和内容分离。

11. struts1.x 和struts 2 的区别

本文将从Struts1和Struts2的各个方面进行比较

特征

Struts 1

Struts 2

Action类

Struts1的action需要去继承一个抽象基类。一个普遍问题就是Struts1是面向抽象类编程来代替接口编程

Struts2的action可以实现一个Action接口，也可以同时实现一些其他的接口来添置一些附加的，常用的服务。Struts2提供一个基类ActionSupport实现了一些常用的接口。虽然Action接口不是必须的。任何附带execute方法的POJO对象都可以作为Struts2的action对象。

线程模型

Struts1的action是单例的而且必须是线程安全的，因为该类会只有唯一一个引用来为action处理所有的请求。单例策略会限制Struts1的action的功能以及需要扩展的额外的功能（The singleton strategy places restrictions on what can be done with Struts 1 Actions and requires extra care to develop）。Struts1的action必须是线程安全的并且是同步的。

Struts2的Action对象是针对每一个请求的，所以自然也就不存在线程安全问题了。（实际上，）

Servlet的依赖

Struts1的Action依赖于Servlet API，因为当Action被调用的时候HttpServletRequest和HttpServletResponse对象是通过execute方法进行处理的。

Struts2的Action和容器的连接并不紧密。通常servlet上下文被描绘成简单的Map映射，允许Action被单独测试。当然，如果需要的话Struts2的Action也可以通过访问初始的request和response来完成一些功能。然而，其他的一些架构元素导致降低或者删除了直接访问request和response的需求。

易测试性

测试Struts1的Action有一个大障碍就是execute方法是直接暴露于servlet API的。

Struts2的Action可以很容易的通过设置属性调用方法来进行测试。当然依赖注入的支持也使得测试变得简单。

输入处理

Struts1使用一个ActionForm对象来获取用户的输入。和action一样，所有的ActionForm都必须继承自一个基类。因为其他的javaBean不能被用作ActionForm，开发者通常要写一些多余的类来获取用户输入。DynaBean可以被用做生成ActionForm类的一个选择，但是开发者需要对现有的javaBean进行重写。

Struts2使用Action属性作为输入属性，除掉了对于输入对象的需求。输入属性可以是一个拥有他自己的属性的对象。Action属性是通过标签和web页面交互。Struts2也支持ActionForm模型，就是POJO的Form对象和POJO的Action。多数的对象类型，包括商业逻辑对象和领域对象都可以作为输入/输入对象。模式驱动特征简化了标签和POJO输入对象的关系。

表达式语言

Struts1和JSTL结合，所以他可以使用JSTL的EL。

Struts2也支持JSTL，但是这个框架也支持更加强大的表达式语言OGNL

表现层和类型值的绑定

Struts1使用标准的JSP机制将对象绑定到page context来进行访问。

Struts2使用”ValueStack”技术，所以标签不用将视图和表现的对象结合就可以得到值.ValueStack策略允许通过一系列可能具有相同属性名字但是不同属性类型的的类型来完成视图的重用，

类型转换

Struts1的ActionForm通常都是String类型。Struts1通过Commons-Beanutils实现类型转换。

Struts2使用OGNL实现类型转换，框架包含了对基础和公共类型的转换器。

验证

Struts1支持通过ActionForm中的validate方法实现手工验证。也可以通过扩展通用的验证框架进行验证。对于同一个类可以有不同的验证，但是不能关联到子对象的验证。

Struts2也支持通过validate方法进行手工验证以及Xwork验证框架进行验证。Xwork验证框架支持将验证链接到子属性，子属性使用了为属性类型和验证上下文定义的验证。

Action执行的控制

Struts1支持为每一个模块分配请求处理（生命周期），但是一个模块中的所有Action必须分享相同的生命周期。

Struts2支持通过拦截器栈为每个Action创建不同的生命周期。通常对于不同的Action根据需要都要有对应的栈被创建和使用。

12 . Struts 的常用标签库及用法

常见的struts标签库有strutshtml 标签库,struts bean标签库, struts Logic标签库,StrutsTemplate 标签库, Struts Nested 标签库.

HTML 标签用来创建能够和Struts 框架和其他相应的HTML 标签交互的HTML 输入表单

Bean 标签在访问JavaBeans 及其属性，以及定义一个新的bean 时使用

Logic 标签管理条件产生的输出和对象集产生的循环

Template 标签随着Tiles框架包的出现，此标记已开始减少使用

Nested 标签增强对其他的Struts 标签的嵌套使用的能力

以下分别讲解struts标签库的用法.

Struts html标签库

<html:form>:生成html<form> 标签

用法:<html:formaction=”checkAction.do”></html:form>

<html:form>标签的action属性用来指定当前用户提交表单后，处理用户请求的组件.

<html:text>生成html<input type=”text”> 标签

该标签在表单上创建HTML文本框字段.

用法:<html:textproperty=”userName”>

property:指定字段的名字

<html:hidden>生成html<input type=”hidden”> 标签

这个标签在表单上生成隐藏字段.隐藏字段用于在表单上存放不希望让用户看到或不允许修改的信息.

<html:submit>生成html<input type=”submit”> 标签

<html:submit>标签生成表单的提交按钮

用法:<html:submit>submit<html:submit>

<html:reset>生成html<form type=”reset”> 标签

<html:reset>标签生成表单复位按钮

用法:<html:reset>reset</html:reset>

<html:cancel>在表单上生成取消按钮

<html:cancel>标签用于生成表单取消按钮

用法:<html:cancel>cancel</html:cancel>

<html:radio>:生成html<input type=”radio”>元素

<html:radio>用于生成单选按钮

用法:<html:radioproperty=”sex” value=”1”>男</html:radio>

<html:radioproperty=”sex” value=”0”>女</html:radio>

单选按钮需要确保property一样,只是value值不一样就可以了.

<html:multibox>:生成复选框 <inputtype=”checkBox”>

用法: <html:multibox property="fav" value="1"></html:multibox>篮球

<html:multibox property="fav" value="2"></html:multibox>足球

<html:multibox property="fav" value="3"></html:multibox>乒乓球

复选框按钮需要确保property一样,value的值不同就可以了.还需要注意的是复选框的值需要写在标签按钮的最后面的.

如果应用中有多个Checkbox,并且希望ActionFromBean 中用单个数组表示,都可以采用<html:multibox>.<html:multibox>的使用方法如下:

(1) 在ActionForm 中定义一个数组,用来存放checkBox的值,

private String strArray[] =new String[0];

public String getStrArray() {

returnthis.strArray;

}

public void SetStrArray(String strArray){

this.StrArray = strArray;

}

(2) 在表单中加入<html:multibox>元素,通过设置property=”strArray”来把它和ActionFrom Bean 关联.

(3) 对于每个<html:multibox>元素,设置它的初始值.

<html:multiboxproperty="strArray" value="1"></html:multibox>value1

<html:select>下拉列表用于生成html<select>元素

它可以在表单上创建下拉列表和多选列表

用法:<html:select property=”colors” size=”7” multibox=”false”>

<html:optionvalue=”1”>value1</html:option>

<html:optionvalue=”2”>value2</html:option>

<html:optionvalue=”3”>value3</html:option>

</html:select>

属性说明:

size:指定每次在网页上显示的可选项的数目.

Multibox:指定是否支持多项选择,如果设置为true,就表示多选列表.支持多项选择;否则表示下拉列表.只支持单项选择,默认为false

Property属性:与actionFrom中的某个属性相对应.这个属性用来存放用户在列表上选中的选项的值.

<html:file>标签生成html<input type=”file”>元素，提供从html表单中上传文件的功能.

<html:file>标签可以方便的实现文件上传的功能.样列代码如下:

<html:form action="/upload.do"method=”post” enctype="multipart/form-data">

<html:fileproperty="file"/></br>

<html:submit>提交</html:submit>

</html:form>

使用<html:file>标签要注意以下几点:

(1) <html:file>标签必须嵌套在<html:form>标签中

(2) <html:form>标签的method属性必须设置为post

(3) <html:form>标签的编码类型emctype属性必须设置为” multipart/form-data”

(4) <html:file>标签必须设置property属性,这个属性和ActionFrom Bean中的FormFile类型的属性对应.

在ActiomForm中设置FormFile属性:

在actionForm中设置一个名为file的属性,这个属性必须为org.apache.struts.upload.FormFile类型.代码如下:

private FormFile file;

public FormFile getFile(){

returnthis.file;

}

public void setFile(FormFile file){

this.file=file

}

上传下载的例子详细参见(My_Java\E实例\小例子\upDownFile)

<html:errors>标签:用于输出错误消息.

<html:errors>标签可以放在网页的任何地方,既可以位于HTML标签内,也可以位于HTML标签外,<html:errors>标签输出的错误消息和它在网页上的位置有关.<html:errors>标签具有以下重要的属性:

name:指定ActionMessage对象存放在request或sessios范围内的属性key.标签处理类将根据这一属性的key来检索request或session范围的ActionMessage对象.默认值为Globals.ERROR_KEY.

Property:指定消息的属性.如果此项没有设置,将显示ActionMessages对象中的所有的ActionMessage.

Bundle:指定Resource Bundle(资源包) ,如果此项没有设置.将从应用默认的Resource Bundle 中获取消息文本. [关于<html:errors>标签的用法详见:精通strutsp326_p328].

错误消息的来源

<html:errors>标签在request或session范围内寻找ActionMessages(或其子类ActionErrors)集合对象.在从ActionMessages集合对象读取ActionMessage对象,把ActionMessage包含的消息文本显示到网页上..

在ActionForm Bean和Action类中都可以生成ActionMessages对象.ActionForm Bean的validate() 方法执行表单验证,返回ActionErrors对象,Struts控制器组件RequestProcessor(请求处理器)然后把ActionErrors对象存放在request范围内,存放时的属性key为Globals.ERROR_KEY .

以下是HtmlErrorForm 的validate() 方法:

public ActionErrors validate(ActionMapping mapping,HttpServletRequest request){

ActionErrorserrors = new ActionErrors();

//如果复选筐被选中了,显示错误消息

If(this,getCheckBox1()){

Errors.add(ActionMessages.Global_MESSAGE,.newActionMessage(“error.global.fromform”));

Errors.add(“checkbox1”,newActionMessage(“error.checkbox”));

}

retrun errors;

}

在action类的execute()方法中可以进行数据逻辑验证,如果验证失败,将生成ActionMessages对象.以下是helloapp应用的LogonAction的execute()方法;

public ActionForward execute(

ActionMapping mapping,

ActionForm form,

HttpServletRequest request,

HttpServletResponse response) {

ActionMessageserrors = new ActionMessages();

StringuserName=(String)((HelloForm)form).getUserName();

StringbadUserName=”Monster”;

If(userName.equalsIgnoreCase(badUserName)){

Errors.add(“userName”,newActionMessage(“hello.don’t.talk.to.monster”,badUserName));

SaveErrors(request,errors);

Return(new ActionForward(mapping.getInput()));

}

以上代码先创建了一个ActionMessages对象,它用来存放ActionMessage对象,最后调用Action基类的saveErrors()方法,saveErrors()方法把ActionMessages 对象保存在request范围内.

<html:message>标签:

用于显示正常消息的代码如下:

<html:messages id=”message” message=”true”>

</html:messages>

<html:messages> 标签有以下一些重要属性:

name:指定actionMessages对象存放在request或session范围内的key.,标签处理类将根据这一属性key来检索request或session范围的ActionMessages对象.

Message属性:指定消息的来源.

Id属性: 用来命名从消息集合中检索出的每个ActionMessage对象.它和<bean:write>标签的name属性匹配.

Struts bean标签库

<bean:message>标签用于输出Resource Bundle 种的一条消息.<bean:message>标签的bundle属性指定ResourceBundle 它和struts配置文件的<message-resource>元素的key属性匹配.如果没有设置bundle 属性,就采用默认的ResourceBundle.

<bean:message> 标签的key属性直接指定消息key. Bundle属性指明资源文件的struts-config.xml文件种的配置的key值.

例如: <bean:message bundle=”special” key=”hello”>

(详细参照:精通struts p339)

<bean:write>标签

<bean:write>标签用于在网页上输出某个Bean 或它的属性的内容.

<bean:write>标签可以输出单个字符串,或责一个对象的某个属性,或责通过迭代器遍历集合的所有值

<bean:write> 标签的name属性指定已经存在的变量.例如:

在action中得到一个字符串的值,然后在页面上显示出来

//得到定单状态(action中)

StringorderState=orderService.getOrderState(userOrderId);

request.setAttribute("orderState",orderState);

//在界面上显示为(界面中)

<bean:writename="orderState"/>

如果希望输出Bean的某个属性值,应该同时设置<bean:write >标签的name属性和property属性. Property属性指定Bean的属性.例如:

//得到当前定单的购货人信息

UserVOuVO =orderService.getUserbyOrderId(userOrderId);

request.setAttribute("userVO",uVO);

//在页面上显示购货人的信息

<tr>

<td align="right" width="20%">购货人姓名:</td>

</tr>

</table>

根据迭代器标签显示集合的所有内容

//得到当前定单的所有商品的信息

Listlist=orderService.getWareByOrderId(userOrderId);

request.setAttribute("wareList",list);

//根据迭代器标签显示所有内容(界面层)

<logic:iterate id="ware" name="wareList">

<tr >

</tr>

</logic:iterate>

Struts Logic标签库

<logic:match>:判断变量中是否包含指定的常量字符串

<logic:notMatch>:判断变量中是否不包含指定变量的类

<logic:empty>和<logic:notEmpty>标签

<logic:empty> 和<logic:notEmpty>标签判断指定变量是否为空字符串.

例子: 以下代码先定义一个字符串变量emptyString ,它是空字符串.接下来<logic:empty>标签判断emptyString变量是否为空字符串.其判断结果为true..因此将执行标签主体的内容.

request.setAttribute(“emptyString”,””);

<logic:empty name=”emptyString”>

the variablenamed emptyString is empty!

</logic:empty>

<logic:iterate>标签是Logic标签中最复杂的标签.也是用途最广的一个标签.它能够在一个循环中遍历数组,Collection,Enumeration,Iterator 或Map中的所有元素.

一:遍历集合

<logic:iterate>的name属性指定需要进行遍历的集合对象.它每次从集合中检索出一个元素,然后把它存放在page范围内.并以id属性指定的字符串来命名这个元素.例如:

Vectoranimals = new Vertor();

animals.addElement(“Dog”);

animals.addElement(“Cat”);

animals.addElement(“Bird”);

animals.addElement(“Chick”);

Request.setAttibute(“Animals”,animals);

<logic:iterate id=”element” name=”Animals”>

<bean:writename=”element”>

</logic:iterate>

<logic:iterate>标签的length属性指定需要遍历的元素的数目,如果没有设置length属性,就遍历集合中的所有元素.offset属性指定开始遍历的起始位置,默认值为”0”,表示中集合的第一个元素开始遍历,indexId属性定义一个代表当前别遍历的元素序号的变量.整个变量存放在page范围内.可以被标签主体的<bean:write>标签访问.例如:

<logic:iterate id=”ilement” indexId=”index”name=”Animals” offset=”1” length=”2”>

<bean:writename=”index” >.<bean:write name=”element”></br>

</logic:iterate>

以上代码输出的内容为:

1. Cat

2. Bird

设置被遍历的变量

设置name属性,name属性指定需要遍历的集合或map.例如:

<logic:iterate name=”Animals” id=”element”>

<bean:writename=”element”/><br/>

</logic>

设置name属性和property属性,name属性指定一个javaBean,property属性指定javaBean的一个属性.这个属性为需要遍历的集合或map. 例如:

<logic:iterate id=”element” name=”Aninals”indexId=”ind”>

<bean:writename=”ind”>.<bean:write name=”element” property=”key” ><br/>

<logic:iterateid=”elementValue” name=”element” property=”value” length=”3” offset=”1”>

--------<bean:writename=”elementValue”>

</logic:iterate>

设置collection 属性,collection属性指定一个运行时表达式,表达式的运算结果为需要遍历的集合或map.例如:

<logic:iterate id=”header” collection=”<% =request.getHeaderNames%>”>

<bean:writename=”header”/><br/>

</logic:iterate>

13、JSP中动态INCLUDE与静态INCLUDE的区别？

动态INCLUDE用jsp:include动作实现 <jsp:includepage="included.jsp" flush="true" />它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数。静态INCLUDE用include伪码实现,定不会检查所含文件的变化，适用于包含静态页面<%@ include file="included.htm" %>

Ø Ajax 篇

1. ajax是什么

Ajax是 Asynchronous JavaScriptand XML（以及DHTML 等）的缩写。ajax不是一项新技术,只是多种技术的综合,或者是设计方式.包括javascript,xhtml和css,dom,xml和XSTL,xmlHttpRequest等技术.

2. ajax实现的原理

ajax采用异步传输方式, 用户触发事件和向服务器发起请求是在一个线程上. Ajax主要是通过XMLHTTPRequest对象调用服务端方法,然后将服务端返回的数据显示在客户端.

3. ajax框架的基本流程

对象初始化à 发送请求à 服务器接受à服务器返回--.>客户端接受à修改客户端页面内容。

4. dwr的实现原理.

Dwr是ajax的开源框架。dwr包含两个主要部分:其一是运行在浏览器客户端的javascript, 这部分被用来与服务端通信,并更新页面内容; 其二是运行在服务器端的java servlet,这部分用来处理请求将响应结构发送给浏览器.

5. ajax 开发步骤.

(1) 初始化xmlHttpRequest 对象.

(2) 设置xmlHttpRequest对象的onreadystatechange属性,指定服务器返回响应数据时要调用的回调函数. 即指定相应处理函数.

(3) 调用xmlHttpRequest对象的open方法创建http请求.

(4) 调用xmlHttpRequest对象的setResourceHeader等方法,设置必要的http请求头信息.

(5) 调用xmlHttpRequest对象的send方法,发送之前创建的http请求.

(6) 根据xmlHttpRequest对象的open方法参数,决定等待或者不等到服务器返回响应数据,如果服务器返回响应数据,则将控制权交给之前设置的回调函数.

Ø Spring 篇

一. 基础知识

1. 对IOC的理解.

IOC的全称是: Inversion ofControl(即: 控制反转). 理解:在传统的应用程序中，控制权在应用程序本身，程序的控制流程完全由开发者控制。在IOC容器中，控制权发生了反转：从应用程序转移到了IOC容器。组件不再由应用程序负责创建和配置，而是由IOC容器负责，应用程序只需要直接使用已经创建并配置好的组件。

为了让组件能在IOC容器中被“装配”出来，需要某种“注入”的机制，才能将一种组件“注入”到另一种组件中。简单来说，依赖注入解决了最主要的问题：将组件的配置与使用相分离，并且由IoC容器负责管理组件的生命周期。

简单来说: 控制反转就是由容器控制程序之间的（依赖）关系.

2. 依赖注入的三种实现形式?

a. 接口注入（InterfaceInjection）说明: 通过实现一个接口来实现对依赖对象的注入.

b. 设值方法注入(Setter注入). 说明: 对象创建之后，将被依赖对象通过set方法设置进去.

c. 构造方法注入(Constructorinjection). 说明: 对象创建时，被依赖对象以构造方法参数的方式注入.

说明: Spring两种依赖注入的类型分别是setter注入和构造方法注入。

setter注入：一般情况下所有的javabean, 我们都会使用setter方法和getter方法去设置和获取属性的值，示例如下：

public class namebean {

String name;

public voidsetName(String a) {

name = a;}

publicString getName() {

returnname; }

}

我们会创建一个bean的实例然后设置属性的值，spring的配置文件如下：

</property>

</bean>

Spring会调用setName方法来只是name熟悉为tom

构造方法注入：构造方法注入中，我们使用带参数的构造方法如下：

public class namebean {

String name;

publicnamebean(String a) {

name = a;

}

我们会在创建bean实例的时候以new namebean(“tom”)的方式来设置name属性, Spring配置文件如下：

<constructor-arg>

<value>My Bean Value</value>

</constructor-arg>

</bean>

使用constructor-arg标签来设置构造方法的参数。

3. Setter注入和构造方法注入比较

Setter注入的优点：

(1)与传统的JavaBean的写法更相似，程序员更容易理解、接受，通过setter方式设定依赖关系显得更加直观、明显;

(2)对于复杂的依赖关系，如果采用构造注入，会导致构造器过于臃肿，难以阅读。Spring在创建Bean实例时，需要同时实例化其依赖的全部实例，因而导致死你功能下降。而使用设置注入，则避免这下问题; 尤其在某些属性可选的情况下，多参数的构造器更加笨拙。

构造注入的优点：

(1)构造注入可以再构造器中决定依赖关系的注入顺序，优先依赖的优先注入。

(2)对于依赖关系无须变化的Bean，构造注入更有用处;因为没有setter方法，所有的依赖关系全部在构造器内设定，因此，不用担心后续代码对依赖关系的破坏。

(3)依赖关系只能在构造器中设定，则只有组件的创建者才能改变组件的依赖关系。对组件的调用者而言，组件内部的依赖关系完全透明，更符合高内聚的原则;

建议采用以设置注入为主，构造注入为辅的注入策略。对于依赖关系无须变化的注入，尽量采用构造注入;而其他的依赖关系的注入，则考虑采用设置注入。

4. 对AOP的理解,以及AOP在项目中是如何使用的?

AOP(Aspect Oriented Programming), 也就是面向切面编程，也有译作面向方面编程。AOP是一种编程思想. 在传统的面向对象（Object-Oriented Programming，OOP）编程中，对垂直切面关注度很高，横切面关注却很少，也很难关注。也就是说，我们利用OOP思想可以很好的处理业务流程，却不能把系统中的某些特定的重复性行为封装在某个模块中。比如在很多的业务中都需要记录操作日志，结果我们不得不在业务流程种嵌入大量的日志记录代码。无论是对业务代码还是对日志记录代码来说，今后的维护都是非常复杂的。由于系统种嵌入了这种大量的与业务无关的其它重复性代码，系统的复杂性、代码的重复性增加了，从而使bug的发生率也大大的增加。IOC使软件组件松散连接成为可能,AOP让你能够捕捉系统中经常使用的功能,把他转化为组件.

简单的说：面向切面编程通过提供另外一种思考程序结构的途径来弥补面向对象编程(OOP)的不足.在OOP中模块化的关键单元是类( ),而在AOP中模块化的单元则是切面。切面能对关注点进行模块化。

AOP将应用系统分为两部分，核心业务逻辑（Core business concerns）及横向的通用逻辑，也就是所谓的方面Crosscutting enterprise concerns。

AOP的应用：例如，所有大中型应用都要涉及到的持久化管理（Persistent）、事务管理（Transaction Management）、安全管理（Security）、日志管理（Logging）和调试管理（Debugging）等。

5. AOP的概念和术语

方面（Aspect）：一个关注点的模块化，这个关注点实现可能另外横切多个对象。事务管理是J2EE应用中一个很好的横切关注点例子。方面用Spring的Advisor或拦截器实现。

连接点（Joinpoint）：程序执行过程中明确的点，如方法的调用或特定的异常被抛出。

通知（Advice）：在特定的连接点，AOP框架执行的动作。各种类型的通知包括“around”、“before”和“throws”通知。通知类型将在下面讨论。许多AOP框架包括Spring都是以拦截器做通知模型，维护一个“围绕”连接点的拦截器链。

切入点（Pointcut）：指定一个通知将被引发的一系列连接点的集合。AOP框架必须允许开发者指定切入点，例如，使用正则表达式。

引入（Introduction）：添加方法或字段到被通知的类。Spring允许引入新的接口到任何被通知的对象。例如，你可以使用一个引入使任何对象实现IsModified接口，来简化缓存。

目标对象（Target Object）：包含连接点的对象，也被称作被通知或被代理对象。

AOP代理（AOP Proxy）：AOP框架创建的对象，包含通知。在Spring中，AOP代理可以是JDK动态代理或CGLIB代理。

编织（Weaving）：组装方面来创建一个被通知对象。这可以在编译时完成（例如使用AspectJ编译器），也可以在运行时完成。Spring和其他纯JavaAOP框架一样，在运行时完成织入。

说明：Target和advice的概念:

1. target (目标): 如果一个对象的执行过程受到某个AOP的修改,那么它就叫一个目标对象.目标对象也常称为被通知对象.

2. advice(通知): 在某一个特定的联接点处运行的代码称为”通知”.通知有很多种,比如在联接点之前执行的前置通知(before advice)和在联接点之后执行的后置通知(after advice).

6. Spring中有五中不同的通知:

前置通知(Before advise)：在某连接点之前执行的通知，但这个通知不能阻止连接点之前的执行流程。（除非它抛出一个异常）

后置通知(After returning advise)：在某连接点正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回。

异常通知(After throwing advise)：在方法抛出异常退出时执行的通知。

最终通知(After(finally) advise)：当某连接点退出的时候执行的通知(无论是正常返回还是异常退出)

环绕通知(Around Advise)：包围一个连接点的通知，如方法调用。这是最强大的一种通知类型。环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它自己的返回值或抛出异常来结束执行。

环绕通知是最常用的通知类型。

7. Spring bean的生命周期:

定义->初始化->使用->销毁

8. Bean的作用域

(1) singleton----在每个Spring IoC容器中一个bean定义对应一个对象实例。

(2) prototype----一个bean定义对应多个对象实例。

(3) request----在一次HTTP请求中，一个bean定义对应一个实例；即每次HTTP请求将会有各自的bean实例，它们依据某个bean定义创建而成。该作用域仅在基于web的SpringApplicationContext情形下有效。

(4) session----在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的SpringApplicationContext情形下有效。

(5) globalsession----在一个全局的HTTP Session中，一个bean定义对应一个实例。典型情况下，仅在使用portlet context的时候有效。该作用域仅在基于web的SpringApplicationContext情形下有效。

9. Spring自动代理

Spring自动代理主要有三个选择:

1. 使用BeanNameAutoProxyCreator(bean名称自动代理生成器)类: 该类允许我们指明一组bean名称以及实施在他们上的一组通知和通知者. Spring会自动用指定的通知代理这些Bean.

2. 使用DefaultAdvisorAutoProxyCreator(默认通知者自动代理生成器)类: 这个自动代理类非常强大,他自动用所有可行的通知者代理ApplicaitonContext中的所有Bean.该类只接受通知者,不接受通知,因为它依赖通知者的切入点来决定该通知者能够通知给定的bean.

3. 使用元数据驱动的自动代理

10.Spring 事务特点

事务是用户定义的一个数据库操作序列。这些操作要么都做，要么都不做，是一个不可分割的工作单位。事务具有四个特性：

1. 原子性：一个事务中所有对数据库的操作是一个不可分割的操作序列。这些操作要么完整的被全部执行，要么一步也不做。是一个逻辑工作单位。

2.一致性：一个事务独立执行的结果将保持一致性，即数据不会因为事务的执行而遭受破坏。

3. 隔离性：一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对其他并发事务是隔离的，并发执行的各个事务之间不能互相干扰。

4.持久性：一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其执行结果有任何影响。

11.谈谈Spring 事务的理解

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

开发中为了避免这种情况一般都会进行事务管理。Spring中也有自己的事务管理机制，一般是使用TransactionMananger进行管理，可以通过Spring的注入来完成此功能。

spring提供了两中方式来实现事务管理：声明式事务和编程式事务。

编程式事务：比较灵活，但是代码量大，存在重复的代码比较多；

声明式的比编程式的更灵活。

11.1 编程式事务

Spring提供两种方式的编程式事务管理，分别是：使用TransactionTemplate和直接使用PlatformTransactionManager。

a. TransactionTempale采用和其他Spring模板，如JdbcTempalte和HibernateTemplate一样的方法。它使用回调方法，把应用程序从处理取得和释放资源中解脱出来。如同其他模板，TransactionTemplate是线程安全的。

b. 也可以使用PlatformTransactionManager直接管理事务。简单地通过一个bean引用给你的bean传递一个你使用的PlatformTransaction对象。然后，使用TransactionDefinition和TransactionStatus对象就可以发起、回滚、提交事务。如下片段：

DefaultTransactionDefinition def= newDefaultTransactionDefinition(); //new 一个事务

//初始化事务,参数定义事务的传播类型;

def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);

//获得事务状态

TransactionStatus status = transactionManager.getTransaction(def);

try{

…………….

transactionManager.commit(status); //提交事务;

}catch(…..)...

{

transactionManager.rollback(status); //回滚事务;

}

11.2 声明式事务

声明式事务是通过AOP实现的。大多数Spring用户选择声明式事务管理，这是最少影响应用代码的选择，因而这是和非侵入性的轻量级容器的观念是一致的。

声明式事务通常通过TransactionProxyFactoryBean设置Spring事务代理。

12.编程式事务和声明式事务如何选择？

当你只有很少的事务操作时，编程式事务管理通常比较合适。例如：如果你只有一个Web应用，其中只有特定的更新操作有事务要求，你可能不愿意使用Spring或其他即使设置事务代理。这种情况下，使用TransactionTemplate可能是个好方法。只有编程式事务管理才能显示的设置事务名称。

如果你的应用中存在大量事务操作，那么声明式事务管理通常是值得的。它将事务管理与业务逻辑分离，而且在Spring中配置也不难。使用Spring，而不是EJB CMT,声明式事务管理在配置上的成本极大的降低了。

二. Spring应用

13.spring中的BeanFactory与ApplicationContext的作用和区别？

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

ApplicationContext是BeanFactory的扩展,除了提供上述BeanFactory所能提供的功能之外，功能得到了进一步的增强,比如容易与SpringAOP集成,资源处理(国际化处理),事件传递及各种不同应用层的context实现0.

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

答: ContextLoaderListener是一个ServletContextListener, 它在你的web应用启动的时候初始化。缺省情况下，它会在WEB-INF/applicationContext.xml文件找Spring的配置。你可以通过定义一个<context-param>元素名字为”contextConfigLocation”来改变Spring配置文件的位置。示例如下：

<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener

    <context-param>
          <param-name>contextConfigLocation</param-name>
           <param-value>/WEB-INF/xyz.xml</param-value>
   </context-param>

</listener-class>

</listener>

15.spring中commons-logging.jar的作用

commons-logging.jar包是使用spring的必备包。（位置在spring-framework-2.5.6. SEC01\lib\jakarta-commons）用来记录程序运行时的活动的日志记录。

16.spring中读取xml配置文件、获取bean的几种方式

获取Spring框架管理的类实例的方法有多种,如下：

方法一：在初始化时保存ApplicationContext对象

代码：

ApplicationContext ac = newFileSystemXmlApplicationContext("applicationContext.xml");

ac.getBean("beanId");

说明：

这种方式适用于采用Spring框架的独立应用程序，需要程序通过配置文件手工初始化Spring的情况。

方法二：通过Spring提供的工具类获取ApplicationContext对象

代码：

import org.springframework.web.context.support.WebApplicationContextUtils;

ApplicationContext ac1 =WebApplicationContextUtils.getRequiredWebApplicationContext (ServletContext sc)

ApplicationContext ac2 =WebApplicationContextUtils.getWebApplicationContext (ServletContext sc)

ac1.getBean("beanId");

ac2.getBean("beanId");

说明：

这种方式适合于采用Spring框架的B/S系统，通过ServletContext对象获取ApplicationContext对象，然后在通过它获取需要的类实例。

上面两个工具方式的区别是，前者在获取失败时抛出异常，后者返回null。

方法三：继承自抽象类ApplicationObjectSupport

说明：

抽象类ApplicationObjectSupport提供getApplicationContext()方法，可以方便的获取到ApplicationContext。Spring初始化时，会通过该抽象类的setApplicationContext(ApplicationContext context)方法将ApplicationContext 对象注入。

方法四：继承自抽象类WebApplicationObjectSupport

说明：

类似上面方法，调用getWebApplicationContext()获取WebApplicationContext

方法五：实现接口ApplicationContextAware

说明：

实现该接口的setApplicationContext(ApplicationContextcontext)方法，并保存ApplicationContext 对象。Spring初始化时，会通过该方法将ApplicationContext 对象注入。

以上方法适合不同的情况，请根据具体情况选用相应的方法。

这里值得提一点的是，系统中用到上述方法的类实际上就于Spring框架紧密耦合在一起了，因为这些类是知道它们是运行在Spring框架上的，因此，系统中，应该尽量的减少这类应用，使系统尽可能的独立于当前运行环境，尽量通过DI的方式获取需要的服务提供者。

本人认为，方法五比较可行，可以设计一个工具类，专门来获取Spring中的类。减少对业务代码的侵入性。

17.Spring 启动参数contextConfigLocation 和ContextLoaderListener 理解

当web服务器(tomcat)启动时,会加载所有工程中的web.xml文件. 在web.xml文件中会配置<context-param>和<listener>这2个属性.配置文件如下:

<listener-class>

org.springframework.web.context.ContextLoaderListener

</listener-class>

</listener>

<context-param>

<param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/applicationContext.xml</param-value>

</context-param>

说明:

context-param是application范围内的参数，存放在servletcontext中。此所设定的参数，在JSP内页中可以使用${initParam.param_name}来取得，若在Servlet可以使用String param_name = getServletContext().getInitParamter(“param_name”);来取得。

在此程序中，参数contextConfigLocation用来定义要装入的Spring配置文件。如果想装入多个配置文件，可以在<param-value>标记中用逗号作为分隔符。

默认情况Spring的配置文件为applicationContext.xml。如果spring的配置文件改变了，就一定要将context-param添加到web.xml中。如果是默认情况则不需要配置。

listener元素用来定义Listerner接口，ContextLoaderListener的作用就是启动Web容器时，自动装配ApplicationContext的配置信息。它实现了ServletContextListener这个接口，在Web.xml配置这个监听器后，启动容器时，就会默认执行它的实现的方法，加载相应的Spring类，以使当对象调用时，实现其相应的注入。

这是一个Spring的重要类，在ContextLoaderListener中关联了ContextLoader类。所以整个加载配置过程由ContextLoader来完成，它创建的是XmlWebApplicationContext这样一个类，这个类实现了BeanFactory接口，所以Spring中的所有的bean都由这个类来创建。

下面是ContextLoaderListener的源码:

//实现了接口ServletContextListener,也就是说他必须实现contextDestroyed,contextInitialized这两个方法

public class ContextLoaderListener implements ServletContextListener {

private ContextLoader contextLoader;

/**

* Initialize the root web application context.

//Spring框架由此启动, contextInitialized也就是监听器类的main入口函数

public void contextInitialized(ServletContextEventevent) {

this.contextLoader = createContextLoader();

this.contextLoader.initWebApplicationContext(event.getServletContext());

}

/**

* Create the ContextLoader to use. Can beoverridden in subclasses.

* @return the new ContextLoader

protected ContextLoader createContextLoader() {

return new ContextLoader();

}

/**

* Return the ContextLoader used by thislistener.

* @return the current ContextLoader

public ContextLoader getContextLoader() {

return this.contextLoader;

}

/**

* Close the root web application context.

public void contextDestroyed(ServletContextEventevent) {

if (this.contextLoader != null) {

this.contextLoader.closeWebApplicationContext(event.getServletContext());

}

说明:

在Servlet API中有一个ServletContextListener接口，它能够监听ServletContext对象的生命周期，实际上就是监听Web应用的生命周期。

当Servlet容器启动或终止Web应用时，会触发ServletContextEvent事件，该事件由ServletContextListener 来处理。在 ServletContextListener 接口中定义了处理ServletContextEvent事件的两个方法。

contextInitialized(ServletContextEventsce)：当Servlet容器启动Web应用时调用该方法。在调用完该方法之后，容器再对Filter初始化，并且对那些在Web应用启动时就需要被初始化的Servlet进行初始化。

contextDestroyed(ServletContextEventsce)：当Servlet容器终止Web应用时调用该方法。在调用该方法之前，容器会先销毁所有的Servlet和Filter过滤器。

关于ServletContextListener详细请参考: \My_Java\B 框架\2 Spring 2\资料\使用ServletContextListener监听器 - - JavaEye技术网站.mht

18.Spring框架在web容器是如何启动的?

答: (1) 当web服务器(tomcat)启动时,会加载所有工程中的web.xml文件.

(2) 在web.xml文件中会配置<context-param>和<listener>这2个属性.配置文件如下:

参数contextConfigLocation用来定义要装入的Spring配置文件。如果想装入多个配置文件，可以在<param-value>标记中用逗号作为分隔符。

listener元素用来定义Listener接口，ContextLoaderListener的作用就是启动Web容器时，自动装配ApplicationContext的配置信息。它实现了ServletContextListener这个接口。在web.xml中配置了这个监听器，当服务器启动时，就会默认执行它的实现的方法，加载相应的Spring类。

ContextLoaderListener是Spring中的一个重要类，在ContextLoaderListener中关联了ContextLoader类。所以整个加载过程都是由ContextLoader来完成，它创建的是XmlWebApplicationContext这样一个类，这个类实现了BeanFactory接口，所以Spring中的所有的bean都由这个类来创建。

Ø Hibernate 篇

1． Hibernate优缺点？

答：

1.优点：

（1）对象/关系数据库映射(Basic O/R Mapping)

它使用时只需要操纵对象，使开发更对象化，抛弃了数据库中心的思想，完全的面向对象思想。

（2）透明持久化(Persistent)

带有持久化状态的、具有业务功能的单线程对象，此对象生存期很短。这些对象可能是普通的JavaBeans/POJO，这个对象没有实现第三方框架或者接口，唯一特殊的是他们正与（仅仅一个）Session相关联。一旦这个Session被关闭，这些对象就会脱离持久化状态，这样就可被应用程序的任何层自由使用。（例如，用作跟表示层打交道的数据传输对象。）

（3）事务Transaction (org.Hibernate.Transaction)

应用程序用来指定原子操作单元范围的对象，它是单线程的，生命周期很短。它通过抽象将应用从底层具体的JDBC、JTA以及CORBA事务隔离开。某些情况下，一个Session之内可能包含多个Transaction对象。尽管是否使用该对象是可选的，但无论是使用底层的API还是使用Transaction对象，事务边界的开启与关闭是必不可少的。

（4）它没有侵入性，即所谓的轻量级框架。

（5）移植性会很好。

（6）缓存机制。提供一级缓存和二级缓存。

（7）简洁的HQL编程。

2.缺点：

（1）Hibernate在批量数据处理的时候是有弱势。

（2）针对某一对象(单个对象)简单的查\改\删\增，不是批量修改、删除，适合用Hibernate；而对于批量修改、删除，不适合用Hibernate，这也是OR框架的弱点;要使用数据库的特定优化机制的时候，不适合用Hibernate。

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

原理：

a. 读取并解析配置文件

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

c. 打开Sesssion

d. 创建事务Transation

e. 持久化操作

f. 提交事务

g. 关闭Session

h. 关闭SesstionFactory

为什么要用hibernate:

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

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

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

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

3． Hibernate是如何延迟加载?

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

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

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

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

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

5．说下Hibernate的缓存机制

答：Hibernate数据缓存(Cache)分为两个层次，以Hibernate语义区分，可分为：

a. 一级缓存（Session Level, 也称为：内部缓存）

b. 二级缓存(SessionFactory Level)

c. 第三方缓存的实现

Hibernate的缓存包括Session的缓存和SessionFactory的缓存，其中

SessionFactory的缓存又可以分为两类：内置缓存和外置缓存。Session的缓存是内置的，不能被卸载，也被称为Hibernate的第一级缓存。SessionFactory的内置缓存中存放了映射元数据和预定义SQL语句，SessionFactory的内置缓存是只读的，应用程序不能修改缓存中的映射元数据和预定义SQL语句，因此SessionFactory不需要进行内置缓存与映射文件的同步。SessionFactory的外置缓存是一个可配置的插件。在默认情况下，SessionFactory不会启用这个插

件。SessionFactory的外置缓存也被称为Hibernate的第二级缓存。事务范围的缓存是持久化层的第一级缓存；进程范围和集群范围的缓存是持久化层的第二级缓存。Hibernate还为查询结果提供了一个查询缓存，它依赖于二级缓存。

持久化层可以提供多种范围的缓存。如果在事务范围的缓存中没有查到相应的数据，还可以到进程范围或集群范围的缓存内查询，如果还是没有查到，那么只有到数据库中查询。事务范围的缓存是持久化层的第一级缓存，通常它是必需的；进程范围或集群范围的缓存是持久化层的第二级缓存，通常是可选的。

我的理解：

Hibernate中的一级缓存是出于Hibernate自身的需要而进行的一次数据缓存，可以在Hibernate中的一般操作中起到数据缓存的作用。而通常所说的缓存技术，实际上对应的就是Hibernate中的二级缓存，只不过在Hibernate中，已经有了Session级别的一级缓存，所以称之为二级缓存。

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

答：

以下情况的数据适合放在二级缓存：

1）很少被修改的数据；

2）不是很重要的数据；

3）不会被并发访问的数据；

4）参考数据。

不适合放到二级缓存中的数据：

1）经常被修改的数据；

2）绝对重要的数据，例如：财务数据；

3）共享数据。

7． Hibernate的查询方式

答：

1) 使用主键id加载对象(load(),get());

2) 通过对象导航,比如通过stu.getTeam()得到team的实例;

3) 使用HQL(Hibernate Query Language).

4) 使用Criteria. Criteria是一种比HQL更面向对象的查询方式.

5) 直接使用sql语句取得记录集;

8．如何优化Hibernate？

答：

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

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

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

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

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

6) 继承类使用显式多态

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

9．说说Hibernate中的update()和saveOrUpdate()的区别

答：

saveOrUpdate()方法可以实现update()的功能，但会多些步骤，具体如下：

如果对象在该session中已经被持久化，不进行操作；对象的标识符属性(identifier property)在数据库中不存在或者是个暂时的值，调用save()方法保存它；如果session中的另一个对象有相同的标识符抛出一个异常；以上皆不符合则调用update()更新之。

10．说说Hibernate中的session的load()和get()的区别。

答：

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

如果未能发现符合条件的记录，get方法返回null，而load方法会抛出一个ObjectNotFoundException；load方法可返回实体的代理类实例，而get方法永远直接返回实体类；load方法可以充分利用内部缓存和二级缓存中的现有数据，而get方法则仅仅在内部缓存中进行数据查找，如没有发现对应数据，将越过二级缓存，直接调用SQL完成数据读取。

11．谈谈Hibernate中inverse的作用

答：inverse属性默认是false,就是说关系的两端都来维护关系。

比如Student和Teacher是多对多关系，用一个中间表TeacherStudent维护。Gp)i

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

12． hibernate中对象的三种状态

答：瞬时态(Transient)、持久态(Persistent)、脱管态(Detached)。处于持久态的对象也称为PO(Persistence Object)，瞬时对象和脱管对象也称为VO（Value Object）。

瞬时态(transient)：数据库中没有数据与之对应，超过作用域会被JVM垃圾回收器回收，一般是new出来且没有与session关联的对象。

瞬时态对象具有以下特点：

1.在数据库中没有与之匹配的数据

2．没有纳入session的管理。

瞬时态－> 持久态

在Hibernate中，可通过session的save()或 saveOrUpdate()方法将瞬时对象与数据库相关联，并将数据对应的插入数据库中，此时该瞬时对象转变成持久化对象。

持久态(persistent)：数据库中有数据与之对应，当前与session有关联，并且相关联的session没有关闭，事务没有提交；持久对象状态发生改变，在事务提交时会影响到数据库(hibernate能检测到)。

持久对象具有如下特点：

1. 和session实例关联；

2. 在数据库中有与之关联的记录。

3. 在清理缓存（脏数据检查）的时候,会和数据库同步

持久态－> 托管态

当一个session执行close()或clear()、evict()之后，持久对象变成脱管对象，此时持久对象会变成脱管对象，此时该对象虽然具有数据库识别值，但它已不在HIbernate持久层的管理之下。

脱管态(detached)：又叫游离态。当与某持久对象关联的session被关闭后，该持久对象转变为脱管对象。当脱管对象被重新关联到session上时，并再次转变成持久对象。

脱管对象拥有数据库的识别值，可通过update()、saveOrUpdate()等方法，转变成持久对象。

脱管对象具有如下特点：

1. 在数据库中有与之匹配的数据.

2. 没有纳入session的管理。

3. 本质上与瞬时对象相同，在没有任何变量引用它时，JVM会在适当的时候将它回收。

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

答： 1) 建索引

2) 减少表之间的关联

3) 优化sql，尽量让sql很快定位数据，不要让sql做全表查询，应该走索引,把数据量大的表排在前面

4) 简化查询字段，没用的字段不要，已经对返回结果的控制，尽量返回少量数据

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

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

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

Ø iBatis 篇

1. iBatis的优缺点？

iBatis入门比较简单，即学即用。iBatis是一个轻量级的ORM框架，iBatis除了提供了对数据库基本的增、删、改、查外还提供了连接管理，缓存支持，线程支持，（分布式）事物管理等一套较为完整的数据库管理功能。【特点】

iBatis最直接的好处就是不但为程序员提供了对象与关系数据库之间的映射，同时提供操作方法与SQL间的直接影射，设计者可以直接为一个方法指定一条SQL语句，从而取得更加准确的数据，同时为优化查询、连接查询提供了方便。【优点】

iBatis的缺点就是框架还是比较简陋，功能尚有缺失，虽然简化了数据绑定代码，但是整个底层数据库查询实际还是要自己写的，工作量也比较大，而且不太容易适应快速数据库修改。【缺点】

当系统属于二次开发,无法对数据库结构做到控制和修改,那iBatis的灵活性将比Hibernate更适合。系统数据处理量巨大，性能要求极为苛刻，这往往意味着我们必须通过经过高度优化的SQL语句（或存储过程）才能达到系统性能设计指标。在这种情况下iBatis会有更好的可控性和表现。【特点】

2. iBatis与Hibernate区别(比较)？

答：

1． iBatis非常简单易学，Hibernate相对较复杂，门槛较高。

2．二者都是比较优秀的开源产品。

3．当系统属于二次开发,无法对数据库结构做到控制和修改,那iBatis的灵活性将比Hibernate更适合。

4．如果系统数据处理量巨大，性能要求极为苛刻，这往往意味着我们必须通过经过高度优化的SQL语句（或存储过程）才能达到系统性能设计指标。在这种情况下iBatis会有更好的可控性和表现。

5． iBatis需要手写sql语句，也可以生成一部分，Hibernate则基本上可以自动生成，偶尔会写一些Hql。同样的需求, iBatis的工作量比Hibernate要大很多。类似的，如果涉及到数据库字段的修改，Hibernate修改的地方很少，而iBatis要把那些sql mapping的地方一一修改。

6． Hibernate和iBatis都是对象关系映射(ORM)框架，Hibernate是将数据库表和Java类进行映射。 iBatis是把sql语句的参数与结果映射为类.它是在类与数据库表之间建立了一个额外的连接层,这样就会在类和数据库表之间建立映射关系带来了更大的灵活性.

简单的说： iBatis映射的是SQL语句,而hibernate映射的是java类和数据库表之间的关系.这就是iBatis和hibernate的本质区别.

7． Hibernate现在已经是主流O/R Mapping框架，从文档的丰富性，产品的完善性，版本的开发速度都要强于iBatis.

8. Hibernate 和iBatis可以说是互相补充,共同发展的关系.

3. iBatis与传统JDBC比较

(1) iBatis比使用JDBC编程减少了61%的代码量

(2) iBatis是最简单的持久化框架

(3) iBatis框架使SQL代码从程序代码中彻底分离,并且SQL语句可以重用.

(4) 增强了项目中的分工和项目的可移植性。

4. Hibernate和iBatis的映射关系

Hibernate是一个ORM(对象关系映射)框架.它使数据库的元数据和类的元数据之间建立一种关系.

iBatis 是把sql语句的参数与结果映射为类.它是在类与数据库表之间建立了一个额外的连接层,这样就会在类和数据库表之间建立映射关系带来了更大的灵活性.使得在不改变数据模型或者对象模型的情况下改变它们的映射关系成为可能.

iBatis映射的是SQL语句,而不是类和表之间的关系.这就是iBatis和hibernate的本质区别.

5. iBatis动态标签有哪些？

动态标签的分类：<dynamic>标签 ; 二元标签 ; 一元标签 ; <iterate>标签。

动态标签都属于SQL语句的一部分，所以这些标签在存在于SQL语句中，具体可以出现在select,insert,delete,update,statement,sql等语句中。

这几类标签的共同属性prepend,open,close。

prepend属性：表示前缀。在标签内容前加的文字。

open属性：在标签内容开始的时候添加的文字

close 属性：在标签内容结束的时候添加的文字。

(1) 一元条件标签

<isPropertyAvailable> ：检查是否存在该属性（存在parameter bean的属性）

<isNotPropertyAvailable> ：检查是否不存在该属性（不存在parameter bean的属性）

<isNull> ：检查属性是否为null

<isNotNull> ：检查属性是否不为null

<isEmpty> ：检查Collection.size()的值，属性的String或String.valueOf()值,是否为null或空（“”或size()< 1）

<isNotEmpty> ：检查Collection.size()的值，属性的String或String.valueOf()值,是否不为null或不为空（“”或size()> 0）

(2) 二元条件标签

<isEqual property=“age” compareValue=“20”> ：比较属性值和静态值或另一个属性值是否相等

<isNotEqual> ：比较属性值和静态值或另一个属性值是否不相等。

<isGreaterThan> ：比较属性值是否大于静态值或另一个属性值。

<isGreaterEqual> ：比较属性值是否大于等于静态值或另一个属性值。

<isLessThan> :比较属性值是否小于静态值或另一个属性值。

<isLessEqual> : 比较属性值是否小于等于静态值或另一个属性值。

6. iBatis中使用like ‘%#filedName#%’ 时，有什么问题？

答：在xml映射文件中，如果直接按如上写法，会报异常：java.sql.SQLException: Invalid argument in JDBC call: parameterindex out of range: 1。

所以一般会采用如下两种方式：

1) 将#换成$，如like ‘%$filedName $%’，这样就没有问题了..

2) 采用字符串联接符||，如：like ‘%’||# filedName #||’%’

7. iBatis中#与$的区别？

# 说明：

a. #是把传入的数据当作字符串，如#field#传入的是id,则sql语句生成是这样，orderby "id".

b. #相当于JDBC中上的？号，以对象的方式传递参数，可以防止SQL注入攻击。

$ 说明：

a. $传入的数据直接生成在sql里，如#field#传入的是id,则sql语句生成是这样，orderby id.

b. $以拼接字符串的方式传递参数，经典用场是like语句，使用$符号做占位符时应特别注意防止SQL注入攻击。

总结：一般能用#就不同$.

Ø 框架问题

1. SSH框架的配置文件加载顺序.

在SSH三层架构中，主要用Struts来实现对页面的响应及页面跳转。当用户向服务器发送某一个请求，这个请求会被服务器（Tomcat）接收到，服务器会根据请求的内容，将这个请求发送给相应的Servlet实例进行处理。Servlet会根据其内容，去生成相应的Action实例。Struts将Action的创建工作交给了Spring来完成，创建这个实例后，将这个实例注入，由Struts调用Action中的相应方法。Action中可以配置一个或多个Service对象，Action调用Service中的方法进行业务处理。Service中通常会有一个或多个DAO的对象，DAO继承了Hibernate的接口，用来处理数据库的操作。而Action，Service，DAO的创建与注入，都是由Spring的Bean工厂来实现的。

（1） Struts与Spring的集成

 在Web.xml中配置Struts的配置文件

 在Web.xml中配置Spring的配置文件，Bean工厂及过滤器

 在Struts配置文件中集成Spring的代理类

 在Spring配置文件中配置Action

（2） Spring与Hibernate的集成

 在Web.xml中配置Hibernate延迟过滤器配置

 在Web.xml中配置Spring的配置文件，Bean工厂及过滤器

 在Spring配置文件中配置DAO

 在Hibernate配置文件中配置数据库信息

 在DAO的实现类中继承HibernateDaoSupport类

2. Spring框架在web容器是如何启动的?

答: (1) 当web服务器(tomcat)启动时,会加载所有工程中的web.xml文件.

(2) 在web.xml文件中会配置<context-param>和<listener>这2个属性.配置文件如下:

参数contextConfigLocation用来定义要装入的Spring配置文件。如果想装入多个配置文件，可以在<param-value>标记中用逗号作为分隔符。

listener元素用来定义Listener接口，ContextLoaderListener的作用就是启动Web容器时，自动装配ApplicationContext的配置信息。它实现了ServletContextListener这个接口，在Web.xml配置这个监听器，启动容器时，就会默认执行它的实现的方法，加载相应的Spring类，以便当对象调用时，实现其相应的注入。