Java面试框架

Dear 丶 2024-03-16 18:07 29阅读 0赞

#### Java面试框架-Spring、SpringMVC、SpringBoot、Mybatis ####

*  Spring
 *   *  Spring的两大核心技术是什么
     *  简单描述下IOC和AOP的理解
     *  AOP能解决那些问题
     *  AOP是如何实现的
     *  简述Spring中几种常用的Advice注解
     *  @Autowired 和 @Resource 的区别
     *  CGLIB代理和JDK代理的区别
     *  Spring如何解决循环依赖问题
     *  事务注解以及作用
     *  事务的四大特性
     *  Spring事务
     *  Spring（SpringBoot）常用的注解有哪些，有什么作用
     *   *  声明bean的注解
         *  注入Bean的注解
         *  Java配置类的相关注解
         *  切面编程（AOP）相关注解
         *  测试相关注解
     *  依赖注入的三种方式
     *  Spring中Bean的作用域
     *  Spring、SpringMVC、SpringBoot、SpringCloud的区别是什么
 *  SpringBoot
 *   *  SpringBoot 自动配置原理
 *  SpringMVC
 *   *  MVC的设计理念
     *  SpringMVC的处理流程
     *  Spring MVC 常用注解
     *  如何处理get请求
 *  MyBatis
 *   *  MyBatis \#\{\}和$\{\}的区别
     *  MyBatis的一级缓存二级缓存
     *  Mybatis如何不走一级缓存
     *  简述Mybatis的单个参数，多个参数如何声明
     *  Mybatis 如何完成批量操作，请举例说明
     *  Mybatis缓存优先级
     *  Mybatis 和 Mybatis plus的区别
     *  Mybatis如何实现分页
     *  写过原生的分页吗，用过什么插件，分页插件的原理
     *  你知道Mybatis延迟加载吗
     *  JDBC 跟 Mybatis 的区别（JDBC 为什么比 Mybatis 效率快）
     *  resultType与resultMap有什么区别
 *  微服务框架
 *   *  nacos
     *  dubbo
     *  sentinel
     *  seata
     *  gateway

## Spring ##

### Spring的两大核心技术是什么 ###

*  IOC
 *  AOP

### 简单描述下IOC和AOP的理解 ###

*  IOC：控制反转，是Spring的一个容器，帮助我们创建对象，不需要我们手动的去创建，它有一个强大的功能依赖注入（DI），通过依赖注入更好的去管理Bean，达到解耦的目的
 *  AOP：面向切面编程，是面向对象编程的一种补充，将一些共性的内容抽取出来，在需要用到的地方，以动态代理的方式插入，在不修改源码的基础上，对我们已有的方法进行增强，常见场景有安全、日志、审计、事务等

### AOP能解决那些问题 ###

AOP面向切面编程，是面向对象编程的一种补充，将一些共有的内容抽取出来，在需要用到的地方，以动态代理的方式插入，在不修改源码的基础上，对我们已有的方法进行增强，常见的场景有安全、日志、审计、事务等

### AOP是如何实现的 ###

Spring的AOP的实现原理很简单，是通过动态代理来实现的

### 简述Spring中几种常用的Advice注解 ###

*  @Before(execution) 在方法执行之前拦截
 *  @AfterReturning(execution) 在方法正常return结束后拦截
 *  @AfterThrowing(execution) 在方法抛出异常时拦截
 *  @After(execution) 在方法结束后拦截，无论正常结束还是异常结束
 *  @Around(execution) 是唯一可以使用ProceedingJoinPoint参数来控制流程的advice，在方法执行之前拦截，可以在切面编程中手动释放拦截，且可以在其后加入逻辑代码，该代码段会在方法执行之后执行

### @Autowired 和 @Resource 的区别 ###

