Java 攻城狮面试题 05_SSM

Spring

Spring 概述

Spring、SpringMVC、SpringBoot、Spring Cloud 有什么区别

简单介绍：

• Spring是一个一站式的轻量级的java开发框架，核心是控制反转（IOC）和面向切面（AOP），针对于开发的WEB层(springMVC)、业务层(Ioc)、持久层(jdbcTemplate)等都提供了多种配置解决方案；Spring使你能够编写更干净、更可管理、并且更易于测试的代码。

• SpringMVC是Spring的一个模块，是Spring基础之上的一个MVC框架，主要处理web开发的路径映射和视图渲染，属于Spring框架中WEB层开发的一部分。通过Dispatcher Servlet, ModelAndView 和 View Resolver，开发web应用变得很容易。主要针对的是网站应用程序或者服务开发——URL路由、Session、模板引擎、静态Web资源等等。

• Spring配置复杂，繁琐（XML、config等配置相对比较繁琐复杂），所以推出了Spring boot，约定优于配置，简化了spring的配置流程。SpringBoot使用了默认大于配置的理念，集成了快速开发的Spring多个插件，同时自动过滤不需要配置的多余的插件，简化了项目的开发配置流程，一定程度上取消xml配置，是一套快速配置开发的脚手架，能快速开发单个微服务；SpringBoot框架相对于SpringMVC框架来说，更专注于开发微服务后台接口，不开发前端视图。

• Spring Cloud构建于Spring Boot之上，是一个关注全局的服务治理框架。SpringCloud大部分的功能插件都是基于SpringBoot去实现的，SpringCloud关注于全局的微服务整合和管理，将多个SpringBoot单体微服务进行整合以及管理；SpringCloud依赖于SpringBoot开发，而SpringBoot可以独立开发；

总结下来：

• Spring是核心，提供了基础功能；
• Spring MVC 是基于Spring的一个 MVC 框架 ；
• Spring Boot 是为简化Spring配置的快速开发整合包；
• Spring Cloud是构建在Spring Boot之上的服务治理框架。

为什么要使用 spring？

• spring 帮助开发者解决了开发中基础性的问题，使得开发人员可以专注于应用程序的开发。
• spring 提供 ioc 技术，容器会帮你管理依赖的对象，从而不需要自己创建和管理依赖对象了，更轻松的实现了程序的解耦。
• spring 提供了事务支持，使得事务操作变的更加方便。
• spring 提供了面向切片编程，这样可以更方便的处理某一类的问题。
• 更方便的框架集成，spring 可以很方便的集成其他框架，比如 MyBatis、hibernate 等。

解释一下什么是 aop？

aop 是面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

简单来说就是统一处理某一“切面”（类）的问题的编程思想，比如统一处理日志、异常等。

Aspect Oriented Program, 面向(方面)切面的编程;Filter(过滤器) 也是一种 AOP. AOP 是一种新的方法论, 是对传统 OOP(Object-Oriented Programming, 面向对象编程) 的补充. AOP 的主要编程对象是切面(aspect), 而切面模块化横切关注点.可以举例通过事务说明.

解释一下什么是 ioc？

ioc：Inversionof Control（中文：控制反转）是 spring 的核心，对于 spring 框架来说，就是由 spring 来负责控制对象的生命周期和对象间的关系，把对象的创建、初始化、销毁交给 spring 来管理，而不是由开发者控制，实现控制反转。

简单来说，控制指的是当前对象对内部成员的控制权；控制反转指的是，这种控制权不由当前对象管理了，由其他（类,第三方容器）来管理。

IOC: Invert Of Control, 控制反转. 也成为 DI(依赖注入)其思想是反转 资源获取的方向. 传统的资源查找方式要求组件向容器发起请求查找资源.作为 回应, 容器适时的返回资源. 而应用了IOC 之后, 则是容器主动地将资源推送 给它所管理的组件,组件所要做的仅是选择一种合适的方式来接受资源. 这种行 为也被称为查找的被动形式

什么是依赖注入？spring 常用的注入方式有哪些？

依赖注入是在编译阶段尚未知所需的功能是来自哪个的类的情况下，将其他对象所依赖的功能对象实例化的模式。这就需要一种机制用来激活相应的组件以提供特定的功能，所以依赖注入是控制反转的基础。否则如果在组件不受框架控制的情况下，框架又怎么知道要创建哪个组件？

• setter 属性注入
• 构造方法注入
• 注解方式注入

spring 有哪些主要模块？

• spring core：框架的最基础部分，提供 ioc 和依赖注入特性。
• spring context：构建于 core 封装包基础上的 context 封装包，提供了一种框架式的对象访问方法。
• spring dao：Data Access Object 提供了 JDBC 的抽象层。
• spring aop：提供了面向切面的编程实现，让你可以自定义拦截器、切点等。
• spring Web：提供了针对 Web 开发的集成特性，例如文件上传，利用
• servlet listeners 进 行 ioc 容 器 初 始 化 和 针 对 Web 的ApplicationContext。
• spring Web mvc：spring 中的 mvc 封装包提供了 Web 应用的Model-View-Controller（MVC）的实现。

Spring 的配置方式

Spring 有几种配置方式？

将 Spring 配置到应用开发中有以下三种方式：

1. 基于 XML 的配置
2. 基于注解的配置
3. 基于 Java 的配置

Spring Bean

在 Spring 中如何配置 Bean ?

Bean 的配置方式:

• 通过全类名（反射）
• 通过工厂方法（静态工厂方法 & 实 例工厂方法）
• FactoryBean

IOC 容器对 Bean 的生命周期:

1. 通过构造器或工厂方法创建 Bean 实例
2. 为 Bean 的属性设置值和对其他 Bean 的引用
3. =将 Bean 实 例 传 递 给 Bean 后 置 处 理 器 的 postProcessBeforeInitialization 方法
4. 调用 Bean 的初始化方法(init-method)
5. 将 Bean 实 例 传 递 给 Bean 后 置 处 理 器 的 postProcessAfterInitialization 方法
6. Bean 可以使用了
7. 当容器关闭时, 调用 Bean 的销毁方法(destroy-method)

spring 中的 bean 是线程安全的吗？

spring 中的 bean 默认是单例模式，spring 框架并没有对单例 bean 进行多线程的封装处理。

实际上大部分时候 spring bean 无状态的（比如 dao 类），所有某种程度上来说 bean 也是安全的，但如果 bean 有状态的话（比如 view model 对象），那就要开发者自己去保证线程安全了，最简单的就是改变 bean 的作用域，把“singleton”变更为“prototype”，这样请求 bean 相当于 new Bean()了，所以就可以保证线程安全了。

• 有状态就是有数据存储功能。
• 无状态就是不会保存数据。

spring 支持几种 bean 的作用域？

spring 支持 5 种作用域，如下：

• singleton：spring ioc 容器中只存在一个 bean 实例，bean 以单例模式存在，是系统默认值；
• prototype：每次从容器调用 bean 时都会创建一个新的示例，既每次getBean()相当于执行 new Bean()操作；

Web 环境下的作用域：

• request：每次 http 请求都会创建一个 bean；
• session：同一个 http session 共享一个 bean 实例；
• global-session：用于 portlet 容器，因为每个 portlet 有单独的session，globalsession 提供一个全局性的 http session。

注意： 使用 prototype 作用域需要慎重的思考，因为频繁创建和销毁 bean 会带来很大的性能开销。

spring 自动装配 bean 有哪些方式？

• no：默认值，表示没有自动装配，应使用显式 bean 引用进行装配。
• byName：它根据 bean 的名称注入对象依赖项。
• byType：它根据类型注入对象依赖项。
• 构造函数：通过构造函数来注入依赖项，需要设置大量的参数。
• autodetect：容器首先通过构造函数使用 autowire 装配，如果不能，则通过 byType 自动装配。

BeanFactory 和 ApplicationContext 有什么区别？

BeanFactory 可以理解为含有 bean 集合的工厂类。BeanFactory 包含了种 bean 的定义，以便在接收到客户端请求时将对应的 bean 实例化。

