【Spring Cloud Alibaba系列】快速入门Spring Cloud Alibaba

下载对应版本的 Nacos Server 2.3.2 下载地址

修改启动脚本:

win系统：修改startup.cmd->set MODE="cluster"中的cluster为standalone即集群模式修改为单机模式。

linux系统：修改startup.sh-> export MODE=“cluster” 的同样字段内容。

单机建议使用内存，集群建议使用数据库，在配置文件进行修改。

默认端口：8848

启动后访问地址： http://ip:port/nacos/index.html

配置子服务的nacos配置

spring:
application:
# 服务名
name: nacos
# nacos配置
cloud:
nacos:
# nacos服务端地址
server-addr: ip:端口号
discovery:
# 与config一致
username: 登录名
password: 登录密码

引入nacos-config依赖

<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>

创建bootstrap.yml配置文件

#配置服务名称
spring:
application:
name: nacos
profiles:
active: dev
# nacos配置
cloud:
nacos:
# nacos配置中心
server-addr: ip/域名:nacos端口号
config:
username: 账号
password: 密码
namespace: 命名空间id
file-extension: 配置文件格式
#配置多个配置文件
shared-configs:
– data-id: database–dev.yaml # 配置文件id
refresh: true #动态刷新
group: DEFAULT_GROUP #分组
config:
# 关键：导入 Nacos 配置
import: optional:nacos:配置文件名称

在需要的地方可以通过@Value注入

@Value("${mysql.username}")
public String username;
@Value("${redis.username}")
public String redis;

@RefreshScope：在需要动态加载nacos配置场景如：controller、数据库连接等。

//在需要动态加载的文件类上加上@RefreshScope
@SpringBootApplication
@RefreshScope
public class NacosApplication {
@Value("${mysql.username}")
public String username;
@Value("${redis.username}")
public String redis;
@PostConstruct
public void init(){
System.out.println("mysql:"+username);
System.out.println("redis:"+redis);
}
public static void main(String[] args) {
SpringApplication.run(NacosApplication.class, args);
}
}

依赖导入：当前仅引入Sentinel的核心库，暂不整合Alibaba

<!–Sentinel的核心库–>
<dependency>
<groupId>com.alibaba.csp</groupId>
<artifactId>sentinel-core</artifactId>
<version>1.8.10</version>
</dependency>
<!–使用@SentinelResource注解–>
<dependency>
<groupId>com.alibaba.csp</groupId>
<artifactId>sentinel-annotation-aspectj</artifactId>
<version>1.8.10</version>
</dependency>

实现代码

@RestController
@RequestMapping("/test")
@Slf4j
public class TestController {
//定义资源
private static final String RESOURCE_A = "resourceA";
private static final String RESOURCE_B = "resourceB";
private static final String RESOURCE_C = "resourceC";

//进行流控
@RequestMapping("/resourceA")//注意接口名称必须与资源名称一致
public String resourceA() {
Entry entry = null;
try {
//获取资源
entry = SphU.entry(RESOURCE_A);
//业务逻辑
log.info("hello world"+"resourceA");
return "hello world"+"resourceA";
} catch (BlockException e) {
//流控逻辑处理
log.info("限流了"+"resourceA");
return "限流了"+"resourceB";
}catch (Exception e){
log.info("异常了"+"resourceA");
//异常逻辑处理
Tracer.trace(e);
}finally {
if (entry != null) {
entry.exit();
}
}
return "error"+"resourceA";
}

/**
* 初始化流控规则
*/
@PostConstruct
public void init(){
List<FlowRule> flowRules = new ArrayList<>();
//创建流控规则
FlowRule flowRule = new FlowRule();
//设置资源的流控
flowRule.setResource(RESOURCE_A);
//设置限流阈值模式
flowRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
//设置限流阈值
flowRule.setCount(1);
flowRules.add(flowRule);
//加载流控规则
FlowRuleManager.loadRules(flowRules);
}
}

使用@SentinelResource注解改善资源定义和流控处理方法

