tomcat面试和Spring的面试题

Tomcat是什么？

tomcat服务器首先是一个开源的服务器，其次他还是一个轻量级，是开发调试的首选；
其次tomcat的端口号默认是8080，它还可以通过tomcat下的conf下的server.xml里的Connector标签进行修改你想要的端口号

3、Tomcat有几种部署方式？

1）直接把Web项目放在webapps下，Tomcat会自动将其部署

2）在server.xml文件上配置节点，设置相关的属性即可

3）通过Catalina来进行配置:进入到conf\Catalina\localhost文件下，创建一个xml文件，该文件的名字就是站点的名字。

编写XML的方式来进行设置。

4、tomcat容器是如何创建servlet类实例？用到了什么原理？

当容器启动时，会读取在webapps目录下所有的web应用中的web.xml文件，然后对xml文件进行解析，并读取servlet注册信息。然后，将每个应用中注册的servlet类都进行加载，并通过反射的方式实例化。（有时候也是在第一次请求时实例化）在servlet注册时加上如果为正数，则在一开始就实例化，如果不写或为负数，则第一次请求实例化。

为什么使用Spring（优缺点）

①、方便解耦，简化开发（Spring提供了IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。）
②、提供了AOP面向切面的编程，可以对某些方法进行扩展）
③、声明式事务的支持（可以从单调烦闷的事务管理代码中解脱出来，）
④、方便程序的测试，由于junt4之后提供了注解，可以通过注解方便的测试Spring程序。
⑤、方便集成各种优秀框架（Spring不排斥各种优秀的开源框架如Struts,Hibernate）

spring容器创建对象的时机
第一种：默认情况下，启动 spring 容器便创建对象（遇到bean便创建对象）
第二种：在spring的配置文件bean中有一个属性（懒加载） lazy-init=“default/true/false”
　　　　①、如果lazy-init为"default/false"在启动spring容器时创建对象（默认情况）
　　　　 ②、如果lazy-init为"true",在context.getBean时才要创建对象

Spring的常用注解解释

第一步：在 applicationContext.xml 中引入命名空间 ，引入的命名空间，简单来说就是用来约束xml文件格式的。
第二步:在 applicationContext.xml 文件中引入注解扫描器
@Component（@Repository ：dao层 @Service：service层 @Controller：web层 功能一样）

@Component将这个bean对象放入到容器中
public class Person {}
等价于
@Component(“p”)
public class Person {}
等价于

@Resource 注解，它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作。 通过 @Resource 的使用来消除 set ，get方法。
@Autowired功能和注解 @Resource 一样，可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作。只不过注解@Resource 是按照名称来进行装配，而@Autowired 则是按照类型来进行装配。（它首先会根据类型去匹配，多个则按名称，空则会抛出异常。法二：@Autowired 和 @Qualifier(“名称”) 配合使用）
@Qualifier:将@Qualifier注解和@Autowire注解结合使用,指定需要装配的确切的bean。
@Required:表明bean的属性必须在配置的时候设置.
@Configuration 声明当前类是一个配置类 @Configuation等价于
@Bean 将这个对象交给Spring容器管理；
注解的方法将会实例化、配置和初始化一个新对象，这个对象将由 Spring的 IoC 容器来管理， 作用与 元素类似
不同点：实现原理不同，@Configuration基于CGlib代理实现，@Component基于反射实现；

Spring MVC的常用注解解释

@Controller 用于标记在一个类上，使用它标记的类就是一个SpringMVC Controller 对象。
@RequestMapping是一个用来处理请求地址映射的注解，可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。
@PathVariable用于将请求URL中的模板变量映射到该方法的参数上，那么该方法是restful风格上

@RequestMapping(value="/product/{productId}",method = RequestMethod.GET)
public String getProduct(@PathVariable(“productId”) String productId)