*  @Autowired 是Spring框架的，默认使用类型byType注入，类型注入失败，再按照名字byName注入
 *  @Resource 是Java注解，默认使用名字byName注入，名字注入失败，再按照类型byType注入
 *  @Autowired的作用相当于@Resource，@Autowired首先类型byType注入，@Resource首先名字byName注入

### CGLIB代理和JDK代理的区别 ###

*  JDK代理只能对实现接口的类生成代理，JDK代理使用反射机制实现AOP动态代理
 *  CGLIB是针对类的实现代理，对指定的类生成一个子类，覆盖其中的方法，这种通过继承类的实现方式，CGLIB使用字节码处理框架ASM，通过修改字节码生成子类

### Spring如何解决循环依赖问题 ###

Spring本身也考虑到了这方面的问题，所以它设计了三级缓存来解决部分循环依赖的问题。

所谓三级缓存，其实就是用来存放不同类型的Bean。

第一级缓存：存放完全初始化好的Bean，这个Bean可以直接使用了  
第二级缓存：存放原始的Bean对象，也就是说Bean里面的属性还没有进行赋值  
第三级缓存：存放Bean工厂对象，用来生成原始Bean对象并放入到二级缓存中

假设BeanA和BeanB存在循环依赖，那么在三级缓存的设计下，我画了这样一个图来描述工作原理。

初始化BeanA，先把BeanA实例化，然后把BeanA包装成ObjectFactory对象保存到三级缓存中。  
接着BeanA开始对属性BeanB进行依赖注入，于是开始初始化BeanB，同样做两件事创建BeanB实例，以及加入到三级缓存。  
然后，BeanB也开始进行依赖注入，在三级缓存中找到了BeanA，于是完成BeanA的依赖注入  
BeanB初始化成功以后保存到一级缓存，于是BeanA可以成功拿到BeanB的实例，从而完成正常的依赖注入。  
![80c177deb46143198b9fb49ef213950b.png][]  
整个流程看起来很复杂，但是它的核心思想就是把Bean的实例化和Bean中属性的依赖注入这两个过程分离出来。

### 事务注解以及作用 ###

*  为单个类或方法开启事务管理
 *  标记了事务注解的类，该类里的全部方法都有事务
 *  标记了事务注解的方法，默认情况下，会开启方法的事务管理，方法里的全部功能执行完毕后，会自动提交事务，默认情况下，如果方法中出现了RuntimeExecption（及其子类）异常会回退事务
 *  Spring框架的声明式事务注解是Spring使用面向切面编程（AOP）来实现的，底层依赖于数据库的事务功能

### 事务的四大特性 ###

*  原子性（Atomicity）：一个事务的全部操作，要么全部完成，要么全部不完成，中途发生错误，也会回滚恢复到事务最开始的状态
 *  一致性（Consistency）：事务开始之前和事务结束以后，数据库的完整性没有被破坏
 *  持久性（Durability）：事务结束后，对数据的修改是永久的，即使系统故障页不会丢失
 *  隔离性（Isolation）：数据库运行多个并发事务同时进行数据的读取与修改，隔离性可以防止多个并发事务同时执行时因交叉执行而导致的数据的不一致

### Spring事务 ###

*  Spring框架提供了一个一致的抽象，在不同的事务API（JDBC、Mybatis）中具有一致的编程模型
 *  支持声明式事务管理，与编程式事务管理，声明式事务管理的API更好用，往往只需要在类或方法上标记事务注解即可
 *  Spring框架的声明式事务管理是Spring面向切面编程（AOP）来实现的，底层依赖于数据的事务功能

### Spring（SpringBoot）常用的注解有哪些，有什么作用 ###

#### 声明bean的注解 ####

*  Component 组件，没有明确的身份
 *  Service 业务逻辑层使用
 *  Controller 展示层使用，控制器的声明
 *  Repository 数据访问层使用

#### 注入Bean的注解 ####

*  @Autowired Spring提供
 *  @Resource Java注解（由JSR-250提供）

#### Java配置类的相关注解 ####