BeanFactory 还能在实例化对象的时生成协作类之间的关系。此举将 bean 自身与 bean 客户端的配置中解放出来。

BeanFactory 还包含 了

• bean 生命周期的控制
• 调用客户端的初始化方法（initialization methods）
• 销毁方法（destruction methods）。

从表面上看，application context 如同 bean factory 一样具有 bean 定义、bean 关联关系的设置，根据请求分发 bean 的功能。但 applicationcontext 在此基础上还提供了其他的功能。

1. 提供了支持国际化的文本消息
2. 统一的资源文件读取方式
3. 已在监听器中注册的 bean 的事件

以下是三种较常见的 ApplicationContext 实现方式：

1、ClassPathXmlApplicationContext：从 classpath 的 XML 配置文件中读取上下文，并生成上下文定义。应用程序上下文从程序环境变量中

ApplicationContext context = new ClassPathXmlApplicationContext(“bean.xml”); 

2、FileSystemXmlApplicationContext ：由文件系统中的 XML 配置文件读取上下文。

ApplicationContext context = new FileSystemXmlApplicationContext(“bean.xml”);

3、XmlWebApplicationContext：由 Web 应用的 XML 文件读取上下文。

4、AnnotationConfigApplicationContext(基于 Java 配置启动容器)

Spring 注解

请举例解释@Autowired 注解？

此注解用于描述属性，构造方法，set方法等，用于告诉spring框架，按找一定的规则为属性进行DI操作，默认按属性，方法参数类型查找对应的对象，假如只找到一个则直接注入，类型多个时还会按照属性名或方法参数名进行值的注入，假如名字也不同，就出报错。

@Autowired 注解对自动装配何时何处被实现提供了更多细粒度的控制。@Autowired 注解可以像@Required 注解、构造器一样被用于在 bean 的设值方法上自动装配 bean的属性，一个参数或者带有任意名称或带有多个参数的方法。

比如，可以在设值方法上使用@Autowired 注解来替代配置文件中的 <property>元素。当 Spring 容器在 setter 方法上找到@Autowired 注解时，会尝试用 byType自动装配。

当然我们也可以在构造方法上使用@Autowired 注解。带有@Autowired 注解的构造方法意味着在创建一个 bean 时将会被自动装配，即便在配置文件中使用<constructor-arg>元素。

public class TextEditor { 
 private SpellChecker spellChecker; 
 @Autowired 
 public TextEditor(SpellChecker spellChecker){ 
 System.out.println("Inside TextEditor constructor." ); 
 this.spellChecker = spellChecker; 
 } 
 public void spellCheck(){ 
 spellChecker.checkSpelling(); 
 } 
}

<beans> 
 
 <context:annotation-config/> 
 
 <!-- Definition for textEditor bean without constructor-arg --> 
 <bean id="textEditor" class="com.howtodoinjava.TextEditor"/> 
 
 <!-- Definition for spellChecker bean --> 
 <bean id="spellChecker" class="com.howtodoinjava.SpellChecker"/> 
 
</beans> 

Spring 事务

spring 事务实现方式有哪些？

• 声明式事务：声明式事务也有两种实现方式，基于 xml 配置文件的方式和注解方式（在类上添加 @Transaction 注解）。
• 编码方式：提供编码的形式管理和维护事务。

说一下 spring 的事务隔离？

spring 有五大隔离级别，默认值为 ISOLATION_DEFAULT（使用数据库的设置），其他四个隔离级别和数据库的隔离级别一致：

• ISOLATION_DEFAULT：用底层数据库的设置隔离级别，数据库设置的是什么我就用什么；

• ISOLATIONREADUNCOMMITTED：==未提交读，==最低隔离级别、事务未提交前，就可被其他事务读取（会出现幻读、脏读、不可重复读）；

• ISOLATIONREADCOMMITTED：提交读，一个事务提交后才能被其他事务读取到（会造成幻读、不可重复读），SQL server 的默认级别；

• ISOLATIONREPEATABLEREAD：可重复读，保证多次读取同一个数据时，其值都和事务开始时候的内容是一致，禁止读取到别的事务未提交的数据（会造成幻读），MySQL 的默认级别；

• ISOLATION_SERIALIZABLE：序列化，代价最高最可靠的隔离级别，该隔离级别能防止脏读、不可重复读、幻读。

• 脏读 ：表示一个事务能够读取另一个事务中还未提交的数据。比如，某个事务尝试插入记录 A，此时该事务还未提交，然后另一个事务尝试读取到了记录A。

• 不可重复读 ：是指在一个事务内，多次读同一数据。

• 幻读 ：指同一个事务内多次查询返回的结果集不一样。比如同一个事务 A 第一次查询时候有 n 条记录，但是第二次同等条件下查询却有 n+1 条记录，这就好像产生了幻觉。发生幻读的原因也是另外一个事务新增或者删除或者修改了第一个事务结果集里面的数据，同一个记录的数据内容被修改了，所有数据行的记录就变多或者变少了。

Spring 其他问题

Spring 框架中都用到了哪些设计模式？

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

• 代理模式 — 在 AOP 和 remoting 中被用的比较多。
• 单例模式—在 spring 配置文件中定义的 bean 默认为单例模式。
• 模板方法—用来解决代码重复的问题。比如. RestTemplate, JmsTemplate, JpaTemplate。
• 前端控制器—Spring 提供了 DispatcherServlet 来对请求进行分发。
• 视图帮助(View Helper )—Spring 提供了一系列的 JSP 标签，高效宏来辅助将分散的代码整合在视图里。
• 依赖注入—贯穿于 BeanFactory / ApplicationContext 接口的核心理念。
• 工厂模式—BeanFactory 用来创建对象的实例

开发中主要使用 Spring 的什么技术 ?

• IOC 容器管理各层的组件
• 使用 AOP 配置声明式事务
• 整合其他框架

Spring MVC

Spring MVC 概述

MVC是什么？MVC设计模式的好处有哪些

mvc是一种设计模式（设计模式就是日常开发中编写代码的一种好的方法和经验的总结）。

• 模型（model）
• 视图（view）
• 控制器（controller）
  三层架构的设计模式。用于实现前端页面的展现与后端业务数据处理的分离。

mvc设计模式的好处

1. 分层设计，实现了业务系统各个组件之间的解耦，有利于业务系统的可扩展性，可维护性。
2. 有利于系统的并行开发，提升开发效率。

什么是Spring MVC？简单介绍下你对Spring MVC的理解。

Spring MVC是一个基于Java的实现了MVC设计模式的请求驱动类型的轻量级Web框架，通过把模型-视图-控制器分离，将web层进行职责解耦，把复杂的web应用分成逻辑清晰的几部分，简化开发，减少出错，方便组内开发人员之间的配合。

Spring MVC的优点？

• 可以支持各种视图技术,而不仅仅局限于JSP；

• 与Spring框架集成（如IoC容器、AOP等）；

• 清晰的角色分配：前端控制器(dispatcherServlet) , 请求到处理器映射（handlerMapping)，处理器适配器(HandlerAdapter)， 视图解析器（ViewResolver）。

• 支持各种请求资源的映射策略。

Spring MVC 核心组件

Spring MVC的主要组件？

• 前置控制器 DispatcherServlet。
• 映射控制器 HandlerMapping。
• 处理器 Controller。
• 模型和视图 ModelAndView。
• 视图解析器 ViewResolver。

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

Spring的MVC框架是围绕DispatcherServlet来设计的，它接收请求、响应结果，相当于转发器，它用来处理所有的HTTP请求和响应。有了DispatcherServlet 就减少了其它组件之间
的耦合度。

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

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

3、处理器适配器 HandlerAdapter

注意：在编写Handler的时候要按照HandlerAdapter要求的规则去编写，这样适配器HandlerAdapter才可以正确的去执行Handler。

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

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

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

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

View是一个接口， 它的实现类支持不同的视图类型（jsp，freemarker，pdf等等）

请描述Spring MVC的工作流程？描述一下 DispatcherServlet 的工作流程？

