SpringCloud( H版 & alibaba )框架开发教程(高级 Alibaba)

4 篇文章 0 订阅

重点 : 约定 > 配置 > 编码

降级方法的参数跟原方法的原始值相同

编码五部曲:

  1. 建module
  2. 改pom
  3. 写yml
  4. 主启动
  5. 业务类

好的环境配置比代码更重要

所有源码地址:https://gitee.com/xyy-kk_admin/spring-cloud

入门篇链接:https://blog.csdn.net/qiwunongqingyin/article/details/117927188
初级篇链接:https://blog.csdn.net/qiwunongqingyin/article/details/118028552
中级篇链接:https://blog.csdn.net/qiwunongqingyin/article/details/118151377
高级篇链接:https://blog.csdn.net/qiwunongqingyin/article/details/118411828


  1. SpringCloud Alibaba 入门简介
  2. SpringCloud Alibaba Nacos 服务注册和配置中心
  3. SpringCloud Alibaba Sentinel 现实熔断与限流
  4. SpringCloud Alibaba Seata处理分布式事务

17. SpringCloud Alibaba 入门简介

官网: https://spring.io/projects/spring-cloud-alibaba

官方参考手册:https://spring-cloud-alibaba-group.github.io/github-pages/greenwich/spring-cloud-alibaba.html

中文文档 : https://github.com/alibaba/spring-cloud-alibaba/blob/master/README-zh.md

Spring Cloud Dalston、Edgware、Finchley 和 Greenwich 都已达到生命周期终止状态,不再受支持。
在这里插入图片描述

  1. 什么是维护模式?

    将模块置于维护模式,意味着Spring Cloud团队将不会再向模块添加新功能。

    他们将修复block级别的 bug 以及安全问题,他们也会考虑并审查社区的小型pull request。

  2. 微服务关系:
    在这里插入图片描述

17.1 SpringCloud Alibaba 带来了什么?

服务限流降级:默认支持Servlet、Feign、RestTemplate、Dubbo和RocketMQ限流降级功能的接入,可以在运行时通过控制台实时修改限流降级规则,还支持查看限流降级Metrics 监控。

服务注册与发现:适配Spring Cloud服务注册与发现标准,默认集成了Ribbon的支持分布式配置管理:支持分布式系统中的外部化配置,配置更改时自动刷新。

消息驱动能力:基于Spring Cloud Stream为微服务应用构建消息驱动能力。

阿里云对象存储:阿里云提供的海量、安全、低成本、高可靠的云存储服务。支持在任何应用、任何时间、任何地点存储和访问任意类型的数据。分布式任务调度:提供秒级、精准、高可靠、高可用的定时(基于Cron表达式)任务调度服务。同时提供分布式的任务执行模型,如网格任务。网格任务支持海量子任务均匀分配到所有Worker (schedulerx-client)上执行。

18. SpringCloud Alibaba Nacos 服务注册和配置中心

官网: https://spring.io/projects/spring-cloud-alibaba#learn

中文网: https://nacos.io/zh-cn/

下载地址: https://github.com/alibaba/nacos/tags 自己寻找版本下载,(我自己2.0.2)

18.1 概述

为什么叫 Nacas?

  • 前四个字母分别为Naming和Configuration的前两个字母,最后的s为Service。

是什么?

  • 一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。
  • Nacos: Dynamic Naming and Configuration Service
  • Nacos就是注册中心+配置中心的组合 -> Nacos = Eureka+Config+Bus

能干嘛?

  • 替代Eureka做服务注册中心
  • 替代Config做服务配置中心

框架对比

服务注册与发现框架CAP模型控制台管理社区活跃度
EurekaAP支持低(2.x版本闭源)
ZookeeperCP不支持
consulCP支持
NacosAP支持

据说Nacos在阿里巴巴内部有超过10万的实例运行,已经过了类似双十一等各种大型流量的考验。

18.2 下载与安装

  1. 本地 Java8 与 maven 环境 ok !!

  2. 下载地址: https://github.com/alibaba/nacos/tags 自己寻找版本下载,(我自己2.0.2,目前推荐的最稳定的版本)

  3. 解压进入bin目录,启动startup.cmd(直接启动是集群环境会报错…)
    打开cmd命令窗口,输入: startup.cmd -m standalone 启动单机模式
    注: wdnmd(唯独你没懂),第一次加载时间超长,可以去吃个饭再回来…

  4. cmd命令窗口会显示访问路径的: http://localhost:8848/nacos
    账号和密码默认都是nacos
    在这里插入图片描述

18.3 基于 Nacos 的服务提供者

spring-cloud alibaba 官网都有的

  1. 新建子项目cloudalibaba-provider-payment9001

  2. pom
    父pom:(应该已经有了)

      <!--spring cloud alibaba 2.2.0.RELEASE-->
      <dependency>
          <groupId>com.alibaba.cloud</groupId>
          <artifactId>spring-cloud-alibaba-dependencies</artifactId>
          <version>2.2.0.RELEASE</version>
          <type>pom</type>
          <scope>import</scope>
      </dependency>
    

    9001pom:

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <parent>
            <artifactId>cloud</artifactId>
            <groupId>com.xyy</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>cloudalibaba-provider-payment9001</artifactId>
    
        <dependencies>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-actuator</artifactId>
            </dependency>
        </dependencies>
    </project>
    
  3. yml

    server:
      port: 9001
    spring:
      application:
        name: nacos-payment-provider
      cloud:
        nacos:
          discovery:
            server-addr: 127.0.0.1:8848
    
    management:
      endpoints:
        web:
          exposure:
            include: '*'
    
  4. 启动类PaymentMain9001,注解:@EnableDiscoveryClient

  5. 业务controller:PaymentNacosController

    @RestController
    @RequestMapping("payment/nacos")
    public class PaymentNacosController {
        @Value("${server.port}")
        private String serverPort;
    
        @GetMapping(value = "getport/{id}")
        public String getPayment(@PathVariable("id") Integer id) {
            return "nacos registry, serverPort: "+ serverPort+"\t id"+id;
        }
    }
    
  6. 访问测试: http://localhost:9001/payment/nacos/getport/1
    nacos页面: http://localhost:8848/nacos -> 服务管理 -> 服务列表 可以看到已经注册成功
    在这里插入图片描述

  7. 为了演示集群,根据9001 新建cloudalibaba-provider-payment9002
    在这里插入图片描述
    或者不新建,使用模拟的方式copy9001:

    1. 右击server栏的9001,复制配置
    2. 在VM options(VM选项)一栏中填入 -> -DServer.port=9002 没空格有点,我没写错
    3. 确认即可

18.4 基于 Nacos 的服务消费者

nacos内嵌ribbon:
在这里插入图片描述

  1. 新建cloudalibaba-consumer-nacos-order80
  2. pom
    	<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <parent>
            <artifactId>cloud</artifactId>
            <groupId>com.xyy</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>cloudalibaba-consumer-nacos-order80</artifactId>
    
        <dependencies>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-actuator</artifactId>
            </dependency>
    
            <dependency>
                <groupId>com.xyy</groupId>
                <artifactId>cloud-api-commons</artifactId>
                <version>${project.version}</version>
            </dependency>
        </dependencies>
    
    </project>
    
  3. yml
    server:
      port: 80
    
    spring:
      application:
        name: nacos-order-consumer
      cloud:
        nacos:
          discovery:
            server-addr: localhost:8848
            
    # 可写可不写,Controller要用,提出来 类 也一样
    #消费者将要去访问的微服务名称(注册成功进nacos的微服务提供者)
    service-url:
      nacos-user-service: http://nacos-payment-provider
    
  4. 启动类OrderNacosMain80,注解:@EnableDiscoveryClient
  5. 配置类:ApplicationContextConfig
    @Configuration
    public class ApplicationContextConfig
    {
        @Bean
        @LoadBalanced
        public RestTemplate getRestTemplate(){
            return new RestTemplate();
        }
    }
    
  6. 业务类controller:OrderNacosController
    @RestController
    @RequestMapping("order/nacos")
    public class OrderNacosController {
    
        @Resource
        private RestTemplate restTemplate;
    	//这个就是在配置类中写的路径
        @Value("${service-url.nacos-user-service}")
        private String serverURL;
    
        @GetMapping(value = "getport/{id}")
        public String getPayment(@PathVariable("id") Integer id) {
            return restTemplate.getForObject(serverURL+"/payment/nacos/getport/"+id,String.class);
        }
    }
    
  7. 启动测试: http://localhost/order/nacos/getport/1
    nacos:在这里插入图片描述

18.5 Nacos服务注册中心对比提升

  1. Nacos全景图:
    在这里插入图片描述
    Nacos和CAP

  2. Nacos与其他注册中心特性对比
    在这里插入图片描述

  3. Nacos服务发现实例模型
    在这里插入图片描述

  4. Nacos支持AP和CP模式的切换

    C是所有节点在同一时间看到的数据是一致的;而A的定义是所有的请求都会收到响应。

    何时选择使用何种模式?

    —般来说,如果不需要存储服务级别的信息且服务实例是通过nacos-client注册,并能够保持心跳上报,那么就可以选择AP模式。当前主流的服务如Spring cloud和Dubbo服务,都适用于AP模式,AP模式为了服务的可能性而减弱了一致性,因此AP模式下只支持注册临时实例。

    如果需要在服务级别编辑或者存储配置信息,那么CP是必须,K8S服务和DNS服务则适用于CP模式。CP模式下则支持注册持久化实例,此时则是以Raft协议为集群运行模式,该模式下注册实例之前必须先注册服务,如果服务不存在,则会返回错误。

    切换命令:
    curl -X PUT '$NACOS_SERVER:8848/nacos/v1/ns/operator/switches?entry=serverMode&value=CP

18.6 Nacos 配置中心 -> 基础配置

  1. 新建子项目cloudalibaba-config-nacos-client3377

  2. pom

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <parent>
            <artifactId>cloud</artifactId>
            <groupId>com.xyy</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>cloudalibaba-config-nacos-client3377</artifactId>
    
        <dependencies>
    <!--    本次主要依赖    -->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
            </dependency>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-actuator</artifactId>
            </dependency>
        </dependencies>
    </project>
    
  3. yml
    配置规则: https://nacos.io/zh-cn/docs/quick-start-spring-cloud.html
    bootstrap.yml是云配置优先,application.yml是本地

    bootstrap.yml:

    # nacos配置
    server:
      port: 3377
    
    spring:
      application:
        name: nacos-config-client
      cloud:
        nacos:
          discovery:
            server-addr: localhost:8848 #Nacos服务注册中心地址
          config:
            server-addr: localhost:8848 #Nacos作为配置中心地址
            file-extension: yaml #指定yaml格式的配置
    
    # nacos 新建配置Data ID的命名规则:
    # 默认项目名(或者: spring.cloud.nacos.config.prefix) - application.yml中的spring.profile.active - config.file-extension
    # ${spring.application.name}-${spring.profile.active}.${spring.cloud.nacos.config.file-extension}
    # nacos-config-client-dev.yaml
    
    # nacos-config-client-test.yaml   ----> config.info
    

    applicaton.yml:

    spring:
      profiles:
        active: dev # 表示开发环境
    
  4. 启动类NacosConfigClientMain3377,注解@NacosConfigClientMain3377

  5. 业务类controller:ConfigClientController

    @RestController
    @RequestMapping("/config")
    @RefreshScope  //支持nacos动态刷新功能
    public class ConfigClientController {
        @Value("${config.info}")
        private String configInfo;
    
        @RequestMapping("/info")
        public String getConfigInfo(){
            return configInfo;
        }
    }
    
  6. 进入nacos页面:http://localhost:8848/nacos
    配置列表添加以下内容发布: (目前仅支持为yaml,Properties,要跟bootstrap.yml中匹配)
    在这里插入图片描述

  7. 测试启动3377,访问路径: http://localhost:3377/config/info
    nacos: 在这里插入图片描述

  8. 修改nacos配置中心内容将nacos-config-client-dev.yaml文件的版本号从1改为2,发布,重新刷新3377页面,会发现直接修改成功