*  @Configuration 声明当前类为配置
 *  @ComponentScan 用于对Component组件进行扫描
 *  @Bean 注解在方法上，声明方法返回一个bean
 *  @EnableAspectJAutoProxy 注解开启Spring对AspectJ代理的支持
 *  @Scope 配置bean的作用域
 *  @PostConstruct 在构造函数执行完之后执行
 *  @PreDestroy 在销毁bean之前执行
 *  @Value 注入属性值
 *  @PropertySource 加载配置类
 *  @EnableScheudling 在配置类上使用，开启计划任务的支持

#### 切面编程（AOP）相关注解 ####

*  @Aspect 声明一个切面，AspectJ的注解
 *  @Before 在方法执行之前执行
 *  @After 在方法执行之后（无论方法是否正常结束）执行
 *  @AfterReturing 在方法正常结束之后执行
 *  @AfterThrowing 在方法出现异常之后执行
 *  @PointCut 声明一个切点

#### 测试相关注解 ####

*  @SpringBootTest

### 依赖注入的三种方式 ###

*  属性注入  
    属性注入是使用@Autowired实现的，如下：将UserService类注入到UserController类中：
    
        public class UserController() {
              
        	@Autowired
        	private UserService userService
        }
    
     *  优点  
        属性注入的最大优点就是实现简单、使用简单。只需要给变量加上一个@Autowired，就可以在不new对象的情况下，直接获得注入的对，这也正是DI的功能及其魅力所在。
 *  构造器注入  
    构造方法注入是Spring官方从4.x之后推荐的注入方式，它的实现代码如下：
    
        public class UserController() {
              
        	private UserService userService;
        	
        	@Autowired
        	public UserController(UserService userService) {
              
        		this.userService = userService;
        	}
        
        	// 就可以调用userSerivce里的方法了
        	public void say() {
              
        	    userService.say("say");
        	}
        }
    
     *  注意，如果当前的类中只有一个构造方法，那么@Autowired也可以省略
 *  setter方法注入  
    setter注入是指将一个类的依赖通过设置一个公共的setter方法注入到该类中，这样就能够让该类使用这个依赖。setter方法通常在类中定义为public，并且以set开头，接着是一个单词，表示注入的属性的名称，例如：
    
        public class UserController() {
              
        	private UserService userService;
        	
        	@Autowired
        	public void setUserService(UserService userService) {
              
        		this.userService = userService;
        	}
        
            // 就可以调用userSerivce里的方法了
            public void say() {
              
            	userService.say("say");
            }
        }
    
     *  优点  
        可以看出，Setter注入其实是比属性注入要麻烦的，但是其也是有优点的，那就是它完全符合单一职责的设计原则，因为每个Setter只针对一个对象。

### Spring中Bean的作用域 ###

*  Spring框架支持五种作用域，分别是：singleton、prototype、request、session、global session
 *  常用的两种是：singleton、prototype
 *  request、session、global session 在web环境下有效

### Spring、SpringMVC、SpringBoot、SpringCloud的区别是什么 ###

*  Spring 是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的容器框架，是Spring全家桶的基石
 *  SpringMVC 是Spring的一部分，是一个web框架，使得开发web应用变得很容易
 *  Spring 的配置复杂、繁琐，所以推出了SpringBoot，约定优于配置，简化了Spring的配置流程，做到开箱即用
 *  SpringCloud 是构建于SpringCloud基础之上，是一个微服务全家桶，可以快速的搭建一个微服务应用

## SpringBoot ##

### SpringBoot 自动配置原理 ###

*  @EnableAutoConfiguration会读取工厂配置 /META-INF/spring.factories
 *  找到标注@Configuration 的自动配置类
 *  自动配置类中使用 @ConditionalXXX 注解，进行条件配置，根据条件初始化Bean组件
 *  可以根据属性文件、Bean对象，Bean类型自动配置

