Spring Cloud

1.0什么是微服务

微服务就是将一个单体架构的应用按业务划分为一个个的独立运行的程序，每个小的服务之间都要进行通信，它们之间通过HTTP资源API进行通信（也可以采用消息队列来通信，如RabbitMQ，Kafaka等)，可以采用不同的编程语言，使用不同的存储技术，自动化部署(如Jenkins)）减少人为控制，降低出错概率。

1.1什么是Spring Cloud

Spring Cloud是一系列框架的有序集合。它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、智能路由、消息总线、负载均衡、断路器、数据监控等，都可以用Spring Boot的开发风格做到一键启动和部署。Spring Cloud并没有重复制造轮子，它只是将各家公司开发的比较成熟、经得起实际考验的服务框架组合起来，通过Spring Boot风格进行再封装屏蔽掉了复杂的配置和实现原理，最终给开发者留出了一套简单易懂、易部署 和易维护的分布式系统开发工具包。

1.2Spring Cloud的组件

Spring Cloud Netflix

Netflix OSS 开源组件集成，包括Eureka、Hystrix(嗨死踹克死)、Ribbon、OpenFeign、Zuul等核心组件。

Eureka：服务治理组件，包括服务端的注册中心和客户端的服务发现机制；

Ribbon：负载均衡的服务调用组件，具有多种负载均衡调用策略；

Hystrix：服务容错组件，实现了断路器模式，为依赖服务的出错和延迟提供了容错能力；

OpenFeign：基于Ribbon和Hystrix的声明式服务调用组件；

Zuul：API网关组件，对请求提供路由及过滤功能。

Spring Cloud Bus

用于传播集群状态变化的消息总线，使用轻量级消息代理链接分布式系统中的节点，可以用来动态刷新集群中的服务配置。

Spring Cloud Consul

基于Hashicorp Consul的服务治理组件。

Spring Cloud Security

安全工具包，对Zuul代理中的负载均衡OAuth2客户端及登录认证进行支持。

Spring Cloud Sleuth

Spring Cloud应用程序的分布式请求链路跟踪，支持使用Zipkin、HTrace和基于日志（例如ELK）的跟踪。

Spring Cloud Stream

轻量级事件驱动微服务框架，可以使用简单的声明式模型来发送及接收消息，主要实现为Apache Kafka及RabbitMQ。

Spring Cloud Task

用于快速构建短暂、有限数据处理任务的微服务框架，用于向应用中添加功能性和非功能性的特性。

Spring Cloud Zookeeper

基于Apache Zookeeper的服务治理组件。

Spring Cloud Gateway

API网关组件，对请求提供路由及过滤功能。

Spring Cloud OpenFeign

基于Ribbon和Hystrix的声明式服务调用组件，可以动态创建基于Spring MVC注解的接口实现用于服务调用，在Spring Cloud 2.0中已经取代Feign成为了一等公民。

1.3SpringBoot和SpringCloud的区别？

1、Spring boot 是 Spring 的一套快速配置脚手架，可以基于spring boot 快速开发单个微服务；Spring Cloud是一个基于Spring Boot实现的云应用开发工具；

2、Spring boot专注于快速、方便集成的单个个体，Spring Cloud是关注全局的服务治理框架；

3、spring boot使用了默认大于配置的理念，很多集成方案已经帮你选择好了，能不配置就不配置，Spring Cloud很大的一部分是基于Spring boot来实现。

4、Spring boot可以离开Spring Cloud独立使用开发项目，但是Spring Cloud离不开Spring boot，属于依赖的关系。

1.4Spring Cloud 和dubbo区别?

（1）服务调用方式 dubbo是RPC springcloud Rest Api

（2）注册中心,dubbo 是zookeeper springcloud是eureka，也可以是zookeeper

（3）服务网关,dubbo本身没有实现，只能通过其他第三方技术整合，springcloud有Zuul路由网关，作为路由服务器，进行消费者的请求分发,springcloud支持断路器，与git完美集成配置文件支持版本控制，事物总线实现配置文件的更新与服务自动装配等等一系列的微服务架构要素。

1.5什么是服务熔断，什么是服务降级

服务熔断：

熔断制机，主要用于应对雪崩效应的一种保护机制。指的是为了保全整体牺牲局部。编程中的熔断主要是为了避免整个服务崩溃，所以行相应的处理，比如将服务降级。

服务降级：

consumer 端：consumer 如果发现某个provider出现异常情况，⽐如，经常超时(可能是熔断引起的降级)，数据错误，这时，consumer可以采取⼀定的策略，降级provider的逻辑，基本的有直接返回固定的数据。

provider 端：当provider 发现流量激增的时候，为了保护⾃身的稳定性，也可能考虑降级服务。

1.直接给consumer返回固定数据

2.需要实时写⼊数据库的，先缓存到队列⾥，异步写⼊数据库。

1.7Spring Cloud断路器的作用

当一个服务调用另一个服务由于网络原因或自身原因出现问题，调用者就会等待被调用者的响应 当更多的服务请求到这些资源导致更多的请求等待，发生连锁效应（雪崩效应）

断路器有三个状态

完全打开状态:一段时间内 达到一定的次数无法调用 并且多次监测没有恢复的迹象 断路器完全打开 那么下次请求就不会请求到该服务

半开:短时间内 有恢复迹象 断路器会将部分请求发给该服务，正常调用时 断路器关闭

关闭：当服务一直处于正常状态 能正常调用

1.8什么是Spring Cloud Config?

在分布式系统中，由于服务数量巨多，为了方便服务配置文件统一管理，实时更新，所以需要分布式配置中心组件。在Spring Cloud中，有分布式配置中心组件spring cloud config ，它支持配置服务放在配置服务的内存中（即本地），也支持放在远程Git仓库中。在spring cloud config 组件中，分两个角色，一是config server，二是config client。

