ToB企服应用市场:ToB评测及商务社交产业平台

标题: spring cloud内容汇总（各个功能模块，启动，部署） [打印本页]
作者: 去皮卡多    时间: 2024-11-18 13:03
标题: spring cloud内容汇总（各个功能模块，启动，部署）
Spring Cloud 是一套基于 Spring Boot 的框架聚集，用于构建分布式微服务架构。它提供了一系列工具和库，资助开辟者更轻松地管理分布式系统中的关键问题，比如服务注册与发现、负载均衡、分布式配置管理、熔断与降级、链路追踪等。
下图展示了微服务架构中每个主要功能模块的常用办理方案。

一、相关功能的介绍

1. 服务注册与发现

服务注册：服务注册与发现用于让各个服务在启动时自动注册到一个中心注册中心（如 Nacos、Eureka），并且能让其他服务通过注册中心找到并调用它们的地址。
发现：每个服务启动后会将自身的地址和端口信息注册到注册中心；其他服务要调用它时，通过注册中心获取服务实例的地址，而不需要固定的地址。
2. 服务调用和负载均衡

服务调用：服务之间的通信方式，可以通过 HTTP（如 RESTful API）或 RPC（远程过程调用）举行服务之间的哀求。
负载均衡：在微服务架构中，通常会有多个雷同的服务实例分布在不同的服务器上。负载均衡用于在多个实例间分配哀求，常见的计谋有轮询、随机、最小连接数等，从而提升系统的处理能力和容错性。
3. 分布式事务

分布式事务用于保证多个服务在处理同一个业务利用时的一致性。例如，用户下单时，需要支付服务和库存服务同时完成，如果某一方失败，整个利用需要回滚。
4. 服务熔断和降级

服务熔断：用于防止一个服务的故障传导到其他服务。如果某个服务在短时间内出现大量的错误或相应缓慢，熔断机制会自动切断对该服务的调用，避免对系统造成更大影响。
服务降级：在服务出现问题时，提供降级计谋，比如返回默认值或简化相应内容，使系统能够在部门服务不可用的情况下继续运行。
5. 服务链路追踪

服务链路追踪用于跟踪分布式系统中一次哀求的完整路径，分析其跨多个服务的执行情况，方便发现延长或错误。
6. 服务网关

服务网关作为服务的同一入口，处理所有外部哀求，提供认证授权、负载均衡、路由分发、监控等功能。它还能对哀求举行限流、熔断、降级等保护。
7. 分布式配置管理

分布式配置管理用于集中管理各服务的配置文件，支持动态更新，不需要重启服务。  可以在配置更新后自动推送至各服务节点，使它们能实时更新配置信息，提升了系统的机动性和一致性。
二、前置内容和预备工作

1、 不同服务之间的调用

下面两个相识其中一个就行
2、 预备工作（引入spring cloud依赖）

1. dependencyManagement

dependencyManagement 是 Maven 构建工具中的一个元素，用于定义项目中依赖的管理方式。它允许我们在父 POM 文件或依赖管理部门中集中声明依赖的版本号和作用范围，所有子模块（子项目）可以自动继承这些声明，而不需要在每个子模块的 pom.xml 中重复定义。
根项目 pom 文件
  1. <packaging>pom</packaging>
  3. <dependencyManagement>
  4.        <dependencies>
  5.            
  6.            <dependency>
  7.                <groupId>org.springframework.cloud</groupId>
  8.                <artifactId>spring-cloud-dependencies</artifactId>
  9.                <version>2023.0.3</version>
  10.                <type>pom</type>
  11.                <scope>import</scope>
  12.            </dependency>
  13.            
  14.            <dependency>
  15.                <groupId>com.alibaba.cloud</groupId>
  16.                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
  17.                <version>2023.0.1.3</version>
  18.                <type>pom</type>
  19.                <scope>import</scope>
  20.            </dependency>
  21.        </dependencies>
  22.    </dependencyManagement>