自动装配简单来说，就是自动去把第三方组件的Bean装载到IOC容器里，不需要开发人员再去写Bean相关的一个配置，在SpringBoot应用里，只需要加上@SpringBootApplication注解就可以去实现自动装配，@SpringBootApplication这个注解是一个复合注解，真正去实现自动装配注解的是@EnableAutoConfiguration这个注解，自动装配的实现主要依靠三个核心的关键技术，第一个，引入Starter，启动依赖组件的时候，这个组件必须必须要包含一个@Configuration配置类，而在这个配置类里需要通过@Bean这个注解去声明需要装配到IOC容器里的Bean对象，第二个，这个配置类是放在第三方的jar包里，然后通过SpringBoot中约定优于配置的理念，去把这个配置类的全路径放在classpath:/META-INF/spring.factories文件里，这样的话，SpringBoot就可以知道第三方jar包里这个配置类的位置，这个步骤主要是用到了Spring里面的SpringFactoriesLoader来完成的，第三个，SpringBoot拿到第三方jar包里声明的配置类以后，再通过Spring提供的ImportSelector接口来实现对这些配置类的动态加载，从而去完成自动装配。

**Starter**  
Starter 组件是可被加载在应用中的Maven依赖项项。只有在Maven配置中添加对应的依赖配置，即可使用对应的Starter组件。例如，添加spring-boot-starter-web依赖，就可以用于构建REST API服务，其包含了SpringMVC和Tomcat内嵌容器。

一个完整的Starter组件包括以下两点：

*  提供自动配置功能的自动配置模块
 *  提供依赖关系管理岗功能的组件模块，即封装了组件所有功能，开箱即用。

**@EnableAutoConfiguration**  
这个注解是帮助我们自动加载默认配置的，它里面有两个关键注解@AutoConfigurationPackage和@Import。\*\*@Import(AutoConfigurationImportSelector.class)\*\*注解，这里导入AutoConfigurationImportSelector类。这个类中有一个非常重要的方法——selectImports（），它几乎涵盖了组件自动装配的所有处理逻辑，包括获得候选配置类、配置类去重、排除不需要的配置类、过滤等，最终返回符合条件的自动配置类的全限定名数组。

@Override
    	public String[] selectImports(AnnotationMetadata annotationMetadata) {
        
    		//检查自动配置功能是否开启，默认开启
    		if (!isEnabled(annotationMetadata)) {
        
    			return NO_IMPORTS;
    		}
    		//加载自动配置的元信息
    		AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
    				.loadMetadata(this.beanClassLoader);
    		AnnotationAttributes attributes = getAttributes(annotationMetadata);
    		//获取候选配置类
    		List<String> configurations = getCandidateConfigurations(annotationMetadata,
    				attributes);
    		//去掉重复的配置类
    		configurations = removeDuplicates(configurations);
    		//获得注解中被exclude和excludeName排除的类的集合
    		Set<String> exclusions = getExclusions(annotationMetadata, attributes);
    		//检查被排除类是否可实例化、是否被自动注册配置所使用，不符合条件则抛出异常
    		checkExcludedClasses(configurations, exclusions);
    		//从候选配置类中去除掉被排除的类
    		configurations.removeAll(exclusions);
    		//过滤
    		configurations = filter(configurations, autoConfigurationMetadata);
    		//将配置类和排除类通过事件传入到监听器中
    		fireAutoConfigurationImportEvents(configurations, exclusions);
    		//最终返回符合条件的自动配置类的全限定名数组
    		return StringUtils.toStringArray(configurations);
    	}

**@AutoConfigurationPackage**：自动配置包，它也是一个组合注解，其中最重要的注解是@Import(AutoConfigurationPackages.Registrar.class)，它是spring框架的底层注解，它的作用就是给容器中导入某个组件类，例如@Import(AutoConfigurationPackages.Registrar.class)，它就是将Registrar这个组件类导入到容器中，可查看Registrar类中registerBeanDefinitions方法，这个方法就是导入组件类的具体实现。