@RestController
@RequestMapping("/test")
@Slf4j
public class TestController {
//定义资源
private static final String RESOURCE_A = "resourceA";
private static final String RESOURCE_B = "resourceB";
private static final String RESOURCE_C = "resourceC";

/**
* 初始化流控规则
*/
@PostConstruct
public void init(){
List<FlowRule> flowRules = new ArrayList<>();
//创建流控规则
FlowRule flowRule = new FlowRule();
//设置资源的流控
flowRule.setResource(RESOURCE_B);
//设置限流阈值模式
flowRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
//设置限流阈值
flowRule.setCount(1);
flowRules.add(flowRule);
//加载流控规则
FlowRuleManager.loadRules(flowRules);
}

/**
* 1. 使用SentinelResource注解
* 2. 配置bean
* @return
*/
@RequestMapping("/resourceB")
//value:定义的资源 blockHandler：配置流控逻辑处理方法
@SentinelResource(value = RESOURCE_B,blockHandler = "handleExceptionUser")
public User resourceB() {
return new User("111", 222, "333");
}

/**
* 流控限制逻辑处理
* 1.必须是public
* 2.参数顺序必须一致
* 3.返回值类型必须一致
* @param e
* @return
*/
public User handleExceptionUser(BlockException e){
return new User("限流了", 222, "resourceB");
}
}

下载控台jar包：控制台jar下载

注意：因为后续需要整合为alibaba所以需要与alibaba的版本对应。

启动控制台服务。

在需要接入的服务中添加依赖

<dependency>
<groupId>com.alibaba.csp</groupId>
<artifactId>sentinel-transport-simple-http</artifactId>
<version>对应下载的控制台版本号</version>
</dependency>

修改服务的启动的vm参数（如果修改了控制台默认的服务端口则需要配置）

-Dcsp.sentinel.dashboard.server=ip:端口号

QSP：每秒的请求数（1秒处理多少个请求）。资源名：对应的接口；单机阈值即每秒处理的请求数量。

如需设定该接口的自定义流控限制逻辑参考本章内容的《快速入门》->第3点。

注：每次重启服务都需要重新设置对应的规则，当前阶段并没有实现持久化。

并发线程数：保护业务的线程池数不被慢调用消耗干净。超过设定的单机阈值则按照处理逻辑进行处理。

直接流控模式：前面的处理模式都是属于直接流控模式即影响的是接口本身。

关联流控模式：即当关联资源的请求数/并发数达到阈值了，受影响的就是当前资源（接口），而不是关联资源（接口）。

链路流控模式：即按照链路的方式来执行的，当入口资源请求当前资源时，达到规则设定时触发异常处理，但是受影响的资源是入口资源而不是当前的资源。

若使用链路模式没生效，需要在对应的配置文件中去添加：

​ spring.cloud.sentinel.web-context-unify: false

若配置了@SentinelResource的接口必须要指定blockHandler参数

快速失败：默认的流控效果，即当超过规则要求的阈值的请求将直接拒绝，返回流控异常处理结果。

Warm UP（预热）：在设定的预热时长内，让请求缓慢进入。（适用流量突然激增的场景）

排队等待：将拒绝的请求，进行超时时间的等待，在超时时间内若处理的阈值可以接受则处理拒绝的请求。

慢调用（默认）：

最大RT：超过设定的RT即视为慢调用；最小请求数：在最小请求数内如果出现慢调用，可忽略不进行降级处理；比列阈值：当慢调用数达到该比列则对该资源（接口）进行降级处理；熔断时长：执行熔断降级的时长，当结束后进入半开状态。

异常比列：访问数中异常数达到设定的比列阈值则触发熔断降级。

异常数：当访问中的请求出现异常的数量达到设定的异常数时触发熔断降级。

必备依赖

<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

修改配置文件，开启oenfeign对sentinel的支持

feign:
sentinel:
enabled: true

创建openfeign的fallback实现类进行兜底：即openfeign创建的是接口，限制提供实现这个接口在出现异常后适用fallback实现类去处理。

@Component
public class UserFeignFallbackService implements UserFeignService{
@Override
public String add(String name) {
return "降级处理";
}
}

在对应的接口的FeignClient注解里面添加fallback参数。

@FeignClient(name = "xxxx-auth",path = "/auth",fallback = UserFeignFallbackService.class)

LOAD自适应（仅对Linux/Unix系统生效）：当系统的load值超过设定的阈值就会触发熔断降级。

RT（平均RT）：当系统的入口流量的平均RT超过设定阈值则触发熔断降级。

线程数：当单台服务器的所有入口流量的并发线程数超过设定的阈值则触发熔断降级。

入口QPS：当单台服务器的所有入口流量的QPS达到阈值则触发熔断降级。

CPU使用率：当CPU使用率超过设定的阈值则触发熔断降级。

引入第三方依赖

<dependency>
<groupId>com.alibaba.csp</groupId>
<artifactId>sentinel-datasource-nacos</artifactId>
</dependency>

nacos中编写配置文件

[
{
"resource":"/xxx",
"controlBehavior":0,
"count":10.0,
"grade":1,
"limitApp":"default",
"strategy":0
}
]