1. 用户发送请求至前端控制器DispatcherServlet；
2. DispatcherServlet收到请求后，调用HandlerMapping处理器映射器，请求获取Handle；
3. 处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet；
4. DispatcherServlet 调用 HandlerAdapter处理器适配器；
5. HandlerAdapter 经过适配调用 具体处理器(Handler，也叫后端控制器)；
6. Handler执行完成返回ModelAndView；
7. HandlerAdapter将Handler执行结果ModelAndView返回给DispatcherServlet；
8. DispatcherServlet将ModelAndView传给ViewResolver视图解析器进行解析；
9. ViewResolver解析后返回具体View；
10. DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）
11. DispatcherServlet响应用户。

核心架构的具体流程步骤如下：

1、首先用户发送请求——>DispatcherServlet，前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行处理，作为统一访问点，进行全局的流程控制；

2、DispatcherServlet——>HandlerMapping， HandlerMapping处理器映射器会找到具体的处理器 （可以根据xml配置、注解进行查找），把请求映射为HandlerExecutionChain 对象（包含一个Handler 处理器（页面控制器）对象、多个HandlerInterceptor 拦截器）对象，一并返回DispatcherServlet。通过这种策略模式，很容易添加新的映射策略；

3、DispatcherServlet——>HandlerAdapter，HandlerAdapter 将会把处理器包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用，从而很容易支持很多类型的处理器；

4、HandlerAdapter——>处理器功能处理方法的调用，HandlerAdapter 将会根据适配的结果调用真正的处理器的功能处理方法（Controller，也叫后端控制器），完成功能处理；并返回一个ModelAndView 对象（包含模型数据、逻辑视图名）；

5、ModelAndView的逻辑视图名——> HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet——>DisPatcherServlet将ModelAndView传给ViewReslover视图解析器

6、View——>渲染，View会根据传进来的Model模型数据进行渲染，（即将模型数据填充至视图中）此处的Model实际是一个Map数据结构，因此很容易支持其他视图技术；

7、返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户，到此一个流程结束。

下边两个组件通常情况下需要开发：
Handler：处理器，即后端控制器用controller表示。
View：视图，即展示给用户的界面，视图中通常需要标签语言展示模型数据。

分析：

M-Model 模型（完成业务逻辑：有javaBean构成，service+dao+entity）

V-View 视图（做界面的展示 jsp，html……）

C-Controller 控制器（接收请求—>调用模型—>根据结果派发页面）

Spring MVC的控制器是不是单例模式?如果是,有什么问题,怎么解决？

是单例模式，所以在多线程访问的时候有线程安全问题，不要用同步，会影响性能的。解决方案是在控制器里面不能写字段。

Spring MVC里面拦截器是怎么写的？

有两种写法

• 一种是实现HandlerInterceptor（ Interceptor /ˌɪntərˈseptər/ 拦截器）接口。
• 另外一种是继承适配器类，接着在接口方法当中，实现处理逻辑；然后在Spring MVC的配置文件中配置拦截器即可：

!-- 配置Spring MVC的拦截器 -->
<mvc:interceptors>
	<!-- 配置一个拦截器的Bean就可以了 默认是对所有请求都拦截 -->
	<bean id="myInterceptor" class="com.zwp.action.MyHandlerInterceptor">
	</bean>
	<!-- 只针对部分请求拦截 -->
	<mvc:interceptor>
	<mvc:mapping path="/modelMap.do" />
	<bean class="com.zwp.action.MyHandlerInterceptorAdapter" />
	</mvc:interceptor>
</mvc:interceptors>

如果在拦截请求中，我想拦截get方式提交的方法,怎么配置？

可以在@RequestMapping注解里面加上method=RequestMethod.GET

Spring MVC 常用注解

注解原理是什么?

注解本质是一个继承了Annotation的特殊接口，其具体实现类是Java运行时生成的动态代理类。

我们通过反射获取注解时，返回的是Java运行时生成的动态代理对象。通过代理对象调用自定义注解的方法，会最终调用AnnotationInvocationHandler的invoke方法。该方法会从memberValues这个Map中索引出对应的值。而memberValues的来源是Java常量池。

Spring MVC常用的注解有哪些？

• @RequestMapping：用于处理请求 url 映射的注解，可用于类或方法上。用于类上，则表示类中的所有响应请求的方法都是以该地址作为父路径。

• @RequestBody：注解实现接收http请求的json数据，将json转换为java对象。

• @ResponseBody：注解实现将conreoller方法返回对象转化为json对象响应给客户。

• @Conntroller：控制器的注解，表示是表现层，不能用用别的注解代替。

针对请求访问的几个组合注解？

@PatchMapping
@PostMapping
@GetMapping
@PutMapping
@DeleteMapping

Sping MVC中的控制器的注解一般用哪个，有没有别的注解可以替代？

一般用@Controller注解，也可以使用@RestController，@RestController注解相当于@ResponseBody ＋ @Controller，表示是表现层，除此之外，一般不用别的注解代替。

@Controller注解的作用

在Spring MVC 中，控制器Controller 负责处理由DispatcherServlet 分发的请求，它把用户请求的数据经过业务处理层处理之后封装成一个Model ，然后再把该Model 返回给对应的View 进行展示。

在Spring MVC 中提供了一个非常简便的定义Controller 的方法，你无需继承特定的类或实现特定的接口，只需使用@Controller 标记一个类是Controller ，然后使用@RequestMapping 和@RequestParam 等一些注解用以定义URL 请求和Controller 方法之间的映射，这样的Controller就能被外界访问到。

此外Controller 不会直接依赖于HttpServletRequest 和HttpServletResponse等HttpServlet 对象，它们可以通过Controller 的方法参数灵活的获取到。@Controller 用于标记在一个类上，使用它标记的类就是一个Spring MVC Controller 对象。

分发处理器将会扫描使用了该注解的类的方法，并检测该方法是否使用了@RequestMapping 注解。

@Controller 只是定义了一个控制器类，而使用@RequestMapping 注解的方法才是真正处理请求的处理器。单单使用@Controller 标记在一个类上还不能真正意义上的说它就是Spring MVC 的一个控制器类，因为这个时候Spring 还不认识它。

那么要如何做Spring 才能认识它呢？

这个时候就需要我们把这个控制器类交给Spring 来管理。有两种方式：

• 在Spring MVC 的配置文件中定义MyController 的bean 对象。

• 在Spring MVC 的配置文件中告诉Spring 该到哪里去找标记为@Controller 的Controller 控制器。

@RequestMapping注解的作用

RequestMapping是一个用来处理请求地址映射的注解，可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。

RequestMapping注解有六个属性，下面我们把她分成三类进行说明（下面有相应示例）。

value， method

• value： 指定请求的实际地址，指定的地址可以是URI Template 模式（后面将会说明）；
• method： 指定请求的method类型， GET、POST、PUT、DELETE等；

consumes，produces

• consumes： 指定处理请求的提交内容类型（Content-Type），例如application/json，text/html;
• produces: 指定返回的内容类型，仅当request请求头中的(Accept)类型中包含该指定类型才返回；

params，headers

• params：指定request中必须包含某些参数值是，才让该方法处理。
• headers：指定request中必须包含某些指定的header值，才能让该方法处理请求。

@ResponseBody注解的作用

作用： 该注解用于将Controller的方法返回的对象，通过适当的HttpMessageConverter转换为指定格式后，写入到Response对象的body数据区。

使用时机：返回的数据不是html标签的页面，而是其他某种格式的数据时（如json、xml等）使用；

@PathVariable和@RequestParam的区别

• 请求路径上有个id的变量值，可以通过@PathVariable来获取 @RequestMapping(value =“/page/{id}”, method = RequestMethod.GET)

• @RequestParam用来获得静态的URL请求入参 spring注解时action里用到。

Spring MVC怎么和AJAX相互调用的？

通过Jackson框架就可以把Java里面的对象直接转化成Js可以识别的Json对象。具体步骤如下 ：
（1）加入Jackson.jar
（2）在配置文件中配置json的映射
（3）在接受Ajax方法里面可以直接返回Object，List等，但方法前面要加上@ResponseBody注解。

Sping MVC 其他问题

Spring MVC中函数的返回值是什么？

