第三阶段面试题

1.1 何为 Spring Bean 容器 ?Spring Bean 容器与 Spring IOC 容器

有什么不同吗 ?

答：用于创建 bean 对象,管理 bean 对象的那个容器

Spring IOC 容器本质上指的的就是 Spring Bean 容器,

Spring Bean 容器中最核心一个机制是 IOC 机制(

控制反转),所以有时候又将 springbean 容器称之为

Spring IOC 容器.

1.2Spring IOC 如何理解 ?

答：IOC 是 Spring 中提供一种控制反转机制,目的是将我们

项目中对象的依赖管理交给 Spring 实现,这样可以更好

实现对象关系的解耦,提高程序的可扩展性.

1.3Spring DI 如何理解 ?

答：DI 是 Spring 中的依赖注入机制,IOC 的实现需要借助

这种机制.我们通常会这样理解,Spring Bean 容器中的

IOC 思想一种目标,DI 是实现这种思想的目标的手段.

1.4Spring 中基于注解如何配置对象作用域 ? 以及如何配置延

迟加载机制 ?

答：@Scope(“singleton”)

@Scope(“prototype”)

@Lazy(value=true) 1.5Spring 工厂底层构建 Bean 对象借助什么机制 ? 当对象不

使用了要释放资源，目的是什么 ? 何为内存泄漏 ?

答：借助反射机制，防止内存泄漏，对象已经不使用了但占用着内存,这种现 象称之

为内存泄漏,内存泄漏不是内存溢出,但是它是内存溢出的一个导火索.

内存溢出直接就

导致系统崩溃了.

1.6 描述 Spring MVC 处理流程及应用优势

答：

1、客户端发出一个 http 请求给 web 服务器，web 服务器对 http 请求进 行 解析，如

果匹配前端控制器(或分发器/DispatcherServlet)的请求映射路径，

web 容器将请求

转交给 DispatcherServlet.

2、DipatcherServlet 接收到这个请求之后将根据请求的信息以及处理器映射 器

(HandlerMapping)的配置找到处理请求的处理器（Handler）。

3、由具体的处理器适配器（HandlerAdapter）对 Handler 进行具体的调用。

4 、 Handler 对 数 据 处 理 完 成 以 后 将 返 回 一 个 ModelAndView() 对 象 给

DispatcherServlet。

5、DispatcherSevlet 通过视图解析器（ViewResolver）将 ModelAndView()转

化

为真正的视图 View。

6、Dispatcher 通过 model 解析出 ModelAndView()中的参数进行解析最终展 现出完

整的 view 并返回给客户端。

1.7Spring 中的事务处理方式及优缺点

答：优点在于：

1：能够实现全局事务的控制，通过 EJB CMT 进行事物的管理。

2：能够保证项目模块在系统中完成的功能是可可控制的的操作（AOP）

缺点在于：

1：Spring 中的事物声明有编程式事物和申明是事物

1.8MyBatis 应用中 # 与 $ 有什么异同点

答：

相同点：都是通过 get 来获取值的

不同点：$传进去的字符串不带引号 #号带引号 1.9MyBatis 应用动态 SQL 解决了什么问题

答：有时候，固定的 sql 语句不能够满足我们的应用需求。这个时候需要在 标准的

基础上建立动态的查询语句。

Mybatis 提供了多种注解，可以提供动态查询语言。

比如说在开发的时候，遇到这样的场景，界面提供了多种查询，但是都是非 必填写，

在选择查询条件时可以选中任意几种组合作为查询条件，如果在使 用 jdbc 的时候，需要

判断参数为空，自己组装 sql，

但是 mybatis 提供动态 sql 机制，依靠标签。

1.10

Shiro 框架权限管理时的认证和授权流程描述 .

答：Shiro 权限控制流程的原理：

应用代码 —- 调用 Subject （shiro 的 Subject 就代表当前登陆用户） 控制权

限 —- Subject 在 shiro 框架内部 调用 Shiro SecurityManager 安全管理器 —–

安全管理器调用 Realm （程序和安全数据连接器 ）。

Subject 要进行任何操作，都必须要调用安全管理器（对我们来说是自动的）。

而安全管理器会调用指定的 Realms 对象，来连接安全数据。

Realms 用来编写安全代码逻辑和访问安全数据，是连接程序和安全数据的桥梁。

1.11 BeanFactory 和 ApplicationContext 有什么区别？

BeanFactory 可以理解为含有 bean 集合的工厂类。BeanFactory 包含了

种 bean 的定义，以便在接收到客户端请求时将对应的 bean 实例化。

BeanFactory 还能在实例化对象的时生成协作类之间的关系。此举将

bean 自身与 bean 客户端的配置中解放出来。BeanFactory 还包含了 bean 生命周期的控制，