18.7 Nacos 配置中心 -> 分类配置

问题 - 多环境多项目管理

  1. 实际开发中,通常一个系统会准备?

    dev开发环境
    test测试环境
    prod生产环境。

    如何保证指定环境启动时服务能正确读取到Nacos上相应环境的配置文件呢?

  2. 一个大型分布式微服务系统会有很多微服务子项目,每个微服务项目又都会有相应的开发环境、测试环境、预发环境、正式环境…那怎么对这些微服务配置进行管理呢?

Nacos的图形化管理界面
在这里插入图片描述
Namespace+Group+Data lD三者关系?为什么这么设计?

  1. 是什么

    类似Java里面的package名和类名最外层的namespace是可以用于区分部署环境的,Group和DatalD逻辑上区分两个目标对象。

  2. 三者情况
    在这里插入图片描述

    默认情况:Namespace=public,Group=DEFAULT_GROUP,默认Cluster是DEFAULT

    Nacos默认的Namespace是public,Namespace主要用来实现隔离。

    比方说我们现在有三个环境:开发、测试、生产环境,我们就可以创建三个Namespace,不同的Namespace之间是隔离的。

    Group默认是DEFAULT_GROUP,Group可以把不同的微服务划分到同一个分组里面去

    Service就是微服务:一个Service可以包含多个Cluster (集群),Nacos默认Cluster是DEFAULT,Cluster是对指定微服务的一个虚拟划分。

    比方说为了容灾,将Service微服务分别部署在了杭州机房和广州机房,这时就可以给杭州机房的Service微服务起一个集群名称(HZ) ,给广州机房的Service微服务起一个集群名称(GZ),还可以尽量让同一个机房的微服务互相调用,以提升性能。

    最后是Instance,就是微服务的实例。

三种方案:

  1. DataID方案:

    指定spring.profile.active和配置文件的DatalD来使不同环境下读取不同的配置

    默认空间+默认分组+新建dev和test两个DatalD
    在这里插入图片描述
    通过spring.profile.active属性就能进行多环境下配置文件的读取
    在这里插入图片描述
    测试: http://localhost:3377/config/info
    配置什么就加载什么!!!

  2. Group 方案:

    新建配置:DEV_GROUP下的nacos-config-client-info.yaml发布:
    在这里插入图片描述
    新建配置:TEST_GROUP下的nacos-config-client-info.yaml发布:
    在这里插入图片描述
    结果: 在这里插入图片描述

    修改yml: 都写在下面了

    # bootstrap.yml
    spring:
      cloud:
        nacos:
          discovery:
            server-addr: localhost:8848 #Nacos服务注册中心地址
          config:
            server-addr: localhost:8848 #Nacos作为配置中心地址
            file-extension: yaml #指定yaml格式的配置
            #新增:
            group: DEV_GROUP
    	        
    # appliction.yml
    spring:
      profiles:
        active: info
      # active: test
      # active: dev # 表示开发环境
    

    访问3377: http://localhost:3377/config/info
    修改bootstrap.yml的group为TEST_GROUP,刷新3377!!!

    配置完成!!!

  3. Namespace 方案:

    访问nacos地址,

    新建 dev | test 两个namespace
    在这里插入图片描述
    在配置列表dev中,新增:(自行修改配置内容)
    在这里插入图片描述
    修改yml

    #bootstrap.yml
    spring:
      cloud:
        nacos:
          discovery:
            server-addr: localhost:8848 #Nacos服务注册中心地址
          config:
            server-addr: localhost:8848 #Nacos作为配置中心地址
            file-extension: yaml #指定yaml格式的配置
            group: DEV_GROUP
            #新增:
            namespace: 37b5cf1e-5ccb-4fdb-bd8e-38cd2129301e
    
    #application.yml
    spring:
      profiles:
        active: dev # 表示开发环境
    

    访问测试:http://localhost:3377/config/info
    修改分组,在刷新3377

18.8 Nacos 集群和持久化

官网: https://nacos.io/zh-cn/docs/deployment.html
在这里插入图片描述
我们需要mysql数据库:

默认Nacos使用嵌入式数据库实现数据的存储。所以,如果启动多个默认配置下的Nacos节点,数据存储是存在一致性问题的。为了解决这个问题,Nacos采用了集中式存储的方式来支持集群化部署,目前只支持MySQL的存储。

Nacos支持三种部署模式

  • 单机模式-用于测试和单机试用。
  • 集群模式-用于生产环境,确保高可用。
  • 多集群模式-用于多数据中心场景。

单机模式支持mysql

在0.7版本之前,在单机模式时nacos使用嵌入式数据库实现数据的存储,不方便观察数据存储的基本情况。0.7版本增加了支持mysql数据源能力,具体的操作步骤:

  • 安装数据库,版本要求:5.6.5+
  • 初始化mysq数据库,数据库初始化文件: nacos-mysql.sql
  • 修改conf/application.properties文件,增加支持mysql数据源配置(目前只- 支持mysql),添加mysql数据源的url、用户名和密码。
    #*************** Config Module Related Configurations ***************#
    ### If use MySQL as datasource:
    spring.datasource.platform=mysql
    
    ### Count of DB:
    db.num=1
    
    ### Connect URL of DB:
    db.url.0=jdbc:mysql://127.0.0.1:3306/nacos_config?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
    db.user.0=root
    db.password.0=root
    
    再以单机模式启动nacos,nacos所有写嵌入式数据库的数据都写到了mysql。

nacos默认存储库: derby

github的pom文件查看: https://github.com/alibaba/nacos/blob/develop/pom.xml

derby切换mysql 步骤:

  1. nacos下的conf目录下找到sql脚本: nacos-mysql.sql,在数据库执行脚本导入

  2. nacos下的conf目录下找到application.properties,将以下注释解除并修改:

  3. 重新启动Nacos,发现之前的配置全部消失 ,是因为使用的为mysql的数据库,其中什么都没有

Linux版Nacos+MySql生产环境配置:

  1. 预计需要 1个Nginx + 3个nacos注册中心 + 1个mysql
  2. Nacos下载linux版:https://github.com/alibaba/nacos/tags
  3. 安装mysql (Ubuntu OS 中Mysql的安装,操作与卸载)
  4. 安装nginx:(Ubuntu 中nginx安装)
  5. 将nacos放到linux中,解压tar -zxvf nacos-2.0.tar.gz,并且拷贝副本为mynacos

集群配置步骤:

  1. Linux 服务器上mysql数据库配置

    //进入mynacos下的conf文件夹,mysql表在此文件夹下(`nacos-mysql.sql`)
    cd mynacos/conf
    //登陆mysql
    mysql -uroot -p
    //查看所有数据库
    show databases;
    //没有数据库nacos-config的话新建
    CREATE DATABASE `nacos_config`;
    //选择数据库
    use `nacos_config`;
    //执行sql脚本
    source nacos-mysql.sql;
    //查看
    show tables;
    

    注,新的nacos比旧的多了一张permissions

  2. 修改 application.properties:

    把这些注解打开,修改数据库名称和用户名密码即可
    在这里插入图片描述

  3. 按照1,2步骤,再配置两台机器

  4. Nginx配置,由他作为负载均衡
    在这里插入图片描述

  5. 启动nginx

  6. 启动nacos

  7. 修改cloudalibaba-provider-payment9002的yml

    spring:
      cloud:
        nacos:
          discovery:
            # server-addr: 127.0.0.1:8848
            server-addr: nginx运行服务器的ip:1234
    
  8. 启动测试

19. SpringCloud Alibaba Sentinel 现实熔断与限流

gibhub: https://github.com/alibaba/Sentinel

官网文档1: https://sentinelguard.io/zh-cn/

官网文档2:https://spring-cloud-alibaba-group.github.io/github-pages/greenwich/spring-cloud-alibaba.html#_spring_cloud_alibaba_sentinel

github文档: https://github.com/alibaba/Sentinel/wiki/%E4%BB%8B%E7%BB%8D

下载地址: https://github.com/alibaba/Sentinel/tags

19.1 概述

  1. sentinel跟Hystrix差别?

    1. Hystrix 需要手动搭建监控平台
    2. Hystrix 没有web界面更加细的配置
      流控,速率控制,服务熔断,服务降级…越来越多,很麻烦
    1. sentinel 单独一个组件,可以独立出来
    2. sentinel 支持界面化细粒度统一配置
     尽量使用配置和注解少写代码
    
  2. 是什么?

    • 丰富的应用场景:哨兵接了阿里巴巴近10年的双十一大促流量的核心场景,例如杀(即爆发流量控制在系统可控制的范围)、消息削峰填谷、流量控制、实时熔断断不能应用等。
    • 您可以在实时监控中同时提供监控功能。您可以在单台实时查看接入应用的机器,甚至台下规模的500秒的汇总运行情况。
    • 广泛的开源生态:Sentinel 提供开箱即用的与其他开源框架/库的整合模块,例如与 Spring Cloud、Dubbo、gRPC 的整合。进入哨兵。
    • 改进的 SPI 扩展点:Sentinel 提供简单易用、改进的 SPI 扩展接口。您可以通过实现扩展来接口快速地自定义逻辑。例如源定制规则管理、适配动态数据等。
  3. 主要特性:(绿)
    在这里插入图片描述

  4. Sentinel 分为两个部分:

    核心库(Java 客户端)不依赖任何框架/库,能够运行于所有 Java 运行时环境,同时对 Dubbo / Spring Cloud 等框架也有较好的支持。

    控制台(Dashboard)基于 Spring Boot 开发,打包后可以直接运行,不需要额外的 Tomcat 等应用容器。

19.2 安装运行

下载地址: https://github.com/alibaba/Sentinel/tags

运行java -jar sentinel1.8.2.jar,默认端口8080(需要java8)

web访问地址: http://localhost:8080

账户: sentinel
密码: sentinel
在这里插入图片描述