返回值可以有很多类型，有String,，ModelAndView。ModelAndView类把视图和数据都合并的一起的，但一般用String比较好。

如果想在拦截的方法里面得到从前台传入的参数,怎么得到？

直接在形参里面声明这个参数就可以,但必须名字和传过来的参数一样。

怎样在方法里面得到Request,或者Session？

直接在方法的形参中声明request,Spring MVC就自动把request对象传入。

如何解决POST请求中文乱码问题，GET的又如何处理呢？

1）解决post请求乱码问题：在web.xml中配置一个CharacterEncodingFilter过滤器，设置成utf-8；

2）get请求中文参数出现乱码解决方法有两个：

1. 修改tomcat配置文件添加编码与工程编码一致，如下：
2. 另外一种方法对参数进行重新编码：

String userName = new String(request.getParamter(“userName”).getBytes(“ISO8859-1”),“utf-8”)

ISO8859-1是tomcat默认编码，需要将tomcat编码后的内容按utf-8编码。

Spring MVC的异常处理？

可以将异常抛给Spring框架，由Spring框架来处理；我们只需要配置简单的异常处理器，在异常处理器中添视图页面即可。

介绍一下 WebApplicationContext

WebApplicationContext 继承了ApplicationContext 并增加了一些WEB应用必备的特有功能，它不同于一般的ApplicationContext ，因为它能处理主题，并找到被关联的ser

Spring Boot

Spring Boot 概述

什么是 Spring Boot？

Spring Boot 是 Spring 开源组织下的子项目，是 Spring 组件一站式解决方案，主要是简化了使用 Spring 的难度，简省了繁重的配置，提供了各种启动器，使开发者能快速上手。

SpringBoot的作用？

Spring Boot框架，其功能非常简单，便是帮助我们实现自动配置。
我们都知道Spring Boot框架的核心是自动配置。只要有相应的jar包, Spring就会帮助我们实现自动配置,而无需像以前我们使用spring框架一样要做很多配置。

当默认配置不能满足我们要求的时候，我们能够用自己的配置来替换这些自动的配置类。

此外，上面我们也提到Spring Boot内嵌了 web应用容器，除此之外还集成了系统监控等功能，这些都可以帮助我们快速搭建企业级的应用程序并使用。

• 可以不依赖tomcat等外部容器来独立运行的web项目， springboot的优点是能够以jar包的形式运行。

• 嵌入式的Servlet容器:我们不需要像以前那边先打个war包,然后再运行,在springboot看来这些都是多余的,我们可以选择他内嵌的tomcat, Jetty或者Undertow等容器来直接运行。

• 使pom文件配置更简化：我们只需要在pom文件中添加starter-web依赖即可，无需像以前一样引入很多依赖而造成容易漏掉。

• 能够生产环境中直接使用性能指标、健康检查和应用信息等。

• ==springboot不需要任何xml文件配置而能实现所有的spring配置。 ==

为什么要用 Spring Boot？Spring Boot 有哪些优点？

• 配置简单，自动装配，无代码生成和 xml 配置
• 内嵌服务容器，独立运行
• 提供应用监控
• 易上手，提升开发效率

Spring Boot 主要有如下优点：

1. 容易上手，提升开发效率，为 Spring 开发提供一个更快、更简单的开发框架。

2. 开箱即用，远离繁琐的配置。

3. 提供了一系列大型项目通用的非业务性功能，例如：内嵌服务器、安全管理、运行数据监控、运行状况检查和外部化配置等。

4. SpringBoot总结就是使编码变简单、配置变简单、部署变简单、监控变简单等。

SpringBoot支持什么前端模板？

thymeleaf，freemarker，jsp，官方不推荐JSP会有限制

Spring Boot 需要独立的容器运行吗？

可以不需要，内置了 Tomcat/ Jetty 等容器。

Spring Boot 的运行与使用

运行 Spring Boot 有哪几种方式？

1. 打包用命令或者放到容器中运行
2. 用 Maven/ Gradle 插件运行
3. 直接执行 main 方法运行

开启 Spring Boot 特性有哪几种方式？

1. 继承spring-boot-starter-parent项目
2. 导入spring-boot-dependencies项目依赖

SpringBoot如何实现打包？

进入项目目录在控制台输入mvn clean package，clean是清空已存在的项目包，package进行打包或者点击左边选项栏中的Mavne，先点击clean在点击package。

Spring Boot 打成的 jar 和普通的 jar 有什么区别 ?

Spring Boot 项目最终打包成的 jar 是可执行 jar ，这种 jar 可以直接通过 java -jar xxx.jar 命令来运行，这种 jar 不可以作为普通的 jar 被其他项目依赖，即使依赖了也无法使用其中的类。

Spring Boot 的 jar 无法被其他项目依赖，主要还是他和普通 jar 的结构不同。

普通的 jar 包，解压后直接就是包名，包里就是我们的代码，而 Spring Boot 打包成的可执行 jar 解压后，在 \BOOT-INF\classes 目录下才是我们的代码，因此无法被直接引用。

如果非要引用，可以在 pom.xml文件中增加配置，将 Spring Boot 项目打包成两个 jar ，一个可执行，一个可引用。

SpringBoot 中的starter？

SpringBoot就是由各种Starter（启动器）组合起来的，Starter 可以理解成对依赖的一种合成，starter会把一个或一套功能相关依赖都包含进来，避免了自己去依赖费事，还有各种包的冲突问题。大大的提升了开发效率。

并且相关配置会有一个默认值，我们自己也可以开发Starter。如果我们自己去配置，就会覆盖默认值。

Spring Boot Starter的工作原理？

在sprinBoot启动时由@SpringBootApplication注解会自动去maven中读取每个starter中的spring.factories文件，该文件里配置了所有需要被创建spring容器中的bean，并且进行自动配置把bean注入SpringContext中 。（SpringContext是Spring的配置文件）

Spring Boot 配置

SpringBoot的自动配置原理是什么

主要是Spring Boot的启动类上的核心注解SpringBootApplication注解主配置类，有了这个主配置类启动时就会为SpringBoot开启一个@EnableAutoConfiguration注解自动配置功能。
有了这个EnableAutoConfiguration的话就会：

1. 从配置文件META_INF/Spring.factories加载可能用到的自动配置类
2. 去重，并将exclude和excludeName属性携带的类排除
3. 过滤，将满足条件（@Conditional）的自动配置类返回

你如何理解 Spring Boot 配置加载顺序？

在 Spring Boot 里面，可以使用以下几种方式来加载配置。
1.properties文件；
2.YAML文件；
3.系统环境变量；
4.命令行参数；
等等……

Spring Boot 核心配置文件是什么？

spring boot 核心的两个配置文件：

• bootstrap (. yml 或 者 . properties) ： boostrap 由 父ApplicationContext 加载的，比 applicaton 优先加载，且 boostrap
  里面的属性不能被覆盖；

• application (. yml 或者 . properties)：用于 spring boot 项目的自动化配置。

Spring Boot 配置文件有哪几种类型？它们有什么区别？

配置文件有 . properties 格式和 . yml 格式，它们主要的区别是书法风格不同。

. properties 配置如下：

spring. RabbitMQ. port=5672

. yml 配置如下：

spring:
 RabbitMQ:
 port: 5672

==. yml 格式不支持 @PropertySource 注解导入。 ==

@PropertySource注解用于指定资源文件读取的位置，它不仅能读取properties文件，也能读取xml文件，并且通过YAML解析器，配合自定义PropertySourceFactory实现解析YAML文件。

application.properties和application.yml文件可放位置?优先级?

1. 外置，在相对于应用程序运行目录的/config子目录里。
2. 外置，在应用程序运行的目录里。
3. 内置，在config包内。
4. 内置，在Classpath根目录。

这个列表按照优先级排序,优先级高的会覆盖优先级低的。当然我们可以自己指定文件的位置来加载配置文件。

什么是 YAML？

YAML（/ˈjæməl/，尾音类似camel骆驼）是一个可读性高，用来表达数据序列化的格式，它通常用于配置文件。与属性文件相比，如果我们想要在配置文件中添加复杂的属性，YAML 文件就更加结构性，而且更少混淆。可以看出 YAML 具有分层配置数据。