调用客户端的初始化方法（initialization methods）和销毁方法（destruction methods）。

从表面上看，application context 如同 bean factory 一样具有 bean 定义、bean 关联关系

的设置，根据请求分发 bean 的功能。但 application context 在此基础上还提供了其他的

功能。

1.12 请解释 Spring Bean 的生命周期？

Spring Bean 的生命周期简单易懂。在一个 bean 实例被初始化时，

需要执行一系列的初始化操作以达到可用的状态。同样的，当一个 bean 不在被调用时需要

进行相关的析构操作，并从 bean 容器中移除。 Spring bean factory 负责管理在 spring 容器中被创建的 bean

的生命周期。Bean 的生命周期由两组回调（call back）方法组成。

初始化之后调用的回调方法。

销毁之前调用的回调方法。

Spring 框架提供了以下四种方式来管理 bean 的生命周期事件：

InitializingBean 和 DisposableBean 回调接口

针对特殊行为的其他 Aware 接口

Bean 配置文件中的 Custom init()方法和 destroy()方法

@PostConstruct 和@PreDestroy 注解方式

使用 customInit()和 customDestroy()方法管理 bean 生命周期的代码

样例如下：

<beans>

<bean id="demoBean" class="com.howtodoinjava.task.DemoBean"

init-method="customInit" destroy-method="customDestroy"></bean>

</beans>

1.13 Spring Bean 的作用域之间有什么区别？

Spring 容器中的 bean 可以分为 5 个范围。所有范围的名称都是自说明

的，但是为了避免混淆，还是让我们来解释一下：

singleton：这种 bean 范围是默认的，这种范围确保不管接受到多少个请求，每个容器中只

有一个 bean 的实例，单例的模式由 bean factory 自身来维护。

prototype：原形范围与单例范围相反，为每一个 bean 请求提供一个实例。

request：在请求 bean 范围内会每一个来自客户端的网络请求创建一个实例，在请求完成以

后，bean 会失效并被垃圾回收器回收。

Session：与请求范围类似，确保每个 session 中有一个 bean 的实例，在 session 过期后，

bean 会随之失效。

global-session：global-session 和 Portlet 应用相关。当你的应用部署在 Portlet 容器

中工作时，它包含很多 portlet。如果你想要声明让所有的 portlet 共用全局的存储变量的

话，那么这全局变量需要存储在 global-session 中。

全局作用域与 Servlet 中的 session 作用域效果相同。

1.14 在 Spring AOP 中，关注点和横切关注的区别是什么？

关注点是应用中一个模块的行为，一个关注点可能会被定义成一个我们想实现的一个功能。

横切关注点是一个关注点，此关注点是整个应用都会使用的功能，并影响整个应用，比如日

志，安全和数据传输，几乎应用的每个模块都需要的功能。因此这些都属于横切关注点。 1.15 使用 Spring 框架的好处是什么？

• 轻量：Spring 是轻量的，基本的版本大约 2MB。

• 控制反转：Spring 通过控制反转实现了松散耦合，对象们给出它们的依赖，而不是创

建或查找依赖的对象们。

• 面向切面的编程(AOP)：Spring 支持面向切面的编程，并且把应用业务逻辑和系统服务

分开。

• 容器：Spring 包含并管理应用中对象的生命周期和配置。

• MVC 框架：Spring 的 WEB 框架是个精心设计的框架，是 Web 框架的一个很好的替代品。

• 事务管理：Spring 提供一个持续的事务管理接口，可以扩展到上至本地事务下至全

局事务（JTA）。

• 异常处理：Spring 提供方便的 API 把具体技术相关的异常（比如由 JDBC，

Hibernate or JDO 抛出的）转化为一致的 unchecked 异常。、

1.16 Spring 中用到了那些设计模式？

• Spring 框架中使用到了大量的设计模式，下面列举了比较有代表性的：

• 代理模式—在 AOP 和 remoting 中被用的比较多。

• 单例模式—在 spring 配置文件中定义的 bean 默认为单例模式。

• 模板方法—用来解决代码重复的问题。比如. RestTemplate, JmsTemplate,

JpaTemplate。

• 工厂模式—BeanFactory 用来创建对象的实例。

• 适配器–spring aop

• 装饰器–spring data hashmapper

• 观察者– spring 时间驱动模型

• 回调–Spring ResourceLoaderAware 回调接口

1.17 Spring 如何保证 Controller 并发的安全？

Spring 多线程请求过来调用的 Controller 对象都是一个，而不是一个请求过来就创建一个

Controller 对象。

并发的安全？ 原因就在于 Controller 对象是单例的，那么如果不小心在类中定义了类变