复制代码
子项目 pom 文件
  1. <parent>
  2.     <groupId>com.cloud</groupId>
  3.     <artifactId>learnCloudAlibaba</artifactId>
  4.     <version>0.0.1-SNAPSHOT</version>
  5.     <relativePath>../pom.xml</relativePath>
  6. </parent>
复制代码
2. 引入依赖 spring Cloud

maven官网
2. 引入依赖 spring Cloud alibaba

3. 版本兼容性问题

下面解说一下每个主要功能模块的部署和配置
三、服务注册与发现 nacos

1. 预备工作

2. 以单例启动

解压进入nacos的 bin目录，以单例模式启动
  1. .\startup.cmd -m standalone
  3. # localhost:8848/nacos 进行访问, 默认账号密码都是 nacos
复制代码
3. 常见配置
  1. spring.cloud.nacos.discovery.namespace=命名空间id # 指定命令空间, 不同空间下的实例不可互相访问
  2. spring.cloud.nacos.discovery.group=DEFAULT_GROUP # 默认是DEFAULT_GROUP，指定group，不同group下的实例不可互相访问
  3. spring.cloud.nacos.discovery.cluster-name=BeiJing # 指定当前实例是哪个集群，一般按照地区划分，讲请求发送距离近的实例
  4. spring.cloud.loadbalancer.nacos.enabled=true # 开启 优先向跟当前发送请求的实例 在同一集群的实例发送请求
  5. spring.cloud.nacos.discovery.weight=1 # 当前实例的权值，权值在1-100，默认是1，权值越大越容易接收请求，一般给配置高的服务器权值高一些
复制代码
4. Nacos 集群架构

对于 Nacos 集群，主要的作用是 实现高可用和数据一致性，保证服务注册和配置管理的可靠性。
可以通过nginx反向代理，实现只暴漏一个nacos服务地址，nginx内容实现负载均衡
也可以通过loadbalancer或是在 application 中添加集群的所有地址实现简单的负载均衡
  1. # 会选其中一个地址注册服务
  2. spring.cloud.nacos.discovery.server-addr: 172.20.10.2:8870,172.20.10.2:8860,172.20.10.2:8848
复制代码
5. 集群模式部署

四、服务调用和负载均衡 LoadBalancer

Spring Cloud LoadBalancer 是 Spring Cloud 中的一个负载均衡模块，用于在服务调用时实现客户端负载均衡。
1. 基本概念

Spring Cloud LoadBalancer 通过客户端负载均衡，在服务调用者和多个实例之间分配流量。它通过服务发现（比如使用 Nacos）获取可用服务实例的列表，并根据不同的负载均衡计谋（如轮询、随机等）选择一个实例举行哀求分发。
2. 配置情况

在项目中使用 Spring Cloud LoadBalancer，在每个需要使用客户端负载均衡功能的子模块中添加：
  1. <dependency>
  2.     <groupId>org.springframework.cloud</groupId>
  3.     <artifactId>spring-cloud-starter-loadbalancer</artifactId>
  4. </dependency>
复制代码
配置默认计谋（轮询）
  1. spring.cloud.loadbalancer.configurations=default
复制代码
3. 负载均衡的使用方式

Spring Cloud LoadBalancer 支持使用 RestTemplate 、WebClient 、OpenFeign  举行负载均衡。
使用 RestTemplate

4. 测试 负载均衡

假设我们有一个根模块, 根模块下面有三个模块 module1，module2，module3。module2 和 module3 我们在本地的不同端口各启动两个（模拟分布式）。当我们通过module1调用 module2 和 module3 的方法，观察哀求的分布
5. 使用不同的负载均衡器

上面的配置是所有服务都是用默认的负载均衡器，即轮询的负载均衡器。下面讲一下怎么让不同服务使用不同的负载均衡器
五、分布式事务 seata