YAML 配置的优势在哪里 ?

YAML 现在可以算是非常流行的一种配置文件格式了，无论是前端还是后端，都可以见到 YAML 配置。那么 YAML 配置和传统的 properties 配置相比到底有哪些优势呢？

• 配置有序，在一些特殊的场景下，配置有序很关键
• 简洁明了，支持数组，数组中的元素可以是基本数据类型也可以是对象
• 相比 properties 配置文件，YAML 还有一个缺点，就是不支持 @PropertySource 注解导入自定义的 YAML 配置。

Spring Boot 是否可以使用 XML 配置 ?

Spring Boot 推荐使用 Java 配置而非 XML 配置，但是 Spring Boot 中也可以使用 XML 配置，通过 @ImportResource 注解可以引入一个 XML 配置。

Spring Boot 有哪几种读取配置的方式？

Spring Boot 可以通过

• @PropertySource,
• @Value
• @Environment
• @ConfigurationPropertie

注解来绑定变量

SpringBoot如何修改端口号?

yml中:

server :
	port : 8888

properties:

server.port : 8888

命令1:

java -jar xiaoka.jar ——— server.port=8888

命令2:

java - Dserver.port=8888 -jar xiaoka.jar

不同的环境的配置文件?

可以是 application-{profile}.properties/yml ，但默认是启动主配置文件application.properties，一般来说我们的不同环境配置如下。
application.properties：主配置文件
application-dev.properties：开发环境配置文件
application-test.properties：测试环境配置文件
application.prop-properties：生产环境配置文件

Spring Boot 注解

Spring Boot 的核心注解是哪个？它主要由哪几个注解组成的？

启动类上面的注解是@SpringBootApplication，它也是 Spring Boot 的核心注解，主要组合包含了以下 3 个注解：

• @SpringBootConfiguration：组合了 @Configuration 注解，实现配置文件的功能。
• @EnableAutoConfiguration：打开自动配置的功能，也可以关闭某个自动配置的选项， 例如： java 如关闭数据源自动配置功能： @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class })。
• @ComponentScan：Spring组件扫描。

Spring Boot 支持哪些日志框架？推荐和默认的日志框架是哪个？

Spring Boot 支持 Java Util Logging、Log4j2、 Lockback 作为日志框架，如果你使用 Starters 启动器，Spring Boot 将使用 Logback 作为默认日志框架，但是不管是哪种日志框架他都支持将配置文件输出到控制台或者文件中。

SpringBoot 实现热部署有哪几种方式？

热部署就是可以不用重新运行SpringBoot项目可以实现操作后台代码自动更新到以运行的项目中。
主要有两种方式：

• Spring Loaded
• Spring-boot-devtools
• Jrebel
• 模版热部署

SpringBoot事物的使用?

SpringBoot的事物很简单，首先使用注解@EnableTransactionManagement开启事物之后，然后在 Service 方法上添加注解@Transactional便可。

Async异步调用方法?

在SpringBoot中使用异步调用是很简单的，只需要在方法上使用@Async注解即可实现方法的异步调用。 注意：需要在启动类加入@EnableAsync使异步调用 @Async 注解生效。

编写测试用例的注解？

@SpringBootTest

SpringBoot异常处理相关注解?

@ControllerAdvice
@ExceptionHandler

如何在 Spring Boot 启动的时候运行一些特定的代码？

可以实现接口 ApplicationRunner 或者 CommandLineRunner，这两个接口实现方式一样，它们都只提供了一个 run 方法。

Spring Boot 中如何实现定时任务 ?

在 Spring Boot 中使用定时任务主要有两种不同的方式：

• 一个就是使用 Spring 中的 @Scheduled 注解
• 另一个则是使用第三方框架 Quartz。使用 Spring 中的 @Scheduled 的方式主要通过 @Scheduled 注解来实现。

SpringBoot如何兼容Spring项目?

在启动类加：@ImportResource(locations = {"classpath:spring.xml"})

什么是 JavaConfig？

Spring JavaConfig 是 Spring 社区的产品，Spring 3.0引入了他，它提供了配置 Spring IOC 容器的纯Java 方法。因此它有助于避免使用 XML 配置。使用 JavaConfig 的优点在于：

• 面向对象的配置。由于配置被定义为 JavaConfig 中的类，因此用户可以充分利用 Java 中的面向对象功能。一个配置类可以继承另一个，重写它的@Bean 方法等。

• 减少或消除 XML 配置。基于依赖注入原则的外化配置的好处已被证明。但是，许多开发人员不希望在 XML 和 Java 之间来回切换。JavaConfig 为开发人员提供了一种纯 Java 方法来配置与 XML 配置概念相似的 Spring 容器。从技术角度来讲，只使用 JavaConfig 配置类来配置容器是可行的，但实际上很多人认为将JavaConfig 与 XML 混合匹配是理想的。

• 类型安全和重构友好。JavaConfig 提供了一种类型安全的方法来配置 Spring容器。由于 Java5.0 对泛型的支持，现在可以按类型而不是按名称检索 bean，不需要任何强制转换或基于字符串的查找。

常用的Java config：

• @Configuration：在类上打上写下此注解，表示这个类是配置类

• @ComponentScan：在配置类上添加 @ComponentScan 注解。该注解默认会扫描该类所在的包下所有的配置类，相当于之前的 <context:component-scan >。

• @Bean：bean的注入：相当于以前的< bean id="objectMapper" class="org.codehaus.jackson.map.ObjectMapper" />

• @EnableWebMvc：相当于xml的<mvc:annotation-driven >

• @ImportResource： 相当于xml的 < import resource="applicationContextcache.xml">

MyBatis & MyBatis-Plus

MyBatis 概述

MyBatis是什么？

• Mybatis 是一个半 ORM（对象关系映射）框架，它内部封装了 JDBC，开发时只需要关注 SQL 语句本身，不需要花费精力去处理加载驱动、创建连接、创建statement 等繁杂的过程。程序员直接编写原生态 sql，可以严格控制 sql 执行性能，灵活度高。

• MyBatis 可以使用 XML 或注解来配置和映射原生信息，将 POJO 映射成数据库中的记录，避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。

Mybatis优缺点是什么？

优点

与传统的数据库访问技术相比，ORM有以下优点：

• 基于SQL语句编程，相当灵活，不会对应用程序或者数据库的现有设计造成任何影响，SQL写在XML里，解除sql与程序代码的耦合，便于统一管理；提供XML标签，支持编写动态SQL语句，并可重用。

• 与JDBC相比，减少了50%以上的代码量，消除了JDBC大量冗余的代码，不需要手动开关连接很好的与各种数据库兼容。（因为MyBatis使用JDBC来连接数据库，所以只要JDBC支持的数据库 MyBatis 都支持）

• 提供映射标签，支持对象与数据库的ORM字段关系映射；提供对象关系映射标签，支持对象关系组件维护。

• 与Spring很好的集成。

缺点

SQL语句的编写工作量较大，尤其当字段多、关联表多时，对开发人员编写SQL语句的功底有一定要求，SQL语句依赖于数据库，导致数据库移植性差，不能随意更换数据库。

ORM是什么？

ORM（Object Relational Mapping），对象关系映射，是一种为了解决关系型数据库数据与简单Java对象（POJO）的映射关系的技术。简单的说，ORM是通过使用描述对象和数据库之间映射的元数据，将程序中的对象自动持久化到关系型数据库中。

为什么说Mybatis是半自动ORM映射工具？它与全自动的区别在哪里？

• Hibernate属于全自动ORM映射工具，使用Hibernate查询关联对象或者关联集合对象时，可以根据对象关系模型直接获取，所以它是全自动的。

• 而==Mybatis在查询关联对象或关联集合对象时，需要手动编写sql来完成，所以，称之为半自动ORM映射工具。

Hibernate 和 MyBatis 的区别？

相同点

都是对jdbc的封装，都是持久层的框架，都用于dao层的开发。

不同点

1、映射关系