量，那么这个类变量是被所有请求共享的，这可能会造成多个请求修改该变量的值，出现与

预期结果不符合的异常 那有没有办法让 Controller 不以单例而以每次请求都重新创建的形式存在呢 ？

答案是当然可以，只需要在类上添加注解@Scope(“prototype”)即可，这样每次请求调用

的类都是重新生成的（每次生成会影响效率）

虽然这样可以解决问题，但增加了时间成本，总让人不爽，还有其他方法么？答案是肯定的！

使用 ThreadLocal 来保存类变量，将类变量保存在线程的变量域中，让不同的请求隔离开来。

1.18 使用 Spring 框架的好处是什么？

轻量：Spring 是轻量的，基本的版本大约 2MB。

控制反转：Spring 通过控制反转实现了松散耦合，对象们给出它们的依赖，而不是创建或

查找依赖的对象们。

面向切面的编程(AOP)：Spring 支持面向切面的编程，并且把应用业务逻辑和系统服务分开。

容器：Spring 包含并管理应用中对象的生命周期和配置。

MVC 框架：Spring 的 WEB 框架是个精心设计的框架，是 Web 框架的一个很好的替代品。

事务管理：Spring 提供一个持续的事务管理接口，可以扩展到上至本地事务下至全局事务

（JTA）。

异常处理：Spring 提供方便的 API 把具体技术相关的异常（比如由 JDBC，Hibernate or JDO

抛出的）转化为一致的 unchecked 异常。

1.19 在 Spring 中如何注入一个 java 集合？

Spring 提供以下几种集合的配置元素：

• <list>类型用于注入一列值，允许有相同的值。

• <set> 类型用于注入一组值，不允许有相同的值。

• <map> 类型用于注入一组键值对，键和值都可以为任意类型。

• <props>类型用于注入一组键值对，键和值都只能为 String 类型

1.20 Spring 支持的事务管理类型

Spring 支持如下两种方式的事务管理： 编程式事务管理：这意味着你可以通过编程的方式管理事务，这种方式带来了很大的灵活性，

但很难维护。

声明式事务管理：这种方式意味着你可以将事务管理和业务代码分离。你只需要通过注解或

者 XML 配置管理事务。

1.21 Spring 框架的事务管理有哪些优点？

它为不同的事务 API(如 JTA, JDBC, Hibernate, JPA, 和 JDO)提供了统一的编程模型。

它为编程式事务管理提供了一个简单的 API 而非一系列复杂的事务 API(如 JTA).

它支持声明式事务管理。

它可以和 Spring 的多种数据访问技术很好的融合。

1.22 Spring MVC 的主要组件？

（

1）前端控制器 DispatcherServlet（不需要程序员开发）

作用：接收请求、响应结果，相当于转发器，有了 DispatcherServlet 就减少了其它组件

之间的耦合度。

（

2）处理器映射器 HandlerMapping（不需要程序员开发）

作用：根据请求的 URL 来查找 Handler

（

3）处理器适配器 HandlerAdapter

注意：在编写 Handler 的时候要按照 HandlerAdapter 要求的规则去编写，这样适配器

HandlerAdapter 才可以正确的去执行 Handler。

（

4）处理器 Handler（需要程序员开发）

（

5）视图解析器 ViewResolver（不需要程序员开发）

作用：进行视图的解析，根据视图逻辑名解析成真正的视图（view）

（

6）视图 View（需要程序员开发 jsp）

View 是一个接口， 它的实现类支持不同的视图类型（jsp，freemarker，pdf 等等） 1.23 SpringMvc 怎么和 AJAX 相互调用的？

通过 Jackson 框架就可以把 Java 里面的对象直接转化成 Js 可以识别的 Json 对象。具体步

骤如下 ：

（

1）加入 Jackson.jar

（

2）在配置文件中配置 json 的映射

（

3）在接受 Ajax 方法里面可以直接返回 Object,List 等,但方法前面要加上

1.24 Mybatis 中 # 和 $ 的区别 ?

1. #{}是预编译处理，${}是字符串替换。

2. Mybatis 在处理#{}时，会将 sql 中的#{}替换为?号，调用 PreparedStatement

的 set 方法来赋值；

3. Mybatis 在处理${}时，就是把${}替换成变量的值，相当于字符串拼接

4. 使用#{}可以有效的防止 SQL 注入，提高系统安全性。

1.25 mybatis 的缓存机制，一级，二级介绍一下

一级缓存

默认开启

SqlSession 级别的缓存，实现在同一个会话中数据的共享

一级缓存的生命周期和 SqlSession 一致

当有多个 SqlSession 或者分布式环境下，数据库写操作会引起脏数据。

二级缓存

默认不开启，需手动开启