Seata 是一款开源的分布式事务办理方案，旨在办理微服务架构中跨服务的事务一致性问题。它提供了易于使用、性能高效的分布式事务管理功能，资助开辟者在分布式系统中保持数据一致性。
1. Seata 的概要

Seata 由阿里巴巴发起，最初的目标是为了办理微服务场景下的数据一致性问题，尤其是在分布式数据库事务中。Seata 提供了全局事务、分支事务以及资源管理等功能。

TM哀求TC开启一个全局事务，TC会天生一个XID作为该全局事务的编号，XID会在微服务的调用链路中传播，保证将多个微服务的子事务关联在一起；RM哀求TC将本地事务注册为全局事务的分支事务，通过全局事务的XID举行关联；TM哀求TC告诉XID对应的全局事务是举行提交还是回滚；TC驱动RM将XID对应的本身的本地事务举行提交还是回滚；
下面以官网的案例来演示整个使用过程
2. 预备工作

终极结果如下

创建三个模块(account, order, storage)，加入相关依赖(数据库驱动，mybatis...)，然后按照下面加入 nacos 和 seata 依赖和配置
3. Seata 与 Spring Boot 集成

3.1 添加 Seata 依赖
  1. <dependency>
  2.    <groupId>com.alibaba.cloud</groupId>
  3.     <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
  4.     <exclusions>
  5.         <exclusion>
  6.             <groupId>io.seata</groupId>
  7.             <artifactId>seata-spring-boot-starter</artifactId>
  8.         </exclusion>
  9.     </exclusions>
  10. </dependency>
复制代码
3.2 配置 Seata

在 Spring Boot 项目标 application.yml 中配置 Seata。
  1. seata:
  2.   registry:
  3.     type: nacos
  4.     nacos:
  5.       server-addr: localhost:8848
  6.       namespace: ""
  7.       group: SEATA_GROUP # 组名  跟我们之前配置的seata的配置文件的是对应的
  8.       application: seata-server # 服务名 跟我们之前配置的seata的配置文件的是对应的
  9.   tx-service-group: default_tx_group
  10.   service:
  11.     vgroup-mapping:
  12.       default_tx_group: default
  13.   data-source-proxy-mode: AT
复制代码
3.3 开启事务管理

@GlobalTransactional 是 Seata 提供的注解，用于实现分布式事务的管理。它是 Seata 的全局事务控制器，通过这个注解，你可以在一个跨多个微服务的利用中，确保数据的一致性和事务的回滚。
作用：

基本语法：
  1. @GlobalTransactional(name = "your-global-tx-name", rollbackFor = Exception.class)
  2. public void yourMethod() {
  3.     // Your business logic
  4. }
复制代码
参数：

4. 演示流程

下面是通过访问 order 订单服务，然后执行 创建新的订单-> 扣除用户支付的钱 -> 减去用户购买商品的数量更新商品库存
  1. @RestController
  2. public class CreateOrderController {
  4.     @Autowired
  5.     OrderMapper orderMapper;
  7.     @Autowired
  8.     RestTemplate restTemplate;
  10.     @RequestMapping("/order/test")
  11.     @GlobalTransactional(name = "create-order", rollbackFor = Exception.class)
  12.     public String createOrder(@RequestParam String userId,
  13.                               @RequestParam String commodityCode,
  14.                               @RequestParam Integer count,
  15.                               @RequestParam Integer money
  16.     ) {
  17.         // 创建订单
  18.         Order order = new Order(null, userId, commodityCode, count, money);
  19.         orderMapper.insert(order);
  21.         // 扣除账户余额
  22.         Map<String, String> mp1 = new HashMap<>();
  23.         mp1.put("userId", userId);
  24.         mp1.put("money", money.toString());
  25.         String resp1 = restTemplate.postForObject("http://localhost:8001/account/test", mp1, String.class);
  27.         // 减去用户购买商品数量，更新库存
  28.         Map<String, String> mp2 = new HashMap<>();
  29.         mp2.put("commodityCode", commodityCode);
  30.         mp2.put("count", count.toString());
  31.         String resp2 = restTemplate.postForObject("http://localhost:8003/storage/test", mp2, String.class);
  33.         if ("ok".equals(resp1) && "ok".equals(resp2)) {
  34.             return "ok";
  35.         }
  36.         return "error";
  37.     }
  38. }