@Responsebody ：作用其实是将java对象转为json格式的数据；
注解表示该方法的返回的结果直接写入 HTTP 响应正文（ResponseBody）中，一般在异步获取数据时使用；
在使用 @RequestMapping 后，返回值通常解析为跳转路径，加上 @Responsebody 后返回结果不会被解析为跳转路径，而是直接写入HTTP 响应正文中。例如，异步获取 json 数据，加上 @Responsebody 注解后，就会直接返回 json 数据。
@RequestParam 在SpringMVC后台控制层获取参数；
的方式主要有两种，一种是request.getParameter(“name”)，另外一种是用注解@RequestParam直接获取。这里主要讲这个注解 。 spring会自动根据参数名字封装进入，我们可以直接拿这个参数名来用

1. @RequestMapping("testRequestParam")    参数同名
2.    public String filesUpload(@RequestParam String inputStr, HttpServletRequest request) {  
             int inputInt = Integer.valueOf(request.getParameter("inputInt"));
前
1. 
"/gadget/testRequestParam" method="post">    
2.      参数inputStr:"text" name="inputStr">    
3.      参数intputInt:"text" name="inputInt">    
4. 
  

1、可以对传入参数指定参数名
@RequestParam(value=“aa”) String inputStr

2、可以通过required=false或者true来要求@RequestParam配置的前端参数是否一定要传
public String filesUpload(@RequestParam(value=“aa”, required=true) String inputStr, HttpServletRequest request)

Mybatis的常用标签或者注解用过哪些

MyBatis 的强大特性之一便是它的动态 SQL
标签：

<if> 
<choose，when,otherwise> 有点像 Java 中的 switch 语句。
<trim>标签 格式化的标记
<foreach> 对一个集合进行遍历， 通常是在构建 IN 条件语句的时候
<foreach collection="" item="" index=""  open="" separator="" close=""></foreach>
bind标签 <bind  name="" value="" />取别名

collection	表示迭代集合的名称
item	表示本次迭代获取的元素，若collection为List、Set或者数组，则表示其中的元素；若collection为map，则代表key-value的value，该参数为必选 ，即就是表示集合中每一个元素进行迭代时的别名
open	表示该语句以什么开始，最常用的是左括弧’(’，注意:mybatis会将该字符拼接到整体的sql语句之前，并且只拼接一次，该参数为可选项
close	表示该语句以什么结束，最常用的是右括弧’)’，注意:mybatis会将该字符拼接到整体的sql语句之后，该参数为可选项
separator	mybatis会在每次迭代后给sql语句append上separator属性指定的字符，该参数为可选项，即就是示在每次进行迭代之间以什么符号作为分隔符
index	在list、Set和数组中,index表示当前迭代的位置，在map中，index代指是元素的key，该参数是可选项。

@Select 简单查询 @Select(" Select * from sellers “)
@Results @Result 用来配置列名和属性 @Result(id = true, column = “id”, property = “id”),
@Insert 简单插入
@Insert(” insert into tb_user(name,sex,age) values(#{name},#{sex},#{age} " )
int saveUser(User user);
@Update 简单更新
@Delete 简单删除
@Delete("delete from sellers where id =#{id} ")
void deleteById(Integer id);
@Mapper

为什么要使用MyBatis？

使用mybatis框架访问数据库：

(1)Mybatis对JDBC进行了封装，可以简化JDBC代码；
(2)Mybatis自身支持连接池（也可以配置其他的连接池），因此可以提高程序的效率；
(3)Mybatis是将SQL配置在mapper文件中，修改SQL只是修改配置文件，类不需要重新编译。
(4)对查询SQL执行后返回的ResultSet对象，Mybatis会帮我们处理，转换成Java对象。

spring bean 的生命周期

1.Spring 容器根据配置中的 bean 定义中实例化 bean。
2. Spring 使用依赖注入填充所有属性，如 bean 中所定义的配置。
3. 如果 bean 实现 BeanNameAware 接口，则工厂通过传递 bean 的 ID 来调用 setBeanName()。
4. 如果 bean 实现 BeanFactoryAware 接口，工厂通过传递自身的实例来调用 setBeanFactory()。
5. 如果存在与 bean 关联的任何 BeanPostProcessors，则调用 postProcessBeforeInitialization() 方法。
6. 如果为 bean 指定了 init 方法（ 的 init-method 属性），那么将调用它。
7. 最后，如果存在与 bean 关联的任何 BeanPostProcessors，则将调用 postProcessAfterInitialization() 方法。
8. 如果 bean 实现 DisposableBean 接口，当 spring 容器关闭时，会调用 destory()。
9. 如果为 bean 指定了 destroy 方法（ 的 destroy-method 属性），那么将调用它。

Spring事务（ACID，隔离级别，事务传播机制）

ACID
①、原子性（Atomicity）：事务是一个原子操作，由一系列动作组成。事务的原子性确保动作要么全部完成，要么完全不起作用。
　　②、一致性（Consistency）：一旦事务完成（不管成功还是失败），事务执行前和事务执行后的和保持不变。
　　③、隔离性（Isolation）：可能有许多事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏。
　　④、持久性（Durability）：一旦事务完成，无论发生什么系统错误，它的结果都不应该受到影响，这样就能从任何系统崩溃中恢复过来。通常情况下，事务的结果被写到持久化存储器中

①、ISOLATION_DEFAULT：使用后端数据库默认的隔离级别-1
　②、ISOLATION_READ_UNCOMMITTED：（读未提交）最低的隔离级别，允许读取尚未提交的数据变更，可能会导致脏读、幻读或不可重复读0
③、ISOLATION_READ_COMMITTED：（读已提交）允许读取并发事务已经提交的数据，可以阻止脏读，但是幻读或不可重复读仍有可能发生1
　④、ISOLATION_REPEATABLE_READ：（可重复读）对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，可以阻止脏读和不可重复读，但幻读仍有可能发生2
　　⑤、ISOLATION_SERIALIZABLE：（序列化）最高的隔离级别，完全服从ACID的隔离级别，确保阻止脏读、不可重复读以及幻读，也是最慢的事务隔离级别，因为它通常是通过完全锁定事务相关的数据库表来实现的4
Spring支持的事务管理类型:1)编程式事务管理 2)声明式事务管理
声明式事务管理要优于编程式事务管理,灵活
声明式事务 　①、在applicationContext.xml 配置事务管理器，将并事务管理器交予spring 　②、在目标类或目标方法添加注解即可 @Transactional（如果在类上添加，则说明类中的所有方法都添加事务，如果在方法上添加，则只有该方法具有事务。）

@Transactional(propagation=Propagation.REQUIRED , isolation = Isolation.DEFAULT)
@Service("accountService")
public class AccountServiceImpl implements AccountService{

IOC底层实现原理
概念：
IOC 是面向对象编程中的一种设计原则，IOC理论提出的观点大体是这样的：借助于“第三方”实现具有依赖关系的对象之间的解耦。所谓IoC，对于spring框架来说，就是由spring来负责控制对象的生命周期和对象间的关系。 是说创建对象的控制权进行转移，以前创建对象的主动权和创建时机是由自己把控的，而现在这种权力转移到第三方。

实现原理：
它是通过反射机制+工厂模式实现的，在实例化一个类时，它通过反射调用类中set方法将事先保存在HashMap中的类属性注入到类中。
控制反转就是：获得依赖对象的方式反转了。

1、依赖注入发生的时间
(1).用户第一次通过getBean方法向IoC容索要Bean时，IoC容器触发依赖注入。
(2).当用户在Bean定义资源中为元素配置了lazy-init属性，即让容器在解析注册Bean定义时进行预实例化，触发依赖注入。
2.依赖注入实现在以下两个方法中：
(1).createBeanInstance：生成Bean所包含的java对象实例。
(2).populateBean ：对Bean属性的依赖注入进行处理。

AOP底层实现原理
概念
AOP（Aspect-OrientedProgramming，面向方面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。 而AOP技术则恰恰相反，它利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即方面。 简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。
AOP的核心思想就是“将应用程序中的商业逻辑同对其提供支持的通用服务进行分离。

AOP的实现
实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码。

动态代理：提供一个基础的接口，作为被调用类型（com.mycorp.HelloImpl）和代理类之间的统一入口，如 com.mycorp.Hello。
实现InvocationHandler，对代理对象方法的调用，会被分派到其 invoke 方法来真正实现动作。
通过 Proxy 类，调用其 newProxyInstance 方法，生成一个实现了相应基础接口的代理类实例，

Java在JDK1.3后引入的动态代理机制，使我们可以在运行期动态的创建代理类。使用动态代理实现AOP需要有四个角色：被代理的类，被代理类的接口，织入器，和InvocationHandler，而织入器使用接口反射机制生成一个代理类，然后在这个代理类中织入代码。被代理的类是AOP里所说的目标，InvocationHandler是切面，它包含了Advice和Pointcut。

如何使用Spring AOP
可以通过配置文件或者编程的方式来使用Spring AOP。 配置可以通过xml文件来进行，大概有四种方式：
1）配置ProxyFactoryBean，显式地设置advisors, advice, target等
2）配置AutoProxyCreator，这种方式下，还是如以前一样使用定义的bean，但是从容器中获得的其实已经是代理对象
3）通过aop:config来配置
4）通aop:aspectj-autoproxy过来配置，使用AspectJ的注解来标识通知及切入点

Spring AOP的实现
如何生成代理类：
Spring提供了两种方式来生成代理对象: JDKProxy和Cglib，具体使用哪种方式生成由AopProxyFactory根据AdvisedSupport对象的配置来决定。默认的策略是如果目标类是接口，则使用JDK动态代理技术，否则使用Cglib来生成代理

切面是如何织入的？
InvocationHandler是JDK动态代理的核心，生成的代理对象的方法调用都会委托到InvocationHandler.invoke()方法。

AOP详解：
AOP（Aspect-OrientedProgramming，面向方面编程）它利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即方面。便于减少系统的重复代码，降低模块间的耦合度，核心思想就是“将应用程序中的商业逻辑同对其提供支持的通用服务进行分离。

性能监控，在方法调用前后记录调用时间，方法执行太长或超时报警。

缓存代理，缓存某方法的返回值，下次执行该方法时，直接从缓存里获取。

软件破解，使用AOP修改软件的验证类的判断逻辑。

记录日志，在方法执行前后记录系统日志。

工作流系统，工作流系统需要将业务代码和流程引擎代码混合在一起执行，那么我们可以使用AOP将其分离，并动态挂接业务。

权限验证，方法执行前验证是否有权限执行当前方法，没有则抛出没有权限执行异常，由业务代码捕捉。

AOP能干什么，也是AOP带来的好处
1：降低模块的耦合度
2：使系统容易扩展
3：设计决定的迟绑定：使用AOP,设计师可以推迟为将来的需求作决定，因为它
可以把这种需求作为独立的方面很容易的实现。
4：更好的代码复用性

AOP基本概念
通知类型(必会)
before: 在目标方法执行之前执行
afterReturning: 在目标方法执行之后返回时执行
afterThrowing: 在目标方法执行之后,抛出异常时执行
after: 无论程序是否执行成功,都要最后执行的通知（相当于关闭该方法 的资源）
around: 在目标方法执行前后 都要执行的通知(完美体现了动态代理模式)，功能最为强大 只有环绕通知可以控制目标方法的执行

1.2 关于AOP名词介绍
1).连接点Joinpoint： 用户可以被扩展的方法，但是现在还没有被扩展；
切入点PointCut： 用户实际扩展的方法，找到指定包里的类，类里的方法，增加功能；
3).通知Advice： 扩展方法的具体实现，即就是要实现什么样的功能；
4).切面Aspect： 将通知应用到切入点的过程，其实就是一个类，由通知和切点组成；