SqlSessionFactory 级别的缓存，实现不同会话中数据的共享，是一个全局变量

可自定义存储源，如 Ehcache

当开启缓存后，数据查询的执行的流程是：二级缓存>一级缓存>数据库 不同于一级缓存，二级缓存可设置是否允许刷新和刷新频率实现

实体类实现序列化，在 mapper 文件中开启<cache>

在配置文件中设置 cacheEnabled 为 true

1.26 pringMVC 与 Struts2 的区别

pringmvc 的入口是一个 servlet 即前端控制器，而 struts2 入口是一个 filter 过虑器。

pringmvc 是基于方法开发，传递参数是通过方法形参，可以设计为单例或多例(建议单例)，

struts2 是基于类开发，传递参数是通过类的属性，只能设计为多例。

1.27 mybatis 的基本工作流程

1.读取配置文件，配置文件包含数据库连接信息和 Mapper 映射文件或者 Mapper 包路径。

2.有了这些信息就能创建 SqlSessionFactory，SqlSessionFactory 的生命周期是程序级,

程序运行的时候建立起来,程序结束的时候消亡

3.SqlSessionFactory 建立 SqlSession,目的执行 sql 语句，SqlSession 是过程级,一个方

法中建立,方法结束应该关闭

4.当用户使用 mapper.xml 文件中配置的的方法时，mybatis 首先会解析 sql 动态标签为对

应数据库 sql 语句的形式，并将其封装进 MapperStatement 对象，然后通过 executor 将 sql

注入数据库执行，并返回结果。

5.将返回的结果通过映射，包装成 java 对象。

1.28 什么是 MyBatis 的接口绑定 , 有什么好处

接口映射就是在 IBatis 中任意定义接口,然后把接口里面的方法和 SQL 语句绑定,我们通过

直接调用接口方法 例如：

UserMapper userMapper=sqlSession.getMapper (UserMapper.class) 就可以,这样比

起原来了 SqlSession 提供的方法,例如 List<Country> countryList =

sqlSession.selectList("selectAll");我们可以有更加灵活的选择和设置.。

注意：（

1）Mapper .xml 文件的 namespace 属性必须配置为接口的全限定名称，接口方法

名与 Mapper.xml 中的<select><insert>id 值必须相同，且接口方法的返回值类型必须与

Mapper.xml 配置的 resultType 一致，这里后者起到决定作用。 （

2）select 查询通过在 Mapper.xml 中配置 ResultMap 标签，将查询结果的列名与字段名

对应。

insert 语句通过#{属性名}从接口参数获取值放到 sql 语句中。

（

3）Mapper.xml 接口绑定本质是动态代理。

1.29 MyBatis 的编程步骤

创建 SqlSessionFactory

通过 SqlSessionFactory 创建 SqlSession

通过 SqlSession 执行数据库操作

调用 session.commit()提交事务

调用 session.close()关闭事务

1.30 JDBC 编程有哪些不足之处， MyBatis 是如何解决这些问

题的？

JDBC 编程的不足之处

数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可

解决此问题。

Sql 语句写在代码中造成代码不易维护，实际应用 sql 变化的可能较大，sql 变动需要改变

java 代码。

向 sql 语句传参数麻烦，因为 sql 语句的 where 条件不一定，可能多也可能少，占位符需要

和参数一一对应。

对结果集解析麻烦，sql 变化导致解析代码变化，且解析前需要遍历，如果能将数据库记录

封装成 pojo 对象解析比较方便。

MyBatis 的解决方案

在 SqlMapConfig.xml 中配置数据链接池，使用连接池管理数据库链接。

将 Sql 语句配置在 XXXXmapper.xml 文件中与 java 代码分离。

Mybatis 自动将 java 对象映射至 sql 语句。 Mybatis 自动将 sql 执行结果映射至 java 对象。

1.31 MyBatis 的优缺点

优点

易于上手和掌握

Sql 写在 xml 里面，便于统一管理和优化

减少 Sql 与程序代码的耦合

提供 xml 标签，支持动态 Sql 编写

缺点

Sql 工作量大，尤其是字段多，关联表多时，更是如此

Sql 依赖于数据库，导致数据库移植性差

由于 xml 里面标签 id 必须唯一，导致 DAO 中方法不支持方法重载。所以 dao 层必须是接口

1.32 使用 MyBatis 的 mapper 接口调用时有哪些要求？

Mapper 接口方法名和 mapper.xml 中定义的每个 sql 的 id 相同

Mapper接口方法的输入参数类型和 mapper.xml 中定义的每个 sql 的 parameterType 的类型

相同

Mapper 接口方法的输出参数类型和 mapper.xml 中定义的每个 sql 的 resultType 的类型相

同