复制代码
如果在调用其他服务时（扣除账户余额，更新库存时），如果抛出异常的话，整个事务就会回滚。比如减去用户购买商品数量时发现库存不足，抛出异常，整个事务回滚，之前的创建订单和扣除账户余额都会回滚
六、服务熔断和降级 sentinel

Sentinel 是阿里巴巴开源的分布式系统流量控制组件，主要用于保护微服务在高并发、突发流量等场景下的稳固性和可靠性。Sentinel 提供了 流量控制、熔断降级、系统自适应保护等机制
1. Sentinel 的核心功能

Sentinel 提供了以下核心功能：
2. Sentinel 的基本概念

在 Sentinel 中，核心是“资源”，可以是服务、接口或方法。每一个资源都会绑定一套限流规则或熔断规则。以下是 Sentinel 的几个基本概念：
3. Sentinel 的监控和控制台

Sentinel 提供了 Dashboard 管理控制台，可以用来监控各个资源的访问情况，并动态配置流量控制和熔断规则。(下载地址, 下载jar包)
4. @SentinelResource注解

@SentinelResource 是 Sentinel 中用于标记 方法 的注解，它允许你在方法调用时应用 Sentinel 的规则和控制计谋。通过使用这个注解，你可以将 Sentinel 的流量控制、熔断降级、热点参数限流等功能集成到业务逻辑中。
1. value 参数：资源名称

2. blockHandler 参数：限流或熔断处理方法

示例：
  1. @SentinelResource(value = "myResource", blockHandler = "handleBlock")
  2. public String someMethod() {
  3.     // 你的业务逻辑
  4.     return "Hello, Sentinel!";
  5. }
  7. // 流控或熔断时的处理方法
  8. public static String handleBlock(BlockException ex) {
  9.     return "Service is currently unavailable due to high traffic. Please try again later.";
  10. }
复制代码
在这个例子中，当 myResource 资源被流控或熔断时，handleBlock 方法将被调用，返回一条友爱的错误信息。
3. fallback 参数：降级处理方法

示例：
  1. @SentinelResource(value = "myResource", fallback = "fallbackMethod")
  2. public String someMethod() {
  3.     // 可能会抛出异常的业务逻辑
  4.     throw new RuntimeException("Something went wrong");
  5. }
  7. // 降级方法
  8. public static String fallbackMethod(Throwable ex) {
  9.     return "Service is temporarily unavailable due to internal error. Please try again later.";
  10. }
复制代码
在这个例子中，当 someMethod 方法抛出异常时，fallbackMethod 会被调用，返回一个默认的降级相应。
4. exceptionsToIgnore 参数：忽略的异常类型

5. blockHandlerClass 参数：自定义流控处理类

示例：
  1. @SentinelResource(value = "myResource", blockHandler = "handleBlock", blockHandlerClass = BlockHandler.class)
  2. public String someMethod() {
  3.     // 业务逻辑
  4.     return "Hello, Sentinel!";
  5. }
  7. // 自定义流控处理类
  8. public class BlockHandler {
  9.     public static String handleBlock(BlockException ex) {
  10.         return "Service is temporarily unavailable due to traffic control.";
  11.     }
  12. }
复制代码
6. fallbackClass 参数：自定义降级处理类