19.3 初始化演示工程

  1. 启动nacosstartup.cmd -m standalone
  2. 启动sentinel java -jar sentinel1.8.jar
    访问路径: http://localhost:8080/
  3. 新建子项目cloudalibaba-sentinel-service8401
  4. pom (openfeign和sentinel-datasource-nacos后面要用,现在先加上)
    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <parent>
            <artifactId>cloud</artifactId>
            <groupId>com.xyy</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>cloudalibaba-sentinel-service8401</artifactId>
    
        <dependencies>
            <!--SpringCloud ailibaba nacos -->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            </dependency>
    
            <!--SpringCloud ailibaba sentinel -->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
            </dependency>
    
            <!--SpringCloud ailibaba sentinel-datasource-nacos 后续做持久化用到-->
            <dependency>
                <groupId>com.alibaba.csp</groupId>
                <artifactId>sentinel-datasource-nacos</artifactId>
            </dependency>
    
            <!--openfeign-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-openfeign</artifactId>
            </dependency>
    
            <!-- SpringBoot整合Web组件+actuator -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-actuator</artifactId>
            </dependency>
            <!--日常通用jar包配置-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-devtools</artifactId>
                <scope>runtime</scope>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>com.xyy</groupId>
                <artifactId>cloud-api-commons</artifactId>
                <version>${project.version}</version>
            </dependency>
        </dependencies>
    </project>
    
  5. yml
    server:
      port: 8401
    
    spring:
      application:
        name: cloudalibaba-sentinel-service
      cloud:
        nacos:
          discovery:
            server-addr: 127.0.0.1:8848 #Nacos服务注册中心地址
        sentinel:
          transport:
            dashboard: 127.0.0.1:8080 #配置Sentinel dashboard地址
            #默认8719,如果被占用会自动+1直到找到未被占用的端口
            port: 8719
    
    management:
      endpoints:
        web:
          exposure:
            include: '*'
      endpoint:
        sentinel:
          enabled: false
    
    
    feign:
      sentinel:
        enabled: true # 激活Sentinel对Feign的支持
    
  6. 启动类SentinelMain8401,注解:@EnableDiscoveryClient
  7. 业务类controller:FlowLimitController
    @RestController
    @RequestMapping("sentinel/flow")
    public class FlowLimitController {
    
    	//这个是显示在sentinel上的方法别名
        @SentinelResource("getA")
        @RequestMapping("A")
        public String testA(){
            return "---A";
        }
    
        @SentinelResource("getB")
        @RequestMapping("B")
        public String testB(){
            return "---B";
        }
    }
    
  8. 启动8401测试: http://localhost:8401/sentinel/flow/A
    访问sentinel: http://localhost:8080
    在这里插入图片描述

注: 需要先访问过8401后再查看sentinel的页面,否则是空的,因为sentinel是懒加载模式,并且如果一段时间不访问方法,则不会显示该方法

19.4 流控规则

在这里插入图片描述

基本介绍:

  • 资源名:唯一名称,默认请求路径。
  • 针对来源:Sentinel可以针对调用者进行限流,填写微服务名,默认default(不区分来源)。
  • 阈值类型/单机阈值:
    • QPS(每秒钟的请求数量)︰当调用该API的QPS达到阈值的时候,进行限流。
  • 线程数:当调用该API的线程数达到阈值的时候,进行限流。
  • 是否集群:不需要集群。
  • 流控模式:
    • 直接:API达到限流条件时,直接限流。
    • 关联:当关联的资源达到阈值时,就限流自己。
    • 链路:只记录指定链路上的流量(指定资源从入口资源进来的流量,如果达到阈值,就进行限流)【API级别的针对来源】。
  • 流控效果:
    • 快速失败:直接失败,抛异常。
    • Warm up:根据Code Factor(冷加载因子,默认3)的值,从阈值/codeFactor,经过预热时长,才达到设置的QPS阈值。
      排队等待:匀速排队,让请求以匀速的速度通过,阈值类型必须设置为QPS,否则无效。

19.4.1 流控模式

直接:

  1. 点击簇点链路给getA添加流控规则:
    在这里插入图片描述

  2. 再次访问http://localhost:8401/sentinel/flow/A,快速刷新,结果500
    (因为配置了@SentinelResource,否则页面显示Blocked by Sentinel (flow limiting),我不配置这个直接加载不到sentinel控制台)

  3. 不管是500还是Blocked by Sentinel (flow limiting),都不是想要的,这时候需要自定义报错页面,之后讲…

  4. 流控规则为并发线程数: 并发情况下,超过指定数量以外的会报错

    getA流控规则换为并发在这里插入图片描述

    testA方法修改:

    @RequestMapping("A")
    public String testA(){
    	ThreadUtil.sleep(800);
    	 return "---A";
    }
    

    疯狂刷新http://localhost:8401/sentinel/flow/A,结果也会报错

关联:

  • 当自己关联的资源达到阈值时,就限流自己
  • 当与A关联的资源B达到阀值后,就限流A自己(B惹事,A挂了)
  1. 将流控规则改为:
    在这里插入图片描述
  2. 并发访问B(我用的是API POST)
    在这里插入图片描述
  3. 在访问 getB 的过程中浏览器访问 getA,getA出错

19.4.2 流控效果

快速失败

直接失败: 抛出异常

预热:

公式: 阈值 / coldFactor(默认3), 经过预热时长后才会到达阈值

Warm Up(RuleConstant.CONTROL_BEHAVIOR_WARM_UP)方式,即预热/冷启动方式。当系统长期处于低水位的情况下,当流量突然增加时,直接把系统拉升到高水位可能瞬间把系统压垮。通过"冷启动",让通过的流量缓慢增加,在一定时间内逐渐增加到阈值上限,给冷系统一个预热的时间,避免冷系统被压垮。详细文档可以参考 流量控制 - Warm Up 文档,具体的例子可以参见 WarmUpFlowDemo。

通常冷启动的过程系统允许通过的 QPS 曲线如下图所示:
在这里插入图片描述
源码 -> com.alibaba.csp.sentinel.slots.block.flow.controller.WarmUpController


案例,阀值为10+预热时长设置5秒。

系统初始化的阀值为10/ 3约等于3,即阀值刚开始为3;然后过了5秒后阀值才慢慢升高恢复到10

在这里插入图片描述
效果: 在前五秒钟疯狂刷新getB链接(超过每秒3个)会有报错信息,五秒之后疯狂刷新(低于每秒10个),则不会有任何报错信息

排队等待

匀速排队: 让请求以均匀的速度通过,阀值类型必须设成QPS,否则无效。

匀速排队(RuleConstant.CONTROL_BEHAVIOR_RATE_LIMITER)方式会严格控制请求通过的间隔时间,也即是让请求以均匀的速度通过,对应的是漏桶算法。详细文档可以参考 流量控制 - 匀速器模式,具体的例子可以参见 PaceFlowDemo

该方式的作用如下图所示:
在这里插入图片描述
这种方式主要用于处理间隔性突发的流量,例如消息队列。想象一下这样的场景,在某一秒有大量的请求到来,而接下来的几秒则处于空闲状态,我们希望系统能够在接下来的空闲期间逐渐处理这些请求,而不是在第一秒直接拒绝多余的请求。
注意:匀速排队模式暂时不支持 QPS > 1000 的场景。

测试: 设置以下内容:
在这里插入图片描述
每秒钟最多五个请求,排队访问,多出来的顺延,访问超过2000毫秒时报错

19.5 降级规则

官网: https://github.com/alibaba/Sentinel/wiki/%E7%86%94%E6%96%AD%E9%99%8D%E7%BA%A7

慢调用比例
在这里插入图片描述
每次未熔断时统计时长为ms,在此时间内. 响应超过RT时间被标记为慢调用,慢调用比例超过比例阈值后熔断 [取值为 0 - 1 之间] ,熔断时长为s,超过该时间取消熔断, 每秒调用数 < 最小请求数 则不启动熔断,

异常比例

在这里插入图片描述
在3000ms内,至少有8个请求,错误率达到60%,则熔断3s,然后重新统计时间

异常数
在这里插入图片描述
在3000ms内,至少有8个请求,异常5个,则熔断3s,然后重新统计时间

19.6 Sentinel 热点 (服务降级)

官网: https://github.com/alibaba/Sentinel/wiki/%E7%83%AD%E7%82%B9%E5%8F%82%E6%95%B0%E9%99%90%E6%B5%81

基础配置

  1. 修改8401的controller:

    	//deal_testHotKey 为降级服务名
        @SentinelResource(value = "testHotKey",blockHandler="deal_testHotKey")
        @RequestMapping("testHotKey")
        public String testHotKey(@RequestParam(value = "p1",required = false)String p1,
                                 @RequestParam(value = "p2",required = false)String p2){
            return "---testHotKey";
        }
    	//BlockException 
        public String deal_testHotKey(String p1, String p2, BlockException blockException){
            return "---deal_testHotKey---o(╥﹏╥)o"+p1+p2;
        }
    
  2. 配置sentinel:
    在这里插入图片描述
    访问链接: http://localhost:8401/sentinel/flow/testHotKey?p1=a&p2=b

    解释: QPS(Queries-per-second)模式是每秒查询速率; 每秒钟,请求包含第0个参数(p1,下标从0开始,方法的参数,不是请求的参数), 访问超过3个,降级5秒

    结果: 访问无参,带参数p2,疯狂刷新没有问题,而全参带p1和p2带p1的请求如果触碰到热点规则则会熔断

高级配置
在这里插入图片描述
p1=浪的时候限流阈值为10,其他的还是3;

注: 支持基本类型和String类型,参数的值=指定值,限流阈值更改(中文需要URL编码改一下)
在这里插入图片描述

testHotKey方法抛异常,加入以下代码int age =10/0;运行测试???

将会直接500,并不会进入兜底方法

注:
@SentinelResource - 处理的是sentinel控制台配置的违规情况,有blockHandler方法配置的兜底处理;
RuntimeException int age = 10/0,这个是java运行时报出的运行时异常RunTimeException,@SentinelResource不管
后面会讲fallback可以配

19.7 系统限流

官网: https://github.com/alibaba/Sentinel/wiki/系统自适应限流

简介:

  • 从整体维度对应用入口流量进行控制

支持模式:

  • Load 自适应(仅对 Linux/Unix-like 机器生效):系统的 load1 作为启发指标,进行自适应系统保护。当系统 load1 超过设定的启发值,且系统当前的并发线程数超过估算的系统容量时才会触发系统保护(BBR 阶段)。系统容量由系统的 maxQps * minRt 估算得出。设定参考值一般是 CPU cores * 2.5。
  • CPU usage(1.5.0+ 版本):当系统 CPU 使用率超过阈值即触发系统保护(取值范围 0.0-1.0),比较灵敏。
  • 平均 RT:当单台机器上所有入口流量的平均 RT 达到阈值即触发系统保护,单位是毫秒。
  • 并发线程数:当单台机器上所有入口流量的并发线程数达到阈值即触发系统保护。
  • 入口 QPS:当单台机器上所有入口流量的 QPS 达到阈值即触发系统保护。
    在这里插入图片描述

19.8 @SentinelResource

上述兜底方案面领的问题:

  • 系统默认的,没有体现我们自己的业务要求。
  • 依照现有条件,我们自定义的处理方法又和业务代码耦合在一块,不直观。
  • 每个业务方法都添加—个兜底的,那代码膨胀加剧。
  • 全局统—的处理方法没有体现。