在服务的配置文件中配置关联的nacos中编写的配置文件，并重启服务。

spring:
application:
name: xxxx–sentinel
cloud:
sentinel:
datasource:
rule-flow: #该名称可自定义
# nacos服务端地址
server-addr: ip:端口号
username: nacos账号
password: nacos密码
data-id: sentinel–flow–rules #对应nacos的配置文件名称
namespace: xxxxxxxxxxxxxx # 命名空间id
rule-type: flow #规则类型

下载TC启动包（版本要按照SpringCloudAlibaba适配版本进行下载）并进行解压（tar -zxvf 压缩包名称）。

修改seata的conf文件夹下的application.yml文件。

seata:
config:
# support: nacos, consul, apollo, zk, etcd3
type: file
registry:
# support: nacos, eureka, redis, zk, consul, etcd3, sofa
type: file
store:
# 修改模式位db
mode: db
# 新增-配置db源(数据库版本需要大于5.7)
db:
datasource: druid
db-type: mysql
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://127.0.0.1:3306/seata?rewriteBatchedStatements=true
user: mysql
password: mysql
min-conn: 10
max-conn: 100
global-table: global_table
branch-table: branch_table
lock-table: lock_table
distributed-lock-table: distributed_lock
query-limit: 1000
max-wait: 5000

创建数据库seata以及初始化（访问资源地址，选择server->db->mysql.sql，根据配置的db类型选择）。

注：下载的是linux版本的则在seata/script下有相关资源文件。