• MyBatis 是一个半自动映射的框架，配置Java对象与sql语句执行结果的对应关系，多表关联关系配置简单。
• Hibernate 是一个全表映射的框架，配置Java对象与数据库表的对应关系，多表关联关系配置复杂。

2、SQL优化和移植性

• Hibernate 对SQL语句封装，提供了日志、缓存、级联（级联比 MyBatis 强大）等特性，此外还提供 HQL（Hibernate Query Language）操作数据库，数据库无关性支持好，但会多消耗性能。如果项目需要支持多种数据库，代码开发量少，但SQL语句优化困难。

• MyBatis 需要手动编写 SQL，支持动态 SQL、处理列表、动态生成表名、支持存储过程。开发工作量相对大些。直接使用SQL语句操作数据库，不支持数据库无关性，但sql语句优化容易。

MyBatis和Hibernate的适用场景?

MyBatis专注于SQL本身，是一个足够灵活的DAO层解决方案。对性能的要求很高，或者需求变化较多的项目，如互联网项目，MyBatis将是不错的选择。

开发难易程度和学习成本

• Hibernate 是重量级框架，学习使用门槛高，适合于需求相对稳定，中小型的项目，比如：办公自动化系统
• MyBatis 是轻量级框架，学习使用门槛低，适合于需求变化频繁，大型的项目，比如：互联网电子商务系统

总结

• MyBatis 是一个小巧、方便、高效、简单、直接、半自动化的持久层框架，
• Hibernate 是一个强大、方便、高效、复杂、间接、全自动化的持久层框架。

传统JDBC开发存在什么问题，MyBatis是如何解决的？

• 频繁创建数据库连接对象、释放，容易造成系统资源浪费，影响系统性能。可以使用连接池解决这个问题。但是使用jdbc需要自己实现连接池。
  解决：在mybatis-config.xml中配置数据链接池，使用连接池管理数据库连接

• sql语句定义、参数设置、结果集处理存在硬编码。实际项目中sql语句变化的可能性较大，一旦发生变化，需要修改java代码，系统需要重新编译，重新发布。不好维护。
  解决：将Sql语句配置在XXXXmapper.xml文件中与java代码分离。

• 使用preparedStatement向占有位符号传参数存在硬编码，因为sql语句的where条件不一定，可能多也可能少，修改sql还要修改代码，系统不易维护。
  解决： Mybatis自动将java对象映射至sql语句。

• 结果集处理存在重复代码，处理麻烦。如果可以映射成Java对象会比较方便。
  解决：Mybatis自动将sql执行结果映射至java对象。

MyBatis 工作原理

MyBatis编程步骤是什么样的？

1、 创建SqlSessionFactory（sql会话工厂）
2、 通过SqlSessionFactory创建SqlSession（sql会话）
3、 通过sqlsession执行数据库操作
4、 调用session.commit()提交事务
5、 调用session.close()关闭会话

请说说MyBatis的工作原理？

1. 读取 MyBatis 配置文件：mybatis-config.xml 为 MyBatis 的全局配置文件，配置了 MyBatis 的运行环境等信息，例如数据库连接信息。

2. 加载映射文件。映射文件即 SQL 映射文件，该文件中配置了操作数据库的 SQL 语句，需要在MyBatis 配置文件 mybatis-config.xml 中加载。mybatis-config.xml 文件可以加载多个映射文件，每个文件对应数据库中的一张表。

3. 构造会话工厂：通过 MyBatis 的环境等配置信息构建会话工厂 SqlSessionFactory。

4. 创建会话对象：由会话工厂创建 SqlSession 对象，该对象中包含了执行 SQL 语句的所有方法。

5. Executor 执行器：MyBatis 底层定义了一个 Executor （执行者 /ɪɡˈzekjətə®/）接口来操作数据库，它将根据 SqlSession传递的参数动态地生成需要执行的 SQL 语句，同时负责查询缓存的维护。

6. MappedStatement 对象：在 Executor 接口的执行方法中有一个 MappedStatement 类型的参数，该参数是对映射信息的封装，用于存储要映射的 SQL 语句的 id、参数等信息。

7. 输入参数映射：输入参数类型可以是 Map、List 等集合类型，也可以是基本数据类型和 POJO 类型。输入参数映射过程类似于 JDBC 对 preparedStatement 对象设置参数的过程。

8. 输出结果映射：输出结果类型可以是 Map、 List 等集合类型，也可以是基本数据类型和 POJO 类型。输出结果映射过程类似于 JDBC 对结果集的解析过程。

映射器

#{}和${}的区别

• #{}是占位符，预编译处理；s{}是拼接符，字符串替换，没有预编译处理。

• Mybatis在处理#{}时，#{}传入参数是以字符串传入，会将SQL中的#{}替换为?号，调用PreparedStatement的set方法来赋值。

• #{} 可以有效的防止SQL注入，提高系统安全性；${} 不能防止SQL 注入

• #{} 的变量替换是在DBMS 中；${} 的变量替换是在 DBMS 外

什么是MyBatis的接口绑定？有哪些实现方式？

接口绑定，就是在MyBatis中任意定义接口，然后把接口里面的方法和SQL语句绑定，我们直接调用接口方法就可以，这样比起原来了SqlSession提供的方法我们可以有更加灵活的选择和设置。

接口绑定有两种实现方式

• 通过注解绑定，就是在接口的方法上面加上 @Select、@Update等注解，里面包含Sql语句来绑定；

• 通过xml里面写SQL来绑定， 在这种情况下，要指定xml映射文件里面的namespace必须为接口的全路径名。当Sql语句比较简单时候，用注解绑定， 当SQL语句比较复杂时候，用xml绑定，一般用xml绑定的比较多。

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

1. Mapper接口方法名和mapper.xml中定义的每个sql的id相同。
2. Mapper接口方法的输入参数类型和mapper.xml中定义的每个sql 的parameterType的类型相
   同。
3. Mapper接口方法的输出参数类型和mapper.xml中定义的每个sql的resultType的类型相同。
4. Mapper.xml文件中的namespace即是mapper接口的类路径。

这个Dao接口的工作原理是什么？Dao接口里的方法，参数不同时，方法能重载吗？

Dao接口的工作原理是JDK动态代理，Mybatis运行时会使用JDK动态代理为Dao接口生成代理proxy对象，代理对象proxy会拦截接口方法，转而执行MappedStatement所代表的sql，然后将sql执行结果返回。

Dao接口里的方法，是不能重载的，因为是全限名+方法名的保存和寻找策略。

Mybatis的Xml映射文件中，不同的Xml映射文件，id是否可以重复？

不同的Xml映射文件，如果配置了namespace，那么id可以重复；如果没有配置namespace，那么id不能重复；毕竟namespace不是必须的，只是最佳实践而已。

原因就是namespace+id是作为Map<String, MappedStatement>的key使用的，如果没有namespace，就剩下id，那么，id重复会导致数据互相覆盖。有了namespace，自然id就可以重复，namespace不同，namespace+id自然也就不同。

简述Mybatis的Xml映射文件和Mybatis内部数据结构之间的映射关系？

Mybatis将所有Xml配置信息都封装到All-In-One重量级对象Configuration内部。

在Xml映射文件中， 标签会被解析为ParameterMap对象，其每个子元素会被解析为ParameterMapping对象。 标签会被解析为ResultMap对象，其每个子元素会被解析为ResultMapping对象。

每一个 、 、 、 标签均会被解析为MappedStatement对象，标签内的sql会被解析为BoundSql对象。

Mybatis是如何将sql执行结果封装为目标对象并返回的？都有哪些映射形式？

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

• 第二种是使用sql列的别名功能，将列别名书写为对象属性名，比如T_NAME AS NAME，对象属性名一般是name，小写，但是列名不区分大小写，Mybatis会忽略列名大小写，智能找到与之对应对象属性名，你甚至可以写成T_NAME AS NaMe，Mybatis一样可以正常工作。

有了列名与属性名的映射关系后，Mybatis通过反射创建对象，同时使用反射给对象的属性逐一赋值并返回，那些找不到映射关系的属性，是无法完成赋值的。

Xml映射文件中，除了常见的select|insert|updae|delete标签之外，还有哪些标签？