19.8.1 自定义限流处理逻辑

  1. 自定义公有兜底类:
    public class CustomerBlockHandler {
    
        public static Output handlerException(BlockException exception){
            return Output.failure(444,exception.getClass().getCanonicalName()+"\t客户自定义兜底方法=========1");
        }
    
        public static Output handlerException2(BlockException exception){
            return Output.failure(444,exception.getClass().getCanonicalName()+"\t客户自定义兜底方法==========2");
        }
    }
    
  2. 新增controller方法:
    	// blockHandlerClass = 兜底类,blockHandler = 兜底类中的那个方法?
        @SentinelResource(value = "customerBlockHandler",
                blockHandlerClass = CustomerBlockHandler.class,
                blockHandler = "handlerException2")
        @GetMapping("/customerBlockHandler")
        public Output byURL1(){
            return Output.success("自定义  限流成功",new Payment(2020L,"serial001"));
        }
    
  3. 增加限流规则:
    在这里插入图片描述
  4. 访问测试: 快速刷新http://localhost:8401/sentinel/rate/customerBlockHandler

19.8.2 更多注解说明

地址:https://github.com/alibaba/Sentinel/wiki/注解支持sentinelresource-注解

注意:注解方式埋点不支持 private 方法。
  • value:资源名称,必需项(不能为空)

  • entryType:entry 类型,可选项(默认为 EntryType.OUT)

  • blockHandler / blockHandlerClass: blockHandler 对应处理 BlockException 的函数名称,可选项。blockHandler 函数访问范围需要是 public,返回类型需要与原方法相匹配,参数类型需要和原方法相匹配并且最后加一个额外的参数,类型为 BlockException。blockHandler 函数默认需要和原方法在同一个类中。若希望使用其他类的函数,则可以指定 blockHandlerClass 为对应的类的 Class 对象,注意对应的函数必需为 static 函数,否则无法解析。

  • fallback / fallbackClass:fallback 函数名称,可选项,用于在抛出异常的时候提供 fallback 处理逻辑。fallback 函数可以针对所有类型的异常(除了 exceptionsToIgnore 里面排除掉的异常类型)进行处理。fallback 函数签名和位置要求:

    • 返回值类型必须与原函数返回值类型一致;
    • 方法参数列表需要和原函数一致,或者可以额外多一个 Throwable 类型的参数用于接收对应的异常。
    • fallback 函数默认需要和原方法在同一个类中。若希望使用其他类的函数,则可以指定 fallbackClass 为对应的类的 Class 对象,注意对应的函数必需为 static 函数,否则无法解析。
  • defaultFallback(since 1.6.0):默认的 fallback 函数名称,可选项,通常用于通用的 fallback 逻辑(即可以用于很多服务或方法)。默认 fallback 函数可以针对所有类型的异常(除了 exceptionsToIgnore 里面排除掉的异常类型)进行处理。若同时配置了 fallback 和 defaultFallback,则只有 fallback 会生效。defaultFallback 函数签名要求:

    • 返回值类型必须与原函数返回值类型一致;
    • 方法参数列表需要为空,或者可以额外多一个 Throwable 类型的参数用于接收对应的异常。
    • defaultFallback 函数默认需要和原方法在同一个类中。若希望使用其他类的函数,则可以指定 fallbackClass 为对应的类的 Class 对象,注意对应的函数必需为 static 函数,否则无法解析。
  • exceptionsToIgnore(since 1.6.0):用于指定哪些异常被排除掉,不会计入异常统计中,也不会进入 fallback 逻辑中,而是会原样抛出。

19.9 服务熔断

sentinel 整合 ribbon + openFeign + fallback

两种降级方法

  • fallback 运行异常降级配置

  • blockHandler sentinel控制台异常降级配置

    @SentinelResource(value = "test",blockHandler = "blockHandler降级方法",fallback ="fallback降级方法")
    

19.9.1 -> 熔断之 Ribbon 系列:

在这里插入图片描述

19.9.1 程序准备

准备三个子项目:

cloudalibaba-provider-payment9003 服务提供者
cloudalibaba-provider-payment9004 服务提供者

cloudalibaba-consumer-nacos-order84 服务消费者

服务提供者:

  1. 新建子项目cloudalibaba-provider-payment9003cloudalibaba-provider-payment9004的集群
  2. pom
    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <parent>
            <artifactId>cloud</artifactId>
            <groupId>com.xyy</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>cloudalibaba-provider-payment9003</artifactId>
    
        <dependencies>
            <!--SpringCloud ailibaba nacos -->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            </dependency>
    
            <!-- SpringBoot整合Web组件+actuator -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-actuator</artifactId>
            </dependency>
            <!--日常通用jar包配置-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
            </dependency>
            <dependency>
                <groupId>com.xyy</groupId>
                <artifactId>cloud-api-commons</artifactId>
                <version>${project.version}</version>
            </dependency>
        </dependencies>
    </project>
    
  3. yml
    server:
      port: 9003 #9004
    
    spring:
      application:
        name: nacos-payment-provider
      cloud:
        nacos:
          discovery:
            server-addr: localhost:8848 #配置Nacos地址
    
    management:
      endpoints:
        web:
          exposure:
            include: '*'
    
  4. 启动类:PaymentMain9003/9004 ,注解:@EnableDiscoveryClient
  5. 业务类controller:PaymentController
    @RestController
    public class PaymentController {
        @Value("${server.port}")
        private String serverPort;
    
        //模拟数据库
        public static HashMap<Long, Payment> hashMap = new HashMap<>();
        static
        {
            hashMap.put(1L,new Payment(1L,"28a8c1e3bc2742d8848569891fb42181"));
            hashMap.put(2L,new Payment(2L,"bba8c1e3bc2742d8848569891ac32182"));
            hashMap.put(3L,new Payment(3L,"6ua8c1e3bc2742d8848569891xt92183"));
        }
    
        @GetMapping(value = "/paymentSQL/{id}")
        public Output<Payment> paymentSQL(@PathVariable("id") Long id)
        {
            Payment payment = hashMap.get(id);
            Output<Payment> result = Output.success("from mysql,serverPort:  "+serverPort,payment);
            return result;
        }
    }
    

服务消费者

  1. 新建子项目cloudalibaba-consumer-nacos-order84

  2. pom

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <parent>
            <artifactId>cloud</artifactId>
            <groupId>com.xyy</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>cloudalibaba-consumer-nacos-order84</artifactId>
    
        <dependencies>
            <!--SpringCloud openfeign -->
            <!--
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-openfeign</artifactId>
            </dependency>
    		-->
            <!--SpringCloud ailibaba nacos -->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            </dependency>
            <!--SpringCloud ailibaba sentinel -->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
            </dependency>
    
            <!-- SpringBoot整合Web组件 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-actuator</artifactId>
            </dependency>
            <!--日常通用jar包配置-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
            <!-- 引入自己定义的api通用包,可以使用Payment支付Entity -->
            <dependency>
                <groupId>com.xyy</groupId>
                <artifactId>cloud-api-commons</artifactId>
                <version>${project.version}</version>
            </dependency>
        </dependencies>
    
    </project>
    
  3. yml

    server:
      port: 84
    
    spring:
      application:
        name: nacos-order-consumer
      cloud:
        nacos:
          discovery:
            server-addr: localhost:8848
        sentinel:
          transport:
            #配置Sentinel dashboard地址
            dashboard: localhost:8080
            #默认8719端口,假如被占用会自动从8719开始依次+1扫描,直至找到未被占用的端口
            port: 8719
    
    #消费者将要去访问的微服务名称(注册成功进nacos的微服务提供者)
    service-url:
      nacos-user-service: http://nacos-payment-provider
    
    # 激活Sentinel对Feign的支持
    feign:
      sentinel:
        enabled: true
    
  4. 启动类 OrderNacosMain84,注解:@EnableDiscoveryClient

  5. 配置类config:ApplicationContextConfig

    @Configuration
    public class ApplicationContextConfig {
    
        @Bean
        @LoadBalanced
        public RestTemplate getRestTemplate() {
            return new RestTemplate();
        }
    }
    
  6. 业务类controller:CircleBreakerController

    @RestController
    public class CircleBreakerController {
        public static final String SERVICE_URL = "http://nacos-payment-provider";
    
        @Resource
        private RestTemplate restTemplate;
    
        @RequestMapping("/consumer/fallback/{id}")
        @SentinelResource(value = "fallback")//没有配置
        public Output<Payment> fallback(@PathVariable Long id)
        {
            Output<Payment> result = restTemplate.getForObject(SERVICE_URL + "/paymentSQL/"+id,Output.class,id);
    
            if (id == 4) {
                throw new IllegalArgumentException ("IllegalArgumentException,非法参数异常....");
            }else if (result.getData() == null) {
                throw new NullPointerException ("NullPointerException,该ID没有对应记录,空指针异常");
            }
            return result;
        }
    }
    

19.9.2 运行错误降级

只加fallback

  1. 修改84的controller
    @RestController
    public class CircleBreakerController {
        public static final String SERVICE_URL = "http://nacos-payment-provider";
    
        @Resource
        private RestTemplate restTemplate;
    
        @RequestMapping("/consumer/fallback/{id}")
        //@SentinelResource(value = "fallback")//没有配置
        @SentinelResource(value="fallback",fallback = "handlerFallback") //运行异常 降级方法
        public Output<Payment> fallback(@PathVariable Long id)
        {
            Output<Payment> result = restTemplate.getForObject(SERVICE_URL + "/paymentSQL/"+id,Output.class,id);
    
            if (id == 4) {
                throw new IllegalArgumentException ("IllegalArgumentException,非法参数异常....");
            }else if (result.getData() == null) {
                throw new NullPointerException ("NullPointerException,该ID没有对应记录,空指针异常");
            }
            return result;
        }
        //Throwable 可以将报错信息带过来
        public Output handlerFallback(Long id,Throwable e)
        {
            return Output.failure(444,"兜底异常 handlerFallback,exception内容 \t id:"+id+"\t"+e.getMessage());
        }
    
    }
    
  2. 测试: http://localhost:84/consumer/fallback/4
    结果:在这里插入图片描述

只加 blockHandler

  1. 修改84controller:
    @RestController
    public class CircleBreakerController {
        public static final String SERVICE_URL = "http://nacos-payment-provider";
    
        @Resource
        private RestTemplate restTemplate;
    
        @RequestMapping("/consumer/fallback/{id}")
        //@SentinelResource(value = "fallback")//没有配置
        //@SentinelResource(value="fallback",fallback = "handlerFallback") //运行异常 降级方法
        @SentinelResource(value = "fallback",blockHandler = "blockHandler")     //sentinel 控制台配置违规
        public Output<Payment> fallback(@PathVariable Long id)
        {
            Output<Payment> result = restTemplate.getForObject(SERVICE_URL + "/paymentSQL/"+id,Output.class,id);
    
            if (id == 4) {
                throw new IllegalArgumentException ("IllegalArgumentException,非法参数异常....");
            }else if (result.getData() == null) {
                throw new NullPointerException ("NullPointerException,该ID没有对应记录,空指针异常");
            }
            return result;
        }
    //    //Throwable 可以将报错信息带过来
    //    public Output handlerFallback(Long id,Throwable e)
    //    {
    //        return Output.failure(444,"兜底异常 handlerFallback,exception内容 \t id:"+id+"\t"+e.getMessage());
    //    }
    
        public Output blockHandler(Long id, BlockException e)
        {
            return Output.failure(444,"兜底异常 blockHandler,exception内容   id:"+id+"   "+e.getMessage());
        }
    }
    
  2. 配置sentinel:
    在这里插入图片描述
  3. 运行测试:
    正确参数:http://localhost:84/consumer/fallback/1快速刷新会进入兜底方法
    错误参数:http://localhost:84/consumer/fallback/4 快速刷新会进入兜底方法,慢速刷新会爆500的错误