— mysql.sql
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_status_gmt_modified` (`status` , `gmt_modified`),
KEY `idx_transaction_id` (`transaction_id`)
) ENGINE = InnoDB
DEFAULT CHARSET = utf8mb4;

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 = utf8mb4;

CREATE TABLE IF NOT EXISTS `lock_table`
(
`row_key` VARCHAR(128) NOT NULL,
`xid` VARCHAR(128),
`transaction_id` BIGINT,
`branch_id` BIGINT NOT NULL,
`resource_id` VARCHAR(256),
`table_name` VARCHAR(32),
`pk` VARCHAR(36),
`status` TINYINT NOT NULL DEFAULT '0' COMMENT '0:locked ,1:rollbacking',
`gmt_create` DATETIME,
`gmt_modified` DATETIME,
PRIMARY KEY (`row_key`),
KEY `idx_status` (`status`),
KEY `idx_branch_id` (`branch_id`),
KEY `idx_xid` (`xid`)
) ENGINE = InnoDB
DEFAULT CHARSET = utf8mb4;

CREATE TABLE IF NOT EXISTS `distributed_lock`
(
`lock_key` CHAR(20) NOT NULL,
`lock_value` VARCHAR(20) NOT NULL,
`expire` BIGINT,
primary key (`lock_key`)
) ENGINE = InnoDB
DEFAULT CHARSET = utf8mb4;

INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('AsyncCommitting', ' ', 0);
INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('RetryCommitting', ' ', 0);
INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('RetryRollbacking', ' ', 0);
INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('TxTimeoutCheck', ' ', 0);

配置application.yml的注册中心和配置中心。

seata:
# 修改配置中心
config:
type: nacos
nacos:
application: seata–server
server-addr: ip:端口号
group: SEATA_GROUP
namespace:
cluster: default
username: 账号
password: 密码
# 修改nacos注册中心
registry:
# 修改为nacos
type: nacos
nacos:
application: seata–server
server-addr: ip:端口号
group: SEATA_GROUP
namespace:
cluster: default
username: 账号
password: 密码

修改seata/script/config-center/config.txt文件，其余不变。

#可以自定义，但是客户端需要一致
service.vgroupMapping.xxxxxx=default
#修改
store.mode=db
store.db.datasource=druid
store.db.dbType=mysql
store.db.driverClassName=com.mysql.jdbc.Driver
#按照实际修改
store.db.url=jdbc:mysql://127.0.0.1:3306/seata?useUnicode=true&rewriteBatchedStatements=true
store.db.user=username
store.db.password=password
store.db.minConn=5
store.db.maxConn=30
store.db.globalTable=global_table
store.db.branchTable=branch_table
store.db.distributedLockTable=distributed_lock
store.db.queryLimit=100
store.db.lockTable=lock_table
store.db.maxWait=5000

进入seata/script/config-center/nacos文件夹下执行命令以注册。

sh /home/yblog/seata/script/config-center/nacos/nacos-config.sh -h ip -p 端口号 -g SEATA_GROUP -t 命名空间id -u 账号 -w 密码

若脚本执行报错，则将sh修改为bash

参数说明：

• -h:nacos的ip地址
• -p:端口号
• -g:分组
• -t:命名空间 建议新开一个空间专门保存该配置
• -u:账号
• -w:密码

注册完配置以后即可启动服务

引入seata依赖（需要操作数据则需要引入orm框架、数据库驱动等）。

<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-seata</artifactId>
</dependency>

在涉及分布式事务的数据库中添加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` DATATIME NOT NULL ,
`log_modified` DATATIME NOT NULL ,
PRIMARY KEY (`id`),
UNIQUE KEY `UX_UNDO_LOG` (`xid`,`branch_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 ;

修改对应服务的配置文件。

seata:
#配置事务分组
tx-service-group: xxxxxx #需要和seata服务端的service.vgroupMapping.xxxxxx一致
#配置seata注册中心
registry:
type: nacos
nacos:
server-addr: ip:端口号
application: seata–server #默认值可不配置，如果修改了需要配置
username: xxxx
password: xxxx
group: SEATA_GROUP #默认值可不配置，如果修改了需要配置
#配置seata配置中心
config:
type: nacos
nacos:
server-addr: ip:端口号
username: xxxx
password: xxxx
group: SEATA_GROUP #默认值可不配置，如果修改了需要配置

使用seata实现分布式事务，在对应的接口上添加@GlobalTransactional注解。

@RequestMapping("/test")
@GlobalTransactional //分布式事务注解
public String test(){
//创建a表数据
sorockService.createData("1");
//调用其他服务
userFeignService.add("tset");
return "hello world ";
}

若启动服务没有生效则查看服务的启动类是否添加@EnableTransactionManagement 注解，没有添加则需要添加上。

添加Gateway依赖，使用Spring Cloud的组件需要在父pom中引入对应的版本管理器

<!–spring-cloud 父pom中引入对应的版本管理器–>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>${spring-boot.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!–spring-cloud-Gateway 在对应的Gateway服务中引入–>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>

编写Gateway的配置文件

server:
port: 8083
spring:
application:
name: xxxx–gateway
# nacos配置
cloud:
#配置网关
gateway:
#配置转发路由数组
routes:
– id: yblog–user #唯一标识：一般是对应项目name
uri: http://localhost:8082/xxxx–user #转发地址：转发到那个服务
#路由断言规则：路由匹配规则
predicates:
#将http://localhost:8083/xxxx-user/user/test转为
#http://localhost:8082/xxxx-user/user/test
– Path=/xxxx–user/** #路径匹配规则
#过滤要求
filters:
– StripPrefix=1 #去除请求的第一层划分
#http://localhost:8082/xxxx-user/user/test->http://localhost:8082/user/test

访问http://localhost:8083/xxxx-user/user/test即可请求到xxxx-user/user/test的服务

在Gateway中引入nacos依赖。

<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

修改Gateway的配置文件。

标准化（推荐）：

server:
port: 8083
spring:
application:
name: xxxx–gateway
# nacos配置
cloud:
nacos:
# nacos服务端地址
server-addr: ip:port
discovery:
username: 账号
password: 密码
namespace: 命名空间
#配置网关
gateway:
#配置转发路由
routes:
– id: yblog–user #唯一标识：一般是对应项目name
uri: lb://xxxx–user #lb://服务名称 lb：使用nacos的负载均衡策略
#路由断言规则：路由匹配规则
predicates:
– Path=/xxxx–user/** #路径匹配规则
#过滤要求
filters:
– StripPrefix=1 #去除请求的第一层划分

简写：

server:
port: 8083
spring:
application:
name: xxxx–gateway
# nacos配置
cloud:
nacos:
# nacos服务端地址
server-addr: ip:port
discovery:
username: 账号
password: 密码
namespace: 命名空间
#配置网关
gateway:
discovery:
locator:
enabled: true #开启服务发现自动生成路由，则不在需要编写routes数组

Datetime类型（配置）：根据时间进行判断

远程地址：根据IP地址进行判断（RemoteAddrRoutePredicateFactort:（一个IP地址参数）请求主机地址是否在地址段中）

– RemoteAddr=192.168.1.1/24

Cookie（配置）：根据请求的Cookie进行判断（CookieRoutePredicateFactort:（一个cookie名称参数+一个正则表达式参数）请求的cookie是否有给定的名称，并且值与正则表达式匹配）

– Cookie=chocolate,ch.p

Header（配置）：根据请求的Header进行判断（HeaderRoutePredicateFactort:（一个标题名称参数+一个正则表达式参数）请求的Header是否有给定的名称，并且值与正则表达式匹配）

– Header=X–Request–Id,\\d+

Host：根据请求的Host进行判断（HostRoutePredicateFactort:（一个主机名参数）请求的Host是否满足匹配规则）

– Host=**.somehost.org,**.anotherhost.org

Method请求方法（配置）：根据请求的类型进行判断（MethodRoutePredicateFactort:（一个请求类型参数）请求的类型是否满足指定的类型）

– Method=GET,POST

path请求路径（配置）：根据请求的URL进行判断（PathRoutePredicateFactort:（一个请求URL参数）请求的URL是否满足指定的路径规则）

– Path=/red/{segment},/blue/{segment}

其他内置断言规则请查看官方文档：内置断言官方文档

创建自定义断言工厂类。

/**
* 1.创建自定义路由断言工厂配置类，且文件名必须以RoutePredicateFactory结尾
* 2.继承AbstractRoutePredicateFactory
* 3.实现静态内部类-Config-并声明接收参数的属性即配置文件的断言参数
* 4.重写shortcutFieldOrder方法来进行绑定
* 5.重写apply方法，实现自定义断言规则判断，返回true|false
*/
@Component
public class SatokenRoutePredicateFactort extends AbstractRoutePredicateFactory<SatokenRoutePredicateFactort.Config> {

public SatokenRoutePredicateFactort() {
super(SatokenRoutePredicateFactort.Config.class);
}

@Override
public List<String> shortcutFieldOrder() {
//对应Config类中的属性名称
return Arrays.asList("token");
}

@Override
public Predicate<ServerWebExchange> apply(SatokenRoutePredicateFactort.Config config) {
return new GatewayPredicate() {
//断言逻辑判断
@Override
public boolean test(ServerWebExchange exchange) {
//判断参数值是否相等
return exchange.getRequest().getQueryParams().getFirst("token").equals(config.getToken());
}
};
}

@Validated
public static class Config {
private String token;

public String getToken() {
return token;
}
}
}

修改配置文件。

spring:
application:
name: xxxx–gateway
# nacos配置
cloud:
#配置转发路由
routes:
– id: xxxx–user
uri: lb://xxxx–user
predicates:
#自定义断言规则
– Satoken=abcdefghijklmnopqrstuvwxyz

创建自定义过滤器。

/**
* 自定义过滤器工厂
* 1.创建过滤器工厂类，且文件名必须以GatewayFilterFactory结尾
* 2.继承AbstractGatewayFilterFactory
* 3.重写apply方法，实现自定义过滤器逻辑
*/
@Component
public class TestGatewayFilterFactory extends AbstractGatewayFilterFactory<TestGatewayFilterFactory.Config> {
public TestGatewayFilterFactory() {
super(TestGatewayFilterFactory.Config.class);
}
@Override
public List<String> shortcutFieldOrder() {
return Arrays.asList("test");
}
@Override
public GatewayFilter apply(TestGatewayFilterFactory.Config config) {
return (exchange, chain) -> {
if (config.getTest().equals("1")){
exchange.getResponse().getHeaders().add("test","1");
}else{
exchange.getResponse().getHeaders().add("test","2");
}
return chain.filter(exchange);
};
}
public static class Config {
private String test;

public String getTest() {
return test;
}
}
}

修改配置文件。

spring:
application:
name: xxxx–gateway
cloud:
gateway:
routes:
– id: xxxx–user
uri: lb://xxxx–user
filters:
– test=1

编写当前项目的日志配置文件（需要记录日志在文件中需要配置）。

<appender name="accessLog" class="ch.qos.logback.core.FileAppender">
<file>access_log.log</file>
<encoder>
<pattern>%msg%n</pattern>
</encoder>
</appender>
<appender name="async" class="ch.qos.logback.classic.AsyncAppender">
<appender-ref ref="accessLog" />
</appender>
<logger name="reactor.netty.http.server.AccessLog" level="INFO" additivity="false">
<appender-ref ref="async"/>
</logger>

将当前的gateway项目打包为jar包。

使用java命令运行jar包并添加-Dreactor.netty.http.server.accessLogEnabled=true参数来启动日志记录。

添加依赖。

<!–集成sentinel实现网关熔断限流–>
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-alibaba-sentinel-gateway</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

添加sentinel配置。

spring:
cloud:
sentinel:
transport:
dashboard: ip:端口号 #控制台的ip+port

实现

• 代码实现（参考sentinel部分）
• 控制台实现（只需要对geatway进行限流熔断配置即可）