示例：
  1. @SentinelResource(value = "myResource", fallback = "fallbackMethod", fallbackClass = FallbackHandler.class)
  2. public String someMethod() {
  3.     // 业务逻辑
  4.     throw new RuntimeException("Something went wrong");
  5. }
  7. // 自定义降级处理类
  8. public class FallbackHandler {
  9.     public static String fallbackMethod(Throwable ex) {
  10.         return "Service is temporarily unavailable due to an error.";
  11.     }
  12. }
复制代码
5. 流量控制

5.1 流控模式

链路流控模式指的是，当从指定接口过来的资源哀求到达限流条件时，开启限流。
  1. # 关闭Context收敛，这样被监控方法可以进行不同链路的单独控制
  2. spring.cloud.sentinel.web-context-unify: false
  3. # 比如我 /test1 和 /test2 接口下都调用了 test 方法，那么我可以在sentinel 控制台中分别对 /test1 和 /test2 的 test 进行设置
复制代码

5.2 流控结果

快速拒绝： 既然不再担当新的哀求，那么我们可以直接返回一个拒绝信息，告诉用户访问频率过高。
预热: 依然基于方案一，但是由于某些情况下高并发哀求是在某一时刻突然到来，我们可以缓慢地将阈值进步到指定阈值，形成一个缓冲保护
排队等待： 不担当新的哀求，但是也不直接拒绝，而是进队列先等一下，如果规定时间内能够执行，那么就执行，要是超时就算了。
5.3 实现对方法的限流控制

我们可以使用到@SentinelResource对某一个方法举行限流控制，无论是谁在那边调用了它，，一旦方法被标注，那么就会举行监控。
  1. @RestController
  2. public class TestController {
  4.     @Autowired
  5.     RestTemplate restTemplate;
  7.     @Autowired
  8.     MyService myService;
  10.     @GetMapping("/test1")
  11.     public String test1() {
  12.         return myService.test();
  13.     }
  15.     @GetMapping("/test2")
  16.     public String test2() {
  17.         return myService.test();
  18.     }
  19. }
  20. // ------------------------
  21. @Service
  22. public class MyService {
  24.     @SentinelResource("mytest")        // 标记方法
  25.     public String test() {
  26.         return "test";
  27.     }
  28. }
复制代码
添加 spring.cloud.sentinel.web-context-unify=false, 可以对 /test1 和 /test2 的 mytest单独控制

不添加的, 无法单独控制

一些坑
如果在方法上添加了 @SentinelResource 注解，但是不在控制台中显示的话(不显示mytest), 大概是由于添加的方法没有加入到spring容器中举行管理。比如我当时下面如许写就出现了不在控制台显示的情况。
  1. @RestController
  2. public class TestController {
  3.    
  4.     @GetMapping("/test1")
  5.     public String test1() {
  6.         return test();
  7.     }
  8.    
  9.     @SentinelResource("mytest")
  10.     public String test() {
  11.         return "test";
  12.     }
  13. }
复制代码
5.4 处理限流情况

当访问某个 接口 出现限流时，会抛出限流异常，重定向到我们添加的路径
  1. @RequestMapping("/blockPage")
  2.     public String blockPage() {
  3.         return "blockPage";
  4.     }
复制代码
  1. # 用于设置当 流控 或 熔断 触发时，返回给用户的 阻塞页面
  2. spring.cloud.sentinel.block-page=/blockPage
复制代码
当访问的某个 方法 出现了限流，为 blockHander 指定方法，当限流时会访问 test2, 并且可以担当 test 的参数
  1. @Service
  2. public class MyService {
  4.     @SentinelResource(value = "mytest", blockHandler = "test2")
  5.     public String test(int id) {
  6.         return "test";
  7.     }
  9.     public String test2(int id, BlockException ex) {
  10.         return "test 限流了 " + id;
  11.     }
  12. }
复制代码
5.5 处理异常的处理