fallback和blockHandler都配置

  1. 修改84 controller

    @RestController
    public class CircleBreakerController {
        public static final String SERVICE_URL = "http://nacos-payment-provider";
    
        @Resource
        private RestTemplate restTemplate;
    
        @RequestMapping("/consumer/fallback/{id}")
        //@SentinelResource(value = "fallback")//没有配置
        //@SentinelResource(value="fallback",fallback = "handlerFallback") //运行异常 降级方法
        //@SentinelResource(value = "fallback",blockHandler = "blockHandler")     //sentinel 控制台配置违规
        @SentinelResource(value="fallback",fallback = "handlerFallback",blockHandler = "blockHandler")
        public Output<Payment> fallback(@PathVariable Long id)
        {
            Output<Payment> result = restTemplate.getForObject(SERVICE_URL + "/paymentSQL/"+id,Output.class,id);
    
            if (id == 4) {
                throw new IllegalArgumentException ("IllegalArgumentException,非法参数异常....");
            }else if (result.getData() == null) {
                throw new NullPointerException ("NullPointerException,该ID没有对应记录,空指针异常");
            }
            return result;
        }
        //Throwable 可以将报错信息带过来
        //运行异常兜底
        public Output handlerFallback(Long id,Throwable e)
        {
            return Output.failure(444,"兜底异常 handlerFallback,exception内容    id:"+id+"    "+e.getMessage());
        }
    	//sentinel控制台违规兜底
        public Output blockHandler(Long id, BlockException e)
        {
            return Output.failure(444,"兜底异常 blockHandler,exception内容   id:"+id+"   "+e.getMessage());
        }
    }
    
  2. sentinel配置:
    在这里插入图片描述

  3. 测试:
    参数正确: http://localhost:84/consumer/fallback/1快速访问会进入blockHandler兜底方法(sentinel配置)
    错误参数:http://localhost:84/consumer/fallback/4快速访问,会进入blockHandler兜底方法,而慢速访问则会因为参数不正确抛出异常进入handlerFallback兜底方法

19.9.3 异常特例

exceptionsToIgnore 出现什么异常不降级
exceptionsToTrace 出现什么异常降级

@SentinelResource(value="fallback",fallback = "handlerFallback",exceptionsToIgnore/exceptionsToTrace = {IllegalArgumentException.class} )

19.9.4 -> 熔断之 openFeign 系列:

  • 84消费者调用提供者9003
  • openFeign一般是消费侧

修改84

  1. pom: 加入以下openfeign依赖
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>
    
  2. pom: 加入以下支持
    # 激活Sentinel对Feign的支持
    feign:
      sentinel:
        enabled: true
    
  3. 启动类加入注解:
    import org.springframework.cloud.openfeign.EnableFeignClients;
    @EnableFeignClients
    
  4. 创建service:
    PaymentService 接口
    //fallback  服务报错降级类
    @FeignClient(value = "nacos-payment-provider",fallback = PaymentServiceFallback.class)
    public interface PaymentService {
    
        @GetMapping(value = "/paymentSQL/{id}")
        Output<Payment> paymentSQL(@PathVariable("id")Long id);
    }
    
    PaymentServiceFallback 实现接口
    //千万不要忘记注解
    @Component
    public class PaymentServiceFallback implements PaymentService{
    
        @Override
        public Output<Payment> paymentSQL(Long id) {
            return Output.failure(400,"openfeign服务降级返回-->> PaymentServiceFallback");
        }
    }
    
  5. 创建controller:FeignOrderController
    @RestController
    @RequestMapping("/consumer/feign")
    public class FeignOrderController {
        @Resource
        public PaymentService paymentService;
    
        @GetMapping("/getSQL/{id}")
        public Output<Payment> paymentSQL(@PathVariable("id")Long id){
            return paymentService.paymentSQL(id);
        }
    }
    
  6. 测试:http://localhost:84/consumer/feign/getSQL/1
    关闭服务端9003,9004后在次测试在这里插入图片描述

19.10 熔断框架比较

-SentinelHystrixresilience4j
隔离策略信号量隔离(并发线程数限流)线程池隔商/信号量隔离信号量隔离
熔断降级策略基于响应时间、异常比率、异常数基于异常比率基于异常比率、响应时间
实时统计实现滑动窗口(LeapArray)滑动窗口(基于RxJava)Ring Bit Buffer
动态规则配置支持多种数据源支持多种数据源有限支持
扩展性多个扩展点插件的形式接口的形式
基于注解的支持支持支持支持
限流基于QPS,支持基于调用关系的限流有限的支持Rate Limiter
流量整形支持预热模式匀速器模式、预热排队模式不支持简单的Rate Limiter模式
系统自适应保护支持不支持不支持
控制台提供开箱即用的控制台,可配置规则、查看秒级监控,机器发观等简单的监控查看不提供控制台,可对接其它监控系统

19.11 持久化(8401)

这个持久化要跟alibaba的nacos集成的,而且感觉不完整,因为目前只支持简单的流控,降级,热点,系统,授权等还未完善…可以自己写代码完善…

是什么?

一旦我们重启应用,sentinel规则将消失,生产环境需要将配置规则进行持久化。

怎么玩?

将限流配置规则持久化进Nacos保存,只要刷新8401某个rest地址,sentinel控制台的流控规则就能看到,只要Nacos里面的配置不删除,针对8401上sentinel上的流控规则持续有效。

步骤

修改8401:

  1. pom: 加入以下依赖

    <!--SpringCloud ailibaba sentinel-datasource-nacos 后续做持久化用到-->
    <dependency>
        <groupId>com.alibaba.csp</groupId>
        <artifactId>sentinel-datasource-nacos</artifactId>
    </dependency>
    
  2. yml

    spring:
      cloud:
        sentinel:
          datasource: #<---------------------------关注点,添加Nacos数据源配置
            ds1:
              nacos:
                server-addr: localhost:8848  #数据在那个nacos中
                dataId: cloudalibaba-sentinel-service	#规则名
                groupId: DEFAULT_GROUP 	#规则在那个分组
                data-type: json	#数据类型
                rule-type: flow	#规则类型:流动
    
  3. 打开nacos:配置规则:
    在这里插入图片描述

    [{
        "resource": "byUrl",
        "IimitApp": "default",
        "grade": 1,
        "count": 1, 
        "strategy": 0,
        "controlBehavior": 0,
        "clusterMode": false
    }]
    

    解释: Data ID: 8401 的 spring.application.name
    选择JSON,

    • resource:资源名称;(@SentinelResource(value))的value
    • limitApp:来源应用;
    • grade:阈值类型,0表示线程数, 1表示QPS;
    • count:单机阈值;
    • strategy:流控模式,0表示直接,1表示关联,2表示链路;
    • controlBehavior:流控效果,0表示快速失败,1表示Warm Up,2表示排队等待;
    • clusterMode:是否集群。
  4. 重启8401,访问:http://localhost:8401/sentinel/rate/byURL快速访问,会发现直接被限流
    查看sentinel的控制台: 有一条记录
    在这里插入图片描述

持久化过程: nacos跟项目配置相同规则 --> 启动项目 --> 项目会从nacos拿配置下来 --> 放入sentinel中 --> 服务停止 --> sentinel会把该服务的所有配置清空 --> 服务再次重启 --> 将会再次从nacos拿下来,配置进sentinel

json示例:

[{
    "resource": "byURL",
    "IimitApp": "default",
    "grade": 1,
    "count": 1, 
    "strategy": 0,
    "controlBehavior": 0,
    "clusterMode": false
},{
    "resource": "customerBlockHandler",
    "IimitApp": "default",
    "grade": 1,
    "count": 1, 
    "strategy": 0,
    "controlBehavior": 0,
    "clusterMode": false 
}]

当nacos的规则修改之后会自动推送到sentinel中,并不需要重启任何服务或者sentinel

20. SpringCloud Alibaba Seata处理分布式事务

官网: https://seata.io/zh-cn/

github: https://github.com/seata/seata

下载地址1: https://seata.io/zh-cn/blog/download.html

下载地址2(): https://github.com/seata/seata/tags

20.1 分布式事务问题由来

分布式前

  • 单机单库没这个问题
  • 从1:1 -> 1:N -> N:N

单体应用被拆分成微服务应用,原来的三个模块被拆分成三个独立的应用,分别使用三个独立的数据源,业务操作需要调用三三 个服务来完成。此时每个服务内部的数据一致性由本地事务来保证, 但是全局的数据一致性问题没法保证。

在这里插入图片描述

一次业务操作需要跨多个数据源或需要跨多个系统进行远程调用,就会产生分布式事务问题。

20.2 简介

以下很多代码的东西都能在下载的压缩包的conf目录下的README-zh.md找到解释,可以去看源码,或者拿sql,老版本的会在conf下有,新版本的只能去github上自己拿了

  1. 能干嘛?

    一个典型的分布式事务过程

    分布式事务处理过程的 一个ID+三组件模型

    Transaction ID XID 全局唯一的事务ID
    三组件概念

    • TC (Transaction Coordinator) - 事务协调者
      维护全局和分支事务的状态,驱动全局事务提交或回滚。
    • TM (Transaction Manager) - 事务管理器
      定义全局事务的范围:开始全局事务、提交或回滚全局事务。
    • RM (Resource Manager) - 资源管理器
      管理分支事务处理的资源,与TC交谈以注册分支事务和报告分支事务的状态,并驱动分支事务提交或回滚。
  2. 处理过程?

    TM向TC申请开启一个全局事务,全局事务创建成功并生成一个全局唯一的XID;

    XID在微服务调用链路的上下文中传播;

    RM向TC注册分支事务,将其纳入XID对应全局事务的管辖;

    TM向TC发起针对XID的全局提交或回滚决议;

    TC调度XID下管辖的全部分支事务完成提交或回滚请求。
    在这里插入图片描述

  3. 使用?

    本地 @Transactional (spring的)

    全局 @GlobalTransactional (springcloud alibaba的)

    在这里插入图片描述

    只需要使用一个 @GlobalTransactional 注解在业务方法上:

20.3 下载 | 安装 | 配置mysql