还有很多其他的标签， 、 、 、 、 ，加上动态sql的9个标签

• trim
• where
• set
• foreach
• if
• choose
• when
• otherwise
• bind
  其中 为sql片段标签，通过 标签引入sql片段， 为不支持自增的主键生成策略标签。

Mybatis映射文件中，如果A标签通过include引用了B标签的内容，请问，B标签能否定义在A标签的后面，还是说必须定义在A标签的前面？

虽然Mybatis解析Xml映射文件是按照顺序解析的，但是，被引用的B标签依然可以定义在任何地方，Mybatis都可以正确识别。

原理是，Mybatis解析A标签，发现A标签引用了B标签，但是B标签尚未解析到，尚不存在，此时，Mybatis会将A标签标记为未解析状态，然后继续解析余下的标签，包含B标签，待所有标签解析完毕，Mybatis会重新解析那些被标记为未解析的标签，此时再解析A标签时，B标签已经存在，A标签也就可以正常解析完成了。

Mybatis是否可以映射Enum枚举类？

• Mybatis可以映射枚举类，不单可以映射枚举类，Mybatis可以映射任何对象到表的一列上。映射方式为自定义一个TypeHandler，实现TypeHandler的setParameter()和getResult()接口方法。

• TypeHandler有两个作用，一是完成从javaType至jdbcType的转换，二是完成jdbcType至javaType的转换，体现为setParameter()和getResult()两个方法，分别代表设置sql问号占位符参数和获取列查询结果。

Mybatis动态sql是做什么的？都有哪些动态sql？能简述一下动态sql的执行原理吗？

Mybatis动态sql可以让我们在Xml映射文件内，以标签的形式编写动态sql，完成逻辑判断和动态拼接sql的功能，Mybatis提供了9种动态sql标签

• trim
• where
• set
• foreach
• if
• choose
• when
• otherwise
• bind

其执行原理为，使用OGNL从sql参数对象中计算表达式的值，根据表达式的值动态拼接sql，以此来完成动态sql的功能。

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

Mybatis仅可以编写针对ParameterHandler、ResultSetHandler、StatementHandler、Executor这4种接口的插件，Mybatis使用JDK的动态代理，为需要拦截的接口生成代理对象以实现接口方法拦截功能，每当执行这4种接口对象的方法时，就会进入拦截方法，具体就是 InvocationHandler 的 invoke() 方法，当然，只会拦截那些你指定需要拦截的方法。

实现Mybatis的Interceptor接口并复写intercept()方法，然后在给插件编写注解，指定要拦截哪一个接口的哪些方法即可，记住，别忘了在配置文件中配置你编写的插件。

Mybatis 应用

MyBatis 分页插件的实现原理是什么？

分页插件的基本原理是使用 MyBatis 提供的插件接口，实现自定义插件，在插件的拦截方法内拦截待执行的 SQL，然后重写 SQL，根据 dialect 方言，添加对应的物理分页语句和物理分页参数。

MyBatis 有几种分页方式？

分页方式：逻辑分页和物理分页。

• 逻辑分页： 使用 MyBatis 自带的 RowBounds 进行分页，它是一次性查询很多数据，然后在数据中再进行检索。

• 物理分页： 自己手写 SQL 分页或使用分页插件 PageHelper，去数据库查询指定条数的分页数据的形式。

Mybatis是如何进行分页的？分页插件的原理是什么？

• Mybatis使用RowBounds对象进行分页，它是针对ResultSet结果集执行的内存分页，而非物理分页，可以在sql内直接书写带有物理分页的参数来完成物理分页功能，也可以使用分页插件来完成物理分页。

• 分页插件的基本原理是使用Mybatis提供的插件接口，实现自定义插件，在插件的拦截方法内拦截待执行的sql，然后重写sql，根据dialect方言，添加对应的物理分页语句和物理分页参数。

• 举例：select * from student ，拦截sql后重写为：select t.* from (select * from student) t limit 0, 10

MyBatis 逻辑分页和物理分页的区别是什么？

• 逻辑分页是一次性查询很多数据，然后再在结果中检索分页的数据。这样做弊端是需要消耗大量的内存、有内存溢出的风险、对数据库压力较大。

• 物理分页是从数据库查询指定条数的数据，弥补了一次性全部查出的所有数据的种种缺点，比如需要大量的内存，对数据库查询压力较大等问题。

在mapper中如何传递多个参数

方法1：顺序传参法

public User selectUser(String name, int deptId);

<select id="selectUser" resultMap="UserResultMap">
select * from user
where user_name = #{0} and dept_id = #{1}
</select>

#{}里面的数字代表传入参数的顺序。

这种方法不建议使用，sql层表达不直观，且一旦顺序调整容易出错。

方法2：@Param注解传参法

public User selectUser(@Param("userName") String name, 
						int @Param("deptId")deptId);

<select id="selectUser" resultMap="UserResultMap">
select * from user
where user_name = #{userName} and dept_id = #{deptId}
</select>

#{}里面的名称对应的是注解@Param括号里面修饰的名称。

这种方法在参数不多的情况还是比较直观的，（推荐使用）。

方法3：Map传参法

public User selectUser(Map<String, Object> params);

<select id="selectUser" parameterType="java.util.Map" resultMap="UserResultMap">
select * from user
where user_name = #{userName} and dept_id = #{deptId}
</select>

#{}里面的名称对应的是Map里面的key名称。

这种方法适合传递多个参数，且参数易变能灵活传递的情况。（推荐使用）。

方法4：Java Bean传参法

public User selectUser(User user);

<select id="selectUser" parameterType="com.jourwon.pojo.User" resultMap="UserResultMap">
select * from user
where user_name = #{userName} and dept_id = #{deptId}
</select>

#{}里面的名称对应的是User类里面的成员属性。

这种方法直观，需要建一个实体类，扩展不容易，需要加属性，但代码可读性强，业务逻辑处理方便，推荐使用。（推荐使用）。

当实体类中的属性名和表中的字段名不一样 ，怎么办

第1种： 通过在查询的SQL语句中定义字段名的别名，让字段名的别名和实体类的属性名一致。

<select id="getOrder" parameterType="int" resultType="com.jourwon.pojo.Order">
select order_id id, order_no orderno ,order_price price form orders
where order_id=#{id};
</select>

第2种： 通过 来映射字段名和实体类属性名的一一对应的关系。

<select id="getOrder" parameterType="int" resultMap="orderResultMap">
	select * from orders where order_id=#{id}
</select>

<resultMap type="com.jourwon.pojo.Order" id="orderResultMap">

<!–用id属性来映射主键字段–>
<id property="id" column="order_id">
<!–用result属性来映射非主键字段，property为实体类属性名，column为数据库表中的属性–>
<result property ="orderno" column ="order_no"/>
<result property="price" column="order_price" />
</reslutMap>

模糊查询like语句该怎么写

• ’%${question}%’ 可能引起SQL注入，不推荐

• “%”#{question}"%" 注意：因为#{…}解析成sql语句时候，会在变量外侧自动加单引号’ '，所以这里 % 需要使用双引号" "，不能使用单引号 ’ '，不然会查不到任何结果。