@Target({
        ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @Import({
        Registrar.class})
    public @interface AutoConfigurationPackage {
        
    }

**@ComponentScan**：自动扫描组件，默认扫描该类所在包及其子包下所有带有指定注解的类，将它们自动装配到bean容器中，会被自动装配的注解包括@Controller、@Service、@Component、@Repository等。也可以指定扫描路径。

## SpringMVC ##

### MVC的设计理念 ###

*  MVC是一种使用MVC设计创建web应用程序德模型
 *  Model（模型）：表示应用程序德核心部分，用于处理程序数据逻辑的部分
 *  View（视图）：显示数据
 *  Controller（控制器）：处理输入与交互流程

### SpringMVC的处理流程 ###

1.  客户发送请求到前端控制器DispatcherServlet
2.  DispatcherServlet收到请求后调用处理器映射器HandlerMapping
3.  处理器映射器根据请求url找到具体的处理器，生成处理器执行链HandlerExecutionChain(包括处理器对象和处理器拦截器)一并返回给 DispatcherServlet。
4.  DispatcherServlet根据处理器Handler获取处理器适配器HandlerAdapter执行HandlerAdapter处理一系列的操作，如：参数封装，数据格式转换，数据验证等操作
5.  执行处理器Handler(Controller，也叫页面控制器)。
6.  Handler执行完成返回ModelAndView
7.  HandlerAdapter将Handler执行结果ModelAndView返回到DispatcherServlet
8.  DispatcherServlet将ModelAndView传给ViewReslover视图解析器
9.  ViewReslover解析后返回具体View
10. DispatcherServlet对View进行渲染视图（即将模型数据model填充至视图中）。
11. DispatcherServlet响应用户。

### Spring MVC 常用注解 ###

*  @Controller：用于配合组件扫描（@ComponentScan）创建控制器对象，常与@RequestMapping注解结合使用，其元注解包括@Component
 *  @RestController : 一个方便的注解，它元注解有@Controller和@ResponseBody注解。
 *  @ResponseBody: 表明控制器方法的返回值绑定到HTTP响应体
 *  @RequstMapping：使用@RequestMapping注解来映射请求到控制器方法
 *  @PostMapping 用于将HTTP POST请求映射到特定的处理方法的注解
 *  @GetMapping ：用于将HTTP GET请求映射到特定的处理方法的注解。
 *  @RequestBody 标注在方法参数上，表示网络请求正文映射到丰富参数。
 *  @RequestParam：将请求参数映射到控制器的方法参数上
 *  @PathVariable：将请求路径上“URI模版”映射到控制器的方法参数上
 *  @ResponseStatus: 设定HTTP响应状态码
 *  @RequestHeader：映射请求头到控制器方法参数

### 如何处理get请求 ###

*  @GetMapping ：用于将HTTP GET请求映射到特定的处理方法的注解。
 *  @RequstMapping：使用@RequestMapping注解来映射请求到控制器方法，添加请求方式属性。

## MyBatis ##

### MyBatis \#\{\}和$\{\}的区别 ###

*  \#\{\}是预编译，$\{\}是字符串替换
 *  MyBatis处理\#\{\}，会将sql中\#\{\}替换成？，调用PreparedStatement的set方法来赋值
 *  Mybatis处理$\{\}，会将sql中的 $\{\}替换成变量的值，也就是字符串拼接，字符串拼接存在SQL注入风险

### MyBatis的一级缓存二级缓存 ###

*  Mybatis一级缓存生命周期与SqlSession一致，当用户发起请求时，Mybatis先在Local Cache（一级缓存）进行查询，如果缓存命中，直接将结果返回给用户，如果缓存没有命中，项数据库查询，将结果写入Local Cache，然后将结果返回给用户
 *  如果多个SqlSession需要共享缓存，则需要使用到二级缓存，二级缓存开启后，同一个namespace下的所有操作语句，都影响着同一个Cache，即二级缓存被多个SqlSession共享，数据的查询执行流程是：二级缓存 -> 一级缓存 -> 数据库

### Mybatis如何不走一级缓存 ###

Mybatis没有提供一级缓存的禁用和开启开关，但是在Mapper文件中对应的语句加 “flushCache” = “true”，可以达到实际禁用一级缓存的作用，一般还会加上 “useCache” = “false”

### 简述Mybatis的单个参数，多个参数如何声明 ###

*  单个参数直接定义接口
 *  多个参数使用@Param注解
 *  使用Java Bean传递多个参数

### Mybatis 如何完成批量操作，请举例说明 ###

*  xml 拼接 sql 语句，适合批量不打的情况，性能最好
 *  使用SqlSessionFactory
    
        SqlSessionFactory session = SqlSessionFacory.openSession(ExecutorType.BATCH, false);
        // 实际Mapper文件
        Mapper mapper = session.getMapper(Mapper.class);
        // 调用Mapper里的方法, itemList为参数，是一个集合
        mapper.insertSelective(itemList.get(i));
        // 提交后无法回滚
        session.commit();
        // 清理缓存，防止溢出
        session.clearCache();

### Mybatis缓存优先级 ###

缓存的优先级通过 mybatis 发起的查询，作用顺序为：二级缓存 -> 一级缓存 -> 数据库

### Mybatis 和 Mybatis plus的区别 ###

*  Mybatis 是一款优秀的持久层框架，支持自定义的SQL，几乎免除了所有的JDBC代码以及参数配置和返回结果集的工作
 *  Mybatis plus 是Mybatis的增强工具，在Mybatis的基础上进行了增强，但不能做修改，使用Mybatis plus 之后既可以使用Mybatis plus 的特有功能，也能使用 Mybatis 原有的功能

### Mybatis如何实现分页 ###

*  通过 limit 实现分页
 *  RowBound分页
 *  使用Mybatis分页插件PageHepler实现分页

### 写过原生的分页吗，用过什么插件，分页插件的原理 ###

*  原生分页就是使用MySQL的 limit 实现的分页
 *  通过 Mybatis 的分页插件 PageHepler
 *  分页插件PageHepler 通过Mybatis拦截器实现的分页，核心类是 PageInterceptor

### 你知道Mybatis延迟加载吗 ###

*  Mybatis 延迟加载就是按需加载，在需要的时候进行加载
 *  在Mybatis的属性中配置：将 lazyLoadingEnabled 设置为 true，表示需要延迟加载，默认为 false，将 arggressiveLazyLoading 设置为 false，表示需要按需加载，默认为 true

### JDBC 跟 Mybatis 的区别（JDBC 为什么比 Mybatis 效率快） ###

*  JDBC 是 Java 提供操作数据库的 API，JDBC存在弊端，编程工作量相对较大繁琐
 *  Mybatis 是支持普通SQL查询、储存过程和高级映射的持久层框架。Mybatis 封装 JDBC API，通过反射将JDBC于Java对象进行映射，基本不同写JDBC代码
 *  Mybatis采用反射机制，性能比原生的JDBC API 略慢

### resultType与resultMap有什么区别 ###

*  resultType与resultMap都是Mybatis里进行数据库连接操作时处理返回结果的
 *  resultType：使用resultType处理SQL返回结果类型时，查询出来的字段名必须和pojo里的属性名一致
    
     *  使用类型
        
        1.  基本类型：int、String等基本数据类型
        2.  List类型：resultType = List中的元素类型
        3.  Map类型：单条记录：resultType = map；多条记录：resultType = Map中value的类型
 *  resultMap：resultMap的功能比resultType功能更强大，在使用resultMap之前需要先定义一个符合当前需要的resultMap，解决查询出来的字段名和pojo里的属性名不一致的问题

## 微服务框架 ##

### nacos ###

注册中心

*  注册中心实现方式基于三大角色：注册中心，服务提供者，服务消费者
 *  服务提供者到注册中心注册自身的信息，如地址和端口，服务消费者就可以通过Nacos找到服务提供者的地址，从而去调用

### dubbo ###

*  dubbo是基于java的高性能的RPC分布式服务框架，本质上是一个远程服务调用的分布式框架
 *  Dubbo的注册发现流程  
    1.首先服务的提供者启动服务时,将自己的具备的服务注册到注册中心,其中包括当前提供者的ip地址和端口号等信息,Dubbo会同时注册该项目提供的远程调用的方法
    
    2.消费者(使用者)启动项目,也注册到注册中心,同时从注册中心中获得当前项目具备的所有服务列表
    
    3.当注册中心中有新的服务出现时,(在心跳时)会通知已经订阅发现的消费者,消费者会更新所有服务列表
    
    4.RPC调用,消费者需要调用远程方法时,根据注册中心服务列表的信息,只需服务名称,不需要ip地址和端口号等信息,就可以利用Dubbo调用远程方法了  
    ![在这里插入图片描述][2c43f6327a51419ea5d6ae58863c8e47.png]

### sentinel ###

Sentinel 以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。

### seata ###

模式

*  **AT(自动)模式**  
    1.事务的发起方™会向事务协调器(TC)申请一个全局事务id,并保存
    
    2.Seata会管理事务中所有相关的参与方的数据源,将数据操作之前和之后的镜像都保存在undo\_log表中,这个表是seata组件规定的表,没有它就不能实现效果,依靠它来实现提交(commit)或回滚(roll back)的操作
    
    3.事务的发起方™会连同全局id一起通过远程调用,运行资源管理器(RM)中的方法
    
    4.RM接收到全局id,去运行指定方法,并将运行结果的状态发送给TC
    
    5.如果所有分支运行都正常,TC会通知所有分支进行提交,真正的影响数据库内容,
    
    反之如果所有分支中有任何一个分支发生异常,TC会通知所有分支进行回滚,数据库数据恢复为运行之前的内容
 *  **TCC模式**：简单来说,TCC模式就是自己编写代码完成事务的提交和回滚  
    在TCC模式下,我们需要为参与事务的业务逻辑编写一组共3个方法
    
    (prepare\\commit\\rollback)
    
    prepare:准备
    
    commit:提交
    
    rollback:回滚
    
     *  prepare方法是每个模块都会运行的方法
     *  当所有模块的prepare方法运行都正常时,运行commit
     *  当任意模块运行的prepare方法有异常时,运行rollback
    
    这样的话所有提交或回滚代码都由自己编写
    
    优点:虽然代码是自己写的,但是事务整体提交或回滚的机制仍然可用(仍然由TC来调度)
    
    缺点:每个业务都要编写3个方法来对应,代码冗余,而且业务入侵量大
    
     *  **SAGA模式**：SAGA模式的思想是对应每个业务逻辑层编写一个新的类,可以设置指定的业务逻辑层方法发生异常时,运行当新编写的类中的代码
        
        相当于将TCC模式中的rollback方法定义在了一个新的类中
        
        这样编写代码不影响已经编写好的业务逻辑代码
        
        一般用于修改已经编写完成的老代码
        
        缺点是每个事务分支都要编写一个类来回滚业务,
        
        会造成类的数量较多,开发量比较大
 *  **XA模式**： 支持XA协议的数据库分布式事务,使用比较少

### gateway ###

网关的主要功能有

*  将所有请求统一经过网关
 *  网关可以对这些请求进行检查
 *  网关方便记录所有请求的日志
 *  网关可以统一将所有请求路由到正确的模块\\服务上

[80c177deb46143198b9fb49ef213950b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/b27d0e85a8b348f2bb9c1405e3b79d63.png
[2c43f6327a51419ea5d6ae58863c8e47.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/537d3547a9364aae82a3c65d2aaf8e53.png