官网: https://seata.io/zh-cn/

  1. 下载
    地址: https://github.com/seata/seata/tags(我自己1.4)
    每个版本的配置可能有差异,详情请看 官网参考文档

  2. 数据源配置为mysql

    seata所有配置1.4.2源文件: https://gitee.com/xyy-kk_admin/springcloud-config/tree/master/seata-conf

    修改conf下的 file.conf 文件(提前备份)

    点我查看,官网完整配置示例

    store{
    	mode="db"
    	db {
        ## the implement of javax.sql.DataSource, such as DruidDataSource(druid)/BasicDataSource(dbcp)/HikariDataSource(hikari) etc.
        datasource = "druid"
        ## mysql/oracle/postgresql/h2/oceanbase etc.
        dbType = "mysql"
        driverClassName = "com.mysql.cj.jdbc.Driver"
    	#这里一定要加时区,否则报错(格林+8)
    	#格林威治时间 ( GMT ),这(UTC)是从英国格林威治零经度线上测得的。
        url = "jdbc:mysql://127.0.0.1:3306/seata?rewriteBatchedStatements=true&serverTimezone=GMT%2B8"
        user = "root"
        password = "root"
      }
    }
    service {
      #事务服务组映射,后缀(_tx_group)
      vgroupMapping.my_test_tx_group = "xyy_tx_group"
      #只支持注册时。Type =file,请不要设置多个地址
      default.grouplist = "127.0.0.1:8091"
      #降级,当前不支持
      enableDegrade = false
      #禁用seata
      disableGlobalTransaction = false
    }
    
  3. 修改registry.conf文件(提前备份)

    registry {
      type = "nacos"
      nacos {
      	# nacos注册服务名
        application = "seata-server"
        #nacos地址
        serverAddr = "127.0.0.1:8848"
        #SEATA_GROUP nacos服务名称
        group = "SEATA_GROUP"
        #命名空间
        namespace = ""
        cluster = "default"
        username = "nacos"
        password = "nacos"
      }
    }
    
  4. mysql创建数据库:

    CREATE DATABASE seata

  5. 导入表:

    20.2 简介第一行

    SQL获取地址: https://gitee.com/xyy-kk_admin/springcloud-config/tree/master/seata-sql自行导入…

    linux 可以先把文件放到服务器中,在脚本目录中登陆mysqlmysql -uroot -p,然后执行use seata选择seata数据库执行导入命令source mysql.sql

  6. 启动服务:

    要先启动nacos再启动seata,别搞错了,因为Seata要注册进入nacos

    window:
    nacos --> startup.cmd -m standalone
    seata --> cmd或双击: seata-server.bat

    linux
    nacos -->sh startup.sh -m standalone
    seata --> sh seata-server.sh

  7. 查看服务:登陆naocs
    在这里插入图片描述

20.4 订单/库存/账户业务数据准备

以下需要nacos和seata都启动成功配置好mysql!!!

分布式业务说明:

  • 这里我们会创建三个服务,一个订单服务,一个库存服务,一个账户服务。

  • 当用户下单时,会在订单服务中创建一个订单, 然后通过远程调用库存服务来扣减下单商品的库存,再通过远程调用账户服务来扣减用户账户里面的余额,最后在订单服务中修改订单状态为已完成。

  • 该操作跨越三个数据库,有两次远程调用,很明显会有分布式事务问题。

    下订单—>扣库存—>减账户(余额)。

数据库 and 表 创建步骤:

完整SQL地址: 完整执行SQL即可不看下面的代码跳到20.5 订单/库存/账户微服务准备

数据库结构(成品):
在这里插入图片描述

  1. 创建数据库:
    seata_ order:存储订单的数据库;
    seata_ storage:存储库存的数据库;
    seata_ account:存储账户信息的数据库。

    CREATE DATABASE seata_order;
    CREATE DATABASE seata_storage;
    CREATE DATABASE seata_account;
    
  2. seata_order库下建 t_order 表

    USE `seata_order`;
    CREATE TABLE t_order (
        `id` BIGINT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY,
        `user_id` BIGINT(11) DEFAULT NULL COMMENT '用户id',
        `product_id` BIGINT(11) DEFAULT NULL COMMENT '产品id',
        `count` INT(11) DEFAULT NULL COMMENT '数量',
        `money` DECIMAL(11,0) DEFAULT NULL COMMENT '金额',
        `status` INT(1) DEFAULT NULL COMMENT '订单状态: 0:创建中; 1:已完结'
    ) ENGINE=INNODB DEFAULT CHARSET=utf8;
    
  3. seata_storage 库下建 t_storage 表,并插入一条数据

    USE `seata_storage`;
    CREATE TABLE t_storage (
    	`id` BIGINT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY,
    	`product_id` BIGINT(11) DEFAULT NULL COMMENT '产品id',
    	`total` INT(11) DEFAULT NULL COMMENT '总库存',
    	`used` INT(11) DEFAULT NULL COMMENT '已用库存',
    	`residue` INT(11) DEFAULT NULL COMMENT '剩余库存'
    ) ENGINE=INNODB DEFAULT CHARSET=utf8;
    
    INSERT INTO seata_storage.t_storage(`id`, `product_id`, `total`, `used`, `residue`)
    VALUES ('1', '1', '100', '0','100');
    
  4. seata_account 库下建 t_account 表,并插入一条数据

    USE `seata_account`;
    CREATE TABLE t_account(
    	`id` BIGINT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY COMMENT 'id',
    	`user_id` BIGINT(11) DEFAULT NULL COMMENT '用户id',
    	`total` DECIMAL(10.0) DEFAULT NULL COMMENT '总额度',
    	`used` DECIMAL(10.0) DEFAULT NULL COMMENT '已用余额',
    	`residue` DECIMAL(10.0) DEFAULT '0' COMMENT '剩余可用额度'
    ) ENGINE=INNODB DEFAULT CHARSET=utf8;
    
    INSERT INTO seata_account.t_account(`id`, `user_id`, `total`, `used`, `residue`)
    VALUES ('1', '1', '1000', '0', '1000');
    
  5. 回滚日志表

    官网地址: https://github.com/seata/seata/blob/develop/script/client/at/db/mysql.sql

    订单(order)-库存(storage)-账户(account)3个库下都需要键各自的回滚日志表

    #  USE `seata_storage`;
    #  USE `seata_account`;
    USE `seata_order`;
    CREATE TABLE IF NOT EXISTS `undo_log`
    (
        `branch_id`     BIGINT       NOT NULL COMMENT '部门事务 id',
        `xid`           VARCHAR(128) NOT NULL COMMENT '全局事务 id',
        `context`       VARCHAR(128) NOT NULL COMMENT '撤消日志上下文,如序列化',
        `rollback_info` LONGBLOB     NOT NULL COMMENT '回滚信息',
        `log_status`    INT(11)      NOT NULL COMMENT '0:正常状态,1:防御状态',
        `log_created`   DATETIME(6)  NOT NULL COMMENT '创建时间',
        `log_modified`  DATETIME(6)  NOT NULL COMMENT '最新修改时间',
        UNIQUE KEY `ux_undo_log` (`xid`, `branch_id`)
    ) ENGINE = INNODB
      AUTO_INCREMENT = 1
      DEFAULT CHARSET = utf8 COMMENT ='AT transaction mode undo table';
    

20.5 订单/库存/账户微服务准备

下订单 -> 减库存 -> 扣余额 -> 改(订单)状态

20.5.1 订单Order-Module