当调用 test 时抛出了异常的话，那么就会执行 fallback 指定的方法, exceptionsToIgnore 指定的是忽略掉的异常。（限流的话会抛出限流的异常，也会被捕捉，执行 fallback 指定的方法）
如果 fallback 和 blockHandler 都指定了方法，出现限流异常会优先执行 blockHandler 的方法
  1. @Service
  2. public class MyService {
  4.     @SentinelResource(value = "mytest", fallback = "except", exceptionsToIgnore = IOException.class)
  5.     public String test(int id) {
  6.         throw new RuntimeException("hello world");
  7.     }
  8. // 注意参数, 必须是跟 test 的参数列表相同, 然后可以多加一个获取异常的参数
  9.     public String except(int id, Throwable ex) {
  10.         System.out.println("hello = " + ex.getMessage());
  11.         return ex.getMessage();
  12.     }
  13. }
复制代码
5.6 热点参数限流

对接口或方法的某个参数举行限流
  1. @GetMapping("/test1")
  2. @SentinelResource(value = "test1")
  3. public String test1(@RequestParam(required = false) String name, @RequestParam(required = false) String age) {
  4.     return name + " " + age;
  5. }
复制代码

6. 熔断降级

1. 服务熔断

当某个服务的错误率或失败次数（如异常或超时）凌驾预设的阈值时，熔断器就会“断开”，该服务的调用将不会继续执行。熔断器“断开”后，所有哀求都会被 拒绝，直到熔断器进入 恢复阶段，然后根据预设规则恢复正常工作。
2. 熔断规则

熔断规则定义了什么情况下触发熔断。常见的触发条件有：
这些规则是可以配置的，通常会在应用初始化时举行设置。
3. 服务降级 (Service Degradation)

服务降级是指在某些情况下，通过返回一个默认值、简单处理或快速失败来淘汰服务的压力，避免因资源超载或异常哀求导致服务崩溃。Sentinel 通过配置不同的降级计谋，使得系统能够在流量激增或服务不稳固时自动切换到降级模式。
最后简单介绍一下限流，熔断，降级之间的接洽。 根据降级的概念，当出现限流或熔断的时候都会触发降级的方法，只不过熔断会根据本身的配置，来跟熔断的服务断开接洽，不再担当哀求。而限流的话不会断开服务，而是继续担当哀求，如果哀求不满意 限流规则的话，还是会进入到降级的方法
七、服务链路追踪

在zipkin官网下载 zipkin.jar 包。下载地址
Micrometer Tracing 是 Spring 官方在现代可观测性（Observability）体系中的新工具，用于实现分布式链路追踪。
1. 核心概念

2. 工作原理

3. 简单配置

在 Spring Boot 3+ 项目中，Micrometer Tracing 的依赖配置如下：
之后就可以访问 http://127.0.0.1:9411
八、服务网关 gateway

Gateway（网关）是微服务架构中的一个重要组件，它通常用作客户端和多个微服务之间的中介，负责哀求的路由、负载均衡、认证、限流、安全控制等功能。它通常部署在前端，起到了“入口”作用，是微服务的前端同一访问点。
1. 网关的核心功能

网关的核心职责是将外部哀求路由到相应的微服务，同时提供一些重要的功能：
2. 预备工作

上面的predicates和filters只写了一部门，具体可以参考spring官网        地址
Spring Cloud Gateway 与其他网关对比

3. 自定义全局和局部过滤器

过滤器是网关的一个重要特性，可以在哀求和相应的生命周期中做一些额外的处理。
3.1 自定义全局过滤器

在 Spring Cloud Gateway 中，全局过滤器（Global Filters）用于在哀求和相应过程中对所有路由举行处理。
1. 创建一个全局过滤器