3、aop编程

3.1 导入命名空间
3.2 使用 aop:config进行配置
proxy-target-class=“true” 声明时使用cglib代理
如果不声明，Spring 会自动选择cglib代理还是JDK动态代理
aop:pointcut 切入点 ，从目标对象获得具体方法
aop:advisor 特殊的切面，只有一个通知 和 一个切入点
advice-ref 通知引用
pointcut-ref 切入点引用
3.3 切入点表达式
execution(* com.ys.aop…(…))
选择方法 返回值任意 包 类名任意 方法名任意 参数任意

aop的专业术语
连接点(join Point)：可以增强的点/方法（就比如我们刚才的新增，更新等方法就是增强的点）
切入点(pointcut)：真正增强的点，虽然我们有新增，更新，删除但是我们真正需要增强的方法只是其中一个方法
注意⚠️：连接点不一定是切入点
增强/通知(advice)：增强的逻辑，也可以说是增强的功能，比如日志管理，权限校验等
目标对象：就是我们要增强的类；
引入：特殊的增强，为类添加属性和方法。哪怕这个类没有任何的属性和方法我们也可以通过aop去添加方法和属性实现逻辑
目标对象（target）：被代理的对象，增强谁的方法，这个类就是目标对象
切面(Aspect)：aop其实就是面向切面编程，切面其实就是我们对方法功能的拓展的类