使用：

（1）添加pom依赖

（2）配置文件添加相关配置

（3）启动类添加注解@EnableConfigServer

1.9什么是Spring Cloud Gateway?

Spring Cloud Gateway是Spring Cloud官方推出的第二代网关框架，取代Zuul（儒勒）网关。网关作为流量的，在微服务系统中有着非常作用，网关常见的功能有路由转发、权限校验、限流控制等作用。

使用了一个RouteLocatorBuilder的bean去创建路由，除了创建路由RouteLocatorBuilder可以让你添加各种predicates和filters，predicates断言的意思，顾名思义就是根据具体的请求的规则，由具体的route去处理，filters是各种过滤器，用来对请求做各种判断和修改。

1.10什么是 Spring Cloud Bus？

Spring Cloud Bus 提供了跨多个实例刷新配置的功能。因此，如果我们刷新一个模块，则会自动刷新所有其他必需的模块。如果我们有多个微服务启动并运行，这特别有用。这是通过将所有微服务连接到单个消息代理来实现的。无论何时刷新实例，此事件都会订阅到侦听此代理的所有微服务，并且它们也会刷新。可以通过使用端点 / 总线 / 刷新来实现对任何单个实例的刷新。

1.10Nacos是什么？

一个更易于构建云原生应用的动态服务发现，配置管理和服务管理中心，Nacos就是注册中心+配置中心的组合等价于Eureka+Config+Bus能替代Eureka做服务注册中心替代Config做服务配置中心

1.11Nacos的作用

(1)服务的发现和健康监测

SpringCloud每启动一个服务的时候，都可以在nacos中查看到服务启动的数量，状态等信息。

