第四部分：流行框架
4.1 Struts2
【题目描述】
Struts 框架可以支持以下哪种程序开发语言？
【选项】
A.C B.C++ C.Java D.C#
【正确答案】 C
【题目描述】
简述基于 Struts 框架 Web 应用的工作流程
【正确答案】
在 web 应用启动时就会加载初始化 ActionServlet,ActionServlet 从 struts-config.xml 文件 中读取配置信息,把它们存放到各种配置对象中， 当 ActionServlet 接收到一个客户请求时,将执行 如下流程.
1) 检索和用户请求匹配的 ActionMapping 实例,如果不存在,就返回请求路径无效信息;
2) 如果 ActionForm 实例不存在,就创建一个 ActionForm 对象,把客户提交的表单数据保存到ActionForm 对象中;
3) 根据配置信息决定是否需要表单验证.如果需要验证,就调用ActionForm的validate()方法;
4) 如果 ActionForm 的 validate()方法返回 null 或返回一个不包含 ActionMessage 的 ActionErrors对象, 就表示表单验证成功;
5) ActionServlet 根据 ActionMapping 所包含的映射信息决定将请求转发给哪个 Action,如果相应的Action 实例不存在,就先创建这个实例,然后调用 Action 的 execute()方法;
6) Action 的 execute()方法返回一个 ActionForward 对象,ActionServlet 在把客户请求转发给ActionForward 对象指向的 JSP 组件;
7) ActionForward 对象指向 JSP 组件生成动态网页,返回给客户;
【题目描述】
MVC 模式中 M，V，C 每个代表意义，并简述在 Struts 中 MVC 的表现方式。
【正确答案】
MVC 是 Model-View-Controller 的缩写，Model 代表的是应用的业务逻辑（通过 JavaBean，EJB 组件 实现），View 是应用的表示层（由 JSP 页面产生）Controller 是通过应用的处理过程控制，（一般是 一个 servert）通过这种设计模型把应用逻辑，处理过程和显示逻辑分成不同的组件实现，这些组件 可以进行交互和重用。
在 Struts 框架中 Controller 功能由 ActionServlet 和 ActionMapping 对象构成，核心是一个 Servlet 类型的对象 ActionServlet，它用来接收客户端的请求。ActionServlet 包括一组基于配置的 ActionMapping 对象，每个 ActionMapping 对象实现了一个请求到一个具体的 Model 部分的 Action 处理器对象之间的映射。Model 部分由 Action 和 ActionForm 对象构成。所有的 Action 处理器对象都 是开发者从 Struts 的 Action 类派生的子类。Action 处理器对象封装了具体的处理逻辑，调用业务逻 辑模块，并且把响应提交到合适的 View 组件以产生响应。Struts 提供的 ActionForm 组件对象可以通 过定义属性描述客户端表单数据，开发者可以从它派生子类对象，并利用它和 Struts 提供的自定义 标记库相结合，可以实现对客户端的表单数据的良好封装和支持，Action 处理器对象可以直接对它进 行读写，而不再需要和 request、response 对象进行数据交互。通过 ActionForm 组件对象实现了对 View 和 Model 之间交互的支持（View 部分是通过 JSP 技术实现的）。Struts 提供了自定义的标记库， 通过这些自定义标记库可以非常容易地和系统的 Model 部分交互，通过使用这些自定义标记库创建的JSP 表单，可以实现对 Model 部分中的 ActionForm 的映射，完成对用户数据的封装。
【题目描述】
常用的获取ApplicationContext的方法：
【正确答案】
FileSystemXmlApplicationContext：从文件系统或者url指定的xml配置文件创建，参数为配置文件名或文件名数组。
ClassPathXmlApplicationContext：从classpath的xml配置文件创建，可以从jar包中读取配置文件。
WebApplicationContextUtils：从web应用的根目录读取配置文件，需要先在web.xml中配置，可以配置监听器或者servlet来实现。
| <listener> <listener-class>org.springframework.web.context.ContextLoaderListener </listener-class> </listener> <servlet> <servlet-name>context</servlet-name> <servlet-class>org.springframework.web.context.ContextLoaderServlet </servlet-class> <load-on-startup>1</load-on-startup> </servlet> |
这两种方式都默认配置文件为web-inf/applicationContext.xml，也可使用context-param指定配置文件。
| <context-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/myApplicationContext.xml</param-value> </context-param> |
【题目描述】
Struts2 包含哪些标签？
【正确答案】
A：
<s:a href=""></s:a>-----超链接，类似于 html 里的<a></a>
<s:action name=""></s:action>-----执行一个 view 里面的一个 action
<s:actionerror/>-----如果 action 的 errors 有值那么显示出来
<s:actionmessage/>-----如果 action 的 message 有值那么显示出来
<s:append></s:append>-----添加一个值到 list，类似于 list.add();
<s:autocompleter></s:autocompleter>-----自动完成<s:combobox>标签的内容，这个是 ajax
B：
<s:bean name=""></s:bean>-----类似于 struts1.x 中的，JavaBean 的值
C：
<s:checkbox></s:checkbox>-----复选框
<s:checkboxlist list=""></s:checkboxlist>-----多选框
<s:combobox list=""></s:combobox>-----下拉框
<s:component></s:component>-----图像符号
D：
<s:date/>-----获取日期格式
<s:datetimepicker></s:datetimepicker>-----日期输入框
<s:debug></s:debug>-----显示错误信息
<s:div></s:div>-----表示一个块，类似于 html 的<div></div>
<s:doubleselect list="" doubleName="" doubleList=""></s:doubleselect>-----双下拉框
E：
<s:if test=""></s:if>
<s:elseif test=""></s:elseif>
<s:else></s:else>-----这 3 个标签一起使用，表示条件判断
F：
<s:fielderror></s:fielderror>-----显示文件错误信息
<s:file></s:file>-----文件上传
<s:form action=""></s:form>-----获取相应 form 的值
G：
<s:generator separator="" val=""></s:generator>----和<s:iterator>标签一起使用
H：
<s:head/>-----在<head></head>里使用，表示头文件结束
<s:hidden></s:hidden>-----隐藏值
I：
<s:i18n name=""></s:i18n>-----加载资源包到值堆栈
<s:include value=""></s:include>-----包含一个输出，servlet 或 jsp 页面
<s:inputtransferselect list=""></s:inputtransferselect>-----获取 form 的一个输入
<s:iterator></s:iterator>-----用于遍历集合
L：
<s:label></s:label>-----只读的标签
M：
<s:merge></s:merge>-----合并遍历集合出来的值
O：
<s:optgroup></s:optgroup>-----获取标签组
<s:optiontransferselect doubleList="" list=""
doubleName=""></s:optiontransferselect>-----左右选择框
P：
<s:param></s:param>-----为其他标签提供参数
<s:password></s:password>-----密码输入框
<s:property/>-----得到'value'的属性
<s:push value=""></s:push>-----value 的值 push 到栈中,从而使 property 标签的能够获取 value的属性
R：
<s:radio list=""></s:radio>-----单选按钮
<s:reset></s:reset>-----重置按钮
S：
<s:select list=""></s:select>-----单选框
<s:set name=""></s:set>-----赋予变量一个特定范围内的值
<s:sort comparator=""></s:sort>-----通过属性给 list 分类
<s:submit></s:submit>-----提交按钮
<s:subset></s:subset>-----为遍历集合输出子集
T：
<s:tabbedPanel id=""></s:tabbedPanel>-----表格框
<s:table></s:table>-----表格
<s:text name=""></s:text>-----I18n 文本信息
<s:textarea></s:textarea>-----文本域输入框
<s:textfield></s:textfield>-----文本输入框
<s:token></s:token>-----拦截器
<s:tree></s:tree>-----树
<s:treenode label=""></s:treenode>-----树的结构
U：
<s:updownselect list=""></s:updownselect>-----多选择框
<s:url></s:url>-----创建 url
【题目描述】
struts2 中，OGNL 访问值栈的时候查找的顺序是什么？请排序：模型对象、临时对象、固定名称 的对象、Action 对象。
【正确答案】
struts2 的值栈排列顺序为：1）.临时对象；2）.模型对象；3）.Action 对象；4）.固定名称 对象（如#application, #session, #request 等对象）。
【题目描述】
struts2 中，Action 通过什么方式获得用户从页面输入的数据，又是通过什么方式把其自身的数据传给视图的？
【正确答案】
1）可以直接通过与表单元素相同名称的数据成员（需要存在符合命名规范 set 和 get 方法）获取页 面表单数据。
2）会把处理好的数据成员放入值栈中，到页面可以使用 struts2 标签取值就可以了。
【题目描述】
struts 中如何实现国际化，涉及哪些文件？
【正确答案】
“国际化”是指一个应用程序在运行时能够根据客户端请求所来自的国家/地区、语言的不同 而显示不同的用户界面。Struts 框架通过使用<bean:message>标记，以及使用 java.util 数据包中定 义的 Locale 和 ResourceBundle 类来支持国际化。java.text.MessageFormat 类定义的技术可以支持 消息的格式。利用此功能，开发人员不需了解这些类的细节就可进行国际化和设置消息的格式。会涉 及到资源文件，不需了解这些类的细节就可进行国际化和设置消息的格式。会涉及到资源文件， struts-config.xml 配置文件,web.xml 配置文件。
【题目描述】
请简单画出 struts 技术构建 mvc 的流程图
【正确答案】
【题目描述】
Struts 的控制器部分，视图部分包括哪些内容？
【正确答案】
控制器:在 struts 中，基本的控制器组件是 ActionServlet 类中的实例 servelt，实际使用的 servlet 在配置文件中由一组映射（由 ActionMapping 类进行描述）进行定义。对于业务逻辑的操作则主要由 Action、ActionMapping、ActionForward 这几个组件协调完成的，其中 Action 扮演了真正的业务逻辑的实现者， ActionMapping 与 ActionForward 则指定了不同业务逻辑或流程的运行方向。 struts-config.xml 文件配置控制器。
视图：视图主要由 JSP 建立，struts 包含扩展自定义标签库（TagLib），可以简化创建完全国际化用 户界面的过程。目前的标签库包括：Bean Tags、HTML tags、Logic Tags、Nested Tags 以及 Template Tags 等。
【题目描述】
如何在web环境中配置applicationContext.xml文件?
【正确答案】
| <listener> <listener-class> org.springframework.web.context.ContextLoaderListener </listener-class> </listener> 或： <servlet> <servlet-name>context</servlet-name> <servlet-class> org.springframework.web.context.ContextLoaderServlet </servlet-class> <load-on-startup>1</load-on-startup> </servlet> |
通过如下方法取出applicationContext实例:
ApplicationContext ac=
WebApplicationContextUtils.getWebApplicationContext(this.getServletContext);
4.2 Hibernate
【题目描述】
以下哪个 Hibernate 主键生成策略是实现主键按数值顺序递增的？
【选项】
A. increment B. identity C. sequence D. native
【正确答案】 A
【解释】
increment 生成策略：当 Hibernate 准备在数据库表中插入一条新记录时，首先从数据库表中获取当 前主键字段的最大值，然后在最大值基础上加 1，作为当前持久化对象的标识符属性值。这种策略即 increment 生成策略，用其生成的标识符属性的类型可以是 long、short、int 及其封装类的类型 identity 生成策略：在 MS SQL Server、MySQL 和 DB2 等数据库中可以设置表中某一个字段的数值自 动增长，identity 生成策略通过这种方式为当前记录获取主键值的同时为持久化对象赋予标识符属性值。
sequence 生成策略：在 Oracle、DB2 和 PostgreSQL 等数据库中创建一个序列（sequence），然后Hibernate 通过该序列为当前记录获取主键值，进而为持久化对象赋予标识符属性值。
native 生成策略：由 Hibernate 根据所使用的数据库支持能力从 identity、sequence 或者等生成策 略中选择一种。
【题目描述】
在Hibernate中Customer类的orders集合属性，采用延迟检索策略，编译或运行以下程序，会出现什么情况：（）
Session session = sessionFactory.openSession();
Transaction 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 编译通过，但运行时抛出异常
D 编译通过，并正常运行
【正确答案】 C
【题目描述】
Hibernate 中：不看数据库，不看 XML 文件，不看查询语句，怎么样能知道表结构？
【正确答案】
可以看与 XML 文件对应的域模型。
【题目描述】
请看如下片段：
| <set name=“address” lazy=“true” inverse=“false” cascade=“all-delete-orphan”> <key column = “USERID”> </key> <one-to-many class=“com.norteksoft.erm.model.Address”/> </ set > |
解释 lazy、inverse、cascade 以及 all-delete-orphan 属性的含义；并给出示例代码，说明在如下组合情况下，对于 save、update、delete一对多关系中的一方对象操作时的区别：
inverse cascade
true all-delete-orphan
false all-delete-orphan
true all
false all
true none
false none
【正确答案】
(一)lazy:延迟加载
Lazy 的有效期：只有在 session 打开的时候才有效；session 关闭后 lazy 就没效了。
lazy 策略可以用在：
a．<class>标签上：可以取值 true/false
b.<property>标签上，可以取值 true/false，这个特性需要类增强
c.<set>/<list>等集合上，可以取值为 true/false/extra
d.<one-to-one>/<many-to-one>等标签上，可以取值 false/proxy/no-proxy
1) get 和 load 的区别：
a.get 不支持延迟加载，而 load 支持。
b.当查询特定的数据库中不存在的数据时，get 会返回 null，而 load 则抛出异常。
2) 类(Class)的延迟加载：
a. 设置<class>标签中的 lazy="true",或是保持默认（即不配置 lazy 属性)
b. 如果 lazy 的属性值为 true，那么在使用 load 方法加载数据时，只有确实用到
数据的时候才会发出 sql 语句；这样有可能减少系统的开销。
3) 集合(collection)的延迟加载：可以取值 true，false，extra a.true:默认取值，它的意思是只有在调用这个集合获取里面的元素对象时，才发出查询语句，加载 其集合元素的数据 b.false:取消懒加载特性，即在加载对象的同时，就发出第二条查询语句加载其关联集合的数据 c.extra:一种比较聪明的懒加载策略，即调用集合的 size/contains 等方法的时候，hibernate 并不 会去加载整个集合的数据，而是发出一条聪明的 SQL 语句，以便获得需要的值，只有在真正需要用到 这些集合元素对象数据的时候，才去发出查询语句加载所有对象的数据。
4) Hibernate 单端关联懒加载策略：即在<one-to-one>/<many-to-one>标签上可以配置 懒加载策略。可以取值为：false/proxy/no-proxy
a.false:取消懒加载策略，即在加载对象的同时，发出查询语句，加载其关联对象
b.proxy:这是 hibernate 对单端关联的默认懒加载策略，即只有在调用到其关联对
象的方法的时候才 真正发出查询语句查询其对象数据，其关联对象是代理类
c.no-proxy:这种懒加载特性需要对类进行增强，使用 no-proxy，其关联对象不是代
理类注意：在 class 标签上配置的 lazy 属性不会影响到关联对象!!!
（二）inverse
inverse 是指的关联关系的控制方向，inverse=false 的 side（side 其实是指 inverse＝false 所位 于的 class 元素）端有责任维护关系，而 inverse＝true 端无须维护这些关系
- cascade
cascade 指的是层级之间 的 连 锁 操 作 。 在 定 义 关 联 对 象 的 映 射 时 ， 使 用 cascade="all" ，cascade="save-update",cascade="all-delete-orphan"或 cascade="delete" a. 如果父对象被保存，所有的子对象会被传递到saveOrUpdate()方法去执行 (cascade="save-update")
b. 如果父对象被传递到 update()或者 saveOrUpdate()，所有的子对象会被传递到 saveOrUpdate()方 法去执行(cascade="save-update") c.如果一个临时的子对象被一 个持久化的父对象引用了，它会被传递到 saveOrUpdate()去执行 (cascade="save-update")
c. 如果父对象被删除了，所有的子对象对被传递到 delete()方法执行 (cascade="delete")
e. 如果临时的子对象不再被持久化的父对象引用，什么都不会发生（必要时，程 序应该明确的删除这 个子对象），除非声明了 cascade="all-delete-orphan"，在这种 情况下，成为“孤儿”的子对象会被删除。
(四) save、update、delete 一对多关系中的一方对象操作时的区别
1）当一方设置 inverse=true 时，所有由一方发出的操作都不会关联到多方。
2)当一方设置 inverse=false, cascade=all-delete-orphan 时，将删除不再和一方对象关联
的所有多方对象。
3）当一方设置 inverse=false, cascade=all 时,当保存和删除一方对象时，级联保存和删
除所有关联的多方对象。
4）当一方设置 inverse=false, cascade=none 时,当对一方操作时，不级联到关联的多方
对象。
【题目描述】
对 hibernate 的延迟加载如何理解，在实际应用中，延迟加载与 session 关闭的矛盾是如何处理的？
【正确答案】
延迟加载就是并不是在读取的时候就把数据加载进来，而是等到使用时再加载。那么 Hibernate 是怎么知识用户在什么时候使用数据了呢？又是如何加载数据呢？其实很简单，它使用了代理机制。 返回给用户的并不是实体本身，而是实体对象的代理。代理对象在用户调用 getter 方法时就会去数 据库加载数据。但加载数据就需要数据库连接。而当我们把会话关闭时，数据库连接就同时关闭了。 这种情况就叫做未初始化的关系。
延迟加载与 session 关闭的矛盾一般可以这样处理：
1)、关闭延迟加载特性。
操作起来比较简单，因为 hibernate 的延迟加载特性是在 hbm 配置里面可控制的。默认 lazy="true"， 具体配置可以查看一下相关文档，就不详细叙述了。使用这个解决办法带来的隐患是十分大的。
首先，出现 no session or session was closed 就证明了您已经在使用外键关联表，如果去掉延迟加载的话，则表示每次查询的开销都会变得十分的大，如果关联表越多，后果也可以想象得到。所以 不建议使用这个方法解决。
2)、在 session 关闭之前把我们想要查询的数据先获取了。
首先需要了解一下 session 什么时候关闭，也就是它的生命周期。通常情况下 hibernate 会在查询数 据关闭 session，而使用 getHibernateTemplate().get 方法查询后会延迟关闭的时间。会在事务结束 后才关闭。使用拦截器(Interceptor)或过滤器(Filter)控制 session。
spring 为解决 hibernate 这一特性提供的解决方案，可以有效的控制 session 生命周期。
【题目描述】
介绍一下 hibernate 的工作原理、优点以及如何优化？
【正确答案】
工作原理：
1)启动 Hibernate 构建 Configuration 实例，初始化该实例中的所有变量 Configuration cfg = new Configuration().configure();
2).加载 hibernate.cfg.xml 文件至该实例内存,通过 hibernate.cfg.xml 文件中的 mapping 节点配置，加载 hbm.xml 文件至该实例内存;
3). 由上面得到的Configuration 实例构建一个 SessionFactory 实例 SessionFactory sf =cfg.buildSessionFactory();
4).由上面得到的 SessionFactory 实例创建连接 Session s = sf.openSession();
5).由上面得到的 Session 实例创建事务操作接口 Transaction 的一个实例 tx Transaction tx =s.beginTransaction();
6).通过 Session 接口提供的各种方法操作数据库的访问
7).提交数据库的操作结果 tx.commit();
8).关闭 Session 链接 s.close();
优点：
1).对 JDBC 访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。
2).Hibernate 是一个基于 JDBC 的主流持久化框架，是一个优秀的 ORM 实现。他很大程度的简化 DAO层的编码工作
3).hibernate 使用 Java 反射机制，而不是字节码增强程序来实现透明性。
4).hibernate 的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。
优化：
1).使用双向一对多关联，不使用单向一对多
2).灵活使用单向一对多关联
3).不用一对一，用多对一取代
4).配置对象缓存，不使用集合缓存
5).一对多集合使用 Bag,多对多集合使用 Set
6).继承类使用显式多态
7).表字段要少，表关联不要怕多，可以利用二级缓存
【题目描述】
Hibernate 实现中，load 和 get 方法的区别，find 和 iterate 的区别?
【正确答案】
load 和 get 方法的区别：hibernate 对于 load 方法认为该数据在数据库中一定存在，可以放心的使用代理来延迟加载，如果在使用过程中发现了问题，只能抛异常；而对于 get 方法，hibernate 一定要获取到真实的数据，否则返回 null。
find 和 iterate 的区别：find 方法通过一条 Select SQL 实现了查询操作，而 iterate 方法要执 行多条 Select SQL.iterate 第一次查询获取所有符合条件的记录的 id，然后再根据各个 id 从库表中 读取对应的记录，这是一个典型的 N+1 次的查询问题，如果符合条件记录有 10000 条，就需要执行 10001条 Select SQL，性能会非常差。
【题目描述】
Hibernate 有哪 5 个核心接口？
【正确答案】
Configuration 接口：配置 Hibernate，根据其启动 hibernate，创建 SessionFactory 对象； SessionFactory 接口：初始化 Hibernate，充当数据存储源的代理，创建 session 对象， sessionFactory 是线程安全的，意味着它的同一个实例可以被应用的多个线程共享，是重量级、二级缓存；
Session 接口：负责保存、更新、删除、加载和查询对象，是线程不安全的，避免多个线程共享 同一个 session，是轻量级、一级缓存；
Transaction 接口：管理事务；
Query 和 Criteria 接口：执行数据库的查询。
【题目描述】
什么是 ORM？
【正确答案】
对象关系映射（Object—Relational Mapping，简称 ORM）是一种为了解决面向对象与面向关 系数据库存在的互不匹配的现象的技术；简单的说，ORM 是通过使用描述对象和数据库之间映射的元 数据，将 java 程序中的对象自动持久化到关系数据库中；本质上就是将数据从一种形式转换到另外 一种形式。
【题目描述】
hibernate 中的 java 对象有几种状态，其相互关系如何（区别和相互转换）。
【正确答案】
在 Hibernate 中，对象有三种状态：临时状态、持久状态和游离状态。
临时状态：当 new 一个实体对象后，这个对象处于临时状态，即这个对象只是一个保存临时数据的内 存区域，如果没有变量引用这个对象，则会被 jre 垃圾回收机制回收。这个对象所保存的数据与数据库没有任何关系，除非通过 Session 的 save 或者 SaveOrUpdate 把临时对象与数据库关联，并把数据 插入或者更新到数据库，这个对象才转换为持久对象； 持久状态:持久化对象的实例在数据库中有对应的记录，并拥有一个持久化表示（ID.。对持久化对象 进行 delete 操作后，数据库中对应的记录将被删除，那么持久化对象与数据库记录不再存在对应关 系，持久化对象变成临时状态。 持久化对象被修改变更后，不会马上同步到数据库，直到数据库事务提交。在同步之前，持久化对象 是脏的（Dirty）。
游离状态：当 Session 进行了 Close、Clear 或者 evict 后，持久化对象虽然拥有持久化标识符和与 数据库对应记录一致的值，但是因为会话已经消失，对象不在持久化管理之内，所以处于游离状态（也叫：脱管状态）。游离状态的对象与临时状态对象是十分相似的，只是它还含有持久化标识。
4.3 Mybatis
【题目描述】
不是Mybatis配置文件中的主要元素是( )
【选项】
A.properties B.transactionManager C.mappers D.bean
【正确答案】 D
【题目描述】
MyBatis中如何实现动态SQL的？
【正确答案】
使用动态sql的元素：
if
choose（when，otherwise）
trim
where
set
foreach
【题目描述】
MyBatis解决插入空值问题？
【正确答案】
MyBatis 插入空值时，需要指定JdbcType jdbcType=NUMERIC
【题目描述】
Mybaties中#与$的区别？
【正确答案】
1)#是把传入的数据当作字符串，如#field#传入的是id,则生成sql语句:order by “id”;
2)$传入的数据直接生成在sql里，如$field$传入的是id,则sql语句生成是这样，order by id ;
3)#方式能够很大程度防止sql注入, 但$方式无法防止sql注入;
4)$方式一般用于传入数据库对象．例如传入表名;
5)一般能用#的就别用$ ;
【题目描述】
Mybaties中使用like ‘%#filedName#%’ 时，有什么问题？
【正确答案】
在xml映射文件中，如果直接按如上写法，会报异常：java.sql.SQLException: Invalid argument in JDBC call: parameter index out of range: 1。
所以一般会采用如下两种方式：
1) 将#换成$，如like ‘%$ filedName $%’，这样就没有问题了..
2) 采用字符串联接符||，如：like ‘%’||# filedName #||’%’
【题目描述】
MyBatis原理,为什么使用，优点是什么
【正确答案】
封装了JDBC操作,将SQL查询结果映射为对象,将对象属性值映射到SQL.
步骤：
1)解析SqlMapConfig.xml和SqlMap.xml(定义SQL)
2)将解析出的SQL生成MappedStatement(预编译Statement)
3)将传入的SQL参数给Statement绑定,参数类型可以为 java对象,Map类型,int,String类型
4)执行mappedstatement,返回sql结果
5)将返回的SQL结果转为Java对象,Map,int,String类型返回
优点:简化数据库访问操作,便于实现DAO操作
【题目描述】
mybatis 和 ibatis比较
【正确答案】
1）Mybatis实现了接口绑定，使用更加方便。在ibatis2.x中我们需要在DAO的实现类中指定具体对应哪个xml映射文件，而Mybatis实现了DAO接口与xml映射文件的绑定，自动为我们生成接口的具体实现，使用起来变得更加省事和方便。这可以说是Mybatis最重要的改进。
注意：
虽然Mybatis支持在接口中直接使用annotation的配置方式来简化配置，不过强烈建议仍然使用xml配置的方式。毕竟annotation的配置方式功能有限且代码入侵性太强。使用xml配置方式才能体现出Mybatis的优势所在
2）对象关系映射的改进，效率更高
相信很多在使用ibatis2.x的朋友并没有通过ibatis的xml映射文件来实现对象间的关系映射。其实也确实没有必要那么做，因为ibatis2.x采用的是“嵌套查询”的方式将对象之间的关系通过查询语句的直接拼装来实现，其效果和在DAO或Service中自行封装是一样的。不过这种方式存在“N+1查询问题”。概括地讲，N+1查询问题可以是这样引起的：
你执行了一个单独的SQL语句来获取结果列表（就是+1）。对返回的每条记录，你执行了一个查询语句来为每个加载细节（就是N）。这个问题会导致成百上千的SQL语句被执行。这通常不是期望的。
而在Mybatis中，除了兼容ibatis2.x中的“嵌套查询”方式外，还提供了直接“嵌套结果”的方式，其效果相当于直接通过一句sql将查询出的dto对象自动封装成所需的对象。
具体实现方法请自行参考Mybatis官方使用手册，不在此累述.
不过实际上这一改进所带来的好处也是很有限的。因为这一方式在使用分页的时候并不起作用，或者说嵌套对象的结果集是不允许进行分页的。这一点在Mybatis框架中已经做出了明确的限制（org.apache.ibatis.executor.resultset.NestedResultSetHandler里34行），而实际项目中需要分页的情况又特别多……
仔细一想，一对多映射确实不能通过配置文件来分页，因为这时查询出的记录数并不等于实际返回对象的size，不过一对一映射为什么也不允许就不太明白了。可能是因为一对一是一对多的特例，而在设计框架的时候并没有考虑去处理或是难于处理这一特例吧。
17. MyBatis采用功能强大的基于OGNL的表达式来消除其他元素。
熟悉struts2的人应该对OGNL表达式不会感到陌生，
MyBatis采用OGNL表达式简化了配置文件的复杂性，使用起来更简洁。
【题目描述】
Mybatis和Hibernate的区别
【正确答案】
共同点：Hibernate和Mybatis都是orm对象关系映射框架，都是用于将数据持久化的框架技术。
区别：1. Hiberante较深度的封装了jdbc，对开发者写sql的能力要求的不是那么的高，我们只要通过hql语句操作对象即可完成对数据持久化的操作了。
2. hibernate可移植性好，使用hibernate只需改变一下数据库方言即可搞定。用hibernate框架，数据库的移植变的非常方便。
3 .hibernate生成的sql语句耗费程序资源，优化起来也不是很方便，且对存储过程支持的也不够太强大。
4. Mybatis 是对jdbc的封装，但是封装的没有hibernate那么深，我们可以再配置文件中写sql语句，可以根据需求定制sql语句，数据优化起来较hibernate容易很多。 5. Mybatis要求程序员写sql的能力要相对使用hibernate的开发人员要高的多，且可移植性也不是很好。
6. 处理大数据时使用Mybatis比较好，因为优化较方便。
【题目描述】
Mybatis中1111错误是什么错误，怎么解决？
【正确答案】
在使用Mybatis时，不同的xml配置文件，有的会提示：无效的列类型: 1111。
通过观察，如果是参数是Map类型或者Java Object类型，如果Map或者Object里面的属性类型不一致，如有些属性是String类型，有些属性是Integer类型，那么MyBatis解析的时候，就会出现问题，类型无法识别。
当然，如果传入参数不是Map或者Java Object，而是多个参数列表的形式，如果参数类型一致，那么不会出现问题，如果参数类型不一致，如既有String类型，也有Integer类型，那么解析的时候同样会出错。或者因为传入的参数的字段为null对象无法获取对应的jdbcType类型，而报的错误。
解决方法：如果有类型不一致的情况，在值后面使用jdbcType加上类型，
例：
passWord = #{passWord,jdbcType=VARCHAR}
enable = #{enable,jdbcType=NUMERIC}
4.4 Spring
【题目描述】
Spring的组成一共有（ ）块组成。
【选项】
A.1 B.3 C.5 D.7
【正确答案】 D
【题目描述】
Spring核心模块的作用（ ）
【选项】
A.做AOP的
B.做IOC的，用来管理Bean的
C.是用来支持Hibernete
D.是用来支持Struts的
【正确答案】 B
【题目描述】
看下面的代码，说法正确的是（ ）
<bean id="userTable" class="com.xfaccp.bean.UserTable">
<property name="userName">
<value>ACCP</value>
</property>
</bean>
【选项】
A.其中<property name="userName">的userName是UserTable中的属性，可以不要get、set方法。
B.其中<property name="userName">的userName是UserTable中的属性，可以不要get方法，但是一定要有set方法
C.其中<property name="userName">的userName是UserTable中的属性，可以不要set方法，但是一定要有get方法
D.其中<property name="userName">的userName是UserTable中的属性，一定要有get和set方法
【正确答案】 B
【题目描述】
看下面的代码，说法正确的是（）
<bean id="beforeAdvisor"
class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<property name="advice">
<ref local="beforeImpl"/>
</property>
<property name="pattern">
<value>.*</value>
</property>
</bean>
【选项】
A.这段代码是在定义目标对象
B.这段代码是在定义切入点
C.这段代码是在定义代理
D.这段代码是在定义织入
【正确答案】 B
【题目描述】
在web.xml文件中配置Spring框架，下面配置正确的是（ ）
【选项】
A.<context-param>
<param-name>config</param-name>
<param-value>/WEB-INF/classes/applicationContext.xml</param-value>
</context-param>
B.<context-param>
<param-name>servletConfig</param-name>
<param-value>/WEB-INF/classes/applicationContext.xml</param-value>
</context-param>
C.<context-param>
<param-name>contextconfig</param-name>
<param-value>/WEB-INF/classes/applicationContext.xml</param-value>
</context-param>
D.<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/classes/applicationContext.xml</param-value>
</context-param>
【正确答案】 D
【题目描述】
下面关于BeanFactory接口说法正确的是（ ）
【选项】
A. BeanFactory是单例模式的实现，负责创建和管理bean
B. BeanFactory是工厂模式的实现，负责创建和管理bean
C. ApplicationContext类是它的实现类
D. 以上说法都不对
【正确答案】 B
【题目描述】
下面关于构造注入优点说法错误的是（ ）
【选项】
A. 构造期即创建一个完整、合法的对象
B. 不需要写繁琐的setter方法的
C. 对于复杂的依赖关系，构造注入更简洁，直观
D. 在构造函数中决定依赖关系的注入顺序
【正确答案】 C
多选
【题目描述】
下面关于Spring的说话正确的是（ ）
【选项】
A.Spring是一个重量级的框架
B.Spring是一个轻量级的框架
C.Spring是一个IOC和AOP容器
D.Spring是一个入侵式的框架
【正确答案】 BC
【题目描述】
下面关于IOC的理解，正确的是（ ）
【选项】
A.控制反转
B.对象被动的接受依赖类
C.对象主动的去找依赖类
D.一定要用接口
【正确答案】 AB
【题目描述】
下面关于AOP的理解，正确的是（ ）
【选项】
A.面向纵向的开发
B.面向横向的开发
C.AOP关注是面
D.AOP关注的是点
【正确答案】 BC
【题目描述】
Spring各模块之间关系（ ）
【选项】
A.Spring各模块之间是紧密联系的，相互依赖的
B.Spring各模块之间可以单独存在
C.Spring的核心模块是必须的，其他模块是基于核心模块
D.Spring的核心模块不是必须的，可以不要
【正确答案】 BC
【题目描述】
Spring的通知类型有（ ）
【选项】
A.Before通知
B.After return通知
C.Throws通知
D.Around通知
【正确答案】 ABCD
【题目描述】
下面关于切入点的说法正确的是（ ）
【选项】
A.是AOP中一系列连连接点的集合
B.在做AOP时定义切入点是必须的
C.在做AOP时定义切入点不是必须的
D.可以用正则表达式来定义切入点
【正确答案】 ACD
【题目描述】
下面是IOC自动装载方法的是（ ）
【选项】
A.byName
B.byType
C.constructor
D.byMethod
【正确答案】 AB
【题目描述】
看下面的代码，说法正确的是（ ）
<bean id=“user" class=“com.xfaccp.bean.User"/>
<constructor-arg>
<value>accp</value>
</constructor-arg>
</bean>
【选项】
A.必须要有一个接受字符串的构造方法
B.可以没有接受一个字符串的构造方法
C.这个类有且只能有一个只接受一个字符串的构造方法
D.这个类可以有多个构造方法，但是一定要有一个只接受一个字符串的构造方法
【正确答案】 AD
【题目描述】
看下面的代码，说法正确的是（ ）
<bean id="before" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="proxyInterfaces"> <value>com.xfaccp.before.BeforeInterface</value>
</property>
<property name="target">
<ref bean="testBefore"/>
</property>
<property name="interceptorNames">
<list>
<value>beforeAdvisor</value>
</list>
</property>
</bean>
【选项】
A.这段代码是做IOC
B.这段代码是做AOP
C.这段代码是在做代理
D.这段代码是在做织入
【正确答案】 BD
【题目描述】
下面关于AOP的理解正确的是（ ）
【选项】
A. 能够降低组件之间的依赖关系
B. 将项目中的公共的问题集中解决，减少代码量，提高系统的可维护性
C. AOP是面向对象的代替品
D. AOP不是面向对象的代替品，是面向对象很好的补充
【正确答案】 BC
问答
【题目描述】
为什么要使用Spring框架，它有什么优点？
【正确答案】
(1) 轻量级的框架
(2) 非侵入性的
(3) 可以整合其它的框架，比如Struts， Hibernate等
(4) 可以提供事务管理
【题目描述】
spring 有几种事务管理，spring 的事务管理接口是什么？
【正确答案】
Spring 提供的事务管理可以分为两类：编程式的和声明式的。编程式的，比较灵活，但是代码 量大，存在重复的代码比较多；而声明式的比编程式的更灵活方便。 接口：其中最重要的三个接口：TransactionDefinition、PlatformTransactionManager 、 TransactionStatus 。
在Spring中 ，事务是通过TransactionDefinition 接口来定义的。该接口包含与事务属性有关的方法，TransactionDefinition 接口中定义了五个表示隔离级别的常量、代表传播行为的常量，在TransactionDefinition 中以int的值来表示超时时间， PlatformTransactionManager.getTransaction( ? ) 方法返回一个TransactionStatus 对象。返回的 TransactionStatus 对象可能代表一个新的或已经存在的事务（如 果在当前调用堆栈有一个符合条件的事务）。TransactionStatus 接口提供了一个简单的控制事务执 行和查询事务状态的方法。
【题目描述】
介绍一下 springMVC 的工作原理、为什么用 spring？
【正确答案】
springMVC 工作原理：
1）.spring mvc 请所有的请求都提交给 DispatcherServlet,它会委托应用系统的其他模块负责负责 对请求进行真正的处理工作。
2）.DispatcherServlet 查询一个或多个 HandlerMapping,找到处理请求的 Controller.
3）.DispatcherServlet 请请求提交到目标 Controller
4）.Controller 进行业务逻辑处理后，会返回一个 ModelAndView
5）.Dispathcher 查询一个或多个 ViewResolver 视图解析器,找到 ModelAndView 对象指定的视图对象
6）.视图对象负责渲染返回给客户端。 为什么用 spring：
AOP 让开发人员可以创建非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。使用 AOP 后，公共服务 （比 如日志、持久性、事务等）就可以分解成方面并应用到域对象上，同时不会增加域对象的对象模型的复杂性。IOC 允许创建一个可以构造对象的应用环境，然后向这些 对象传递它们的协作对象。正如单词 倒置 所表明的，IOC 就像反 过来的 JNDI。没有使 用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction），每一 个对象都是用其协作对象构造的。因此是由容器管理协作对象（collaborator）。 Spring 既是一个 AOP 框架，也是一 IOC 容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring，只要用 JavaBean 属性和配置文件加入依赖性（协作对象）。然后可以很容易地在需要时替换具有类似接口的 协作对象。
【题目描述】
spring常用注解
【正确答案】
@Repository、 @Service、 @Controller
@Controller对应表现层的Bean，也就是Action
@Service对应的是业务层Bean
@Repository对应数据访问层Bean
【题目描述】
怎么使用Spring配置事务 ?
【正确答案】
Spring同时支持编程式事务策略和声明式事务策略，大部分时候都采用声明式事务策略。
声明式事务管理的配置方式，通常有以下4种：
(1) 使用TransactionProxyFactoryBean为目标Bean生成事务代理的配置。此方式是最传统、配置文件最臃肿、最难以阅读的方式。
(2) 采用Bean继承的事务代理配置方式，比较简洁，但依然是增量式配置。
(3) 采用BeanNameAutoProxyCreator，根据Bean Name自动生成事务代理的方式。这是直接利用Spring的AOP框架配置事务代理的方式，需要对Spring的AOP框架有所理解。但这种方式避免了增量式配置，效果非常不错。
(4) 采用DefaultAdvisorAutoProxyCreator，直接利用Spring的AOP框架配置事务代理的方式，效果非常不错，只是这种配置方式的可读性不如第3种方式。
【解释】无
【题目描述】
简述Spring MVC的处理流程。
【正确答案】
a.浏览器发送HTTP请求,请求到达DispatcherServlet主控制器
b.主控制器调用HandlerMapping,解析请求寻找相应的Controller组件处理请求.
c.执行Controller约定方法,调用Service,DAO处理请求,处理完毕,返回一个ModelAndView对象
d.主控器调用ViewResoler,解析ModelAndView结果,寻找相应的View组件
e.调用View组件,解析标签和EL表达式,生成响应HTML界面
f.输出HTML流,为客户浏览器响应
【题目描述】
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> |
【题目描述】
如何在web应用里面配置spring?
【正确答案】
在web.xml中加入如下同容,在启动web服务器时加载/WEB-INF/applicationContext.xml中的内容。
| <servlet> <servlet-name>context</servlet-name> <servlet-class> org.springframework.web.context.ContextLoaderServlet </servlet-class> <load-on-startup>1</load-on-startup> </servlet> |
通过如下类得到ApplicationContext实例
WebApplicationContextUtils.getWebApplicationContext
【题目描述】
Spring里面如何定义hibernate mapping？
【正确答案】
添加hibernate mapping 文件到web/WEB-INF目录下的applicationContext.xml文件里面。示例如下：
| <property name=”mappingResources”> <list> <value>org/appfuse/model/User.hbm.xml</value> </list> </property> |
【题目描述】
spring中的BeanFactory与ApplicationContext的作用有哪些？
【正确答案】
1. BeanFactory负责读取bean配置文档，管理bean的加载，实例化，维护bean之间的依赖关系，负责bean的声明周期。
2. ApplicationContext除了提供上述BeanFactory所能提供的功能之外，还提供了更完整的框架功能：
a. 国际化支持
b. 资源访问：Resource rs = ctx. getResource(”classpath:config.properties”), “file:c:/config.properties”
c. 事件传递：通过实现ApplicationContextAware接口
【题目描述】
spring中的核心类有那些，各有什么作用?
【正确答案】
BeanFactory：产生一个新的实例，可以实现单例模式
BeanWrapper：提供统一的get及set方法
ApplicationContext:提供框架的实现，包括BeanFactory的所有功能
【题目描述】
AOP里面重要的几个名词概念解释：
【正确答案】
切面（Aspect）： 一个关注点的模块化，这个关注点可能会横切多个对象。事务管理是J2EE应用中一个关于横切关注点的很好的例子。 在Spring AOP中，切面可以使用通用类（基于模式的风格） 或者在普通类中以@Aspect 注解（@AspectJ风格）来实现。
连接点（Joinpoint）： 在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时候。 在Spring AOP中，一个连接点 总是 代表一个方法的执行。 通过声明一个org.aspectj.lang.JoinPoint类型的参数可以使通知（Advice）的主体部分获得连接点信息。
通知（Advice）： 在切面的某个特定的连接点（Joinpoint）上执行的动作。通知有各种类型，其中包括“around”、“before”和“after”等通知。 通知的类型将在后面部分进行讨论。许多AOP框架，包括Spring，都是以拦截器做通知模型， 并维护一个以连接点为中心的拦截器链。
切入点（Pointcut）： 匹配连接点（Joinpoint）的断言。通知和一个切入点表达式关联，并在满足这个切入点的连接点上运行（例如，当执行某个特定名称的方法时）。 切入点表达式如何和连接点匹配是AOP的核心：Spring缺省使用AspectJ切入点语法。
引入（Introduction）： （也被称为内部类型声明（inter-type declaration））。声明额外的方法或者某个类型的字段。 Spring允许引入新的接口（以及一个对应的实现）到任何被代理的对象。 例如，你可以使用一个引入来使bean实现 IsModified 接口，以便简化缓存机制。
目标对象（Target Object）： 被一个或者多个切面（aspect）所通知（advise）的对象。也有人把它叫做 被通知（advised） 对象。 既然Spring AOP是通过运行时代理实现的，这个对象永远是一个 被代理（proxied） 对象。
AOP代理（AOP Proxy）： AOP框架创建的对象，用来实现切面契约（aspect contract）（包括通知方法执行等功能）。 在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。 注意：Spring 2.0最新引入的基于模式（schema-based）风格和@AspectJ注解风格的切面声明，对于使用这些风格的用户来说，代理的创建是透明的。
织入（Weaving）： 把切面（aspect）连接到其它的应用程序类型或者对象上，并创建一个被通知（advised）的对象。 这些可以在编译时（例如使用AspectJ编译器），类加载时和运行时完成。 Spring和其他纯Java AOP框架一样，在运行时完成织入。
通知的类型：
前置通知（Before advice）： 在某连接点（join point）之前执行的通知，但这个通知不能阻止连接点前的执行（除非它抛出一个异常）。
返回后通知（After returning advice）： 在某连接点（join point）正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回。
抛出异常后通知（After throwing advice）： 在方法抛出异常退出时执行的通知。
后通知（After (finally) advice）： 当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。
环绕通知（Around Advice）： 包围一个连接点（join point）的通知，如方法调用。这是最强大的一种通知类型。 环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。
环绕通知是最常用的一种通知类型。大部分基于拦截的AOP框架，例如Nanning和JBoss4，都只提供环绕通知。
切入点（pointcut）和连接点（join point）匹配的概念是AOP的关键，这使得AOP不同于其它仅仅提供拦截功能的旧技术。 切入点使得定位通知（advice）可独立于OO层次。 例如，一个提供声明式事务管理的around通知可以被应用到一组横跨多个对象中的方法上（例如服务层的所有业务操作）。
【题目描述】
Spring框架的优点都有什么？
【正确答案】
Spring是分层的架构，你可以选择使用你需要的层而不用管不需要的部分；
Spring是POJO编程，POJO编程使得可持续构建和可测试能力提高；
依赖注入和IoC使得JDBC操作简单化；
Spring是开源的免费的；
Spring使得对象管理集中化合简单化。
【题目描述】
描述一下Spring中实现DI（Dependency Injection）的几种方式
【正确答案】
方式一：接口注入，在实际中得到了普遍应用，即使在IOC的概念尚未确立时，这样的方法也已经频繁出现在我们的代码中。
方式二：Type2 IoC: Setter injection对象创建之后，将被依赖对象通过set方法设置进去
方式三：Type3 IoC: Constructor injection对象创建时，被依赖对象以构造方法参数的方式注入Spring的方式
【题目描述】
Spring容器中存储的是对象么？容器中为什么要存放对象？
【正确答案】
是对象。要对象与对象之间的依赖不需要通过实现类实现，而是利用容器来管理，spring根据配置文件，通过java的反射机制去动态的组装对象，相对于一般建立对象是用的new用spring建立对象，降低了代码的耦合。
【题目描述】
说明反转控制（IOC）和面向方向编程（AOP）在 spring 中的应用
【正确答案】
Spring 核心容器（Core）提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory， 它是工厂模式的实现。BeanFactory 使用控制反转（Ioc）模式将应用程序的配置和依赖性规范与实际 的应用代码程序分开。Spring 的声明式事务基于 AOP 实现，却并不需要程序开发者成为 AOP 专家，亦 可轻易使用 Spring 的声明式事务管理。
【题目描述】
在项目中用过 Spring 的哪些方面？及用过哪些 Ajax 框架？
【正确答案】
在项目使用过 Spring IOC ，AOP，DAO，ORM，还有上下文环境。
在项目使用过 Ext,Juery 等 Ajax 框架.
4.5 框架整合
【题目描述】
对Hibernate的支持主要用到Spring的那个模块（ ）
【选项】
A.Spring核心模块
B.Spring ORM模块
C.Spring MVC模块
D.Spring Web模块
【正确答案】 B
【题目描述】
对Struts的支持主要用到Spring的那个模块（ ）
【选项】
A.Spring核心模块
B.Spring ORM模块
C.Spring MVC模块
D.Spring Web模块
【正确答案】 D
【题目描述】
Spring包装Hibernate之后的Hibernate的DAO应该继承那个类（ ）
【选项】
A.HibernateDAO
B.SessionFactory
C.HibernateDAOSuport
D.Session
【正确答案】 C
【题目描述】
Spring包装Hibernate之后，关于findByExample方法说法正确的是（）
【选项】
A.是根据对象来找，对象中有的属性都作为条件，包括主键，根据对象来动态的查询
B.是根据对象来找，对象中有的属性都作为条件，不包括主键，根据对象来动态的查询
C.是根据SQL语句来找
D.是根据HQL来找
【正确答案】 B
【题目描述】
在struts1.2同Spring集成的中，需要在struts-config.xml文件中配置一个请求处理器，下面配置办法正确的是（）
【选项】
A. <controller className="org.springframework.web.struts.DelegatingRequestProcessor">
</controller>
- <controller processorClass="org.springframework.web.struts.DelegatingRequestProcessor">
</controller>
- <processor className="org.springframework.web.struts.DelegatingRequestProcessor">
</controller>
- <processor processorClass=
"org.springframework.web.struts.DelegatingRequestProcessor">
</controller>
【正确答案】 B
【题目描述】
关于Spring 与 Hibernate集成，下面说法错误的是( )
【选项】
A. Spring提供了HibernateDaoSupport类来简化Hibernate的使用
B. 在Spring配置文件种可以通过Spring提供的LocalSessionFactoryBean,来获得SessionFactory的实例
C. 通过集成Spring和Hibernate,用Spring管理程序的依赖关系，将SessionFactory注入到DataSource中
D. 通过Spring,可以在Biz层代码中无需直接实例化DAO类，而是通过注入得到
【正确答案】 C
【题目描述】
Spring和Hibernate整合过程中各对象注入的顺序是（ ）
【选项】
A. DataSource->SessionFactory-> Biz -> DAO
B. SessionFactory -> DataSource ->DAO->Biz
C. DataSource->SessionFactory->DAO->Biz
D. SessionFactory -> DataSource -> Biz -> DAO
【正确答案】 C
【解释】无
多选
【题目描述】
下面对Spring包装Struts1.2的说法正确的是（ ）
【选项】
A.Spring包装Struts的ActionServlet
B.Spring包装Struts的Action
C.主要是利用Spring的依赖注入
D.主要利用Spring的面向方面的编程
【正确答案】 BC
【题目描述】
Spring包装Struts时那些Spring模块是必须的（ ）
【选项】
A.Spring核心模块
B.Spring AOP模块
C.Spring MVC模块
D.Spring WEB模块
【正确答案】 AD
【题目描述】
Spring包装Struts的动作说法正确的是（）
【选项】
A.Action配置的type属性还是指向自己的Action类
B.Action配置的type属性不需要指向自己的Action类，但是Action要在Spring配置文件中配置
C.Action配置的type属性一定要指向Spring提供的代理类，但是Action要在Spring配置文件中配置
D.Action配置的type属性可以不指向Spring提供的代理类，可以利用Spring提供的中央处理器来处理，但是Action要在Spring配置文件中配置
【正确答案】 BD
【题目描述】
Struts2同Spring集成的说法正确的是（）
【选项】
A. 可以在struts.properties中增加一个配置：struts.beanFactory=spring
B. 可以在struts.xml中配置一个<processor processorClass="org.springframework. web.struts.DelegatingRequestProcessor"></controller>的配置
C. 可以在struts.xml中增加一个<constant name="struts.beanFactory" value="spring" />
D. 可以在struts.xml中增加一个插件
<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn"><set-property property="contextConfigLocation" value="classpath:applicationContext.xml" />
</plug-in>
【正确答案】 AC
【题目描述】
Spring包装Hibernate之后，能够来保存数据的方法有（ ）
【选项】
A.save
B.load
C.saveOrUpdate
D.merge
【正确答案】 AC
问答
【题目描述】
说出几个与 spring 同类型的开源框架，说出几个与 hibernate 同类型的开源框架,说出几个与struts 同类型的开源框架
【正确答案】
1）与 spring 同类型的开源框架：JUIDE、EJB3.0、picoContainer
2）与 hibernate 同类型的开源框架 ：ibatis，jdo，JPA
3）几个与 struts 同类型的开源框架：webwork，tapestry，JSF
【题目描述】
简要描述如何结合 struts、hibernate、spring 开发 Web 应用？
【正确答案】
Struts 可以将 jsp 页面的表单关联起来,就是把 JSP 页面的表单数据封装成 javaBean,这样的 话,在 action 中你再也不需要使用传统的 request.getParameter("name");还有 struts 有一个控制器, 你在 struts 编程中的控制器(XxxAction)都是继承总的 ActionServlet,它能集中处理请求,然后转到 相关的页面。还有 struts 的表单验证组件,不用你写 js 验证了,只需要你配置一下文件就可以了。另 外 struts 的令牌机制可以防表单重复提交。
Spring 是一个轻量级容器,非侵入性.包含依赖注入,AOP 等。它是为了解决企业应用程序开发复 杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。
Hibernate:它可以让我们以 OO 的方式操作数据库，这让我们看到了 hibernate 的强大之处，体验到操作数据的方便。但 hibernate 最耀眼之处是 hibernate 的缓存机制，而不是以 OO 的方式操作 数据库。Hibernate 的缓存机制不外乎是一级缓存 session，二级缓存 sessionFactory，和第三方缓 存如 ehcache。也就是 hibernate 的最强大的地方是它的缓存，理解了这个才能真正的理解 hibernate,Hibernate 的命名查询/命名参数查询，就是将 hql 语句放在一个单独的 xml 文件之中，它 仍然让人们以面向对象的方式去操纵数据，而不用在以 OO 的方式写着代码的同时，然后再转变思维， 用面向关系的方式去写那些 sql 语句。但 hibernate 不仅做了这些，它的 native sql 查询方式，完 全满足 sql 语句的偏爱者，它像 ibatis 一样，将 sql 语句放在配置文件之中。
【题目描述】
Spring的MVC和Struts的MVC的区别
【正确答案】
相同点：
1.都是mvc框架；
2.感觉struts的action类似于spring的ioc，都是使用java反射机制来实现的依赖注入；
3.struts2的拦截器使用也类似于spring的aop，都是通过动态代理实现的；
不同点：
1.配置不一样
2.spring的控制器对象的处理请求方法需要带有HttpServletRequest和HttpServletResponse参数，这样不于调试；
3.参数的接收，在struts2中通过set方法就实现了，而spring则从request中获取，另外参数的传递也比较方便；
4.struts2处理请求的返回页比较方便，通过action的返回的结果名称，定位返回的页面或者重定向到另一个action
5.struts2同时提供了对于请求变量的校验和类型的转换；
6.spring在mvc框架中相对于struts2的优势在于它的IOC，struts2只是注入action，而spring可以将更多的bean注入到这个action中；
综上所述，springmvc较struts2更轻量，但是没有struts2在mvc方面功能强大；
【题目描述】
如何配置spring+struts?
【正确答案】
在struts-config.xml加入一个插件，通过它加载applicationContext.xml
? 在struts-config.xml修改action-mapping标记，具体action交给了DelegateActionProxy
? 通过DelegateActionProxy进入一spring的环境。
? 在spring的applicationContext.xml加入<bean name=”/login” class=”" singleton=”false”/>
【题目描述】
spring+hibernate的配置文件中的主要类有那些?如何配置?
【正确答案】
dataSource
sessionFactory:hibernate.cfg.xml
transactionManager
userDao (extends HibernateDaoSupport)
sessionFactory
facade
proxy
sessionFactory
transactionManager
facade
在myeclipse中先加入spring环境再加入hibernate环境。
思考，如果spring与hibernate结合在一起可以不需要hibernate.cfg.xml文件是否正确？
【题目描述】
Spring对多种ORM框架提供了很好的支持，简单描述在Spring中使用Hibernate的方法。
【正确答案】
在context中定义DataSource，创建SessionFactoy，设置参数；DAO类继承HibernateDaoSupport，实现具体接口，从中获得HibernateTemplate进行具体操作。在使用中如果遇到OpenSessionInView的问题，可以添加OpenSessionInViewFilter或OpenSessionInViewInterceptor