AOP的通知Advice类型

前置通知（就是业务执行之前进行使用），比如权限校验
后置通知（就是业务执行之前进行使用），比如日志管理
环绕通知（就是业务执行之前后进行使用）某个方法执行的时间等
最终通知（方法执行结束之后进行使用）
异常通知就是在方法中出现之后有异常出现进行使用

Spring MVC 运行流程(好

用户发起请求到前端控制器（Controller）
前端控制器没有处理业务逻辑的能力，需要找到具体的模型对象处理（Handler），到处理器映射器（HandlerMapping）中查找Handler对象（Model）。
HandlerMapping返回执行链，包含了2部分内容： ① Handler对象、② 拦截器数组
前端处理器通过处理器适配器包装后执行Handler对象。
处理业务逻辑。
Handler处理完业务逻辑，返回ModelAndView对象，其中view是视图名称，不是真正的视图对象。
将ModelAndView返回给前端控制器。
视图解析器（ViewResolver）返回真正的视图对象（View）。
（此时前端控制器中既有视图又有Model对象数据）前端控制器根据模型数据和视图对象，进行视图渲染。
返回渲染后的视图（html/json/xml）返回。
11。给用户产生响应。
1）. 用户发请求–>DispatcherServlet，前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行处理，作为统一访问点，进行全局的流程控制。
2）.DispatcherServlet–>HandlerMapping，HandlerMapping将会把请求映射为HandlerExecutionChain对象（包含一个Handler处理器,多个HandlerInterceptor拦截器)。
3）.DispatcherServlet–>HandlerAdapter,HandlerAdapter将会把处理器包装为适配器，从而支持多种类型的处理器。
4）.HandlerAdapter–>处理器功能处理方法的调用，HandlerAdapter将会根据适配的结果调用真正的处理器的功能处理方法，完成功能处理，并返回给一个ModelAndView对象(包含模型数据，逻辑视图名)
5）.ModelAndView的逻辑视图名–>ViewResolver，ViewResoler将把逻辑视图名解析为具体的View。
6）.View–>渲染，View会根据传进来的Model模型数据进行渲染，此处的Model实际是一个Map数据结构
7）.返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户。

