本笔记学习自B站尚硅谷Springcloud时所记录
笔记内容包括了:Springcloud的H版以及Alibaba版本
点击直达
SpringCloud Alibaba的中文使用教程
SpringCloud Alibaba的学习地址
SpringCloud Alibaba的Github地址
SpringCloud Alibaba英文使用教程
Spring Cloud Alibaba 致力于提供微服务开发的一站式解决方案。此项目包含开发分布式应用微服务的必需组件,方便开发者通过 Spring Cloud 编程模型轻松使用这些组件来开发分布式应用服务。
依托 Spring Cloud Alibaba,您只需要添加一些注解和少量配置,就可以将 Spring Cloud 应用接入阿里微服务解决方案,通过阿里中间件来迅速搭建分布式应用系统。
诞生:2018.10.31,Spring Cloud Alibaba 正式入驻了Spring Cloud官方孵化器,并在Maven 中央库发布了第一个版本。
@GlobalTransactional
注解, 高效并且对业务零侵入地解决分布式事务问题。 <dependencyManagement>
<dependencies>
<dependency>
<groupId>com.alibaba.cloudgroupId>
<artifactId>spring-cloud-alibaba-dependenciesartifactId>
<version>2.2.5.RELEASEversion>
<type>pomtype>
<scope>importscope>
dependency>
dependencies>
dependencyManagement>
Sentinel:把流量作为切入点,从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。
Nacos:一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。
RocketMQ:一款开源的分布式消息系统,基于高可用分布式集群技术,提供低延时的、高可靠的消息发布与订阅服务。
Dubbo:Apache Dubbo™ 是一款高性能 Java RPC 框架。
Seata:阿里巴巴开源产品,一个易于使用的高性能微服务分布式事务解决方案。
Alibaba Cloud OSS: 阿里云对象存储服务(Object Storage Service,简称 OSS),是阿里云提供的海量、安全、低成本、高可靠的云存储服务。您可以在任何应用、任何时间、任何地点存储和访问任意类型的数据。
Alibaba Cloud SchedulerX: 阿里中间件团队开发的一款分布式任务调度产品,提供秒级、精准、高可靠、高可用的定时(基于 Cron 表达式)任务调度服务。
Alibaba Cloud SMS: 覆盖全球的短信服务,友好、高效、智能的互联化通讯能力,帮助企业迅速搭建客户触达通道。
更多组件请参考 Roadmap。
Eureka + Config + Bus
的组合环境准备: 本地Java8+Maven环境需要安装并配置OK
下载地址: 官网
安装使用
nacos\bin\startup.cmd
文件,将里面的配置改成如下图所示:nacos\conf\application.properties
文件,取消以下注释nacos\conf\nacos-mysql.sql
文件nacos\bin\shutdown.cmd
服务访问: 命令运行成功后直接访问http://localhost:8848/nacos
,默认账号密码都是nacos
第一步: 新建一个Module,名为:cloud-provider-alibaba-payment9001
第二步: 改pom文件
<dependency>
<groupId>com.alibaba.cloudgroupId>
<artifactId>spring-cloud-alibaba-dependenciesartifactId>
<version>2.1.0.RELEASEversion>
<type>pomtype>
<scope>importscope>
dependency>
cloud-provider-alibaba-payment9001
服务中引入以下依赖:
<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>cloud2021artifactId>
<groupId>com.oldou.springcloudgroupId>
<version>1.0-SNAPSHOTversion>
parent>
<modelVersion>4.0.0modelVersion>
<artifactId>cloud-provider-alibaba-payment9001artifactId>
<dependencies>
<dependency>
<groupId>com.alibaba.cloudgroupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
<version>2.2.5.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-actuatorartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-devtoolsartifactId>
<scope>runtimescope>
<optional>trueoptional>
dependency>
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
<optional>trueoptional>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
dependencies>
project>
第三步: 改yml文件
server:
port: 9001
spring:
application:
name: nacos-payment-provider
cloud:
nacos:
discovery:
server-addr: localhost:8848 #注册到哪,这里是配置Nacos的地址
management:
endpoints:
web:
exposure:
include: '*'
第四步: 主启动类
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
@EnableDiscoveryClient
@SpringBootApplication
public class PaymentMain9001 {
public static void main(String[] args) {
SpringApplication.run(PaymentMain9001.class, args);
}
}
第五步: 业务类
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class PaymentController {
@Value("${server.port}")
private String serverPort;
@GetMapping(value = "/pay/nacos/{id}")
public String getPay(@PathVariable("id") Integer id) {
return "nacos registry, serverPort: "+ serverPort+"\t id"+id;
}
}
第六步: 启动测试,访问:http://localhost:9001/pay/nacos/1
同时,nacos的服务列表中,该服务就已经注册进去了。
同样的,参照以上步骤,新建一个cloud-provider-alibaba-payment9002
的服务
提问: 为什么nacos支持负载均衡?
答:因为spring-cloud-starter-alibaba-nacos-discovery内含netflix-ribbon包。
第一步: 新建一个Module,名为:cloud-consumer-alibaba-nacos-order83
第二步: 改pom文件
<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>cloud2021artifactId>
<groupId>com.oldou.springcloudgroupId>
<version>1.0-SNAPSHOTversion>
parent>
<modelVersion>4.0.0modelVersion>
<artifactId>cloud-consumer-alibaba-nacos-order83artifactId>
<dependencies>
<dependency>
<groupId>com.alibaba.cloudgroupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
<version>2.2.5.RELEASEversion>
dependency>
<dependency>
<groupId>com.oldou.springcloudgroupId>
<artifactId>cloud-api-commonsartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-actuatorartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-devtoolsartifactId>
<scope>runtimescope>
<optional>trueoptional>
dependency>
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
<optional>trueoptional>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
dependencies>
project>
第三步: 改yml文件
server:
port: 83
spring:
application:
name: nacos-order-consumer
cloud:
nacos:
discovery:
server-addr: localhost:8848
#这里是消费者将要去访问的微服务名称(注册成功进nacos的微服务提供者名称)
service-url:
nacos-user-service: http://nacos-payment-provider
第四步: 主启动类
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
@EnableDiscoveryClient
@SpringBootApplication
public class OrderNacosMain83 {
public static void main(String[] args) {
SpringApplication.run(OrderNacosMain83.class,args);
}
}
第五步: 业务类
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
@Configuration
public class ApplicationContextConfig {
@Bean
@LoadBalanced
public RestTemplate getRestTemplate() {
return new RestTemplate();
}
}
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import javax.annotation.Resource;
@RestController
@Slf4j
public class OrderNacosController {
@Resource
private RestTemplate restTemplate;
@Value("${service-url.nacos-user-service}")
private String serverURL;
@GetMapping(value = "/consumer/pay/nacos/{id}")
public String payInfo(@PathVariable("id") Long id) {
return restTemplate.getForObject(serverURL+"/pay/nacos/"+id,String.class);
}
}
第六步: 启动测试
http://localhost:83/consumer/pay/nacos/13
Nacos和CAP
Nacos服务发现实例模型
重点注意: Nacos支持AP和CP模式的切换
何时选择使用何种模式?
—般来说,如果不需要存储服务级别的信息且服务实例是通过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
第一步: 新建一个Module,名为:cloud-config-alibaba-nacos-client3377
第二步: 改pom文件
<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>cloud2021artifactId>
<groupId>com.oldou.springcloudgroupId>
<version>1.0-SNAPSHOTversion>
parent>
<modelVersion>4.0.0modelVersion>
<artifactId>cloud-config-alibaba-nacos-client3377artifactId>
<dependencies>
<dependency>
<groupId>com.alibaba.cloudgroupId>
<artifactId>spring-cloud-starter-alibaba-nacos-configartifactId>
<version>2.2.5.RELEASEversion>
dependency>
<dependency>
<groupId>com.alibaba.cloudgroupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
<version>2.2.5.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-actuatorartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-devtoolsartifactId>
<scope>runtimescope>
<optional>trueoptional>
dependency>
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
<optional>trueoptional>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
dependencies>
project>
第三步: 改yml文件
Nacos同springcloud-config一样,在项目初始化时,要保证先从配置中心进行配置拉取,拉取配置之后,才能保证项目的正常启动。
springboot中配置文件的加载是存在优先级顺序的,bootstrap优先级高于application
创建以下两个配置文件
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中的匹配规则公式,dataId的完整格式如下:
# ${prefix}-${spring.profile.active}.${file-extension} 最终公式如下:
# ${spring.application.name}-${spring.profile.active}.${spring.cloud.nacos.config.file-extension}
# 1、spring.application.name ---服务的名称
# 2、spring.profile.active --- 当前环境对应的profile,当这个为空时,对应的连接符 - 也将不存在,
# dataId会变成${spring.application.name}.${spring.cloud.nacos.config.file-extension}
# 但是需要注意的是,这里最好不要为空
# 3、file-extension --- 配置内容的数据格式,可以通过 spring.cloud.nacos.config.file-extension 来进行配置
# 目前只支持properties 和 yaml 两种类型
# spring.application.name 为 nacos-config-client
# spring.profile.active 为 application.yml文件中的配置,值为 dev
# spring.cloud.nacos.config.file-extension 为 yaml
# 我们按照最终公式,当前环境的dataId最终为:nacos-config-client-dev.yaml
# nacos-config-client-test.yaml ----> config.info
application.yml
spring:
profiles:
active: dev # 表示开发环境
#active: test # 表示测试环境
#active: prod
第四步: 主启动类
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
@EnableDiscoveryClient
@SpringBootApplication
public class NacosConfigClientMain3377 {
public static void main(String[] args) {
SpringApplication.run(NacosConfigClientMain3377.class, args);
}
}
第五步: 业务类
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RefreshScope //此注解支持Nacos的动态刷新功能。
public class ConfigClientController {
@Value("${config.info}")
private String configInfo;
@GetMapping("/config/info")
public String getConfigInfo() {
return configInfo;
}
}
第六步:DataId配置属性介绍
Nacos中的dataid的组成格式及与SpringBoot配置文件中的匹配规则
官方文档说明
说明:之所以需要配置spring.application.name,是因为它是构成Nacos配置管理dataId 字段的一部分。
在 Nacos Spring Cloud中,dataId的完整格式如下:
${prefix}-${spring-profile.active}.${file-extension}
prefix
:默认为spring.application.name
的值,也可以通过配置项spring.cloud.nacos.config.prefix来配置。spring.profile.active
:即为当前环境对应的 profile,详情可以参考 Spring Boot文档。注意:当spring.profile.active
为空时,对应的连接符 - 也将不存在,datald 的拼接格式变成${prefix}.${file-extension}
file-exetension
:为配置内容的数据格式,可以通过配置项spring .cloud.nacos.config.file-extension
来配置。目前只支持properties
和yaml
类型。@RefreshScope
实现配置自动更新。最后公式如下所示:
${spring.application.name)}-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}
在我们这个配置中心的服务中,最终的dataId名为:nacos-config-client-dev.yaml,具体为什么是这个,请查看我在配置文件中标注的注释
启动cloud-config-alibaba-nacos-client3377
Nacos自带动态刷新功能
我们在启动服务的情况下,修改下Nacos中的yaml配置文件,再次调用查看配置的接口,就会发现配置信息会根据修改进行动态刷新。
问题一:多环境多项目管理
(1)我们在实际开发中,通常一个系统会有多个环境【开发、测试、生产…等等】,那么如何保证指定环境启动时服务能正确读取到Nacos上相应环境的配置文件呢?
(2)一个大型分布式微服务系统会有很多微服务子项目,每个微服务项目又都会有相应的开发环境、测试环境、预发环境、正式环境…怎么对这些微服务配置进行管理呢?
Nacos的图形化管理界面
我们在Nacos的界面中发现,Nacos有DataId、Group、命名空间。
提问:Namespace+Group+Data lD三者有什么关系?为什么这么设计?
三者情况如下图所示:
默认情况:Namespace=public,Group=DEFAULT_GROUP,默认Cluster是DEFAULT
Nacos默认的Namespace
【命名空间】是public,Namespace主要用来实现隔离。
Group
默认是DEFAULT_GROUP,Group可以把不同的微服务划分到同一个分组里面去
Service
就是微服务:一个Service可以包含多个Cluster (集群),Nacos默认Cluster是DEFAULT,Cluster是对指定微服务的一个虚拟划分。
最后是Instance
,就是微服务的实例。
重点: 指定spring.profile.active
和配置文件的DatalD
来使不同环境下读取不同的配置
默认空间+默认分组+新建dev和test两个DatalD
spring.profile.active
属性就能进行多环境下配置文件的读取,这里我们配置读取test的【nacos-config-client-test.yaml】http://localhost:3377/config/info
通过Group实现环境区分:新建两个相同DataId的配置文件,但是配置时使用不同的分组。
接下来我们还需要去修改bootstrap.yml和application.yml文件
启动测试:
将bootstrap.yml中的分组配置成DEV_GROUP
因此,以上就实现了DataId相同,但是可以根据配置分组来实现不同环境的隔离。
通过Namespace实现环境区分:Nacos有一个默认的命名空间public,这个命名空间不可修改/删除,同时当我们新建一个命令空间时,新建的命名空间会有一个命名空间ID。
命名空间创建之后,我们可以在配置管理中进行选择,并新建配置
我们在dev命名空间下新建以下三个配置:
YML更改: 由于我们使用命名空间,所以要添加配置,这里由于我使用的是dev,因此要将dev的命名空间id给设置进去
测试
学会使用命名空间很重要,这里我不过多介绍,其余的自行测试。
Nacos集群官方文档说明
官网架构图
集群部署架构图
因此开源的时候推荐用户把所有服务列表放到一个vip下面,然后挂到一个域名下面
根据官方给出的介绍,总结如下:
以上结构图中,配置Nacos的集群,首先需要Nginx集群,Nacos集群,还有就是数据库Mysql
Nacos的环境部署介绍
Nacos默认使用嵌入式数据库实现数据的存储。如果启动多个默认配置下的Nacos节点,数据存储是存在一致性问题的。为了解决这个问题,Nacos采用了集中式存储的方式来支持集群化部署,目前只支持MySQL的存储。
Nacos支持三种部署模式
Nacos默认自带的是嵌入式数据库derby,nacos的pom.xml中就可以看出。
而我们要实现持久化,一般会使用Mysql。
将Nacos从derby到mysql切换配置步骤在安装Nacos处就已经介绍过:
我们先去数据库中,创建一个名为nacos的数据库,字符集为utf-8,排序规则为如下所示,然后在该数据库中导入nacos\conf\nacos-mysql.sql
文件
找到nacos\conf\application.properties
文件,取消以下注释,同时填写好自己数据库信息
启动Nacos,可以看到是个全新的空记录界面,以前是记录进derby,当然了,这里我们安装的时候就已经将持久化设置成了Mysql,所以记录还是会有的。
实际上,我们要配置Nacos的集群的话,是需要2个Nginx+3个Nacos注册中心+Mysql集群,但是这里不过多介绍。
环境需求: 我们需要1个Nginx+3个nacos注册中心+1个mysql
安装步骤:
tar -zxf nacos-server-2.0.2.tar.gz nacos
cp nacos /usr/local/ -r
cd /usr/local/nacos/bin
cp startup.sh startup.sh.bk -r
第一步:Linux服务器上mysql数据库配置
nacos_config
nacos-mysql.sql
脚本第二步:修改application.properties文件
/usr/local/nacos/conf/application.properties
cp application.properties application.properties.init
vim application.properties
第三步:Linux服务器上Nacos的集群配置cluster.conf
目的:梳理出三台Nacos机器的不同服务端口号【3333、4444、5555】
文件备份:cp cluster.conf.example cluster.conf
编辑:vim cluster.conf
,注意,这里的ip不能写127.0.0.1,必须是Linux命令hostname -i
能够识别的ip
进入到bin目录下,备份好startup.sh文件之后,开始编辑
vim startup.sh
需要注意的是,新版的nacos中的p不是端口,不是端口,不是端口,重要的说三遍,找了好久的原因。
到最底部,修改如下所示:
nohup $JAVA - Dserver.port=${PORT} ${JAVA_OPT} nacos.nacos >> ${BASE_DIR}/logs/start.out 2>&1 &
# 注意:EMBEDDED_STORAGE就是上图中的 EMBEDDED_STORAGE=$OPTARG;;
由于Nacos启动的话,所占用的内存会非常大,因此我们需要调一下内存,这里我们设置最大为256m最小为128m。可根据自身情况进行设定。 如果内存大的请忽略该修改
第五步:启动方式
startup.sh - t 端口号
startup.sh - t 3333
就是启动了端口3333的nacos,然后再执行startup.sh - t 4444
就相当于又启动了端口4444的nacos到这里,Nacos的配置基本上就是完成了,接下来就是配置Nginx了。
Nginx的安装目录如下所示,这里因为我在/usr/local下已经有一个Nginx了,所以安装在这个位置
备份nginx.conf文件: cp nginx.conf nginx.conf.bk
启动三台Nacos
查看Nacos是否启动了三台:ps -ef|grep nacos|grep -v grep | wc -l
如果三台nacos启动不了的话,可能是配置错误或者是需要重启一下虚拟机
启动Nginx,/root/upload-file/nginx/sbin/nginx -c /root/upload-file/nginx/conf/nginx.conf
查看Nginx是否启动:ps -ef|grep nginx
访问Nacos:http://192.168.15.131:1111/nacos/#/login
以上测试结果表示配置成功,接下来我们让微服务cloud-provider-alibaba-payment9002
启动注册进nacos集群 - 修改配置文件
server:
port: 9002
spring:
application:
name: nacos-payment-provider
c1oud:
nacos:
discovery:
#配置Nacos地址
#server-addr: Localhost:8848
#换成nginx的1111端口,做集群
server-addr: 192.168.111.144:1111
management:
endpoints:
web:
exposure:
inc1ude: '*'
配置文件中的地址写成Nginx的地址以及端口,然后由Nginx转发给Nacos集群
高可用总结:
以上测试中,我们9002服务找到Nginx,Nacos集群的机器数目是多少不用管,服务只找Nginx,然后由Nginx进行转发,转发到Nacos集群中的某台机器,最后写进Mysql,最终实现高可用。
Sentinel是什么?
Sentinel的基本特征:
服务中遇到的各种问题:
为什么已经有Hystrix了还要出现Sentinel?
Sentinel 分为两个部分:
Sentinel的官方使用教程
Sentinel的下载地址
下载到本地是一个sentinel-dashboard-1.8.2.jar
如何运行?
java -jar +sentinel的jar包就可以了
localhost:8080
,账号密码均为sentinel
前提:
需要新建一个微服务,该微服务注册进Nacos,同时使用Sentinel进行流量监控
第一步: 新建一个Module,名为:cloud-alibaba-sentinel-service8401
第二步: 改pom文件
<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>cloud2021artifactId>
<groupId>com.oldou.springcloudgroupId>
<version>1.0-SNAPSHOTversion>
parent>
<modelVersion>4.0.0modelVersion>
<artifactId>cloud-alibaba-sentinel-service8401artifactId>
<dependencies>
<dependency>
<groupId>com.oldou.springcloudgroupId>
<artifactId>cloud-api-commonsartifactId>
<version>1.0-SNAPSHOTversion>
dependency>
<dependency>
<groupId>com.alibaba.cloudgroupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
dependency>
<dependency>
<groupId>com.alibaba.cspgroupId>
<artifactId>sentinel-datasource-nacosartifactId>
dependency>
<dependency>
<groupId>com.alibaba.cloudgroupId>
<artifactId>spring-cloud-starter-alibaba-sentinelartifactId>
dependency>
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-starter-openfeignartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-actuatorartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-devtoolsartifactId>
<scope>runtimescope>
<optional>trueoptional>
dependency>
<dependency>
<groupId>cn.hutoolgroupId>
<artifactId>hutool-allartifactId>
dependency>
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
<optional>trueoptional>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
dependencies>
project>
第三步: 改yml文件
server:
port: 8401
spring:
application:
name: cloud-alibaba-sentinel-service
cloud:
nacos:
discovery:
server-addr: localhost:8848 #Nacos服务注册中心地址
sentinel:
transport:
dashboard: localhost:8080 #配置Sentinel dashboard地址
port: 8719
management:
endpoints:
web:
exposure:
include: '*'
feign:
sentinel:
enabled: true # 激活Sentinel对Feign的支持
第四步: 主启动类
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
@EnableDiscoveryClient
@SpringBootApplication
public class MainApp8401 {
public static void main(String[] args) {
SpringApplication.run(MainApp8401.class, args);
}
}
第五步: 业务类
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@Slf4j
public class FlowLimitController {
@GetMapping("/testA")
public String testA() {
return "------testA";
}
@GetMapping("/testB")
public String testB() {
log.info(Thread.currentThread().getName()+"\t"+"...testB");
return "------testB";
}
}
第六步: 启动测试,启动微服务cloud-alibaba-sentinel-service8401
去Sentinel Dashboard管理界面上查看
我们发现,Sentinel的监控页面空空如也,啥都没有,这是因为Sentinel采用的懒加载机制
我们访问以下8401服务上的接口,Sentinel Dashboard实时监控8401
http://localhost:8401/testA
,http://localhost:8401/testB
,多访问几次总结: sentinel8080正在监控微服务8401
上节我们介绍了流控规则的基本参数,这节我们开始配置,【QPS–>直接–>快速失败】
重点:当调用该API的每秒钟的请求数量达到阈值的时候,进行限流。
我们打开Sentinel dashboard,点击左边的簇点链路
我们本地要对/testA
接口添加一个流控,点击右边的流控
,设置的意思为:当我们的/testA
接口每秒请求超过【单机阈值】一次,那么就会【直接快速失败】直接报错。
点击新建之后,我们就可以在流控规则出看到新增了一条规则,此规则可进行修改/删除
测试:
http://localhost:8401/testA
,当一秒钟访问一次的时候,是没有任何问题的,但是一秒钟超过一次之后,就会报错Blocked by Sentinel (flow limiting) 哨兵阻挡(流量限制)
当然,这是Sentinel默认的提示信息,我们是可以对提示信息进行设置的,它可以进行自定义的后续处理,类似fallback的兜底方法,请看后文设置。
重点:当调用该API的线程数达到阈值的时候,进行限流。
我们在/testA
接口中添加一个线程睡眠800ms:
然后去Sentinel的监控页面,编辑流控规则,将阈值类型改成【并发线程数】,点击确认
测试:
Sentinel流控有三种模式,分别是:直接【默认】、关联、链路,而此次我们讲解的是关联
关联:当自己关联的资源达到阈值时,就限流自己。
当与A关联的资源B达到阀值后,就限流A自己(B惹事,A挂了)
我们cloud-alibaba-sentinel-service8401
服务中有/testA
和/testB
两个接口,因此我们设置/testA
,打开Sentinel 控制台,找到流控规则,点击编辑
将代码中的延时去除:
使用Postman工具模拟并发密集访问testB
结论: 大批量线程高并发访问B,由于B与A进行了关联,所以导致A失效了。
应用场景: 当双十一的时候,当支付接口达到阈值以后,就限流下订单的服务防止连座效应。
Sentinel流控-链路:只记录指定链路上的流量(指定资源从入口资源进来的流量,如果达到阈值,就进行限流)【API级别的针对来源】
官网地址
概念: 预热,Warm Up(RuleConstant.CONTROL_BEHAVIOR_WARM_UP
)方式,即预热/冷启动方式,当系统长期处于低水位的情况下,当流量突然增加时,直接把系统拉升到高水位可能瞬间把系统压垮。通过"冷启动",让通过的流量缓慢增加,在一定时间内逐渐增加到阈值上限,给冷系统一个预热的时间,避免冷系统被压垮。
默认coldFactor为3,即请求QPS 从 threshold / 3开始,经预热时长逐渐升至设定的QPS阈值。链接
我们设置testA,希望它每秒钟能够承受10个请求,但是我们给它慢慢预热起来,冷加载因子默认是3,一运行的时候单机阈值就是【10/3=3】个,然后给你一个缓存预热的时间5秒,在5秒后,单机阈值慢慢的从3个升到10个。
【系统初始化的阀值为10/ 3约等于3,即阀值刚开始为3;然后过了5秒后阀值才慢慢升高恢复到10】
公式: 阈值除以coldFactor(默认值是3),经过预热时长后才会达到阈值
源码 - com.alibaba.csp.sentinel.slots.block.flow.controller.WarmUpController
测试: 将testA设置成如下所示:
不断迅速刷新访问testA,就会发现访问成功,然后报错,然后成功,然后报错然后一直成功。
应用场景 :秒杀系统在开启的瞬间,会有很多流量上来,很有可能把系统打死,预热方式就是把为了保护系统,可慢慢的把流量放进来,慢慢的把阀值增长到设置的阀值。
排队等待: 匀速排队,让请求以均匀的速度通过,阀值类型必须设成QPS,否则无效。
个人理解: 当B的QPS设置成1时,此时有大量的请求同时访问B接口,此时B只会一秒钟处理一个请求,其他的请求超时也好等待也好随意。
设置: /testB每秒1次请求,超过的话就排队等待,等待的超时时间为20000毫秒
匀速排队: RuleConstant.CONTROL_BEHAVIOR_RATE_LIMITER
,此方式会严格控制请求通过的间隔时间,也即是让请求以均匀的速度通过,对应的是漏桶算法。详细文档可以参考 流量控制 - 匀速器模式,具体的例子可以参见 PaceFlowDemo。
这种方式主要用于处理间隔性突发的流量,例如消息队列。想象一下这样的场景,在某一秒有大量的请求到来,而接下来的几秒则处于空闲状态,我们希望系统能够在接下来的空闲期间逐渐处理这些请求,而不是在第一秒直接拒绝多余的请求。
注意:匀速排队模式暂时不支持 QPS > 1000 的场景。链接
源码 - com.alibaba.csp.sentinel.slots.block.flow.controller.RateLimiterController
测试:
官方文档介绍
熔断降级概述
除了流量控制以外,对调用链路中不稳定的资源进行熔断降级也是保障高可用的重要措施之一。一个服务常常会调用别的模块,可能是另外的一个远程服务、数据库,或者第三方 API 等。例如,支付的时候,可能需要远程调用银联提供的 API;查询某个商品的价格,可能需要进行数据库查询。然而,这个被依赖服务的稳定性是不能保证的。如果依赖的服务出现了不稳定的情况,请求的响应时间变长,那么调用服务的方法的响应时间也会变长,线程会产生堆积,最终可能耗尽业务自身的线程池,服务本身也变得不可用。
现代微服务架构都是分布式的,由非常多的服务组成。不同服务之间相互调用,组成复杂的调用链路。以上的问题在链路调用中会产生放大的效果。复杂链路上的某一环不稳定,就可能会层层级联,最终导致整个链路都不可用。因此我们需要对不稳定的弱依赖服务调用进行熔断降级,暂时切断不稳定调用,避免局部不稳定因素导致整体的雪崩。熔断降级作为保护自身的手段,通常在客户端(调用端)进行配置。
RT----平均响应时间,秒级,V1.7及以下版本
Dcsp.sentinel.statistic.max.rt=XXXX
才能生效)。异常比列—秒级
异常数----分钟统计
注意:Sentinel 1.7.0才有平均响应时间(DEGRADE_GRADE_RT),Sentinel 1.8.0的没有这项,取而代之的是慢调用比例 (SLOW_REQUEST_RATIO)。
慢调用比例 (SLOW_REQUEST_RATIO):选择以慢调用比例作为阈值,需要设置允许的慢调用 RT(即最大的响应时间),请求的响应时间大于该值则统计为慢调用。当单位统计时长(statIntervalMs)内请求数目大于设置的最小请求数目,并且慢调用的比例大于阈值,则接下来的熔断时长内请求会自动被熔断。经过熔断时长后熔断器会进入探测恢复状态(HALF-OPEN 状态),若接下来的一个请求响应时间小于设置的慢调用 RT 则结束熔断,若大于设置的慢调用 RT 则会再次被熔断。链接
Sentinel熔断降级介绍
Sentinel熔断降级会在调用链路中某个资源出现不稳定状态时(例如调用超时或异常比例升高),对这个资源的调用进行限制,让请求快速失败,避免影响到其它的资源而导致级联错误。
当资源被降级后,在接下来的降级时间窗口之内,对该资源的调用都自动熔断(默认行为是抛出 DegradeException)。
Sentinei的断路器是没有类似Hystrix半开状态的。(Sentinei 1.8.0 已有半开状态)
半开的状态系统自动去检测是否请求有异常,没有异常就关闭断路器恢复使用,有异常则继续打开断路器不可用。
Sentinel实现的熔断其实就会导致服务降级。
RT的基本概念:
DEGRADE_GRADE_RT
):当1s内持续进入5个请求,对应时刻的平均响应时间(秒级)均超过阈值( count,以ms为单位),那么在接下的时间窗口(DegradeRule中的timeWindow,以s为单位)之内,对这个方法的调用都会自动地熔断(抛出DegradeException )。-Dcsp.sentinel.statistic.max.rt=xxx
来配置。RT测试
@GetMapping("/testC")
public String testC() {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
log.info("testC 测试RT");
return "testC 测试RT";
}
测试结果:按照上述配置,永远一秒钟打进来10个线程(大于5个了)调用testD,我们希望200毫秒处理完本次任务,如果超过200毫秒还没处理完,在未来1秒钟的时间窗口内,断路器打开(保险丝跳闸)微服务不可用,保险丝跳闸断电了后续我停止jmeter,没有这么大的访问量了,断路器关闭(保险丝恢复),微服务恢复OK。
由于Sentinel 1.7.0才有平均响应时间(DEGRADE_GRADE_RT
),但是Sentinel 1.8.0的没有这项,取而代之的是慢调用比例 (SLOW_REQUEST_RATIO
)。
选择以慢调用比例作为阈值,需要设置允许的慢调用 RT(即最大的响应时间),请求的响应时间大于该值则统计为慢调用。当单位统计时长(statIntervalMs)内请求数目大于设置的最小请求数目,并且慢调用的比例大于阈值,则接下来的熔断时长内请求会自动被熔断。经过熔断时长后熔断器会进入探测恢复状态(HALF-OPEN 状态),若接下来的一个请求响应时间小于设置的慢调用 RT 则结束熔断,若大于设置的慢调用 RT 则会再次被熔断。链接
也就是说Sentinel在1.8.0版本对熔断降级做了大的调整,可以定义任意时长的熔断时间,引入了半开启恢复支持。
V1.8版本的熔断状态: 有三种,分别为OPEN、HALF_OPEN、CLOSED
熔断降级支持慢调用比例、异常比例、异常数三种熔断策略。
熔断(OPEN): 请求数大于最小请求数并且慢调用的比率大于比例阈值则发生熔断,熔断时长为用户自定义设置。
探测(HALFOPEN): 当熔断过了定义的熔断时长,状态由熔断(OPEN)变为探测(HALFOPEN)。
如果接下来的一个请求小于最大RT,说明慢调用已经恢复,结束熔断,状态由探测(HALF_OPEN)变更为关闭(CLOSED)
如果接下来的一个请求大于最大RT,说明慢调用未恢复,继续熔断,熔断时长保持一致
注意Sentinel默认统计的RT上限是4900ms,超出此阈值的都会算作4900ms,若需要变更此上限可以通过启动配置项-Dcsp.sentinel.statistic.max.rt=xxx
来配置
Sentinel V1.7版本
基本概念:
异常比例(
DEGRADE_GRADE_EXCEPTION_RATIO
):当资源的每秒请求量 >= 5,并且每秒异常总数占通过量的比值超过阈值( DegradeRule中的 count)之后,资源进入降级状态,即在接下的时间窗口(DegradeRule
中的timeWindow
,以s为单位)之内,对这个方法的调用都会自动地返回。异常比率的阈值范围是[0.0, 1.0]
,代表0% -100%。
也就是说,满足QPS≥5,并且每秒异常总数占通过量的比值超过阈值( DegradeRule中的 count)这两个条件才能触发服务熔断降级。
1.7版本测试:
@GetMapping("/testD")
public String testD() {
log.info("testD 异常比例");
int age = 10/0;
return "------testD";
}
但是需要注意的是,以上描述的是Sentinel1.8之前的,与Sentinel 1.8.0相比,有些不同(Sentinel 1.8.0才有的半开状态),Sentinel 1.8.0的如下:
Sentinel V1.8版本
异常比例(
ERROR_RATIO
):当单位统计时长(statIntervalMs
)内请求数目大于设置的最小请求数目,并且异常的比例大于阈值,则接下来的熔断时长内请求会自动被熔断。经过熔断时长后熔断器会进入探测恢复状态(HALF-OPEN 状态),若接下来的一个请求成功完成(没有错误)则结束熔断,否则会再次被熔断。异常比率的阈值范围是 [0.0, 1.0],代表 0% - 100%。链接
statIntervalMs
)内请求数目大于设置的最小请求数目之前的QPS是每秒内的请求次数大于5次,这个在1.8版本之前是限定死的,不可修改,而在1.8版本之后,这些是可以设置的,按照上图中的设置,意思就是:设置了2秒内的请求大于大于5个,并且请求数目中发生异常的比例≥20%,那么接下来在2秒内请求会被自动熔断,当2秒后的下一个请求成功了则会结束熔断,否则会再次被熔断
Sentinel V1.7版本
异常数(
DEGRADE_GRADF_EXCEPTION_COUNT
):当资源近1分钟的异常数目超过阈值之后会进行熔断。注意由于统计时间窗口是分钟级别的,若timeWindow小于60s,则结束熔断状态后码可能再进入熔断状态。
注意:异常数是按照分钟统计的,时间窗口一定要大于等于60秒。
1.7版本的测试:
@GetMapping("/testE")
public String testE(){
log.info("testE 测试异常数");
int age = 10/0;
return "------testE 测试异常数";
}
注意,与Sentinel 1.8.0相比,有些不同(Sentinel 1.8.0才有的半开状态),Sentinel 1.8.0的如下:
Sentinel V1.8版本
异常数 (
ERROR_COUNT
):当单位统计时长内的异常数目超过阈值之后会自动进行熔断。经过熔断时长后熔断器会进入探测恢复状态(HALF-OPEN 状态),若接下来的一个请求成功完成(没有错误)则结束熔断,否则会再次被熔断。
热点的概念
热点即经常访问的数据。很多时候我们希望统计某个热点数据中访问频次最高的 Top K 数据,并对其访问进行限制。
比如:
热点参数限流会统计传入参数中的热点参数,并根据配置的限流阈值与模式,对包含热点参数的资源调用进行限流。热点参数限流可以看做是一种特殊的流量控制,仅对包含热点参数的资源调用生效。
Sentinel 利用 LRU 策略统计最近最常访问的热点参数,结合令牌桶算法来进行参数级别的流控。热点参数限流支持集群模式。
提示信息: 我们之前说到,Sentinel出现熔断限流后,都是用的系统默认提示: Blocked by Sentinel (flow limiting)
,那么我们能不能想Hystrix一样有一个兜底的方法,能够自己定义提示信心呢?
从HystrixCommand
到@SentinelResource
案例演示:演示第一个参数p1,当QPS超过1秒1次点击后马上被限流。
代码修改: 我们在cloud-alibaba-sentinel-service8401
服务中新增以下代码
@GetMapping("/testHotKey")
@SentinelResource(value = "testHotKey",blockHandler/*兜底方法*/ = "deal_testHotKey")
public String testHotKey(@RequestParam(value = "p1",required = false) String p1,
@RequestParam(value = "p2",required = false) String p2) {
//int age = 10/0;
return "------testHotKey";
}
/*兜底方法*/
public String deal_testHotKey (String p1, String p2, BlockException exception) {
//sentinel系统默认的提示:Blocked by Sentinel (flow limiting)
return "------deal_testHotKey,o(╥﹏╥)o";
}
Sentinel控制台配置
以上的配置说明:资源名称为@SentinelResource(value = "testHotKey",blockHandler/*兜底方法*/ = "deal_testHotKey")
的value的值,参数索引为对索引为0的参数进行限流,我们这里有两个参数【p1和p2】,因此索引为0的是p1,单机阈值设置为1,窗口时长也是设置为1,也就是说:1秒钟访问不能超过1次。方法testHotKey里面第一个参数只要QPS超过每秒1次,马上熔断降级处理
测试:
http://localhost:8401/testHotKey?p1=abc&p2=33
,先一秒刷新一次,然后1秒刷新两次及以上http://localhost:8401/testHotKey?p1=abc
http://localhost:8401/testHotKey?p2=abc
,不管你刷多少次,都不会限流。@SentinelResource的注解说明
@SentinelResource(value = "testHotKey", blockHandler = "dealHandler_testHotKey")
@SentinelResource(value = "testHotKey")
时,也就是不需要兜底的方法时,服务进行熔断降级后会将异常打到了前台用户界面看到,这样特别不友好,因此使用此注解,强烈建议配置兜底的方式。上节案例我们演示了对第一个参数p1进行热点Key的限流,当QPS超过1秒1次点击后马上被限流。本节主要讲述参数例外项
本节目标:
配置
这里需要注意的是:参数类型为8中基本数据类型和String类型,根据需要限流的参数类型进行选择,设置好特殊值之后记得要点击添加。
测试:
http://localhost:8401/testHotKey?p1=5
,当p1等于5的时候,阈值变为200,只要一秒内不超过200次,都是正常http://localhost:8401/testHotKey?p1=3
,当一秒内超过1次,就会限流注意事项:
@SentinelResource
只处理sentinel控制台配置的违规情况,有blockHandler方法配置的兜底处理,但是如果接口内报异常的话,那么是不会调用兜底的提示信息的。如下所示:
RuntimeException int age = 10/0
,这个是java运行时报出的运行时异常RunTimeException,@SentinelResource不管
@SentinelResource主管配置出错,运行出错该走异常走异常
官方文档
我们前面的限流,范围基本上是对系统的某个接口甚至方法,而本节介绍的是对整个系统进行自适应限流,举个例子说:整个系统就相当于一个小区,而里面的住户就相当于一个个的接口,之前的都是面向住户的,而这个就是面向小区所有住户的。
系统自适应限流:
Sentinel 系统自适应限流从整体维度对应用入口流量进行控制,结合应用的 Load、CPU 使用率、总体平均 RT、入口 QPS 和并发线程数等几个维度的监控指标,通过自适应的流控策略,让系统的入口流量和系统的负载达到一个平衡,让系统尽可能跑在最大吞吐量的同时保证系统整体的稳定性。
系统规则介绍
- 系统保护规则是从应用级别的入口流量进行控制,从单台机器的 load、CPU 使用率、平均 RT、入口 QPS 和并发线程数等几个维度监控应用指标,让系统尽可能跑在最大吞吐量的同时保证系统整体的稳定性。
- 系统保护规则是应用整体维度的,而不是资源维度的,并且仅对入口流量生效。入口流量指的是进入应用的流量(EntryType.IN),比如 Web 服务或 Dubbo 服务端接收的请求,都属于入口流量。
系统规则支持的模式:
(1)按照资源名称进行限流处理
目标:根据@SentinelResource
注解中属性value的值进行限流
环境:需要启动Nacos、Sentinel控制台
业务类:在cloud-alibaba-sentinel-service8401
服务中新增一个名为RateLimitController
的业务类
import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.oldou.springcloud.entities.CommonResult;
import com.oldou.springcloud.entities.Payment;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class RateLimitController {
@GetMapping("/byResource")
@SentinelResource(value = "byResource",blockHandler = "handleException")
public CommonResult byResource() {
return new CommonResult(200,"按资源名称限流测试OK",new Payment(2020L,"serial001"));
}
public CommonResult handleException(BlockException exception) {
return new CommonResult(444,exception.getClass().getCanonicalName()+"\t 服务不可用");
}
}
测试:访问http://localhost:8401/byResource
,当QPS大于1时会调用我们自定义的异常提示方法
问题:当我们在IDEA中停止cloud-alibaba-sentinel-service8401
服务的运行时,Sentinel控制台上配置的流控规则消失了!!!【持久性和临时性问题】
(2)按照访问的URL进行限流处理
@GetMapping("/rateLimit/byUrl")
@SentinelResource(value = "byUrl")
public CommonResult byUrl() {
return new CommonResult(200,"按url限流测试OK",new Payment(2020L,"serial002"));
}
http://localhost:8401/rateLimit/byUrl
,会返回Sentinel自带的限流处理结果 Blocked by Sentinel (flow limiting)(3)以上两个测试的实现出现的问题:
本节重点:自定义限流处理逻辑
自定义限流处理类
package com.oldou.springcloud.config;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.oldou.springcloud.entities.CommonResult;
public class CustomerBlockHandler {
// 注意:这里不能是private,同时必须是static的
public static CommonResult handlerException(BlockException exception) {
return new CommonResult(4444,"按客戶自定义,global handlerException----1");
}
public static CommonResult handlerException2(BlockException exception) {
return new CommonResult(4444,"按客戶自定义,global handlerException----2");
}
}
RateLimitController新增接口:
@GetMapping("/rateLimit/customerBlockHandler")
@SentinelResource(value = "customerBlockHandler", //<-------- 限流规则
blockHandlerClass = CustomerBlockHandler.class,//<-------- 指向自定义限流处理类
blockHandler = "handlerException2")//<----------- 指向那个方法
public CommonResult customerBlockHandler() {
return new CommonResult(200,"按客戶自定义",new Payment(2020L,"serial003"));
}
http://localhost:8401/rateLimit/customerBlockHandler
,多刷新几次可以看见我们自定义的提示信息已经打印出来了。解释:
@SentinelResource(value = "customerBlockHandler", //<-------- 限流规则
blockHandlerClass = CustomerBlockHandler.class,//<-------- 指向自定义限流处理类
blockHandler = "handlerException2")
value
:这里我们指向的是Sentinel中配置的流控规则blockHandlerClass
:这里的意思是当违背了流控规则之后,我们兜底的类是哪一个?blockHandler
:这个是从兜底的类中去哪个方法进行调用结论: 解决了上一节提出的四个问题。
本节重点:@SentinelResource注解的其他属性介绍
注意:此注解方式埋点不支持 private 方法。
官方文档说明
@SentinelResource
用于定义资源,并提供可选的异常处理和 fallback 配置项。
@SentinelResource
注解包含以下属性:
value
:资源名称,必需项(不能为空)entryType
:entry 类型,可选项(默认为 EntryType.OUT)blockHandler / blockHandlerClass
: blockHandler 对应处理 BlockException 的函数名称,可选项。blockHandler 函数访问范围需要是 public,返回类型需要与原方法相匹配,参数类型需要和原方法相匹配并且最后加一个额外的参数,类型为 BlockException。blockHandler 函数默认需要和原方法在同一个类中。若希望使用其他类的函数,则可以指定 blockHandlerClass 为对应的类的 Class 对象,注意对应的函数必需为 static 函数,否则无法解析。fallback /fallbackClass
:fallback 函数名称,可选项,用于在抛出异常的时候提供 fallback 处理逻辑。fallback 函数可以针对所有类型的异常(除了exceptionsToIgnore里面排除掉的异常类型)进行处理。fallback 函数签名和位置要求:
Throwable
类型的参数用于接收对应的异常。fallbackClass
为对应的类的 Class
对象,注意对应的函数必需为 static 函数,否则无法解析。defaultFallback(since 1.6.0)
:默认的 fallback 函数名称,可选项,通常用于通用的 fallback 逻辑(即可以用于很多服务或方法)。默认 fallback 函数可以针对所有类型的异常(除了exceptionsToIgnore里面排除掉的异常类型)进行处理。若同时配置了 fallback 和 defaultFallback,则只有 fallback 会生效。defaultFallback 函数签名要求:
exceptionsToIgnore(since 1.6.0)
:用于指定哪些异常被排除掉,不会计入异常统计中,也不会进入 fallback 逻辑中,而是会原样抛出。Sentinel主要有三个核心Api:SphU定义资源、Tracer定义统计、ContextUtil定义了上下文
本节目标: sentinel整合Ribbon+OpenFeign+fallback
Ribbon系列
提供者9003/9004的新建: 新建cloud-alibaba-provider-payment9003/9004
,两个一样的做法
第一步: 新建一个Module,名为:cloud-alibaba-provider-payment9003
第二步: 改pom文件
<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>cloud2021artifactId>
<groupId>com.oldou.springcloudgroupId>
<version>1.0-SNAPSHOTversion>
parent>
<modelVersion>4.0.0modelVersion>
<artifactId>cloud-alibaba-provider-payment9003artifactId>
<dependencies>
<dependency>
<groupId>com.alibaba.cloudgroupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
dependency>
<dependency>
<groupId>com.oldou.springcloudgroupId>
<artifactId>cloud-api-commonsartifactId>
<version>${project.version}version>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-actuatorartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-devtoolsartifactId>
<scope>runtimescope>
<optional>trueoptional>
dependency>
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
<optional>trueoptional>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
dependencies>
project>
第三步: 改yml文件
server:
port: 9003
spring:
application:
name: nacos-payment-provider
cloud:
nacos:
discovery:
server-addr: localhost:8848 #配置Nacos地址
management:
endpoints:
web:
exposure:
include: '*'
第四步: 主启动类
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
@SpringBootApplication
@EnableDiscoveryClient
public class PaymentMain9003 {
public static void main(String[] args) {
SpringApplication.run(PaymentMain9003.class, args);
}
}
第五步: 业务类
import com.oldou.springcloud.entities.CommonResult;
import com.oldou.springcloud.entities.Payment;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
@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 CommonResult<Payment> paymentSQL(@PathVariable("id") Long id)
{
Payment payment = hashMap.get(id);
CommonResult<Payment> result = new CommonResult(200,"from mysql,serverPort: "+serverPort,payment);
return result;
}
}
第六步: 测试
同理,9004参照9003步骤
消费者84服务
第一步: 新建一个Module,名为:cloud-alibaba-consumer-nacos-order84
第二步: 改pom文件
<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>cloud2021artifactId>
<groupId>com.oldou.springcloudgroupId>
<version>1.0-SNAPSHOTversion>
parent>
<modelVersion>4.0.0modelVersion>
<artifactId>cloud-alibaba-consumer-nacos-order84artifactId>
<dependencies>
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-starter-openfeignartifactId>
dependency>
<dependency>
<groupId>com.alibaba.cloudgroupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
dependency>
<dependency>
<groupId>com.alibaba.cloudgroupId>
<artifactId>spring-cloud-starter-alibaba-sentinelartifactId>
dependency>
<dependency>
<groupId>com.oldou.springcloudgroupId>
<artifactId>cloud-api-commonsartifactId>
<version>${project.version}version>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-actuatorartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-devtoolsartifactId>
<scope>runtimescope>
<optional>trueoptional>
dependency>
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
<optional>trueoptional>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
dependencies>
project>
第三步: 改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: false
第四步: 主启动类
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
@EnableDiscoveryClient
@SpringBootApplication
@EnableFeignClients
public class OrderNacosMain84 {
public static void main(String[] args) {
SpringApplication.run(OrderNacosMain84.class, args);
}
}
第五步: 业务类
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
@Configuration
public class ApplicationContextConfig {
@Bean
@LoadBalanced
public RestTemplate getRestTemplate() {
return new RestTemplate();
}
}
import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.oldou.springcloud.entities.CommonResult;
import com.oldou.springcloud.entities.Payment;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import javax.annotation.Resource;
@RestController
@Slf4j
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 CommonResult<Payment> fallback(@PathVariable Long id)
{
CommonResult<Payment> result = restTemplate.getForObject(SERVICE_URL + "/paymentSQL/"+id,CommonResult.class,id);
if (id == 4) {
throw new IllegalArgumentException ("IllegalArgumentException,非法参数异常....");
}else if (result.getData() == null) {
throw new NullPointerException ("NullPointerException,该ID没有对应记录,空指针异常");
}
return result;
}
}
以上就是三个服务的搭建过程,后面的测试中,修改84服务的代码以后记得要重启服务:
要实现的目标:
启动服务9003/9004、84三个,然后测试84消费者是否能够实现以负载均衡轮询的方式调用9003/9004
测试:
http://localhost:84/consumer/fallback/1
,刷新发现9003/9004的端口在不停变化,测试OKhttp://localhost:84/consumer/fallback/4
http://localhost:84/consumer/fallback/5
@SentinelResource注解的fallback管Java的运行异常
业务类Controller修改
@RestController
@Slf4j
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") //情况二:配置fallback,只负责业务异常,需要一个兜底方法handlerFallback
public CommonResult<Payment> fallback(@PathVariable Long id)
{
CommonResult<Payment> result = restTemplate.getForObject(SERVICE_URL + "/paymentSQL/"+id,CommonResult.class,id);
if (id == 4) {
throw new IllegalArgumentException ("IllegalArgumentException,非法参数异常....");
}else if (result.getData() == null) {
throw new NullPointerException ("NullPointerException,该ID没有对应记录,空指针异常");
}
return result;
}
//本例是fallback,兜底方法
public CommonResult handlerFallback(@PathVariable Long id,Throwable e) {
Payment payment = new Payment(id,"null");
return new CommonResult<>(444,"兜底异常handlerFallback,exception内容 "+e.getMessage(),payment);
}
}
访问之前的地址:http://localhost:84/consumer/fallback/4
再次访问:http://localhost:84/consumer/fallback/5
我们发现,使用了fallback,Java运行时异常返回的提示信息都变得非常友好了。
@SentinelResource注解的blockHandler管Sentinel控制台的配置违规
业务类
@RestController
@Slf4j
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") //情况二:配置fallback,只负责业务异常,需要一个兜底方法handlerFallback
@SentinelResource(value = "fallback",blockHandler = "blockHandler") //blockHandler只负责sentinel控制台配置违规
public CommonResult<Payment> fallback(@PathVariable Long id) {
CommonResult<Payment> result = restTemplate.getForObject(SERVICE_URL + "/paymentSQL/"+id,CommonResult.class,id);
if (id == 4) {
throw new IllegalArgumentException ("IllegalArgumentException,非法参数异常....");
}else if (result.getData() == null) {
throw new NullPointerException ("NullPointerException,该ID没有对应记录,空指针异常");
}
return result;
}
//本例是fallback,兜底方法
/*
public CommonResult handlerFallback(@PathVariable Long id,Throwable e) {
Payment payment = new Payment(id,"null");
return new CommonResult<>(444,"兜底异常handlerFallback,exception内容 "+e.getMessage(),payment);
}*/
//本例是blockHandler
public CommonResult blockHandler(@PathVariable Long id, BlockException blockException) {
Payment payment = new Payment(id,"null");
return new CommonResult<>(445,"blockHandler-sentinel限流,无此流水: blockException "+blockException.getMessage(),payment);
}
}
测试地址 - http://localhost:84/consumer/fallback/4
当2秒内报异常超过2次,就会触发规则,当访问第一次时,会有以下界面
当我们快速刷新,2秒内刷新两次及以上:
若blockHandler和fallback 都进行了配置,则被限流降级而抛出BlockException时只会进入blockHandler处理逻辑。
package com.oldou.springcloud.controller;
import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.oldou.springcloud.entities.CommonResult;
import com.oldou.springcloud.entities.Payment;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import javax.annotation.Resource;
@RestController
@Slf4j
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") //情况二:配置fallback,只负责业务异常,需要一个兜底方法handlerFallback
//@SentinelResource(value = "fallback",blockHandler = "blockHandler") //blockHandler只负责sentinel控制台配置违规
@SentinelResource(value = "fallback",fallback = "handlerFallback",blockHandler = "blockHandler")
public CommonResult<Payment> fallback(@PathVariable Long id) {
CommonResult<Payment> result = restTemplate.getForObject(SERVICE_URL + "/paymentSQL/"+id,CommonResult.class,id);
if (id == 4) {
throw new IllegalArgumentException ("IllegalArgumentException,非法参数异常....");
}else if (result.getData() == null) {
throw new NullPointerException ("NullPointerException,该ID没有对应记录,空指针异常");
}
return result;
}
//本例是fallback,兜底方法
public CommonResult handlerFallback(@PathVariable Long id,Throwable e) {
Payment payment = new Payment(id,"null");
return new CommonResult<>(444,"兜底异常handlerFallback,exception内容 "+e.getMessage(),payment);
}
//本例是blockHandler
public CommonResult blockHandler(@PathVariable Long id, BlockException blockException) {
Payment payment = new Payment(id,"null");
return new CommonResult<>(445,"blockHandler-sentinel限流,无此流水: blockException "+blockException.getMessage(),payment);
}
}
exceptionsToIgnore,忽略指定异常,即这些异常不用兜底方法处理。
@SentinelResource(value = "fallback",fallback = "handlerFallback",blockHandler = "blockHandler",
exceptionsToIgnore = {IllegalArgumentException.class})
// 若配置了exceptionsToIgnore 属性,那么久不会走fallback 兜底的方法
本节重点:整合OpenFeign实现服务降级
修改84模块
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-starter-openfeignartifactId>
dependency>
import com.oldou.springcloud.entities.CommonResult;
import com.oldou.springcloud.entities.Payment;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
// 服务提供者的名称 后面是服务降级的处理方法
@FeignClient(value = "nacos-payment-provider",fallback = PaymentFallbackService.class)
public interface PaymentService {
@GetMapping(value = "/paymentSQL/{id}")
public CommonResult<Payment> paymentSQL(@PathVariable("id") Long id);
}
import com.oldou.springcloud.entities.CommonResult;
import com.oldou.springcloud.entities.Payment;
import org.springframework.stereotype.Component;
@Component
public class PaymentFallbackService implements PaymentService {
@Override
public CommonResult<Payment> paymentSQL(Long id) {
return new CommonResult<>(44444,"服务降级返回,---PaymentFallbackService",new Payment(id,"errorSerial"));
}
}
@RestController
@Slf4j
public class CircleBreakerController {
...
//==================OpenFeign
@Resource
private PaymentService paymentService;
@GetMapping(value = "/consumer/paymentSQL/{id}")
public CommonResult<Payment> paymentSQL(@PathVariable("id") Long id){
return paymentService.paymentSQL(id);
}
}
http://localhost:84/consumer/paymentSQL/1
访问正常这是控制台最上面的
sun.misc.Unsafe.park(Native Method)
java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:215)
java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(AbstractQueuedSynchronizer.java:2078)
java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(ScheduledThreadPoolExecutor.java:1093)
java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(ScheduledThreadPoolExecutor.java:809)
java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1074)
java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1134)
java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
java.lang.Thread.run(Thread.java:748)
#下面的是这样
Caused by: java.lang.AbstractMethodError: com.alibaba.cloud.sentinel.feign.SentinelContractHolder.parseAndValidateMetadata(Ljava/lang/Class;)Ljava/util/List;
at feign.ReflectiveFeign$ParseHandlersByName.apply(ReflectiveFeign.java:151) ~[feign-core-10.7.4.jar:na]
at feign.ReflectiveFeign.newInstance(ReflectiveFeign.java:49) ~[feign-core-10.7.4.jar:na]
at feign.Feign$Builder.target(Feign.java:252) ~[feign-core-10.7.4.jar:na]
at org.springframework.cloud.openfeign.HystrixTargeter.target(HystrixTargeter.java:38) ~[spring-cloud-openfeign-core-2.2.2.RELEASE.jar:2.2.2.RELEASE]
at org.springframework.cloud.openfeign.FeignClientFactoryBean.loadBalance(FeignClientFactoryBean.java:253) ~[spring-cloud-openfeign-core-2.2.2.RELEASE.jar:2.2.2.RELEASE]
at org.spring
framework.cloud.openfeign.FeignClientFactoryBean.getTarget(FeignClientFactoryBean.java:282) ~[spring-cloud-openfeign-core-2.2.2.RELEASE.jar:2.2.2.RELEASE]
at org.springframework.cloud.openfeign.FeignClientFactoryBean.getObject(FeignClientFactoryBean.java:262) ~[spring-cloud-openfeign-core-2.2.2.RELEASE.jar:2.2.2.RELEASE]
at org.springframework.beans.factory.support.FactoryBeanRegistrySupport.doGetObjectFromFactoryBean(FactoryBeanRegistrySupport.java:171) ~[spring-beans-5.2.4.RELEASE.jar:5.2.4.RELEASE]
... 33 common frames omitted
之后我找了很多问题,最后发现是SpringCloud的版本问题
这个问题是由于版本冲突造成的,because:spring-cloud版本不同,openfeign的版本也不同
我将Springcloud的版本修改成2.2.0版本就可以了
问题产生的背景: 当我们重启服务的时候,我们在Sentinel控制台中配置的规则将消失,而生产环境需要将配置规则进行持久化。
解决方法: 将限流配置规则持久化进Nacos保存,只要刷新8401某个rest地址,sentinel控制台的流控规则就能看到,只要Nacos里面的配置不删除,针对8401上sentinel上的流控规则持续有效。
本次演示的服务为:cloud-alibaba-sentinel-service8401
实现持久化的步骤:
修改cloud-alibaba-sentinel-service8401服务
<dependency>
<groupId>com.alibaba.cspgroupId>
<artifactId>sentinel-datasource-nacosartifactId>
dependency>
server:
port: 8401
spring:
application:
name: cloud-alibaba-sentinel-service
cloud:
nacos:
discovery:
server-addr: localhost:8848 #Nacos服务注册中心地址
sentinel:
transport:
dashboard: localhost:8080 #配置Sentinel dashboard地址
port: 8719
datasource: #添加Nacos数据源配置,用于Sentinel的持久化 <------
ds1:
nacos:
server-addr: localhost:8848
dataId: cloud-alibaba-sentinel-service
groupId: DEFAULT_GROUP
data-type: json
rule-type: flow
management:
endpoints:
web:
exposure:
include: '*'
feign:
sentinel:
enabled: true # 激活Sentinel对Feign的支持
[{
"resource": "/rateLimit/byUrl",
"IimitApp": "default",
"grade": 1,
"count": 1,
"strategy": 0,
"controlBehavior": 0,
"clusterMode": false
}]
以上参数的介绍:
resource
:资源名称;limitApp
:来源应用;grade
:阈值类型,0表示线程数, 1表示QPS;count
:单机阈值;strategy
:流控模式,0表示直接,1表示关联,2表示链路;controlBehavior
:流控效果,0表示快速失败,1表示Warm Up,2表示排队等待;clusterMode
:是否集群。测试:
http://localhost:8401/rateLimit/byUrl
,访问成功之后我们去Sentinel控制台配置一个简单的流控规则http://localhost:8401/rateLimit/byUrl
, 页面返回Blocked by Sentinel (flow limiting)
http://localhost:8401/rateLimit/byUrl
,流控规则又重新出现了!!以上配置实现了Sentinel配置的持久化。
问题: 单体应用被拆分成微服务应用,原来的三个模块被拆分成三个独立的应用,分别使用三个独立的数据源,业务操作需要调用三个服务来完成。此时每个服务内部的数据一致性由本地事务来保证, 但是全局的数据一致性问题没法保证。
举个例子说:用户购买商品的业务逻辑,整个业务逻辑由三个微服务提供支持:
总结:一次业务操作需要跨多个数据源或需要跨多个系统进行远程调用,就会产生分布式事务问题。 因此我们要保证全局数据一致性问题。
基本概念: Seata是一款开源的分布式事务解决方案,致力于在微服务架构下提供高性能和简单易用的分布式事务服务。
作用: 它是一个典型的分布式事务过程,分布式事务处理过程的一个ID+三个组件模型:
Transaction ID XID
:全局唯一的事务IDTC (Transaction Coordinator)
:事务协调者,维护全局和分支事务的状态,驱动全局事务提交或回滚;TM (Transaction Manager)
: 事务管理器,定义全局事务的范围:开始全局事务、提交或回滚全局事务。RM (Resource Manager)
:资源管理器,管理分支事务处理的资源,与TC交谈以注册分支事务和报告分支事务的状态,并驱动分支事务提交或回滚。举例解释过程:
假设上图中的一个Microservices就是一个组,一个组是20个同学【RM是同学】,TC就是授课的老师,TM就是班主任;
大家阅读时,请注意我加粗的字体和后面的【信息】是对应的,这样加深理解。
下载地址:http://seata.io/zh-cn/blog/download.html
版本发布地址:Seata的版本发布地址
我本地下载的是Seata版本是:V1.3.0 (这里需要注意的是,别下载1.4的,有问题巨坑)
安装步骤:
第一步:解压到指定目录,进入到seata-server-1.3.0\seata\conf
目录下;
第二步:先备份file.conf
文件,我们主要修改的是【事务日志存储模式为db+数据库连接信息】【1.0版本以前需要修改自定义事务组名称】;
第三步:打开file.conf
文件进行以下修改【注意:我下载的是1.3版本的,和0.9版本的不一样】:
store {
## store mode: file、db、redis
mode = "db" # 将存储方式设置成数据库db
....
## database store property
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.jdbc.Driver"
url = "jdbc:mysql://127.0.0.1:3306/seata" #修改这里 数据库连接信息
user = "root" #修改这里 数据库连接信息
password = "root" # 修改这里 数据库连接信息
minConn = 5
maxConn = 100
globalTable = "global_table"
branchTable = "branch_table"
lockTable = "lock_table"
queryLimit = 100
maxWait = 5000
}
....
}
第四步:在mysql5.7数据库中新建一个名为seata
的数据库
第五步:在数据库seata中新建表,导入sql文件,这里我说明一下,有点坑,这个建表语句在下面这个压缩包中的seata-1.3.0\script\server\db\mysql.sql
这里,但是sql语句我给出来了
-- -------------------------------- The script used when storeMode is 'db' --------------------------------
-- the table to store GlobalSession data
CREATE TABLE IF NOT EXISTS `global_table`
(
`xid` VARCHAR(128) NOT NULL,
`transaction_id` BIGINT,
`status` TINYINT NOT NULL,
`application_id` VARCHAR(32),
`transaction_service_group` VARCHAR(32),
`transaction_name` VARCHAR(128),
`timeout` INT,
`begin_time` BIGINT,
`application_data` VARCHAR(2000),
`gmt_create` DATETIME,
`gmt_modified` DATETIME,
PRIMARY KEY (`xid`),
KEY `idx_gmt_modified_status` (`gmt_modified`, `status`),
KEY `idx_transaction_id` (`transaction_id`)
) ENGINE = InnoDB
DEFAULT CHARSET = utf8;
-- the table to store BranchSession data
CREATE TABLE IF NOT EXISTS `branch_table`
(
`branch_id` BIGINT NOT NULL,
`xid` VARCHAR(128) NOT NULL,
`transaction_id` BIGINT,
`resource_group_id` VARCHAR(32),
`resource_id` VARCHAR(256),
`branch_type` VARCHAR(8),
`status` TINYINT,
`client_id` VARCHAR(64),
`application_data` VARCHAR(2000),
`gmt_create` DATETIME(6),
`gmt_modified` DATETIME(6),
PRIMARY KEY (`branch_id`),
KEY `idx_xid` (`xid`)
) ENGINE = InnoDB
DEFAULT CHARSET = utf8;
-- the table to store lock data
CREATE TABLE IF NOT EXISTS `lock_table`
(
`row_key` VARCHAR(128) NOT NULL,
`xid` VARCHAR(96),
`transaction_id` BIGINT,
`branch_id` BIGINT NOT NULL,
`resource_id` VARCHAR(256),
`table_name` VARCHAR(32),
`pk` VARCHAR(36),
`gmt_create` DATETIME,
`gmt_modified` DATETIME,
PRIMARY KEY (`row_key`),
KEY `idx_branch_id` (`branch_id`)
) ENGINE = InnoDB
DEFAULT CHARSET = utf8;
第六步:备份此文件,并打开seata-server-1.3.0\seata\conf\registry.conf
文件作以下修改
registry {
# file 、nacos 、eureka、redis、zk、consul、etcd3、sofa
type = "nacos" # 指定注册中心为nacos <-----
loadBalance = "RandomLoadBalance"
loadBalanceVirtualNodes = 10
nacos {
application = "seata-server"
serverAddr = "localhost:8848" # 修改Nacos的链接信息 <-----
group = "SEATA_GROUP"
namespace = ""
cluster = "default"
username = ""
password = ""
}
...........
}
安装配置完成!!!
案例:SEATA 的分布式交易解决方案
我们只需要使用一个 @GlobalTransactional
注解在业务方法上;
这里我们会创建三个服务,一个订单服务,一个库存服务,一个账户服务。
当用户下单时,会在订单服务中创建一个订单, 然后通过远程调用库存服务来扣减下单商品的库存,再通过远程调用账户服务来扣减用户账户里面的余额,最后在订单服务中修改订单状态为已完成。
该操作跨越三个数据库,有两次远程调用,很明显会有分布式事务问题。
总的来说:下订单—>扣库存—>减账户(余额)。
创建业务数据库
分别在以上三个数据库中创建表:
seata_order库中新建t_order
表
CREATE TABLE `t_order` (
`id` bigint(11) NOT NULL AUTO_INCREMENT,
`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:已完结',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
SELECT * FROM t_order;
seata_storage库中新建t_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 AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
INSERT INTO seata_storage.t_storage(`id`, `product_id`, `total`, `used`, `residue`)
VALUES ('1', '1', '100', '0','100');
SELECT * FROM t_storage;
seata_account库中新建t_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 AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
INSERT INTO seata_account.t_account(`id`, `user_id`, `total`, `used`, `residue`)
VALUES ('1', '1', '1000', '0', '1000');
SELECT * FROM t_account;
按照上述3库分别建对应的回滚日志表
-- the table to store seata xid data
-- 0.7.0+ add context
-- you must to init this sql for you business databese. the seata server not need it.
-- 此脚本必须初始化在你当前的业务数据库中,用于AT 模式XID记录。与server端无关(注:业务数据库)
-- 注意此处0.3.0+ 增加唯一索引 ux_undo_log
drop table `undo_log`;
CREATE TABLE `undo_log` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`branch_id` bigint(20) NOT NULL,
`xid` varchar(100) NOT NULL,
`context` varchar(128) NOT NULL,
`rollback_info` longblob NOT NULL,
`log_status` int(11) NOT NULL,
`log_created` datetime NOT NULL,
`log_modified` datetime NOT NULL,
`ext` varchar(100) DEFAULT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `ux_undo_log` (`xid`,`branch_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
到此,数据库就完成了。
第一步: 新建一个Module,名为:seata-order-service2001
第二步: 改pom文件
<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>cloud2021artifactId>
<groupId>com.oldou.springcloudgroupId>
<version>1.0-SNAPSHOTversion>
parent>
<modelVersion>4.0.0modelVersion>
<artifactId>seata-order-service2001artifactId>
<dependencies>
<dependency>
<groupId>com.alibaba.cloudgroupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
dependency>
<dependency>
<groupId>com.alibaba.cloudgroupId>
<artifactId>spring-cloud-starter-alibaba-seataartifactId>
<exclusions>
<exclusion>
<artifactId>seata-allartifactId>
<groupId>io.seatagroupId>
exclusion>
exclusions>
dependency>
<dependency>
<groupId>io.seatagroupId>
<artifactId>seata-allartifactId>
<version>1.3.0version>
dependency>
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-starter-openfeignartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-actuatorartifactId>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
dependency>
<dependency>
<groupId>com.alibabagroupId>
<artifactId>druid-spring-boot-starterartifactId>
<version>1.1.10version>
dependency>
<dependency>
<groupId>org.mybatis.spring.bootgroupId>
<artifactId>mybatis-spring-boot-starterartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
<optional>trueoptional>
dependency>
dependencies>
project>
第三步: 配置文件
server:
port: 2001
spring:
application:
name: seata-order-service
cloud:
alibaba:
seata:
#自定义事务组名称需要与seata-server中的对应 没有配置写default
tx-service-group: default
nacos:
discovery:
server-addr: localhost:8848
datasource:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://localhost:3306/seata_order
username: root
password: 123456
feign:
hystrix:
enabled: false
logging:
level:
io:
seata: info
mybatis:
mapperLocations: classpath:mapper/*.xml
## transaction log store, only used in seata-server
store {
## store mode: file、db、redis
mode = "db"
## file store property
file {
## store location dir
dir = "sessionStore"
# branch session size , if exceeded first try compress lockkey, still exceeded throws exceptions
maxBranchSessionSize = 16384
# globe session size , if exceeded throws exceptions
maxGlobalSessionSize = 512
# file buffer size , if exceeded allocate new buffer
fileWriteBufferCacheSize = 16384
# when recover batch read size
sessionReloadReadSize = 100
# async, sync
flushDiskMode = async
}
## database store property
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.jdbc.Driver"
url = "jdbc:mysql://127.0.0.1:3306/seata"
user = "root"
password = "root"
minConn = 5
maxConn = 100
globalTable = "global_table"
branchTable = "branch_table"
lockTable = "lock_table"
queryLimit = 100
maxWait = 5000
}
## redis store property
redis {
host = "127.0.0.1"
port = "6379"
password = ""
database = "0"
minConn = 1
maxConn = 10
maxTotal = 100
queryLimit = 100
}
}
registry {
# file 、nacos 、eureka、redis、zk、consul、etcd3、sofa
type = "nacos" # 指定注册中心为nacos
loadBalance = "RandomLoadBalance"
loadBalanceVirtualNodes = 10
nacos {
application = "seata-server"
serverAddr = "localhost:8848" # 修改Nacos的链接信息
group = "SEATA_GROUP"
namespace = ""
cluster = "default"
username = ""
password = ""
}
eureka {
serviceUrl = "http://localhost:8761/eureka"
application = "default"
weight = "1"
}
redis {
serverAddr = "localhost:6379"
db = 0
password = ""
cluster = "default"
timeout = 0
}
zk {
cluster = "default"
serverAddr = "127.0.0.1:2181"
sessionTimeout = 6000
connectTimeout = 2000
username = ""
password = ""
}
consul {
cluster = "default"
serverAddr = "127.0.0.1:8500"
}
etcd3 {
cluster = "default"
serverAddr = "http://localhost:2379"
}
sofa {
serverAddr = "127.0.0.1:9603"
application = "default"
region = "DEFAULT_ZONE"
datacenter = "DefaultDataCenter"
cluster = "default"
group = "SEATA_GROUP"
addressWaitTime = "3000"
}
file {
name = "file.conf"
}
}
config {
# file、nacos 、apollo、zk、consul、etcd3
type = "file"
nacos {
serverAddr = "127.0.0.1:8848"
namespace = ""
group = "SEATA_GROUP"
username = ""
password = ""
}
consul {
serverAddr = "127.0.0.1:8500"
}
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 = ""
}
etcd3 {
serverAddr = "http://localhost:2379"
}
file {
name = "file.conf"
}
}
第四步: 主启动类
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class SeataOrderMainApp2001 {
public static void main(String[] args) {
SpringApplication.run(SeataOrderMainApp2001.class,args);
}
}
第五步: 实体类
package com.oldou.springcloud.domain;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CommonResult<T>{
private Integer code;
private String message;
private T data;
public CommonResult(Integer code, String message){
this(code,message,null);
}
}
package com.oldou.springcloud.domain;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.math.BigDecimal;
@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:已完结
}
Dao层
package com.oldou.springcloud.dao;
import com.oldou.springcloud.domain.Order;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
@Mapper
public interface OrderDao {
//1 新建订单
void create(Order order);
//2 修改订单状态,从零改为1
void update(@Param("userId") Long userId,@Param("status") Integer status);
}
OrderMapper.xml: 在resources下新建一个mapper的包
DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.oldou.springcloud.dao.OrderDao">
<resultMap id="BaseResultMap" type="com.oldou.springcloud.domain.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">
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 user_id=#{userId} and status = #{status};
update>
mapper>
service层:
package com.oldou.springcloud.service;
import com.oldou.springcloud.domain.Order;
/**
* 订单服务
*/
public interface OrderService {
void create(Order order);
}
package com.oldou.springcloud.service;
import com.oldou.springcloud.domain.CommonResult;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
/**
* 库存服务的feign调用
*/
@FeignClient(value = "seata-storage-service")
public interface StorageService {
@PostMapping(value = "/storage/decrease")
CommonResult decrease(@RequestParam("productId") Long productId, @RequestParam("count") Integer count);
}
package com.oldou.springcloud.service;
import com.oldou.springcloud.domain.CommonResult;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import java.math.BigDecimal;
/**
* 订单服务的RPC调用
*/
@FeignClient(value = "seata-account-service")
public interface AccountService {
@PostMapping(value = "/account/decrease")
CommonResult decrease(@RequestParam("userId") Long userId, @RequestParam("money") BigDecimal money);
}
package com.oldou.springcloud.service.impl;
import com.oldou.springcloud.dao.OrderDao;
import com.oldou.springcloud.domain.Order;
import com.oldou.springcloud.service.AccountService;
import com.oldou.springcloud.service.OrderService;
import com.oldou.springcloud.service.StorageService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class OrderServiceImpl implements OrderService {
@Resource
private OrderDao orderDao;
@Resource
private StorageService storageService;
@Resource
private AccountService accountService;
/**
* 创建订单->调用库存服务扣减库存->调用账户服务扣减账户余额->修改订单状态
* 简单说:下订单->扣库存->减余额->改状态
*/
@Override
//@GlobalTransactional(name = "fsp-create-order",rollbackFor = Exception.class)
public void create(Order order) {
log.info("----->开始新建订单");
//1 新建订单
orderDao.create(order);
//2 扣减库存
log.info("----->订单微服务开始调用库存,做扣减Count");
storageService.decrease(order.getProductId(),order.getCount());
log.info("----->订单微服务开始调用库存,做扣减end");
//3 扣减账户
log.info("----->订单微服务开始调用账户,做扣减Money");
accountService.decrease(order.getUserId(),order.getMoney());
log.info("----->订单微服务开始调用账户,做扣减end");
//4 修改订单状态,从零到1,1代表已经完成
log.info("----->修改订单状态开始");
orderDao.update(order.getUserId(),0);
log.info("----->修改订单状态结束");
log.info("----->下订单结束了,O(∩_∩)O哈哈~");
}
}
controller层
package com.oldou.springcloud.controller;
import com.oldou.springcloud.domain.CommonResult;
import com.oldou.springcloud.domain.Order;
import com.oldou.springcloud.service.OrderService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
@RestController
public class OrderController {
@Resource
private OrderService orderService;
@GetMapping("/order/create")
public CommonResult create(Order order) {
orderService.create(order);
return new CommonResult(200,"订单创建成功");
}
}
配置类
package com.oldou.springcloud.config;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@MapperScan({"com.oldou.springcloud.dao"})
public class MyBatisConfig {
}
package com.oldou.springcloud.config;
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 {
@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();
}
}
订单服务seata-order-service2001的启动类
package com.oldou.springcloud;
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
@EnableFeignClients
//取消数据源的自动创建,而是使用自己定义的
@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
public class SeataOrderMainApp2001 {
public static void main(String[] args) {
SpringApplication.run(SeataOrderMainApp2001.class,args);
}
}
与seata-order-service2001
服务类似:
第一步: 新建一个Module,名为:seata-storage-service2002
第二步: 改pom文件(与seata-order-service2001服务一致)
第三步: 配置文件
server:
port: 2002
spring:
application:
name: seata-storage-service
cloud:
alibaba:
seata:
tx-service-group: fsp_tx_group
nacos:
discovery:
server-addr: localhost:8848
datasource:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://localhost:3306/seata_storage
username: root
password: root
logging:
level:
io:
seata: info
mybatis:
mapperLocations: classpath:mapper/*.xml
第四步: 实体类,除了以下类之外,CommonResult和2001一致
@Data
public class Storage {
private Long id;
/**
* 产品id
*/
private Long productId;
/**
* 总库存
*/
private Integer total;
/**
* 已用库存
*/
private Integer used;
/**
* 剩余库存
*/
private Integer residue;
}
第五步: 业务类
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
@Mapper
public interface StorageDao {
//扣减库存
void decrease(@Param("productId") Long productId, @Param("count") Integer count);
}
DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.oldou.springcloud.dao.StorageDao">
<resultMap id="BaseResultMap" type="com.oldou.springcloud.domain.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>
public interface StorageService {
/**
* 扣减库存
*/
void decrease(Long productId, Integer count);
}
import javax.annotation.Resource;
@Service
public class StorageServiceImpl implements StorageService {
private static final Logger LOGGER = LoggerFactory.getLogger(StorageServiceImpl.class);
@Resource
private StorageDao storageDao;
/**
* 扣减库存
*/
@Override
public void decrease(Long productId, Integer count) {
LOGGER.info("------->storage-service中扣减库存开始");
storageDao.decrease(productId,count);
LOGGER.info("------->storage-service中扣减库存结束");
}
}
import com.oldou.springcloud.domain.CommonResult;
import com.oldou.springcloud.service.StorageService;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
@RestController
public class StorageController {
@Resource
private StorageService storageService;
/**
* 扣减库存
*/
@RequestMapping("/storage/decrease")
public CommonResult decrease(Long productId, Integer count) {
storageService.decrease(productId, count);
return new CommonResult(200,"扣减库存成功!");
}
}
config与2001服务保持一致
启动类:与2001类似,改改名称即可
与seata-order-service2001
服务类似:
第一步: 新建一个Module,名为:seata-account-service2003
第二步: 改pom文件(与seata-order-service2001服务一致)
第三步: 配置文件
server:
port: 2003
spring:
application:
name: seata-account-service
cloud:
alibaba:
seata:
tx-service-group: default
nacos:
discovery:
server-addr: localhost:8848
datasource:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://localhost:3306/seata_account?useSSL=false
username: root
password: root
feign:
hystrix:
enabled: false
logging:
level:
io:
seata: info
mybatis:
mapperLocations: classpath:mapper/*.xml
第四步: 实体类,除了以下类之外,CommonResult和2001一致
package com.oldou.springcloud.domain;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.math.BigDecimal;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Account {
private Long id;
/**
* 用户id
*/
private Long userId;
/**
* 总额度
*/
private BigDecimal total;
/**
* 已用额度
*/
private BigDecimal used;
/**
* 剩余额度
*/
private BigDecimal residue;
}
第五步: 业务类
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.math.BigDecimal;
@Mapper
public interface AccountDao {
/**
* 扣减账户余额
*/
void decrease(@Param("userId") Long userId, @Param("money") BigDecimal money);
}
DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.oldou.springcloud.dao.AccountDao">
<resultMap id="BaseResultMap" type="com.oldou.springcloud.domain.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>
import org.springframework.web.bind.annotation.RequestParam;
import java.math.BigDecimal;
public interface AccountService {
/**
* 扣减账户余额
* @param userId 用户id
* @param money 金额
*/
void decrease(@RequestParam("userId") Long userId, @RequestParam("money") BigDecimal money);
}
package com.oldou.springcloud.service.impl;
import com.oldou.springcloud.dao.AccountDao;
import com.oldou.springcloud.service.AccountService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.math.BigDecimal;
/**
*/
@Service
public class AccountServiceImpl implements AccountService {
private static final Logger LOGGER = LoggerFactory.getLogger(AccountServiceImpl.class);
@Resource
private AccountDao accountDao;
/**
* 扣减账户余额
*/
@Override
public void decrease(Long userId, BigDecimal money) {
LOGGER.info("------->account-service中扣减账户余额开始");
accountDao.decrease(userId,money);
LOGGER.info("------->account-service中扣减账户余额结束");
}
}
@RestController
public class AccountController {
@Resource
AccountService accountService;
/**
* 扣减账户余额
*/
@RequestMapping("/account/decrease")
public CommonResult decrease(@RequestParam("userId") Long userId, @RequestParam("money") BigDecimal money){
accountService.decrease(userId,money);
return new CommonResult(200,"扣减账户余额成功!");
}
}
config与2001服务保持一致
启动类:与2001类似,改改名称即可
倒刺,我们环境和代码就准备好了。
测试的流程: 订单服务下订单 -> 库存服务减库存 -> 账户服务扣余额 -> 订单服务改(订单)状态
数据库数据初始情况:
启动Nacos、Seata-server以及三个微服务,Nacos中可以看到服务注册进列表
正常下单测试: 调用http://localhost:2001/order/create?userId=1&productId=1&count=10&money=100
下单成功之后数据库状况:
测试异常,我们在账户服务的AccountServiceImpl
中添加一个延时代码,由于Feign调用默认时间是1秒钟,我们这里弄一个超时异常
模拟AccountServiceImpl添加超时
@Service
public class AccountServiceImpl implements AccountService {
private static final Logger LOGGER = LoggerFactory.getLogger(AccountServiceImpl.class);
@Resource
private AccountDao accountDao;
/**
* 扣减账户余额
*/
@Override
public void decrease(Long userId, BigDecimal money) {
//让线程睡20秒钟,模拟超时异常,全局事务回滚
try { TimeUnit.SECONDS.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); }
LOGGER.info("------->account-service中扣减账户余额开始");
accountDao.decrease(userId,money);
LOGGER.info("------->account-service中扣减账户余额结束");
}
}
修改账户服务的代码以后,重启服务,再次访问: http://localhost:2001/order/create?userId=1&productId=1&count=10&money=100
数据库状况:
从以上测试数据我们发现,服务出现异常,当库存和账户金额扣减后,订单状态并没有设置为已经完成,没有从0改为1,同时由于feign的重试机制,账户余额和库存还有可能被多次扣减,这是一个大问题啊。
解决方案:Seata的全局事务@GlobalTransactional
首先,找到业务的入口:订单服务的OrderServiceImpl
,用@GlobalTransactional
标注create()
方法
@Service
@Slf4j
public class OrderServiceImpl implements OrderService {
@Resource
private OrderDao orderDao;
@Resource
private StorageService storageService;
@Resource
private AccountService accountService;
/**
* 创建订单->调用库存服务扣减库存->调用账户服务扣减账户余额->修改订单状态
* 简单说:下订单->扣库存->减余额->改状态
*
* @GlobalTransactional的属性说明
* --name:随便命名,只要名字不冲突
* --rollbackFor:发生什么异常的时候进行回滚,这里定义为Exception.class表示发生任何异常都进行回滚
*/
@Override
@GlobalTransactional(name = "fsp-create-order",rollbackFor = Exception.class)
public void create(Order order) {
log.info("----->开始新建订单");
//1 新建订单
orderDao.create(order);
//2 扣减库存
log.info("----->订单微服务开始调用库存,做扣减Count");
storageService.decrease(order.getProductId(),order.getCount());
log.info("----->订单微服务开始调用库存,做扣减end");
//3 扣减账户
log.info("----->订单微服务开始调用账户,做扣减Money");
accountService.decrease(order.getUserId(),order.getMoney());
log.info("----->订单微服务开始调用账户,做扣减end");
//4 修改订单状态,从零到1,1代表已经完成
log.info("----->修改订单状态开始");
orderDao.update(order.getUserId(),0);
log.info("----->修改订单状态结束");
log.info("----->下订单结束了,O(∩_∩)O哈哈~");
}
}
重启订单服务,再次测试,还是模拟AccountServiceImpl添加超时,下单后数据库数据并没有任何改变,记录都添加不进来,达到出异常,数据库回滚的效果。
Seata: Simple Extensible Autonomous Transaction Architecture
,简单可扩展自治事务框架。2020起始,建议使用1.0以后的版本,0.9版本的不支持集群。
结合我们的案例,再看一下TC、TM、RM
seata-server-1.3.0
@GlobalTransactional
的方法分布式事务的执行流程
@GlobalTransactional
注解就开启事务】;事务的一阶段和二阶段,后续解释。
Seata 是一款开源的分布式事务解决方案,致力于提供高性能和简单易用的分布式事务服务。Seata 将为用户提供了 AT、TCC、SAGA 和 XA 事务模式,为用户打造一站式的分布式解决方案。
AT模式的介绍以及底层工作原理
前提
- 基于支持本地 ACID 事务的关系型数据库。
- Java 应用,通过 JDBC 访问数据库。
整体机制 两阶段提交协议的演变:官方解释
- 一阶段:业务数据和回滚日志记录在同一个本地事务中提交,释放本地锁和连接资源。
- 二阶段:
- 提交异步化,非常快速地完成。
- 回滚通过一阶段的回滚日志进行反向补偿。
详细描述各阶段
以上操作全部在一个数据库事务内完成,这样就保证了一阶段操作的原子性。类似于Spring的AOP思想
二阶段提交: 二阶段如果是顺利提交的话【表示不会出现异常】,由于“业务SQL”在一阶段的时候已经提交到数据库了,所以Seata框架只需要将一阶段保存的快照数据和行锁删掉,完成数据的清理即可。【提交异步化,非常快速地完成】