(2）动态的配置服务

nacos中可以把对应服务的配置文件配置到nacos中，例如application.properties配置文件就可以配置到nacos中。(3）动态的DNS服务

dns: dns的作用就是将域名翻译为ip

nacos: nacos中动态的DNS服务就是可以通过服务名字来解析到所需要请求的服务的ip端口号。

(4）存储元数据管理

在nacos中配置的application.properties中配置的元数据，然后在服务中的控制器中的一个处理器中拿到application,properties中相对应的数据。

1.12openfeign是什么？

openfeign能够完成restTemplate+Ribbon+容错等功能，既能够设计Ribbon的负载均衡策略，又能够使用restTemplate来完成服务之间的相互调用，还可以通过设置容错，来完成如果服务器提供者发生错误的时候或者服务提供者关闭服务时候，开启容错。

1.13OpenFeign的使用

OpenFeign的作用就是不用使用restTemplate来通过ip访问相应的服务，相当于Service层，就是通过service接口来连接到相对应的服务器提供者，然后在controller中使用@Autowried实现service然后调用方法就行。

使用:1.添加pom依赖。2.启动类添加@EnableFeignClients3.定义一个接口@FeignClient(name=“xxx”)指定调用哪个服务

1.14OpenFeign容错的实现？

容错就是消费者依赖服务提供者，如果服务提供者有异常或者挂掉了，消费者可以激活容器容错接口，继续提供服务，可以保证你服务的高可用(类似汽车的备胎，短暂使用可以，大部分时候容错返回的数据都是死数据）。

1.15Nacos Config？

( 1) config就是nacos分布式配置中心，将同一服务的配置文件放置到nacos中，每次应用启动的时候，会从nacos中拉取新的配置文件，初始化到应用中，并且如果配置中的配置文件值发生变化的时候，应用就会立即感知到。

(2）配置文件，从左到右，优先级依次降低

bootstrap.properties > > bootstrap.yaml > > application.properties>> application.yaml

(3）如果服务中配置的有配置文件并且·nacos中也有相应的配置文件会优先读取bootstap.properties中的数据值。

(4) bootstrap.properties是在应用启动之前读取的，如果想要读取nacos中的内容，必须配置到bootstrap.properties、bootstrap.yaml。

1.16什么是Sentinel？

Sentinel是Springcloud中的哨兵，作用是用来监控各个接口的流量，根据流量大小完成流量熔断（超过流量完成熔断)，异常熔断（一定时间内超过一定数量的异常触发熔断)、超时熔断（超过响应时长的比例触发熔断)、容错（如果被调用的服务挂了，哨兵也有容错的功能，服务中的容错一般是使用哨兵模式，而不是使用feign实现容错)

1.17流量监控和熔断降级作用？

reidis哨兵模式中的哨兵，用sh来监控redis master节点，通过·心跳模式来监控master节点是否还活着，如果master挂掉了，选举slaver节点为master

随着微服务的流行，服务和服务之间的稳定性变得越来越重要。Sentinel以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。

1.18sleuth是什么，什么作用?

Sleuth是一个分布式链路追踪框架，能够记录每一个请求响应的时间，并且改请求调用的其他方法的响应时间也会有记录的，并且可以把请求调用的方法的依赖关系显示出来。

1.19.Zipkin是什么?

Zipkin是一个分布式跟踪系统，用来数据的收集和查找，通俗的说就是Zipkin可以接收sleuth产生的数据，通过可视化的方式显示出来，以及依赖关系也可以显示出来。

1.20.Gateway是什么?

gateway是一个微服务网关，就相当于过滤器拦截器的作用

功能:拦截过滤鉴权，还有动态路由，负载均衡，限流等

浏览器发送的一个请求，不会直接去请求消费者，而是让网关gateway来分发路径，决定去那个消费者，然后消费者服务器再去请求服务提供者，另外一方面就是可以作为拦截器、过滤器来对请求进行过滤鉴权。

网关是独立的应用，不可以和springboot-starter-web一起使用，需要通过一个配置类才可以远程调用cache

1.21.Spring Cloud和dubbo之间的区别?

( 1) dubbo是基于RPC进行通信的，Spring Cloud是通过使用Feign来完成Rest接口来实现通信的

(2) dubbo使用的二进制传输，占用带宽少一些 Spring Cloud使用的http协议传输，占用带宽多一些。

(3) dubbo中使用zk作为服务注册中心，Spring Cloud使用的nacos或者Eurake作为注册中心来完成(服务的健康监测、动态的DNS配置服务、动态的配置中心、存储元数据管理)

1.22gateway网关路由匹配规则

核心概念

路由(Route): 路由是网关最基础的部分，路由信息由ID、目标URI、一组断言和一组过滤器组成，如果断言路由为真，则说明请求的URI和配置匹配。
断言(Predicate): java8中的断言函数。SpringCloud Gateway中的断言函数输入类型是spring5.0框架中的ServerWebExchage。SpringCloud Gateway中的断言函数允许开发者去定义匹配来自于Http Request中的任何信息，比如请求头和参数等。
过滤器(Filter): 一个标准的Spring Web Filter。 Spring Cloud GateWay 中的Filter分为两种类型，分别是Gateway Filter和Global Filter。过滤器将会对请求和响应进行处理。

配置路由规则

1.path路由匹配规则

spring:
  application:
    name: gateway-server
  cloud:
    gateway:
      # 路由规则
       routes:
          - id: product-service   # 路由ID,唯一，一般为各个服务名称
           uri: http://localhost:7070/ #目标URI,路由到微服务的地址
           predicates:
              - Path=/product/**  # 匹配对应的URL请求，将匹配到的请求追加在目标 URI 之后

2.query路由匹配规则

spring:
  application:
    name: gateway-server
  cloud:
    gateway:
      # 路由规则
       routes:
          - id: product-service   # 路由ID,唯一，一般为各个服务名称
           uri: http://localhost:7070/ #目标URI,路由到微服务的地址
           predicates:
              #- Query=token # 匹配请求参数中包含 token 的请求
              - Query=token, abc. # 匹配请求参数中包含 token 并且参数值满足正则表达式 abc.(abc开头，后面匹配任意字符) 的请求

3. method路由匹配规则

spring:
  application:
    name: gateway-server
  cloud:
    gateway:
      # 路由规则
       routes:
          - id: product-service   # 路由ID,唯一，一般为各个服务名称
           uri: http://localhost:7070/ #目标URI,路由到微服务的地址
           predicates:
              - Method=GET  # 匹配任意 GET 请求

4. Datetime路由匹配规则

spring:
  application:
    name: gateway-server
  cloud:
    gateway:
      # 路由规则
       routes:
          - id: product-service   # 路由ID,唯一，一般为各个服务名称
           uri: http://localhost:7070/ #目标URI,路由到微服务的地址
           predicates:
            # 匹配中国上海时间 2021-02-02 20:20:20 之后的请求
              - After=2021-02-02T20:20:20.000+08:00[Asia/Shanghai]
            #- Before 在某某时间之前的请求 -Between 介于某某时间之间

5. RemoteAddr路由匹配规则

spring:
  application:
    name: gateway-server
  cloud:
    gateway:
      # 路由规则
       routes:
          - id: product-service   # 路由ID,唯一，一般为各个服务名称
           uri: http://localhost:7070/ #目标URI,路由到微服务的地址
           predicates:
            # 匹配远程地址请求RemoteAddr的请求，0表示子网掩码
              - RemoteAddr=192.168.10.1/0

6.Header路由匹配规则

spring:
  application:
    name: gateway-server
  cloud:
    gateway:
      # 路由规则
       routes:
          - id: product-service   # 路由ID,唯一，一般为各个服务名称
           uri: http://localhost:7070/ #目标URI,路由到微服务的地址
           predicates:
            # 匹配请求头包含X-Request-Id 并且其值匹配正则表达式 \d+(匹配任意数字) 的请求
              - Header=X-Request-Id, \d+

Spring

1.1什么是spring？

Spring是一个轻量级的控制反转和面向切面的容器框架，用来解决企业项目开发的复杂度问题—解耦

• 控制反转：IoC（Inverse of Control）,把创建对象的工作交由Spring完成，Spring在创建对象的时候同时可以完成对象属性赋值（DI）
• 面向切面：AOP（Aspect Oriented Programming）面向切面编程，可以在不改变原有业务逻辑的情况下实现对业务的增强

1.2Spring由哪些模块组成？

spring core：提供了框架的基本组成部分，包括控制反转（Inversion of Control，IOC）和依赖注入（Dependency Injection，DI）功能。

spring beans：提供了BeanFactory，是工厂模式的一个经典实现，Spring将管理对象称为Bean。

spring context：构建于 core 封装包基础上的 context 封装包，提供了一种框架式的对象访问方法。

spring jdbc：提供了一个JDBC的抽象层，消除了烦琐的JDBC编码和数据库厂商特有的错误代码解析， 用于简化JDBC。

spring aop：提供了面向切面的编程实现，让你可以自定义拦截器、切点等。

spring Web：提供了针对 Web 开发的集成特性，例如文件上传，利用 servlet listeners 进行 ioc 容器初始化和针对 Web 的 ApplicationContext。

spring test：主要为测试提供支持的，支持使用JUnit或TestNG对Spring组件进行单元测试和集成测试。

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

工厂模式：BeanFactory就是简单工厂模式的体现，用来创建对象的实例；

单例模式：Bean默认为单例模式。

代理模式：Spring的AOP功能用到了JDK的动态代理和CGLIB字节码生成技术；

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

观察者模式：定义对象键一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知被制动更新，如Spring中listener的实现–ApplicationListener。

1.4.Spring 中 beanFactory 和 ApplicationContext 的联系和区别?

BeanFactory 是 spring 中较为原始的 Factory，无法支持 spring 的许多插件，如 AOP 功能、

Web 应用等。

ApplicationContext 接口是通过 BeanFactory 接口派生而来的，除了具备 BeanFactory 接口的

功能外，还具备资源访问、事件传播、国际化消息访问等功能。

总体区别如下：

1）使用 ApplicationContext，配置 bean 默认配置是 singleton，无论是否使用，都会被实例化。

优点是预先加载，缺点是浪费内存；

2）使用 BeanFactory 实例化对象时，配置的 bean 等到使用的时候才会被实例化。优点是节

约内存，缺点是速度比较慢，多用于移动设备的开发；

3）没有特殊要求的情况下，应该使用 ApplicationContext 完成，ApplicationContext 可以实现

BeanFactory 所有可实现的功能，还具备其他更多的功能。

1.5Spring IoC注入的几种方式

构造器注入

set 方法注入

接口注入

1.6SpringIOC 是什么?

控制反转：理论思想，原来的对象是由使用者来进行控制，有了spring之后，可以把整个对象交给spring来帮我们进行管理

DI：依赖注入，把对应的属性的值注入到具体的对象中，@Autowired，populateBean完成属性值的注入

容器：存储对象，使用map结构来存储，在spring中一般存在三级缓存，singletonObjects存放完整的bean对象,

整个bean的生命周期，从创建到使用到销毁的过程全部都是由容器来管理（bean的生命周期）

SpringIOC的应用场景

正常情况下我们使用一个对象时都是需要new Object() 的。而ioc是把需要使用的对象提前创建好，放到spring的容器里面。需要使用的时候直接使用就行，而且可以设置单例或多例，非常灵活。

1.7什么是Spring beans？

Spring Beans 的理解

Spring Beans 是被实例的，组装的及被 Spring 容器管理的 Java 对象；

Spring Beans 会被 Spring 容器自动完成 @bean 对象的实例化 ；

Spring 框架定义的 Beans 都是默认为单例，也可以配置为多例。

1.8.Spring bean 的生命周期？

SpringBean的生命周期

在表述的时候不要只说图中有的关键点，要学会扩展描述

1、实例化bean：反射的方式生成对象

2、填充bean的属性：populateBean(),循环依赖的问题（三级缓存）

3、调用aware接口相关的方法：invokeAwareMethod(完成BeanName,BeanFactory,BeanClassLoader对象的属性设置)

4、调用BeanPostProcessor中的前置处理方法：使用比较多的有（ApplicationContextPostProcessor,设置

ApplicationContext,Environment,ResourceLoader,EmbeddValueResolver等对象)

5、调用initmethod方法：invokelnitmethod(),判断是否实现了initializingBean接口，如果有，调用afterPropertiesSet方法，没有就不调用

6、调用BeanPostProcessor的后置处理方法：spring的aop就是在此处实现的，AbstractAutoProxyCreator

注册Destuction相关的回调接口

7、获取到完整的对象，可以通过getBean的方式来进行对象的获取

8、销毁流程，1；判断是否实现了DispoableBean接口，2，调用destroyMethod方法

1.9什么是bean的自动装配？

就是将一个 Bean 注入到其它的 Bean 的 Property 中，默认情况下，容器不会自动装配，需

要我们手动设定。Spring 可以通过向 Bean Factory 中注入的方式来搞定 bean 之间的依赖关

系，达到自动装配的目的。

1.10自动装配有哪些局限性？

自动装配的局限性是：

重写：你仍需用 和 配置来定义依赖，意味着总要重写自动装配。

基本数据类型：你不能自动装配简单的属性，如基本数据类型，String字符串，和类。

模糊特性：自动装配不如显式装配精确，如果有可能，建议使用显式装配。

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

no：默认的方式是不进行自动装配的，通过手工设置ref属性来进行装配bean。

byName：通过bean的名称进行自动装配，如果一个bean的 property 与另一bean 的name 相同，就进行自动装配。

byType：通过参数的数据类型进行自动装配。

constructor：利用构造函数进行装配，并且构造函数的参数通过byType进行装配。

autodetect：自动探测，如果有构造方法，通过 construct的方式自动装配，否则使用 byType的方式自动装配。

1.12spring各个注解的作用？

@Component：这将 java 类标记为 bean。它是任何 Spring 管理组件的通用构造类型。spring 的组件扫描机制现在可以将其拾取并将其拉入应用程序环境中。

@Controller：这将一个类标记为 Spring Web MVC 控制器。标有它的 Bean 会自动导入到 IoC 容器中。

@Service：用于标注业务层组件。标有它的 Bean 会自动导入到 IoC 容器中。

@Repository：这个注解是具有类似用途和功能的 @Component 注解的特化。它为 DAO 提供了额外的好处。它将 DAO 导入 IoC 容器，并使未经检查的异常有资格转换为 Spring DataAccessException。

@RequestMapping 注解用于将特定 HTTP 请求方法映射到将处理相应请求的控制器中的特定类/方法。

@Autowired默认是按照类型装配注入的，默认情况下它要求依赖对象必须存在

@Qualifier 使用 @Autowired 注解，以避免在存在多个 bean 类型实例时出现混淆。

@ResponseBody - 用于发送 Object 作为响应，通常用于发送 XML 或 JSON 数据作为响应。

1.13Spring支持的事务管理类型

Spring支持两种类型的事务管理：

编程式事务管理：这意味你通过编程的方式管理事务，给你带来极大的灵活性，但是难维护。

声明式事务管理：这意味着你可以将业务代码和事务管理分离，你只需用注解和XML配置来管理事务

1.14Spring的事务传播行为

① PROPAGATION_REQUIRED：如果当前没有事务，就创建一个新事务，如果当前存在事务，就加入该事务，该设置是最常用的设置。

② PROPAGATION_SUPPORTS：支持当前事务，如果当前存在事务，就加入该事务，如果当前不存在事务，就以非事务执行。

③ PROPAGATION_MANDATORY：支持当前事务，如果当前存在事务，就加入该事务，如果当前不存在事务，就抛出异常。

④ PROPAGATION_REQUIRES_NEW：创建新事务，无论当前存不存在事务，都创建新事务。

⑤ PROPAGATION_NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

⑥ PROPAGATION_NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。

⑦ PROPAGATION_NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则按REQUIRED属性执行。

1.15spring 的事务隔离级别？

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

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

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

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

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

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

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

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

spring事务是如何回滚的

总：spring的事务是由aop来实现的，首先要生成具体的代理对象，然后按照aop的整套流程来执行具体的操作逻辑，正常情况下要通过通知来完成核心功能，但是事务不是通过通知来实现的，而是通过一个TransactionInterceptor来实现的，然后调用invoke来实现具体的逻辑

分：1、先做准备工作，解析各个方法上事务相关的属性，根据具体的属性来判断是否开始新事务

2、当需要开启的时候，获取数据库连接，关闭自动提交功能，开起事务

3、执行具体的sqI逻辑操作

4、在操作过程中，如果执行失败了，那么会通过completeTransactionAfterThrowing看来完成事务的回滚操作，回滚的具体逻辑是通过doRollBack方法来实现的，实现的时候也是要先获取连接对象，通过连接对象来回滚

5、如果执行过程中，没有任何意外情况的发生，那么通过commitTransactionAfterReturning来完成事务的提交操作，提交的具体逻辑是通过doCommit方法来实现的，实现的时候也是要获取连接，通过连接对象来提交

6、当事务执行完毕之后需要清除相关的事务信息cleanupTransactionInfo

1、事务失效的7种情况

1. 未启用spring事务管理功能
2. 方法不是public类型的
3. 数据源未配置事务管理器
4. 自身调用问题
5. 异常类型错误
6. 异常被吞了
7. 业务和spring事务代码必须在一个线程中

1.16Spring AOP是什么？

aop就是ioc的一个扩展的一个功能，先有ioc，再有aop，而aop只是在ioc整个流程的过程中新增的一个扩展点而已，bean创建的过程中，有一个步骤可以对bean进行扩展实现，所以就是在BeanPostProcessor的后置处理方法中进行实现的。

Spring AOP使用的动态代理，所谓的动态代理就是说AOP再不去修改源代码的情况下，而是在内存中临时为方法生成一个AOP对象，这个AOP对象包含了目标对象的全部方法，并且在特定的切点做了增强处理，并回调给原对象的方法。它的动态代理主要有两种方式，JDK动态代理和CGLIB动态代理。JDK动态代理通过反射来接收被代理的类，并且要求被代理的类必须实现一个接口。JDK动态代理的核心是InvocationHandler接口和Proxy类。如果目标类没有实现接口，那么Spring AOP会选择使用CGLIB来动态代理目标类。CGLIB是一个代码生成的类库，可以在运行时动态的生成某个类的子类，

Spring AOP的应用场景

1.比方说我现在要弄一个日志，记录某些个接口调用的方法时间。使用Aop我可以在这个接口前插入一段代码去记录开始时间，在这个接口后面去插入一段代码记录结束时间。

2.又或者你去访问数据库，而你不想管事务（太烦），所以，Spring在你访问数据库之前，自动帮你开启事务，当你访问数据库结束之后，自动帮你提交/回滚事务！

3.异常处理你可以开启环绕通知，一旦运行接口报错，环绕通知捕获异常跳转异常处理页面。

1.17Spring 和 Struts 的区别？

Spring：

具备 IOC/DI、AOP 等通用能力，提高研发效率 ；

除了支持 Web 层建设以外，还提供了 J2EE 整体服务 ；

方便与其他不同技术结合使用，例如：Hibernate，Mybatis 等 ；

Spring 拦截机制是方法级别 。

Struts：

是一个基于 MVC 模式的一个 Web 层的处理器；

Struts 拦截机制是类级别。

什么是Aspect 切面？

AOP 核心就是切面，它将多个类的通用行为封装成可重用的模块，该模块含有 一组 API 提供横切功能。比如，一个日志模块可以被称作日志的 AOP 切面。 根据需求的不同，一个应用程序可以有若干切面。在 Spring AOP 中，切面通过带有 @Aspect 注解的类实现。

spring异常处理的三种方式

1. 异常处理方式一. @ExceptionHandler
2. 异常处理方式二. 实现HandlerExceptionResolver接口
3. 异常处理方式三. @ControllerAdvice+@ExceptionHandler

spring的运行原理

Spring 启动时读取应用程序提供的 Bean 配置信息，并在 Spring 容器中生成一份相应的Bean 配置注册表，然后根据这张注册表实例化 Bean ，装配好 Bean 之间的依赖关系，为上 层应用提供准备就绪的运行环境。

1.读取Bean的配置信息（xml中的<bean>，java类中有@Configuration，通过注解@Autowrite）

2.将读取到的Bean的配置信息放入Spring配置的容器中的Bean定义的注册表，通过注册表将Bean实例化到Bean的实现类中，形成依赖注入

3.再将Bean实例放入Spring容器中的Bean的缓存池

4.如果需要，就从SpringIOC中的缓存池中取出

SpringMVC

1.1什么是Spring MVC？

Spring MVC 是由Spring官方提供的基于MVC设计理念的web框架。

SpringMVC是基于Servlet封装的用于实现MVC控制的框架，实现前端和服务端的交互。

SpringMVC的主要作用就是代替了servlet

1.2Spring MVC的优点

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

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

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

（4） 支持各种请求资源的映射策略。

1.3Spring 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.4SpringMVC的工作原理

第一步：发起请求到前端控制器(DispatcherServlet)

第二步：前端控制器请求HandlerMapping查找 Handler可以根据xml配置、注解进行查找

第三步：处理器映射器HandlerMapping向前端控制器返回Handler

第四步：前端控制器调用处理器适配器去执行Handler

第五步：处理器适配器去执行Handler

第六步：Handler执行完成给适配器返回ModelAndView

第七步：处理器适配器向前端控制器返回ModelAndView

ModelAndView是springmvc框架的一个底层对象，包括Model和view

第八步：前端控制器请求视图解析器去进行视图解析

根据逻辑视图名解析成真正的视图(jsp)

第九步：视图解析器向前端控制器返回View

第十步：前端控制器进行视图渲染 视图渲染将模型数据(在ModelAndView对象中)填充到request域

第十一步：前端控制器向用户响应结果

1.5Spring MVC常用的注解有哪些？

@RequestMapping：处理请求地址映射的注解，可用于类或方法上。

@PathVariable：绑定 URI 模板变量值是用来获得请求 url 中的动态参数。

@RequestParam：用于将指定的请求参数赋值给方法中的形参。

@RequestBody：读取 Request 请求的 body 部分数据。

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

Spring MVC的异常处理？

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

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

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

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

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

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

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

如果前台有很多个参数传入,并且这些参数都是一个对象的,那么怎么样快速得到这个对象？

答：直接在方法中声明这个对象,Spring MVC就自动会把属性赋值到这个对象里面。

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

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

Spring MVC用什么对象从后台向前台传递数据的？

答：通过ModelMap对象,可以在这个对象里面调用put方法,把对象加到里面,前台就可以通过el表达式拿到。

怎么样把ModelMap里面的数据放入Session里面？

答：可以在类上面加上@SessionAttributes注解,里面包含的字符串就是要放入session里面的key。

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

有两种写法,一种是实现HandlerInterceptor接口，另外一种是继承适配器类，接着在接口方法当中，实现处理逻辑；然后在Spring MVC的配置文件中配置拦截器即可：

SpringBoot

1.1什么是 Spring Boot？

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

1.2Spring Boot 有哪些优点？

Spring Boot 主要有如下优点：

1. 容易上手，提升开发效率，为 Spring 开发提供一个更快、更广泛的入门体验。
2. 开箱即用，远离繁琐的配置。
3. 提供了一系列大型项目通用的非业务性功能，例如：内嵌服务器、安全管理、运行数据监控、运行状况检查和外部化配置等。
4. 没有代码生成，也不需要XML配置。
5. 避免大量的 Maven 导入和各种版本冲突。

1.3Spring Boot 的核心注解是哪个？

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

@SpringBootConfiguration：组合了 @Configuration 注解，实现配置文件的功能。

@EnableAutoConfiguration：打开自动配置的功能，也可以关闭某个自动配置的选项，如关闭数据源自动配置功能： @SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })。

@ComponentScan：Spring组件扫描。

8、@Scope

指定bean的作用域，默认singleton，其它包括prototype、request、session、globalSession

9、@Lazy

使bean懒加载，取消bean预初始化。

10、@Primary

自动装配时当出现多个Bean候选者时，被注解为@Primary的Bean将作为首选者，否者将抛出异常。

11、@Profile

指定Bean在哪个环境下被激活

12、@DependsOn

依赖的bean注册完成，才注册当前类，依赖bean不存在会报错。用于控制bean加载顺序

13、@PostConstruct

bean的属性都注入完毕后，执行注解标注的方式进行初始化工作

14、@Autowired

默认按类型装配，如果我们想使用按名称装配，可以结合@Qualifier注解一起使用。

15、@Lookup

根据方法返回的类型，去容器中捞出对应

16、@Qualifier

申明bean名字，且可以按bean名字加载bean

1.4Spring Boot 自动配置原理是什么？

1.首先在@SpringBootApplication中有一个注解@EnableAutoConfiguration，翻译成人话就是开启自动配置

2.而@EnableAutoConfiguration这个注解中有个导入的注解导入了AutoConfigurationImportSelector.class 这个类

3.这个类中调用了 selectImports（）方法，这个方法里面调用了一个getCandidateConfigurations方法，就是用来获取 META-INF/spring.factories中配置文件中的需要自动装配的类名，这些类基本都是被@Configuration注解的

1.5什么是 YAML？

YAML 是一种人类可读的数据序列化语言。它通常用于配置文件。与属性文件相比，如果我们想要在配置文件中添加复杂的属性，YAML 文件就更加结构化，而且更少混淆。可以看出 YAML 具有分层配置数据。

1.6YAML 配置的优势在哪里 ?

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

1.配置有序，在一些特殊的场景下，配置有序很关键

2.支持数组，数组中的元素可以是基本数据类型也可以是对象

3.简洁

1.7Spring Boot Starter 理解

首先它提供了一个自动化配置类，一般命名为 XXXAutoConfiguration ，在这个配置类中通过条件注解来决定一个配置是否生效（条件注解就是 Spring 中原本就有的），然后它还会提供一系列的默认配置，也允许开发者根据实际情况自定义相关配置，然后通过类型安全的属性注入将这些配置属性注入进来，新注入的属性会代替掉默认属性。

1.8运行 Spring Boot 有哪几种方式？

1）打包用命令或者放到容器中运行

2）用 Maven/ Gradle 插件运行

3）直接执行 main 方法运行

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

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

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

1）继承spring-boot-starter-parent项目

2）导入spring-boot-dependencies项目依赖

1.11如何使用 Spring Boot 实现异常处理？

Spring 提供了一种使用 ControllerAdvice 处理异常的非常有用的方法。 我们通过实现一个 ControlerAdvice 类，来处理控制器类抛出的所有异常。

1.12如何使用 Spring Boot 实现分页和排序？

使用 Spring Boot 实现分页非常简单。使用 Spring Data-JPA 可以实现将可分页的传递给存储库方法。

1.13微服务中如何实现 session 共享 ?

在微服务中，一个完整的项目被拆分成多个不相同的独立的服务，各个服务独立部署在不同的服务器上，各自的 session 被从物理空间上隔离开了，但是经常，我们需要在不同微服务之间共享 session ，常见的方案就是 Spring Session + Redis 来实现 session 共享。将所有微服务的 session 统一保存在 Redis 上，当各个微服务对 session 有相关的读写操作时，都去操作 Redis 上的 session 。这样就实现了 session 共享，Spring Session 基于 Spring 中的代理过滤器实现，使得 session 的同步操作对开发人员而言是透明的，非常简便。

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

定时任务也是一个常见的需求，Spring Boot 中对于定时任务的支持主要还是来自 Spring 框架。

在 Spring Boot 中使用定时任务主要有两种不同的方式，一个就是使用 Spring 中的 @Scheduled 注解，另一个则是使用第三方框架 Quartz。

使用 Spring 中的 @Scheduled 的方式主要通过 @Scheduled 注解来实现。

使用 Quartz ，则按照 Quartz 的方式，定义 Job 和 Trigger 即可。

1.15 spring和springboot的区别 

Spring框架为开发Java应用程序提供了全面的基础架构支持。它包含一些很好的功能，如依赖注入和开箱即用的模块而Spring Boot基本上是Spring框架的扩展，它消除了设置Spring应用程序所需的XML配置，为更快，更高效的开发生态系统铺平了道路 


















 

Mybatis

1.0 ORM是什么

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

1.1什么是 Mybatis？

MyBatis 是一个优秀的持久层框架，是一个半 ORM（对象关系映射）框架，它对 jdbc 的操作数据库的过程进行封装，使开发者只需要关注 SQL 本身，而不需要花费精力去处理例如加载驱动、创建连接、创建 statement 等繁杂的过程。

Mybatis 通过 xml 或注解的方式将要执行的 statement 配置起来，并通过 java 对象和 statement 中的 sql 进行映射生成最终执行的 sql 语句，最后由 mybatis 框架执行 sql 并将结果映射成 java 对象并返回。

1.2Mybatis 的优点与缺点？

优点：

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

2.与 JDBC 相比，减少了 JDBC 大量冗余的代码，不需要手动开关连接。

3.很好的与各种数据库兼容。

4.能够与 Spring 很好的集成。

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

缺点：

1.SQL 语句的编写工作量较大，尤其当字段多、关联表多时，对开发人员编写 SQL 语句的功底有一定要求。

2.SQL 语句依赖于数据库，导致数据库移植性差，不能随意更换数据库。

1.3#{} 和 ${} 的区别是什么？

• ${key} 表示获取参数，先获取参数的值拼接到SQL语句中，再编译执行SQL语句;可能引起SQL注入问题
• #{key} 表示获取参数，先完成SQL编译(预编译)，预编译之后再将获取的参数设置到SQL与中 ，可以避免SQL注入问题

1.4Mybatis 的一级、二级缓存？

一级缓存：Mybatis 的一级缓存是指 SQLSession，一级缓存的作用域是 SQlSession，Mabits 默认开启一级缓存。在同一个 sqlSession 中两次执行相同的 sql 语句，第一次执行完毕会将数据库中查询的数据写到缓存（内存），第二次会从缓存中获取数据将不再从数据库查询，从而提高查询效率。当一个 sqlSession 结束后该 sqlSession 中的一级缓存也就不存在了。

1：一级缓存是默认开启的；

2：底层其实是基于 hashmap 的本地内存缓存；

3：作用域是 session（其实就相当于一个方法）；

4：当 session 关闭或者刷新的时候缓存清空；

5：不同 sqlsession 之间缓存互不影响。

二级缓存： 二级缓存是 mapper 级别的，Mybatis 默认是没有开启二级缓存的。多个 SqlSession 去操作同一个 Mapper 的 sql 语句，多个 SqlSession 去操作数据库得到数据会存在二级缓存区域，多个 SqlSession 可以共用二级缓存，二级缓存是多个 SqlSession 共享的。

1：首先 mybatis 默认是没有开启二级缓存的；

2：二级缓存需要我们手动开启，它是 mapper 级别的缓存；

3：同一个 namespace 下的所有操作语句，都影响着同一个 Cache，即二级缓存被多个 SqlSession 共享，是一个全局的变量。

1.5 MyBatis 的 mapper 接口调用哪些要求？

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

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

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

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

1.6Mybatis 是如何防止 SQL 注入的？

MyBatis 启用了预编译功能，在 SQL 执行前，会先将上面的 SQL 发送给数据库进行编译；执行时，直接使用编译好的 SQL，替换占位符 “?” 就可以了。因为 SQL 注入只能对编译过程起作用，所以这样的方式就很好地避免了 SQL 注入的问题。

1.7Mybatis实现多参数的处理

1.使用注解@Param

2.封装类，使用对象

3.使用Map集合，键值对

4.默认参数名称: arg0 arg1

1.8MyBatis的工作原理

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 接口来操作数据库，它将根据 SqlSession 传递的参数动态地生成需要执行的 SQL 语句，同时负责查询缓存的维护。

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

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

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

1.9MyBatis三层架构

API接口层：提供给外部使用的接口API，开发人员通过这些本地API来操纵数据库。接口层一接收到调用请求就会调用数据处理层来完成具体的数据处理。

数据处理层：负责具体的SQL查找、SQL解析、SQL执行和执行结果映射处理等。它主要的目的是根据调用的请求完成一次数据库操作。

基础支撑层：负责最基础的功能支撑，包括连接管理、事务管理、配置加载和缓存处理，这些都是共用的东西，将他们抽取出来作为最基础的组件。为上层的数据处理层提供最基础的支撑。

1.10分页插件PageHelper

PageHelper只支持Mybatis框架的使用，使用的前提是添加正确的依赖和配置文件的正确配置，

查询数据库时只需要查询需要分页的所有数据（findAll）,分页的sql不需要自己写，PageHelper会

自动根据配置文件中参数的数据类型生成对应的分页sql语句，在Service中需要使用PageHelper.startPage((参数1)当前页，(参数2))方法即可，其他分页所需要的数据例如数据库表中的数据、数据总数、总页数等PageHelper会自动保存。

1.11mybatis的延迟加载（懒加载）

延迟加载—如果在MyBatis开启了延迟加载，在执行了子查询（至少查询两次及以上）时，默认只执行第一次查询，当用到子查询的查询结果时，才会触发子查询的执行；如果无需使用子查询结果，则子查询不会执行.

1.12Mybatis的设计模式

1. Builder模式 :例如 SqlSessionFactoryBuilder、XMLConfigBuilder、XMLMapperBuilder、XMLStatementBuilder、CacheBuilder；
2. 工厂模式 :例如SqlSessionFactory、ObjectFactory、MapperProxyFactory；
3. 单例模式 :例如ErrorContext和LogFactory；
4. 代理模式 :Mybatis实现的核心，比如MapperProxy、ConnectionLogger，用的jdk的动态代理；还有executor.loader包使用了cglib或者javassist达到延迟加载的效果；
5. 组合模式 :例如SqlNode和各个子类ChooseSqlNode等；
6. 模板方法模式 : 例如BaseExecutor和SimpleExecutor，还有BaseTypeHandler和所有的子类例如IntegerTypeHandler；
7. 适配器模式 : 例如Log的Mybatis接口和它对jdbc、log4j等各种日志框架的适配实现；
8. 装饰者模式 : 例如cache包中的cache.decorators子包中等各个装饰者的实现；
9. 迭代器模式 : 例如迭代器模式PropertyTokenizer；

1.16什么是动态sql

Mybatis的动态sql的作用：

动态sql就是（在进行sql操作的时候）动态的根据属性值（所匹配的条件）来拼接数据库执行的sql语句，也就是多次查询或变更操作，根据传入的属性值不同，动态拼接出不同的可执行sql。包含判断为空、循环等；

Mybatis动态sql（有哪些）标签：

1、<if>:

if是为了判断传入的值是否符合某种规则，比如是否不为空；

2、<where>:

where标签可以用来做动态拼接查询条件，当和if标签配合的时候，不用显示的声明类似where 1=1这种无用的条件；

3、<choose><when><otherwise>:

这是一组组合标签，他们的作用类似于 Java 中的 switch、case、default。只有一个条件生效，也就是只执行满足的条件 when，没有满足的条件就执行 otherwise，表示默认条件；

4、<foreach>:

foreach标签可以把传入的集合对象进行遍历，然后把每一项的内容作为参数传到sql语句中，里面涉及到 item(具体的每一个对象), index(序号), open(开始符), close(结束符), separator(分隔符)；

5、<include>:

include可以把大量重复的代码整理起来，当使用的时候直接include即可，减少重复代码的编写；

6、<set>:

适用于更新中，当匹配某个条件后，才会对该字段进行更新操作

7、<trim>:

是一个格式化标签，主要有4个参数:

prefix(前缀)；

prefixOverrides(去掉第一个标记)；

suffix(后缀)；

suffixOverrides(去掉最后一个标记)；

动态sql的执行原理：

第一部分：在启动加载解析xml配置文件的时候进行解析，根据关键标签封装成对应的handler处理对象，封装成sqlSource对象存在mappedStatement。

调用流程：

I、SqlSessionFactoryBuilder对builder对象的时候，调用XMLConfigBuilder解析sqlMapConfig.xml配置文件，在解析过程中使用到了私有的mapperElement(XNode parent)方法

II、上面方法中通过构建XMLMapperBuilder,获取到所有的配置mapper配置，

在调用private void configurationElement(XNode context)方法进行解析mapper.xml,通过void buildStatementFromContext(List<XNode> list, String requiredDatabaseId)方法解析mapper.xml内的每一个标签

III、循环中构建XMLStatementBuilder对象，调用parseStatementNode()方法来封装mappedStatment对象，

IIII、在过程中需要构建sqlSource对象，通过XMLLanguageDriver对象进行处理，在XMLLanguageDriver中构建解析动态标签对象XMLScriptBuilder

第二部分：在执行过程中获取sqlSource中获取bondSql对象时，执行相应的标签handler

调用查询执行到BaseExecutor的query方法时候会去getBoundSql并且将参数传进去，

在sqlSource接口DynamicSqlSource实现类中，调用getBoundSql方法执行过程共创建DynamicContext对象进行判定解析封装成SqlSource对象返回。

Mybatis与Dao的连接方式

映射文件中的mapper标签的namespace属性与 mapper 接口的全限定名相同

映射文件中的每条映射语句中id的属性值与 mapper 接口中方法名相同

映射文件中的每条映射语句的parameterType属性与 mapper 接口中方法的形参相同

映射文件中的每条映射语句的resultType属性与 mapper 接口中方法的返回值类型相同

Restful风格的请求

分为POST、DELETE、PUT、GET四种方法，使用不同方法对资源进行操作（增、删、改、查）

http://127.0.0.1/item/1 （查询,GET）GET请求没有 @RequestBody

http://127.0.0.1/item （新增,POST）POST请求不能用@RequestParam（不安全）只能用@PathVariable

http://127.0.0.1/item （更新,PUT）

http://127.0.0.1/item/1 （删除,DELETE）

@PathVariable在路径后添加{value}

@RequestParam