什么是控制反转（Inversion of Control）与依赖注入（Dependency Injection）
控制反转：是指将创建对象的功能交给Spring容器，在我们需要使用对象的时候不需要自己创建，可以直接从容器中获取。 依赖注入：动态的向某个对象提供它所依赖的其他对象。

Mybatis中的#{}跟${}有什么区别

1）mybatis在处理#{}时，会将sql中的#{}替换为?号，调用PreparedStatement的set方法来赋值。
 （2）mybatis在处理${}时，就是把${}替换成变量的值。
（3）使用#{}可以有效的防止SQL注入攻击，提高系统安全性。原因在于：预编译机制。

从架构设计的角度，可以将 MyBatis 分为哪几层？每层都有哪些主要模块？

mybatis架构自下而上分为基础支撑层、数据处理层、API接口层这三层。

基础支撑层，主要是用来做连接管理、事务管理、配置加载、缓存管理等最基础组件，为上层提供最基础的支撑。
数据处理层，主要是用来做参数映射、sql解析、sql执行、结果映射等处理，可以理解为请求到达，完成一次数据库操作的流程。
API接口层，主要对外提供API，提供诸如数据的增删改查、获取配置等接口。

spring 常用的注入方式有哪些？

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

spring bean 的作用域：

applicationContext.xml 文件中配置：