首先，需要创建一个实现 GlobalFilter 接口的类。在这个类中，你可以定义过滤器的逻辑。
  1. import org.springframework.cloud.gateway.filter.GatewayFilterChain;
  2. import org.springframework.cloud.gateway.filter.GlobalFilter;
  3. import org.springframework.core.Ordered;
  4. import org.springframework.http.HttpHeaders;
  5. import org.springframework.stereotype.Component;
  6. import org.springframework.web.server.ServerWebExchange;
  7. import reactor.core.publisher.Mono;
  9. @Component
  10. public class AddHeaderGlobalFilter implements GlobalFilter, Ordered {
  12.    @Override
  13.    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
  14.        return chain.filter(exchange);
  15.    }
  17.    @Override
  18.    public int getOrder() {
  19.        return 1;
  20.    }
  21. }
复制代码
2. 全局过滤器的工作原理

3. 示例：添加哀求头

假设我们需要为每个哀求添加一个特定的哀求头。
  1. package com.cloud.gateway.config;
  3. import org.springframework.cloud.gateway.filter.GatewayFilterChain;
  4. import org.springframework.cloud.gateway.filter.GlobalFilter;
  5. import org.springframework.core.Ordered;
  6. import org.springframework.http.HttpHeaders;
  7. import org.springframework.stereotype.Component;
  8. import org.springframework.web.server.ServerWebExchange;
  9. import reactor.core.publisher.Mono;
  11. @Component
  12. public class AddHeaderGlobalFilter implements GlobalFilter, Ordered {
  14.     @Override
  15.     public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
  16.         // 获取请求的 headers
  17.         HttpHeaders headers = exchange.getRequest().getHeaders();
  19.         // 打印原始请求头
  20.         System.out.println("Request Headers: " + headers);
  22.         // 为请求添加一个新的头部
  23.         exchange.getRequest().mutate()
  24.                 .header("test", "hello world") // 添加请求头
  25.                 .build();
  27.         // 继续传递到下一个过滤器
  28.         return chain.filter(exchange);
  29.     }
  31.     @Override
  32.     public int getOrder() {
  33.         return 1;
  34.     }
  35. }
复制代码
3.1 自定义局部过滤器

自定义局部过滤器（GatewayFilter）：
  1. import org.springframework.cloud.gateway.filter.GatewayFilter;
  2. import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
  3. import org.springframework.http.HttpStatus;
  4. import org.springframework.stereotype.Component;
  6. @Component
  7. public class AuthFilter  extends AbstractGatewayFilterFactory<AuthFilter.Config> {
  9.     public AuthFilter () {
  10.         super(Config.class);
  11.     }
  13.     @Override
  14.     public GatewayFilter apply(Config config) {
  15.         return (exchange, chain) -> {
  16.             System.out.println("AuthFilter");
  17.             // 下面实现自己的逻辑
  18.             String token = exchange.getRequest().getHeaders().getFirst("token");
  19.             if (token == null || !token.equals(config.getToken())) {
  20.                 exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
  21.                 return exchange.getResponse().setComplete();
  22.             }
  23.             return chain.filter(exchange);  // 继续处理链中的其他过滤器
  24.         };
  25.     }
  28.     public static class Config {
  29.         private String token;
  31.         public String getToken() {
  32.             return token;
  33.         }
  35.         public void setToken(String token) {
  36.             this.token = token;
  37.         }
  38.     }
  39. }
复制代码
使用局部过滤器

局部过滤器通常在路由配置中使用，你可以将它应用于特定的路由，例如：
  1. spring:
  2.   cloud:
  3.     gateway:
  4.       routes:
  5.         - id: user-service
  6.           uri: lb://USER-SERVICE
  7.           predicates:
  8.             - Path=/users/**
  9.           filters:
  10.             - AuthFilter  # 这里引用自定义的局部过滤器
复制代码
九、分布式配置管理 nacos

分布式配置管理功能的主要作用是在不同的服务之间集中管理和同一分发配置。这使得系统在配置变动时无需重启服务，可以实时更新配置，从而到达快速相应的结果。
基本概念

Nacos 配置管理的使用步骤


引入 Nacos 配置管理

我踩的一些坑:

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4