• CONCAT(’%’,#{question},’%’) 使用CONCAT()函数，（推荐）

• 使用bind标签（不推荐）

<select id="listUserLikeUsername" resultType="com.jourwon.pojo.User">
<bind name="pattern" value="'%' + username + '%'" />
select id,sex,age,username,password from person 
where username LIKE #{pattern}
</select>

如何获取生成的主键

新增标签中添加：keyProperty=" ID " 即可

<insert id="insert" useGeneratedKeys="true" keyProperty="userId" >
	insert into user(user_name, user_password, create_time)
	values(#{userName}, #{userPassword} , #{createTime, jdbcType=TIMESTAMP})
</insert>

Mybatis如何执行批量操作

1、使用foreach标签

foreach的主要用在构建in条件中，它可以在SQL语句中进行迭代一个集合。foreach标签的属性主要有item，index，collection，open，separator，close。

• item   表示集合中每一个元素进行迭代时的别名，随便起的变量名；
• index   指定一个名字，用于表示在迭代过程中，每次迭代到的位置，不常用；
• open   表示该语句以什么开始，常用“(”；
• separator 表示在每次进行迭代之间以什么符号作为分隔符，常用“,”；
• close   表示以什么结束，常用“)”。

在使用foreach的时候最关键的也是最容易出错的就是collection属性，该属性是必须指定的，但是在不同情况下，该属性的值是不一样的，主要有一下3种情况：

1. 如果传入的是单参数且参数类型是一个List的时候，collection属性值为list
2. 如果传入的是单参数且参数类型是一个array数组的时候，collection的属性值为array
3. 如果传入的参数是多个的时候，我们就需要把它们封装成一个Map了，当然单参数也可以封装成map，实际上如果你在传入参数的时候，在MyBatis里面也是会把它封装成一个Map的，map的key就是参数名，所以这个时候collection属性值就是传入的List或array对象在自己封装的map里面的key。

具体用法如下：

<!-- 批量保存(foreach插入多条数据两种方法)
int addEmpsBatch(@Param("emps") List<Employee> emps); -->
<!-- MySQL下批量保存，可以foreach遍历 mysql支持values(),(),()语法 --> //推荐使用
<insert id="addEmpsBatch">
	INSERT INTO emp(ename,gender,email,did)
	VALUES
	<foreach collection="emps" item="emp" separator=",">
	(#{emp.eName},#{emp.gender},#{emp.email},#{emp.dept.id})
	</foreach>
</insert>

<!-- 这种方式需要数据库连接属性allowMutiQueries=true的支持
如jdbc.url=jdbc:mysql://localhost:3306/mybatis?allowMultiQueries=true -->
<insert id="addEmpsBatch">
	<foreach collection="emps" item="emp" separator=";">
	INSERT INTO emp(ename,gender,email,did)
	VALUES(#{emp.eName},#{emp.gender},#{emp.email},#{emp.dept.id})
	</foreach>
</insert>

2、使用ExecutorType.BATCH

Mybatis内置的ExecutorType有3种，默认为simple,该模式下它为每个语句的执行创建一个新的预处理语句，单条提交sql；而batch模式重复使用已经预处理的语句，并且批量执行所有更新语句，显然batch性能将更优； 但batch模式也有自己的问题，比如在Insert操作时，在事务没有提交之前，是没有办法获取到自增的id，这在某型情形下是不符合业务要求的
具体用法如下：

//批量保存方法测试
@Test
public void testBatch() throws IOException {
    SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    //可以执行批量操作的sqlSession
    SqlSession openSession = sqlSessionFactory.openSession(ExecutorType.BATCH);

    //批量保存执行前时间
    long start = System.currentTimeMillis();
    try {
        EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
        for (int i = 0; i < 1000; i++) {
            mapper.addEmp(
                    new Employee(UUID.randomUUID().toString().substring(0, 5), "b", "1"));
        }
        openSession.commit();
        long end = System.currentTimeMillis();
        //批量保存执行后的时间
        System.out.println("执行时长" + (end - start));
        //批量 预编译sql一次==》设置参数==》10000次==》执行1次 677
        +
    //非批量 （预编译=设置参数=执行 ）==》10000次 1121
    } finally {
        openSession.close();
    }
}

mapper和mapper.xml如下

public interface EmployeeMapper {
	//批量保存员工
	Long addEmp(Employee employee);
}

<mapper namespace="com.jourwon.mapper.EmployeeMapper"
	<!--批量保存员工 -->
	<insert id="addEmp">
		insert into employee(lastName,email,gender)
		values(#{lastName},#{email},#{gender})
	</insert>
</mapper>

Mapper 编写有哪几种方式？

第一种：接口实现类继承 SqlSessionDaoSupport：使用此种方法需要编写mapper 接口，mapper 接口实现类、mapper.xml 文件。

1、在 sqlMapConfig.xml 中配置 mapper.xml 的位置

<mappers>
	<mapper resource="mapper.xml 文件的地址" />
	<mapper resource="mapper.xml 文件的地址" />
</mappers>

2、定义 mapper 接口

3、实现类集成 SqlSessionDaoSupport，mapper 方法中可以 this.getSqlSession()进行数据增删改查。

4、 spring 配置

<bean id=" " class="mapper 接口的实现">
	<property name="sqlSessionFactory"
	ref="sqlSessionFactory"></property>
</bean>

第二种：使用 org.mybatis.spring.mapper.MapperFactoryBean：

1、 在 sqlMapConfig.xml 中配置 mapper.xml 的位置，如果 mapper.xml 和 mappre 接口的名称相同且在同一个目录，这里可以不用配置。

2、定义 mapper 接口：

<mappers> 
	<mapper resource="mapper.xml 文件的地址" /> 
	<mapper resource="mapper.xml 文件的地址" /> 
</mappers>

3、mapper.xml 中的 namespace 为 mapper 接口的地址。

4、 mapper 接口中的方法名和 mapper.xml 中的定义的 statement 的 id 保持一致
5、Spring 中定义

第三种：使用 mapper 扫描器：

1、mapper.xml 文件编写：

• mapper.xml 中的 namespace 为 mapper 接口的地址；
• mapper 接口中的方法名和 mapper.xml 中的定义的 statement 的 id 保持一致；
  如果将 mapper.xml 和 mapper 接口的名称保持一致则不用在 sqlMapConfig.xml中进行配置。

2、 定义 mapper 接口：注意 mapper.xml 的文件名和 mapper 的接口名称保持一致，且放在同一个目录。

3、配置 mapper 扫描器：

<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"> 
	<property name="basePackage" value="mapper 接口包地址 "></property> 
	<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/> 
</bean>

4、 使用扫描器后从 spring 容器中获取 mapper 的实现对象。

Mybatis 其他问题

MyBatis 如何编写一个自定义插件？

自定义插件实现原理

MyBatis 自定义插件针对 MyBatis 四大对象（Executor、StatementHandler、ParameterHandler、ResultSetHandler）进行拦截：

• Executor：拦截内部执行器，它负责调用 StatementHandler 操作数据库，并把结果集通过 ResultSetHandler 进行自动映射，另外它还处理了二级缓存的操作；

• StatementHandler：拦截 SQL 语法构建的处理，它是 MyBatis 直接和数据库执行 SQL 脚本的对象，另外它也实现了
  MyBatis 的一级缓存；

• ParameterHandler：拦截参数的处理；

• ResultSetHandler：拦截结果集的处理。

说一下 MyBatis 的一级缓存和二级缓存？

1. 一级缓存: 基于 PerpetualCache（永久缓存） 的 HashMap 本地缓存，其存储作用域为 Session，它的声明周
   期是和 SQLSession 一致的，有多个 SQLSession 或者分布式的环境中数据库操作，可能会出现脏数据。当 Session flush 或 close 之后，该 Session 中的所有 Cache 就将清空，默认打开一级缓存。

2. 二级缓存与一级缓存其机制相同，默认也是采用 PerpetualCache，HashMap 存储，不同在于其存储作用域为 Mapper(Namespace)，，它的声明周期是和 SQLSession 一致的，有多个 SQLSession 或者分布式的环境中
   数据库操作，可能会出现脏数据。默认不打开二级缓存，要开启二级缓存，使用二级缓存属性类需要实现Serializable序列化接口(可用来保存对象的状态)，可在它的映射文件中配置 <cache/>。

开启二级缓存数据查询流程：二级缓存 -> 一级缓存 -> 数据库。

对于缓存数据更新机制，当某一个作用域(一级缓存 Session/二级缓存Namespaces)的进行了C/U/D 操作后，默认该作用域下所有 select 中的缓存将被 clear。

Mybatis能执行一对多，一对一的联系查询吗，有哪些实现方法

能，不止可以一对多，一对一还可以多对多，一对多

实现方式：

1. 单独发送一个SQL去查询关联对象，赋给主对象，然后返回主对象。

2. 使用嵌套查询，似JOIN查询，一部分是A对象的属性值，另一部分是关联对 象 B的属性值，好处是只要发送一个属性值，就可以把主对象和关联对象查出来。

3. 子查询。