singleton：spring ioc 容器中只存在一个 bean 实例，bean 以单例模式存在，是系统默认值；
prototype：每次从容器调用 bean 时都会创建一个新的示例，既每次 getBean()相当于执行 new Bean()操作；
在单例模式下，启动 spring 容器，便会创建对象；在多例模式下，启动容器并不会创建对象，获得 bean 的时候才会创建对象
Web 环境下的作用域：
request：每次 http 请求都会创建一个 bean；
session：同一个 http session 共享一个 bean 实例；
global-session：用于 portlet 容器，因为每个 portlet 有单独的 session，globalsession 提供一个全局性的 http session。

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

说一下 spring 的事务隔离？

spring 有五大隔离级别，默认值为 ISOLATION_DEFAULT（使用数据库的设置），其他四个隔离级别和数据库的隔离级别一致：
ISOLATION_DEFAULT：用底层数据库的设置隔离级别，数据库设置的是什么我就用什么；
ISOLATIONREADUNCOMMITTED：未提交读，最低隔离级别、事务未提交前，就可被其他事务读取（会出现幻读、脏读、不可重复读）；
ISOLATIONREADCOMMITTED：读已提交，一个事务提交后才能被其他事务读取到（会造成幻读、不可重复读），SQL server 的默认级别；
ISOLATIONREPEATABLEREAD：可重复读，保证多次读取同一个数据时，其值都和事务开始时候的内容是一致，禁止读取到别的事务未提交的数据（会造成幻读），MySQL 的默认级别；
ISOLATION_SERIALIZABLE：序列化，代价最高最可靠的隔离级别，该隔离级别能防止脏读、不可重复读、幻读。

@RequestMapping 的作用是什么？
将 http 请求映射到相应的类/方法上。

@Autowired 的作用是什么？
@Autowired 它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作，通过@Autowired 的使用来消除 set/get 方法。

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

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

二级缓存：也是基于 PerpetualCache 的 HashMap 本地缓存，不同在于其存储作用域为 Mapper 级别的，如果多个SQLSession之间需要共享缓存，则需要使用到二级缓存，并且二级缓存可自定义存储源，如 Ehcache。默认不打开二级缓存，要开启二级缓存，使用二级缓存属性类需要实现 Serializable 序列化接口(可用来保存对象的状态)。

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

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

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

MyBatists的 resultType和resultmap的区别

接下来说说有关Mapper.xml配置文件中查询标签中关于返回值类型resultType与resultMap
1） resultType是直接表示返回类型的，而resultMap 指的是定义好了的id的，是定义好的resyltType的引用，但是resultType跟resultMap不能同时存在。
2） 当提供的返回类型属性是resultType时，MyBatis会将Map里面的键值对取出赋给resultType所指定的对象对应的属性。所以其实MyBatis的每一个查询映射的返回类型都是ResultMap，只是当提供的返回类型属性是resultType的时候，MyBatis会自动的给把对应的值赋给resultType所指定对象的属性。
3）resultType对应的是java对象中的属性，大小写不敏感, 如果放的是java.lang.Map,key是查询语句的列名，value是查询的值，大小写敏感；resultMap对应的是对已经定义好了id的resultType的引用，key是查询语句的列名，value是查询的值，大小写敏感；
4)使用resultType的时候，要保证结果集的列名与java对象的属性相同，而resultMap则不用, 而且resultMap可以用typeHander转换
5) resultMap 元素，它是 MyBatis 中最重要最强大的元素，它能提供级联查询，缓存等功能。
https://blog.csdn.net/leo3070/article/details/77899574
返回单个实例

<select id="selectUser" parameterType="int" resultType="User">
select * from user where id = #{id}

<resultMap type="User" id="userMap">
<id column="id" property="id"/>
<result column="name" property="name"/>
</resultMap>