项目结构:
在这里插入图片描述

  1. 新建子项目seata-order-service2001

  2. pom

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xmlns="http://maven.apache.org/POM/4.0.0"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <parent>
            <artifactId>cloud</artifactId>
            <groupId>com.xyy</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>seata-order-service2001</artifactId>
    
        <dependencies>
            <!--nacos-->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            </dependency>
            <!--seata  自带1.0.0,用1.4.2改一下-->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-seata</artifactId>
            </dependency>
            <dependency>
                <groupId>io.seata</groupId>
                <artifactId>seata-all</artifactId>
                <version>1.4.2</version>
            </dependency>
    
            <!--openfeign-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-openfeign</artifactId>
            </dependency>
    
            <!--web-actuator-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-actuator</artifactId>
            </dependency>
    
            <!--mysql-druid-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <optional>true</optional>
            </dependency>
        </dependencies>
    </project>
    
  3. yml

    tx-service-group的值请去查看20.3 配置文件的file.conf 下的service

    server:
      port: 2001
    
    spring:
      application:
        name: seata-order-service
      cloud:
        nacos:
          discovery:
            server-addr: localhost:8848
        alibaba:
          seata:
            #这个在 conf文件下的 service.vgroupMapping.my_test_tx_group = "xyy_tx_group"
            tx-service-group: xyy_tx_group
      datasource:
        #数据库8.0的配置方式
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://localhost:3306/seata_order?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8
        username: root
        password: root
    #一定要false吧hystrix服务降级关了,否则如果报错全局事务将无法进行
    feign:
      hystrix:
        enabled: false
    
    logging:
      level:
        io:
          seata: info
    
    mybatis:
      type-aliases-package: com.xyy.springcloudalibaba.entity
      mapperLocations: classpath:mapper/*.xml
    
  4. conf
    跟application.yml同级

    file.conf
    注意更改vgroupMapping.后面的值
    disableGlobalTransaction 一定要等于false才是打开事务,true是关闭事务

    transport {
      # tcp, unix-domain-socket
      type = "TCP"
      #NIO, NATIVE
      server = "NIO"
      #enable heartbeat
      heartbeat = true
      # the client batch send request enable
      enableClientBatchSendRequest = true
      #thread factory for netty
      threadFactory {
        bossThreadPrefix = "NettyBoss"
        workerThreadPrefix = "NettyServerNIOWorker"
        serverExecutorThread-prefix = "NettyServerBizHandler"
        shareBossWorker = false
        clientSelectorThreadPrefix = "NettyClientSelector"
        clientSelectorThreadSize = 1
        clientWorkerThreadPrefix = "NettyClientWorkerThread"
        # netty boss thread size
        bossThreadSize = 1
        #auto default pin or 8
        workerThreadSize = "default"
      }
      shutdown {
        # when destroy server, wait seconds
        wait = 3
      }
      serialization = "seata"
      compressor = "none"
    }
    service {
      #transaction service group mapping
      vgroupMapping.xyy_tx_group = "default"
      #only support when registry.type=file, please don't set multiple addresses
      default.grouplist = "127.0.0.1:8091"
      #degrade, current not support
      enableDegrade = false
      #disable seata
      disableGlobalTransaction = false
    }
    
    client {
      rm {
        asyncCommitBufferLimit = 10000
        lock {
          retryInterval = 10
          retryTimes = 30
          retryPolicyBranchRollbackOnConflict = true
        }
        reportRetryCount = 5
        tableMetaCheckEnable = false
        tableMetaCheckerInterval = 60000
        reportSuccessEnable = false
        sagaBranchRegisterEnable = false
        sagaJsonParser = jackson
        sagaRetryPersistModeUpdate = false
        sagaCompensatePersistModeUpdate = false
        tccActionInterceptorOrder = -2147482648 #Ordered.HIGHEST_PRECEDENCE + 1000
      }
      tm {
        commitRetryCount = 5
        rollbackRetryCount = 5
        defaultGlobalTransactionTimeout = 60000
        degradeCheck = false
        degradeCheckPeriod = 2000
        degradeCheckAllowTimes = 10
        interceptorOrder = -2147482648 #Ordered.HIGHEST_PRECEDENCE + 1000
      }
      undo {
        dataValidation = true
        onlyCareUpdateColumns = true
        logSerialization = "jackson"
        logTable = "undo_log"
        compress {
          enable = true
          # allow zip, gzip, deflater, 7z, lz4, bzip2, default is zip
          type = zip
          # if rollback info size > threshold, then will be compress
          # allow k m g t
          threshold = 64k
        }
      }
      loadBalance {
          type = "RandomLoadBalance"
          virtualNodes = 10
      }
    }
    log {
      exceptionRate = 100
    }
    

    registry.conf:
    都注册进入nacos

    registry {
      # file 、nacos 、eureka、redis、zk、consul、etcd3、sofa、custom
      type = "nacos"
    
      nacos {
        application = "seata-server"
        serverAddr = "127.0.0.1:8848"
        group = "SEATA_GROUP"
        namespace = ""
        username = "nacos"
        password = "nacos"
      }
      eureka {
        serviceUrl = "http://localhost:8761/eureka"
        weight = "1"
      }
      redis {
        serverAddr = "localhost:6379"
        db = "0"
        password = ""
        timeout = "0"
      }
      zk {
        serverAddr = "127.0.0.1:2181"
        sessionTimeout = 6000
        connectTimeout = 2000
        username = ""
        password = ""
      }
      consul {
        serverAddr = "127.0.0.1:8500"
        aclToken = ""
      }
      etcd3 {
        serverAddr = "http://localhost:2379"
      }
      sofa {
        serverAddr = "127.0.0.1:9603"
        region = "DEFAULT_ZONE"
        datacenter = "DefaultDataCenter"
        group = "SEATA_GROUP"
        addressWaitTime = "3000"
      }
      file {
        name = "file.conf"
      }
      custom {
        name = ""
      }
    }
    
    config {
      # file、nacos 、apollo、zk、consul、etcd3、springCloudConfig、custom
      type = "nacos"
    
      nacos {
        serverAddr = "127.0.0.1:8848"
        namespace = ""
        group = "SEATA_GROUP"
        username = "nacos"
        password = "nacos"
        dataId = "seata.properties"
      }
      consul {
        serverAddr = "127.0.0.1:8500"
        aclToken = ""
      }
      apollo {
        appId = "seata-server"
        apolloMeta = "http://192.168.1.204:8801"
        namespace = "application"
        apolloAccesskeySecret = ""
      }
      zk {
        serverAddr = "127.0.0.1:2181"
        sessionTimeout = 6000
        connectTimeout = 2000
        username = ""
        password = ""
        nodePath = "/seata/seata.properties"
      }
      etcd3 {
        serverAddr = "http://localhost:2379"
      }
      file {
        name = "file.conf"
      }
      custom {
        name = ""
      }
    }
    
  5. 实体类entity:

    output 实体类点我

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Order {
        private Long id;
        private Long userId;
        private Long productId;
        private Integer count;
        private BigDecimal money;
        private Integer status; //订单状态:0:创建中;1:已完结
    }
    
  6. 接口 OrderMapper 和OrderMapper.xml

    import com.xyy.springcloudalibaba.entity.Order;
    import org.apache.ibatis.annotations.Mapper;
    import org.apache.ibatis.annotations.Param;
    @Mapper
    public interface OrderMapper {
        //1, 新建订单
        void create(Order order);
        //2. 修改订单状态,0-->1
        Integer update(@Param("id") Long id);
    }
    

    xml: 按照自己的路径修改

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
    
    <mapper namespace="com.xyy.springcloudalibaba.mapper.OrderMapper">
    
        <resultMap id="BaseResultMap" type="com.xyy.springcloudalibaba.entity.Order">
            <id column="id" property="id" jdbcType="BIGINT"/>
            <result column="user_id" property="userId" jdbcType="BIGINT"/>
            <result column="product_id" property="productId" jdbcType="BIGINT"/>
            <result column="count" property="count" jdbcType="INTEGER"/>
            <result column="money" property="money" jdbcType="DECIMAL"/>
            <result column="status" property="status" jdbcType="INTEGER"/>
        </resultMap>
    
        <insert id="create" useGeneratedKeys="true" keyProperty="id"
                parameterType="com.xyy.springcloudalibaba.entity.Order">
            insert into t_order (id, user_id, product_id, count, money, status)
            values (null, #{userId}, #{productId}, #{count}, #{money}, 0);
        </insert>
        
        <update id="update">
            update t_order
            set status = 1
            where id = ${id}
        </update>
    </mapper>
    
  7. 业务类 service:

    OrderService:

    import com.xyy.springcloudalibaba.entity.Order;
    
    public interface OrderService {
        Long create(Order order);
    }
    

    AccountFeignService:

    import com.xyy.springcloudalibaba.entity.Output;
    import org.springframework.cloud.openfeign.FeignClient;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    
    import java.math.BigDecimal;
    
    @FeignClient(value = "seata-account-service")
    public interface AccountFeignService {
    	//使用说明方式去访问其他服务的方法
        @PostMapping(value = "/account/decrease")
        Output decrease(@RequestParam("userId") Long userId, @RequestParam("money") BigDecimal money);
    }
    

    StorageFeignService:

    import com.xyy.springcloudalibaba.entity.Output;
    import org.springframework.cloud.openfeign.FeignClient;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    
    @FeignClient(value = "seata-storage-service")
    public interface StorageFeignService {
    	//使用说明方式去访问其他服务的方法
        @PostMapping(value = "/storage/decrease")
        Output decrease(@RequestParam("productId") Long productId, @RequestParam("count") Integer count);
    
    }
    

    OrderServiceImpl:

    import com.xyy.springcloudalibaba.entity.Order;
    import com.xyy.springcloudalibaba.entity.Output;
    import com.xyy.springcloudalibaba.mapper.OrderMapper;
    import com.xyy.springcloudalibaba.service.AccountFeignService;
    import com.xyy.springcloudalibaba.service.OrderService;
    import com.xyy.springcloudalibaba.service.StorageFeignService;
    import io.seata.spring.annotation.GlobalTransactional;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.stereotype.Service;
    
    import javax.annotation.Resource;
    
    @Service
    @Slf4j
    public class OrderServiceImpl implements OrderService {
        @Resource
        private OrderMapper orderMapper;
        @Resource
        private StorageFeignService storageFeignService;
        @Resource
        private AccountFeignService accountFeignService;
    
        /**
         * 创建订单->调用库存服务扣减库存->调用账户服务扣减账户余额->修改订单状态
         * 简单说:下订单->扣库存->减余额->改状态
         */
        @Override
        //@GlobalTransactional   //暂时不要启动这个注解
        public Long create(Order order) {
            log.info("----->开始新建订单");
            //1 新建订单
            orderMapper.create(order);
            log.info("----->订单id为:" + order.getId());
            //2 扣减库存
            log.info("----->订单微服务开始调用库存,做扣减Count");
            storageFeignService.decrease(order.getProductId(), order.getCount());
            log.info("----->订单微服务开始调用库存,做扣减end");
    
            //3 扣减账户
            log.info("----->订单微服务开始调用账户,做扣减Money");
    		accountFeignService.decrease(order.getUserId(), order.getMoney());
            log.info("----->订单微服务开始调用账户,做扣减end");
    
            //4 修改订单状态,从零到1,1代表已经完成
            log.info("----->修改订单状态开始");
            orderMapper.update(order.getId());
            log.info("----->修改订单状态结束");
    
            log.info("----->下订单结束了,O(∩_∩)O哈哈~");
            return order.getId();
        }
    }
    
  8. 业务类controller:OrderController

    import com.xyy.springcloudalibaba.entity.Order;
    import com.xyy.springcloudalibaba.entity.Output;
    import com.xyy.springcloudalibaba.service.OrderService;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.annotation.Resource;
    
    @RestController
    @RequestMapping("order")
    public class OrderController {
    
        @Resource
        private OrderService orderService;
    
        //http://localhost:2001/order/create?userId=1&productId=1&cout=10&money=100
        @GetMapping("create")
        public Output create(Order order) {
            Long orderid = orderService.create(order);
            return Output.success("成功", "订单id: " + orderid);
        }
    }
    
  9. 配置类:

    MyBatisConfig:

    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.context.annotation.Configuration;
    
    @Configuration
    @MapperScan("com.xyy.springcloudalibaba.mapper")
    public class MyBatisConfig {
    }
    

    DataSourceProxyConfig:

    import com.alibaba.druid.pool.DruidDataSource;
    import io.seata.rm.datasource.DataSourceProxy;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.mybatis.spring.SqlSessionFactoryBean;
    import org.mybatis.spring.transaction.SpringManagedTransactionFactory;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
    
    import javax.sql.DataSource;
    
    
    /**
     * 使用Seata对数据源进行代理
     */
    @Configuration
    public class DataSourceProxyConfig {
    	
    	//mybatis.mapperLocations在yml里定义的 mapper.xml路径
        @Value("${mybatis.mapperLocations}")
        private String mapperLocations;
    
        @Bean
        @ConfigurationProperties(prefix = "spring.datasource")
        public DataSource druidDataSource() {
            return new DruidDataSource();
        }
    
        @Bean
        public DataSourceProxy dataSourceProxy(DataSource dataSource) {
            return new DataSourceProxy(dataSource);
        }
    
        @Bean
        public SqlSessionFactory sqlSessionFactoryBean(DataSourceProxy dataSourceProxy) throws Exception {
            SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
            sqlSessionFactoryBean.setDataSource(dataSourceProxy);
            sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(mapperLocations));
            sqlSessionFactoryBean.setTransactionFactory(new SpringManagedTransactionFactory());
            return sqlSessionFactoryBean.getObject();
        }
    }
    
  10. 启动类: SeataOrderMain2001

    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    import org.springframework.cloud.openfeign.EnableFeignClients;
    
    @EnableDiscoveryClient  //注册nacos启动
    @EnableFeignClients	//feign启动
    @SpringBootApplication(exclude = DataSourceAutoConfiguration.class)  //排除自带的数据源配置,用自己配置的
    public class SeataOrderMain2001 {
        public static void main(String[] args) {
            SpringApplication.run(SeataOrderMain2001.class, args);
        }
    }
    

启动测试没有问题(不要打开order实现类中的那个注解)

20.5.2 库存 storage-Module