Mapper.xml 文件中的 namespace 即是 mapper 接口的类路径

1.33 谈谈你对 SpringMVC 的理解

1. 是一个基于 MVC 的 web 框架

2. SpringMVC 是 Spring 的一个模块，是 Spring 的子容器，子容器可以拿父容器的东西，

但是父容器不能拿子容器的东西 3. SpringMVC 的前端控制器 DispatcherServlet，用于分发请求，使开发变得简单

4. SpringMVC 流程（重点）. SpringMVC 三大组件

1）HandlerMapping：处理器映射器

用户请求路径到 Controller 方法的映射

2）HandlerAdapter：处理器适配器

根据 handler(controlelr 类）的开发方式（注解开发/其他开发） 方

式的不同去寻找不同的处理器适配器

3）ViewResolver：视图解析器

可以解析 JSP/freemarkerr/pdf 等

1.34 简述 Mybatis 的插件运行原理，以及如何编写一个插

件？

答：

1）Mybatis 仅可以编写针对 ParameterHandler、ResultSetHandler、StatementHandler、

Executor 这 4 种接口的插件，Mybatis 通过动态代理，为需要拦截的接口生成代理对象以实

现接口方法拦截功能，每当执行这 4 种接口对象的方法时，就会进入拦截方法，具体就是

InvocationHandler 的 invoke()方法，当然，只会拦截那些你指定需要拦截的方法。

2）实现 Mybatis 的 Interceptor 接口并复写 intercept()方法，然后在给插件编写注解，

指定要拦截哪一个接口的哪些方法即可，记住，别忘了在配置文件中配置你编写的插件。

1.35 Mybatis 动态 sql 是做什么的？都有哪些动态 sql ？能简

述一下动态 sql 的执行原理不？

答：1）Mybatis 动态 sql 可以让我们在 Xml 映射文件内，以标签的形式编写动态 sql，完成

逻辑判断和动态拼接 sql 的功能。2）Mybatis 提供了 9 种动态 sql 标签：

trim|where|set|foreach|if|choose|when|otherwise|bind。

3）其执行原理为，使用 OGNL 从 sql 参数对象中计算表达式的值，根据表达式的值动态拼接

sql，以此来完成动态 sql 的功能。 1.36 Mybatis 是否支持延迟加载？如果支持，它的实现原理

是什么？

答：1）Mybatis 仅支持 association 关联对象和 collection 关联集合对象的延迟加载，

association 指的就是一对一，collection 指的就是一对多查询。在 Mybatis 配置文件中，

可以配置是否启用延迟加载 lazyLoadingEnabled=true|false。

2）它的原理是，使用 CGLIB 创建目标对象的代理对象，当调用目标方法时，进入拦截器方

法，比如调用 a.getB().getName()，拦截器 invoke()方法发现 a.getB()是 null 值，那么

就会单独发送事先保存好的查询关联 B 对象的 sql，把 B 查询上来，然后调用 a.setB(b)，

于是 a 的对象 b 属性就有值了，接着完成 a.getB().getName()方法的调用。这就是延迟加

载的基本原理。

1.37 Mybatis 能执行一对一、一对多的关联查询吗？都有哪

些实现方式，以及它们之间的区别？

答：能，Mybatis 不仅可以执行一对一、一对多的关联查询，还可以执行多对一，多对多的

关联查询，多对一查询，其实就是一对一查询，只需要把 selectOne()修改为 selectList()

即可；多对多查询，其实就是一对多查询，只需要把 selectOne()修改为 selectList()即可。

关联对象查询，有两种实现方式，一种是单独发送一个 sql 去查询关联对象，赋给主对象，

然后返回主对象。另一种是使用嵌套查询，嵌套查询的含义为使用 join 查询，一部分列是

A 对象的属性值，另外一部分列是关联对象 B 的属性值，好处是只发一个 sql 查询，就可以

把主对象和其关联对象查出来。

1.38 Mybatis 是如何将 sql 执行结果封装为目标对象并返回

的？都有哪些映射形式？

答：第一种是使用<resultMap>标签，逐一定义列名和对象属性名之间的映射关系。

第二种是使用 sql 列的别名功能，将列别名书写为对象属性名，比如 T_NAME AS NAME，对

象属性名一般是 name，小写，但是列名不区分大小写，Mybatis 会忽略列名大小写，智能找

到与之对应对象属性名，你甚至可以写成 T_NAME AS NaMe，Mybatis 一样可以正常工作。 1.39

Mybatis 映射文件中，如果 A 标签通过 include 引用了 B

标签的内容，请问， B 标签能否定义在 A 标签的后面，还

是说必须定义在 A 标签的前面？

答：虽然 Mybatis 解析 Xml 映射文件是按照顺序解析的，但是，被引用的 B 标签依然可以定

义在任何地方，Mybatis 都可以正确识别。原理是，Mybatis 解析 A 标签，发现 A 标签引用

了 B 标签，但是 B 标签尚未解析到，尚不存在，此时，Mybatis 会将 A 标签标记为未解析状

态，然后继续解析余下的标签，包含 B 标签，待所有标签解析完毕，Mybatis 会重新解析那

些被标记为未解析的标签，此时再解析 A 标签时，B 标签已经存在，A 标签也就可以正常解

析完成了。

1.40

MyBatis 里面的动态 Sql 是怎么设定的 ? 用什么语法 ?

答：MyBatis 里面的动态 Sql 一般是通过 if 节点来实现，通过 OGNL 语法来实现，但是

如果要写的完整，必须配合 where、trim 节点，where 节点是判断包含节点有内容就插

入 where，否则不插入，trim 节点是用来判断如果动态语句是以 and 或 or 开始，那么

会自动把这个 and 或者 or 取掉 。

1.41

Mybatis 都有哪些 Executor 执行器？它们之间的区别是

什么？

答：Mybatis 有三种基本的 Executor 执行器，SimpleExecutor、ReuseExecutor、

BatchExecutor。

SimpleExecutor：每执行一次 update 或 select，就开启一个 Statement 对象，用完立刻关

闭 Statement 对象。

ReuseExecutor：执行 update 或 select，以 sql 作为 key 查找 Statement 对象，存在就使

用，不存在就创建，用完后，不关闭 Statement 对象，而是放置于 Map<String, Statement>

内，供下一次使用。简言之，就是重复使用 Statement 对象。

BatchExecutor：执行 update（没有 select，JDBC 批处理不支持 select），将所有 sql 都

添加到批处理中（addBatch()），等待统一执行（executeBatch()），它缓存了多个 Statement 对象，每个 Statement 对象都是 addBatch()完毕后，等待逐一执行 executeBatch()批处理。

与 JDBC 批处理相同。

作用范围：Executor 的这些特点，都严格限制在 SqlSession 生命周期范围内。

1.42 为什么说 Mybatis 是半自动 ORM 映射工具？它与全自

动的区别在哪里？

答：Hibernate 属于全自动 ORM 映射工具，使用 Hibernate 查询关联对象或者关联集合对象

时，可以根据对象关系模型直接获取，所以它是全自动的。而 Mybatis 在查询关联对象或关

联集合对象时，需要手动编写 sql 来完成，所以，称之为半自动 ORM 映射工具。

面试题看似都很简单，但是想要能正确回答上来，必定是研究过源码且深入的人，而不是仅

会使用的人或者用的很熟的人，以上所有面试题及其答案所涉及的内容，在我的 Mybatis

系列博客中都有详细讲解和原理分析。

1.43 简单介绍下你对 mybatis 的理解？

1. mybatis 配置

2. SqlMapConfig.xml，此文件作为 mybatis 的全局配置文件，配置了 mybatis 的运行环境

等信息。

3. mapper.xml 文件即 sql 映射文件，文件中配置了操作数据库的 sql 语句。此文件需要在

SqlMapConfig.xml 中加载。

4. 通过 mybatis 环境等配置信息构造 SqlSessionFactory 即会话工厂

5. 由会话工厂创建 sqlSession 即会话，操作数据库需要通过 sqlSession 进行。

6. mybatis 底层自定义了 Executor 执行器接口操作数据库，Executor 接口有两个实现，一

个是基本执行器、一个是缓存执行器。

7. Mapped Statement 也是 mybatis 一个底层封装对象，它包装了 mybatis 配置信息及 sql

映射信息等。mapper.xml 文件中一个 sql 对应一个 Mapped Statement 对象，sql 的 id 即是

Mapped statement 的 id。

8. Mapped Statement对sql执行输入参数进行定义，包括HashMap、基本类型、pojo，Executor

通过 Mapped Statement 在执行 sql 前将输入的 java 对象映射至 sql 中，输入参数映射就是

jdbc 编程中对 preparedStatement 设置参数。

9. Mapped Statement对sql执行输出结果进行定义，包括HashMap、基本类型、pojo，Executor

通过 Mapped Statement 在执行 sql 后将输出结果映射至 java 对象中，输出结果映射过程相

当于 jdbc 编程中对结果的解析处理过程。

1.44 介绍一下 Spring 的事物管理

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

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

开发中为了避免这种情况一般都会进行事务管理。Spring 中也有自己的事务管理机制，一

般是使用 TransactionMananger 进行管 理，可以通过 Spring 的注入来完成此功能。

Spring 支持如下两种方式的事务管理：

编程式事务管理：这意味着你可以通过编程的方式管理事务，这种方式带来了很大的灵活性，

但很难维护。

声明式事务管理：这种方式意味着你可以将事务管理和业务代码分离。你只需要通过注解或

者 XML 配置管理事务。

一般选择声明式事务管理，因为这种方式和应用程序的关联较少。

1.45 SSM 优缺点、使用场景？

1. Mybatis 和 hibernate 不同，它不完全是一个 ORM 框架，因为 MyBatis 需要程序员自己

编写 Sql 语句，不过 mybatis 可以通过 XML 或注解方式灵活配置要运行的 sql 语句，并将

java 对象和 sql 语句映射生成最终执行的 sql，最后将 sql 执行的结果再映射生成 java 对

象。

2. Mybatis 学习门槛低，简单易学，程序员直接编写原生态 sql，可严格控制 sql 执行性能，

灵活度高，非常适合对关系数据模型要求不高的软件开发，例如互联网软件、企业运营类软

件等，因为这类软件需求变化频繁，一但需求变化要求成果输出迅速。但是灵活的前提是

mybatis 无法做到数据库无关性，如果需要实现支持多种数据库的软件则需要自定义多套

sql 映射文件，工作量大。

3. Hibernate 对象/关系映射能力强，数据库无关性好，对于关系模型要求高的软件（例如

需求固定的定制化软件）如果用 hibernate 开发可以节省很多代码，提高效率。但是

Hibernate 的学习门槛高，要精通门槛更高，而且怎么设计 O/R 映射，在性能和对象模型之

间如何权衡，以及怎样用好 Hibernate 需要具有很强的经验和能力才行。

4. 总之，按照用户的需求在有限的资源环境下只要能做出维护性、扩展性良好的软件架构

都是好架构，所以框架只有适合才是最好。

1.46 SpringMVC 的工作流程 ?

用户发送请求至前端控制器 DispatcherServlet

DispatcherServlet 收到请求调用 HandlerMapping 处理器映射器。

处理器映射器根据请求 url 找到具体的处理器，生成处理器对象及处理器拦截器(如果有则

生成)一并返回给 DispatcherServlet。

DispatcherServlet 通过 HandlerAdapter 处理器适配器调用处理器

执行处理器(Controller，也叫后端控制器)。

Controller 执行完成返回 ModelAndView HandlerAdapter 将 controller 执行结果 ModelAndView 返回给 DispatcherServlet

DispatcherServlet 将 ModelAndView 传给 ViewReslover 视图解析器

ViewReslover 解析后返回具体 View

DispatcherServlet 对 View 进行渲染视图（即将模型数据填充至视图中）。

DispatcherServlet 响应用户

1.47 如果你也用过 struts2. 简单介绍下 springMVC 和 struts2

的区别有哪些 ?

springmvc 的入口是一个 servlet 即前端控制器，而 struts2 入口是一个 filter 过虑

器。

springmvc 是基于方法开发(一个 url 对应一个方法)，请求参数传递到方法的形参，可

以设计为单例或多例(建议单例)，struts2 是基于类开发，传递参数是通过类的属性，只能

设计为多例。

Struts 采用值栈存储请求和响应的数据，通过 OGNL 存取数据， springmvc 通过参数解析器

是将 request 请求内容解析，并给方法形参赋值，将数据和视图封装成 ModelAndView 对象，

最后又将 ModelAndView 中的模型数据通过 reques 域传输到页面。Jsp 视图解析器默认使用

jst l。 1.48

怎么样把数据放入 Session 里面

可以声明一个 request,或者 session 先拿到 session,然后就可以放入数据,或者可以

在类上面加上@SessionAttributes 注解,里面包含的字符串就是要放入 session 里面

的 key

1.49

讲下 SpringMvc 的执行流程

系统启动的时候根据配置文件创建 spring 的容器, 首先是发送 http 请求到核心控制

器 DispatcherServlet，spring 容器通过映射器去寻找业务控制器，

使用适配器找到相应的业务类，在进业务类时进行数据封装，在封装前可能会涉及到

类型转换，执行完业务类后使用 ModelAndView 进行视图转发，

数据放在 model 中，用 map 传递数据进行页面显示。

1.50

MyBatis(IBatis) 的好处是什么

ibatis 把 sql 语句从 Java 源程序中独立出来，放在单独的 XML 文件中编写，给程序的

维护带来了很大便利。

ibatis 封装了底层 JDBC API 的调用细节，并能自动将结果集转换成 JavaBean 对象，

大大简化了 Java 数据库编程的重复工作。

因为 Ibatis 需要程序员自己去编写 sql 语句，程序员可以结合数据库自身的特点灵活

控制 sql 语句，

因此能够实现比 hibernate 等全自动 orm 框架更高的查询效率，能够完成复杂查询。

1.51 Bean 工厂和 Application contexts 有什么区别？

Application contexts 提供一种方法处理文本消息，一个通常的做法是加载文件资源（比

如镜像），它们可以向注册为监听器的 bean 发布事件。另外，在容器或容器内的对象上执

行的那些不得不由 bean 工厂以程序化方式处理的操作，可以在 Application contexts 中以

声明的方式处理。Application contexts 实现了 MessageSource 接口，该接口的实现以可

插拔的方式提供获取本地化消息的方法。 1.52 解释 Spring 支持的几种 bean 的作用域

Spring 框架支持以下五种 bean 的作用域：

singleton : bean 在每个 Spring ioc 容器中只有一个实例。

prototype：一个 bean 的定义可以有多个实例。

request：每次 http 请求都会创建一个 bean，该作用域仅在基于 web 的 Spring

ApplicationContext 情形下有效。

session：在一个 HTTP Session 中，一个 bean 定义对应一个实例。该作用域仅在基于 web

的 Spring ApplicationContext 情形下有效。

global-session：在一个全局的 HTTP Session 中，一个 bean 定义对应一个实例。该作用域

仅在基于 web 的 Spring ApplicationContext 情形下有效。

缺省的 Spring bean 的作用域是 Singleton。

1.53 什么是 bean 的自动装配？

Spring 容器能够自动装配相互合作的 bean，这意味着容器不需要<constructor-arg>和

<property>配置，能通过 Bean 工厂自动处理 bean 之间的协作。

1.54 什么是基于 Java 的 Spring 注解配置 ? 给一些注解的例

子。

基于 Java 的配置，允许你在少量的 Java 注解的帮助下，进行你的大部分 Spring 配置而非

通过 XML 文件。

以@Configuration 注解为例，它用来标记类可以当做一个 bean 的定义，被 Spring IOC 容

器使用。另一个例子是@Bean 注解，它表示此方法将要返回一个对象，作为一个 bean 注册

进 Spring 应用上下文。

1.55 使用 Spring 通过什么方式访问 Hibernate?

在 Spring 中有两种方式访问 Hibernate： 控制反转 Hibernate Template 和 Callback。

继承 HibernateDAOSupport 提供一个 AOP 拦截器。

1.56 如何通过 HibernateDaoSupport 将 Spring 和 Hibernate

结合起来？

用 Spring 的 SessionFactory 调用 LocalSessionFactory。集成过程分三步：

配置 the Hibernate SessionFactory。

继承 HibernateDaoSupport 实现一个 DAO。

在 AOP 支持的事务中装配。

1.57 Spring 框架的事务管理有哪些优点？

它为不同的事务 API 如 JTA，JDBC，Hibernate，JPA 和 JDO，提供一个不变的编程模式。

它为编程式事务管理提供了一套简单的 API 而不是一些复杂的事务 API 如

它支持声明式事务管理。

它和 Spring 各种数据访问抽象层很好得集成。

1.58 在 Spring AOP 中，关注点和横切关注的区别是什么？

关注点是应用中一个模块的行为，一个关注点可能会被定义成一个我们想实现的一个功能。

横切关注点是一个关注点，此关注点是整个应用都会使用的功能，并影响整个应用，比如日

志，安全和数据传输，几乎应用的每个模块都需要的功能。因此这些都属于横切关注点。 1.59 AOP 作用是什么 , 底层如何实现在哪些地方会用到 , 分别

简述切面 , 切入点和通知。

AOP:面向切面编程:将一个系统中共同的业务逻辑提取出来,进行单独的封装成一个组件(切

面),然后以配置的方式作用于系统中,实现程序的可插拔性,提高代码的复用性,提升系统的

灵活性和性能

底层实现:JDK 动态代理,只支持接口注入 CGLIB:可以支持普通类的注入

那些地方会用到:事物开启,日志记录,安全验证,权限验证

切面:系统中共通的业务提取出来,在某个时刻或者某个阶段共同调用

切入点:找到目标方法,给它追加共通的业务逻辑,在 spring 中提供了切入点表达式帮助我

们找到目标方法 execution

通知:什么时候调用这个共通的业务逻辑,用于指定切面方法作用到系统中的时机.前置通知,

后置通知,环绕通知,异常通知,最终通知。

1.60 Spring 中 AutoWired 和 ,Resource 之间区别是什么

AutoWried:按照类型进行匹配—spring 框架自带的,查看当前 Spring 容器中那个 bean 类型

和引用类型一致,就进行注入,如果有多个匹配类型就会报错.

Resource:默认按照名称进行注入,如果找不到对应的名称按照 bean 类型进行注入