MyBatists的好处？
1） 避免创建、释放频繁造成系统资源浪费 ：在 SqlMapConfig.xml 中配置数据链接池，使用连接池管理数据库链接。
2） 将 Sql 语句配置在 XXXXmapper.xml 文件中与 java 代码分离。
3） Mybatis 自动将 java 对象映射至 sql 语句。因为向 sql 语句传参数麻烦，因为 sql 语句的 where 条件不一定，可能多也可能少，占位符需要和参数一一对应
4） Mybatis 自动将 sql 执行结果映射至 java 对象。因为 对结果集解析麻烦， sql 变化导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装成 pojo 对象解析比较方便

为什么要使用MyBatis？
使用mybatis框架访问数据库：

(1)Mybatis对JDBC进行了封装，可以简化JDBC代码；
(2)Mybatis自身支持连接池（也可以配置其他的连接池），因此可以提高程序的效率；
(3)Mybatis是将SQL配置在mapper文件中，修改SQL只是修改配置文件，类不需要重新编译。
(4)对查询SQL执行后返回的ResultSet对象，Mybatis会帮我们处理，转换成Java对象。

MyBatis 与 Hibernate 的区别？
1） Mybatis 学习门槛低，简单易学，程序员直接编写原生态 sql
2） mybatis 可以通过 XML 或注解方式灵活配置要运行的 sql 语句，并将 java 对象和 sql 语句映射生成最终执行的 sql，最后将 sql 执行的结果再映射生成 java 对象。
3） MyBatis灵活度高，适合需求变化频繁

使用 MyBatis 的 mapper 接口调用时有哪些要求
① Mapper 接口方法名和 mapper.xml 中定义的每个 sql 的 id 相同
② Mapper 接口方法的输入参数类型和 mapper.xml 中定义的每个 sql 的 parameterType 的类
型相同
③ Mapper 接口方法的输出参数类型和 mapper.xml 中定义的每个 sql 的 resultType 的类型相
同 ④
Mapper.xml 文件中的 namespace 即是 mapper 接口的类路径。

SpringMVC 怎么样设定重定向和转发的？

在返回值前面加”forward:” 就可以让结果转发。 ”forward:user.do?name=method4” 在返回值前面加”redirect:”就可以让返回值重定向,
如果在拦截请求中,我想拦截 get 方式提交的方法,怎么配置？ 可以在@RequestMapping 注解里面加上 method=RequestMethod.GET

SpringMVC 里面拦截器是怎么写的？

一种是实现接口,另外一种是继承适配器类,然后在 SpringMvc 的配置文件中配置
拦截器即可:

<!-- 只针对部分请求拦截 -->
<mvc:interceptor>
<mvc:mapping path="/modelMap.do" />
<bean class="com.et.action.MyHandlerInterceptorAdapter" />
</mvc:interceptor>

SpringBoot常用注解
@SpringBootApplication： 包含@Configuration、@EnableAutoConfiguration、@ComponentScan@RestController： 用于标注控制层组件，包含@Controller和@ResponseBody
@Autowired
@Qualifier：（1）在使用@Autowire自动注入的时候，加上@Qualifier(“test”)可以指定注入哪个对象；
（2）可以作为筛选的限定符，我们在做自定义注解时可以在其定义上增加@Qualifier，用来筛选需要的对象。这个理解看下面的代码吧，不好解释。
@RequestMapping

谈谈你对SpringBoot的理解
Spring Boot开发始于 2013 年，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。
spring boot 他简化了开发过程，配置过程、部署过程、监控过程。
它默认配置了很多框架的使用方式，就像maven整合了所有的jar包，spring boot整合了很多的框架，同时将其他技术同spring结合起来。通过SpringBoot我们可以很快的搭建一套web项目。
不足：

为所有Spring开发提供一个更快，更广泛的入门体验。立即开始开发
提供大型项目（如嵌入式服务器，安全性，指标，运行状况检查和外部配置）通用的一系列非功能性功能。

讲一下SpringBoot的四大核心功能
起步依赖机制：通过起步依赖机制（Starter）,简化jar包的引用，解决jar版本冲突问题。
自动配置：可以实现简单配置，甚至是零配置，就能搭建整套框架。
StringBoot CLI（命令行界面）：一种命令工具。
Actuator：是SpringBoot的程序监控器，可监控Spring应用程序上下文中的Bean、查看自动配置决策、Controller映射、线程活动、应用程序健康状况等。