项目结构:
在这里插入图片描述

  1. 创建子项目seata-storage-service2002

  2. pom跟seata-order-service2001的pom相同

  3. yml
    除了这些不一样以外,其他一模一样

    server:
      port: 2002
    
    spring:
      application:
        name: seata-storage-service
      datasource:
        # 数据库变了`seata_storage`
        url: jdbc:mysql://localhost:3306/seata_storage?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8
    
  4. file.confregistry.confseata-order-service2001的一模一样

  5. 实体类entity:

    output 实体类点我

    Storage

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Storage {
    
        private Long id;
    
        /**
         * 产品id
         */
        private Long productId;
    
        /**
         * 总库存
         */
        private Integer total;
    
        /**
         * 已用库存
         */
        private Integer used;
    
        /**
         * 剩余库存
         */
        private Integer residue;
    }
    
  6. mapper :

    @Mapper
    public interface StorageMapper {
        //扣减库存
        Integer decrease(@Param("productId") Long productId, @Param("count") Integer count);
    }
    

    xml

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
    
    <mapper namespace="com.xyy.springcloudalibaba.mapper.StorageMapper">
    
        <resultMap id="BaseResultMap" type="com.xyy.springcloudalibaba.entity.Storage">
            <id column="id" property="id" jdbcType="BIGINT"/>
            <result column="product_id" property="productId" jdbcType="BIGINT"/>
            <result column="total" property="total" jdbcType="INTEGER"/>
            <result column="used" property="used" jdbcType="INTEGER"/>
            <result column="residue" property="residue" jdbcType="INTEGER"/>
        </resultMap>
    
        <update id="decrease">
            UPDATE
                t_storage
            SET used    = used + #{count},
                residue = residue - #{count}
            WHERE product_id = #{productId}
        </update>
    
    </mapper>
    
  7. 业务类 service:

    StorageService:

    public interface StorageService {
        //扣减库存
        void decrease(Long productId, Integer count);
    }
    

    StorageServiceImpl:

    @Service
    @Slf4j
    public class StorageServiceImpl implements StorageService {
    
        @Resource
        private StorageMapper storageMapper;
    
        @Override
        public void decrease(Long productId, Integer count) {
            log.info("----->开始减库存");
            log.info("--->productId="+productId+"  count="+count);
            Integer result = storageMapper.decrease(productId, count);
            log.info("---->result="+result);
            log.info("----->结束减库存");
        }
    }
    
  8. 业务类controller:

    import com.xyy.springcloudalibaba.entity.Output;
    import com.xyy.springcloudalibaba.service.StorageService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    @RequestMapping("storage")
    public class StorageController {
    
        @Autowired
        private StorageService storageService;
    
        //  扣减库存
        @PostMapping("decrease")
        public Output decrease(Long productId, Integer count) {
            storageService.decrease(productId, count);
            return Output.success("扣减库存成功!",null);
        }
    }
    
  9. config : 跟seata-order-service2001相同

  10. 启动类 : SeataStorageMain2002

    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    @EnableDiscoveryClient
    @SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
    public class SeataStorageMain2002 {
        public static void main(String[] args) {
            SpringApplication.run(SeataStorageMain2002.class,args);
        }
    }
    

20.5.2 存款Account-Module

项目结构:
在这里插入图片描述

  1. 创建子项目seata-account-service2003

  2. pom跟seata-order-service2001的pom相同

  3. yml
    除了这些不一样以外,其他一模一样

    server:
      port: 2003
    
    spring:
      application:
        name: seata-account-service
      datasource:
        # 数据库变了`seata_storage`
        url: jdbc:mysql://localhost:3306/seata_account?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8
    
  4. file.confregistry.confseata-order-service2001的一模一样

  5. 实体类entity:

    output 实体类点我

    Account

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Account {
    
        private Long id;
    
        /**
         * 用户id
         */
        private Long userId;
    
        /**
         * 总额度
         */
        private BigDecimal total;
    
        /**
         * 已用额度
         */
        private BigDecimal used;
    
        /**
         * 剩余额度
         */
        private BigDecimal residue;
    }
    
  6. mapper :

    @Mapper
    public interface AccountMapper {
    
        // 扣减账户余额
        Integer decrease(@Param("userId") Long userId, @Param("money") BigDecimal money);
    }
    

    xml

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
    
    <mapper namespace="com.xyy.springcloudalibaba.mapper.AccountMapper">
    
        <resultMap id="BaseResultMap" type="com.xyy.springcloudalibaba.entity.Account">
            <id column="id" property="id" jdbcType="BIGINT"/>
            <result column="user_id" property="userId" jdbcType="BIGINT"/>
            <result column="total" property="total" jdbcType="DECIMAL"/>
            <result column="used" property="used" jdbcType="DECIMAL"/>
            <result column="residue" property="residue" jdbcType="DECIMAL"/>
        </resultMap>
    
        <update id="decrease">
            UPDATE t_account
            SET residue = residue - #{money},
                used    = used + #{money}
            WHERE user_id = #{userId};
        </update>
    </mapper>
    
    
  7. 业务类 service:

    AccountService:

    public interface AccountService {
    
        /**
         * 扣减账户余额
         * @param userId 用户id
         * @param money 金额
         */
        void decrease(@RequestParam("userId") Long userId, @RequestParam("money") BigDecimal money);
    }
    

    AccountServiceImpl:

    @Service
    @Slf4j
    public class AccountServiceImpl implements AccountService {
        @Resource
        private AccountMapper accountMapper;
    
        /**
         * 扣减账户余额
         */
        @Override
        public void decrease(Long userId, BigDecimal money) {
            log.info("------->account-service中扣减账户余额开始");
            log.info("--->userId:"+userId+"   money:"+money);
            //模拟超时异常(feign默认一秒,没响应就报错),全局事务回滚
            //先注释不搞异常
            //try {
            //    Thread.sleep(30000);
            //} catch (InterruptedException e) {
            //    e.printStackTrace();
            //}
            Integer result = accountMapper.decrease(userId,money);
            log.info("---->result="+result);
            log.info("------->account-service中扣减账户余额结束");
        }
    }
    
  8. 业务类controller:

    @RestController
    @RequestMapping("/account")
    public class AccountController {
    
        @Resource
        private AccountService accountService;
    
        /**
         * 扣减账户余额
         */
        @PostMapping("/decrease")
        public Output decrease(@RequestParam("userId") Long userId, @RequestParam("money") BigDecimal money){
            accountService.decrease(userId,money);
            return Output.success("扣减账户余额成功!",null);
        }
    }
    
    
  9. config : 跟seata-storage-service2002相同

  10. 启动类 : SeataAccountMain2003

    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    
    @EnableDiscoveryClient
    @SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
    public class SeataAccountMain2003 {
        public static void main(String[] args) {
            SpringApplication.run(SeataAccountMain2003.class,args);
        }
    }
    

20.6 整体完成测试

  1. 启动服务:
    启动 nacos
    启动 seata
    启动seata-order-service2001 订单服务
    启动seata-storage-service2002 库存服务
    启动seata-account-service2003 账户服务

  2. 访问http://localhost:2001/order/create?userId=1&productId=1&count=10&money=100
    用户1,买商品id为1,买10件,一共100元

  3. 结果:
    页面结果:
    在这里插入图片描述
    2001(订单)控制台:
    在这里插入图片描述

    数据库:
    在这里插入图片描述

    2002(库存)控制台:
    **加粗样式**

    数据库: 在这里插入图片描述

    2003(账户)控制台: 在这里插入图片描述

    数据库:
    在这里插入图片描述

可以看到数据完美没有出错

20.7 设置异常测试

  1. 将2003连接超时

    将2003的实现类AccountServiceImpl线程休眠打开

  2. 重启2003,再次访问地址测试
    在这里插入图片描述
    2001(订单)数据库:订单状态还在进行中: 在这里插入图片描述
    2002(库存)数据库:库存已出
    在这里插入图片描述
    2003(账户)数据库:被扣款(30秒后的结果)
    在这里插入图片描述

可以看到订单还在创建中,并没有结束,假如2003在扣款前抛出异常的话,订单有了,库存已减,就是亏损了啊

20.8 事务解决异常进行回滚

  1. 在所有方法最开始调用的地方加上注解: @GlobalTransactional
    也就是在seata-order-service2001 OrderServiceImpl类的create方法上:

    public class OrderServiceImpl implements OrderService {
    	@GlobalTransactional
        public Long create(Order order) {
       		...
        }
    }
    
  2. 重启seata-order-service2001, 这时2001控制台可能会反复一直报错:

    2021-07-09 14:14:19.682 ERROR 4688 — [ileListener_3_1] io.seata.config.FileConfiguration : fileListener execute error, dataId :service.disableGlobalTransaction
    在这里插入图片描述
    不用管,这个好像是senta 1.4.2 的bug:官网问答中不止我一个人是这样的

  3. 再次访问: http://localhost:2001/order/create?userId=1&productId=1&count=10&money=100
    在这里插入图片描述
    还是500,查看数据库:

    2001(订单)数据库: 在这里插入图片描述
    2002(库存)数据库:
    在这里插入图片描述
    2003(账户)数据库:
    在这里插入图片描述

  4. 结果:

    查看2002控制台和2003控制台发现并不是没有执行访问,而是执行访问之后报错,但是数据库并没有订单和库存被扣除的数据,这就是Seata的全局事务注解@GlobalTransactional

20.9 深度总结**

seata 简介:

各种模式介绍:https://seata.io/zh-cn/docs/overview/what-is-seata.html

2019年1月份蚂蚁金服和阿里巴巴共同开源的分布式事务解决方案

Simple Extensible Autonomous Transaction Architecture,简单可扩展自治事务框架

TC/TM/RM三大组件:
在这里插入图片描述
分布式事务的执行流程

  • TM开启分布式事务(TM向TC注册全局事务记录) ;
  • 按业务场景,编排数据库、服务等事务内资源(RM向TC汇报资源准备状态) ;
  • TM结束分布式事务,事务一阶段结束(TM通知TC提交/回滚分布式事务) ;
  • TC汇总事务信息,决定分布式事务是提交还是回滚;
  • TC通知所有RM提交/回滚资源,事务二阶段结束。

AT模式如何做到对业务的无侵入

  • 基于支持本地 ACID 事务的关系型数据库。

  • Java 应用,通过 JDBC 访问数据库。
    整体机制

    两阶段提交协议的演变:

    • 一阶段:业务数据和回滚日志记录在同一个本地事务中提交,释放本地锁和连接资源。
    • 二阶段:
      提交异步化,非常快速地完成。
      回滚通过一阶段的回滚日志进行反向补偿。

在一阶段,Seata会拦截“业务SQL”

  1. 解析SQL语义,找到“业务SQL" 要更新的业务数据,在业务数据被更新前,将其保存成"before image”
  2. 执行“业务SQL" 更新业务数据,在业务数据更新之后,
  3. 其保存成"after image”,最后生成行锁。

以上操作全部在一个数据库事务内完成, 这样保证了一阶段操作的原子性。
在这里插入图片描述

二阶段提交

二阶段如果顺利提交的话,因为"业务SQL"在一阶段已经提交至数据库,所以Seata框架只需将一阶段保存的快照数据和行锁删掉,完成数据清理即可。
在这里插入图片描述
二阶段回滚

  1. 二阶段如果是回滚的话,Seata 就需要回滚一阶段已经执行的 “业务SQL",还原业务数据。

  2. 回滚方式便是用"before image"还原业务数据;但在还原前要首先要校验脏写,对比“数据库当前业务数据”和"after image"。

  3. 如果两份数据完全一致就说明没有脏写, 可以还原业务数据,如果不一致就说明有脏写, 出现脏写就需要转人工处理。

在这里插入图片描述


  • 3
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值