java guide Spring Cloud Gateway 答疑2

raiseup2

已于 2024-08-15 20:29:54 修改

阅读量842

点赞数 29

文章标签： java 开发语言 spring cloud

于 2024-08-15 20:29:15 首次发布

本文链接：https://blog.csdn.net/2401_86733530/article/details/141231093

版权

spring.cloud.nacos.config.refresh-enabled这个默认是true，用nacos可以让网关配置动态更新

GlobalFilter实现自定义全局过滤器的接口，还有很多内置全局过滤器，如LoadBalancerClientFilter，内置的，用lb://就行

非网关项目可以用@RestControllerAdvice和 @ExceptionHandler，网关项目不行

============

===========
APISIX 基于 etcd 来做配置中心，不存在单点问题，云原生友好；而 Kong 基于 Apache Cassandra/PostgreSQL ，存在单点风险，需要额外的基础设施保障做高可用。
——-------------单点风险是什么？

单点风险（Single Point of Failure，SPOF）是指系统中的某一个组件或节点如果发生故障，会导致整个系统的不可用或崩溃。换句话说，如果这个组件或节点出现问题，整个系统的服务就会中断。

在您的例子中，APISIX和Kong分别使用不同的存储和配置中心：

1. **APISIX**：基于etcd来做配置中心。etcd是一种分布式键值存储，设计用于高可用性和一致性。etcd通过分布式架构和多副本机制，避免了单点故障的问题。

2. **Kong**：基于Apache Cassandra或PostgreSQL。虽然这两种数据库都可以通过集群配置实现高可用性，但如果配置不当或者没有足够的基础设施保障，它们仍然可能存在单点风险。

### 单点风险的具体表现

1. **数据库单点风险**：如果Kong的配置中心使用的是单个PostgreSQL实例，那么这个数据库实例就是一个单点。如果这个实例发生故障（例如硬件故障、网络问题或软件崩溃），整个Kong网关的配置管理和操作就会中断，导致服务不可用。

2. **基础设施单点风险**：即使使用的是分布式数据库（如Cassandra），如果基础设施没有足够的冗余和高可用性配置（如缺乏多个数据中心、负载均衡、自动故障转移等），某个节点或组件的故障仍然可能导致系统的部分或全部不可用。

### 避免单点风险的策略

为了避免单点风险，通常需要采取以下策略：

1. **高可用配置**：确保关键组件（如数据库、配置中心等）通过集群或多副本机制实现高可用。例如，etcd通过多节点集群实现高可用性，PostgreSQL可以通过主从复制和自动故障转移实现高可用。

2. **冗余和备份**：在系统设计中引入冗余，确保某个组件故障时有备用组件可以接管其工作。同时，定期进行数据备份，以防止数据丢失。

3. **自动故障转移**：配置自动故障转移机制（如负载均衡、自动重启等），确保某个节点或组件故障时，系统能够自动切换到备用节点或组件

==========
一对多：一个路由规则可以包含多个断言。如上图中路由 Route1 配置了三个断言 Predicate。同时满足：如果一个路由规则中有多个断言，则需要同时满足才能匹配。如上图中路由 Route2 配置了两个断言，客户端发送的请求必须同时满足这两个断言，才能匹配路由 Route2。第一个匹配成功：如果一个请求可以匹配多个路由，则映射第一个匹配成功的路由。如上图所示，客户端发送的请求满足 Route3 和 Route4 的断言，但是 Route3 的配置在配置文件中靠前，所以只会匹配 Route3。
------
具体举例

好的，让我们通过一个具体的例子来说明如何在Spring Cloud Gateway中配置多个断言（Predicates）和路由规则，以及如何处理多个路由匹配的情况。

### 配置文件示例

假设我们有一个Spring Cloud Gateway的配置文件`application.yml`，其中定义了多个路由规则和断言：

```yaml
spring:
cloud:
gateway:
routes:
- id: route1
uri: http://service1.local
predicates:
- Path=/api/service1/**
- Method=GET
- Header=X-Request-Id, \d+
- id: route2
uri: http://service2.local
predicates:
- Path=/api/service2/**
- Query=version, v1
- id: route3
uri: http://service3.local
predicates:
- Path=/api/service3/**
- Header=User-Agent, .*Chrome.*
- id: route4
uri: http://service4.local
predicates:
- Path=/api/service3/**
- Header=User-Agent, .*Firefox.*
```

### 解释

1. **Route1**：
- **Path**：请求路径必须匹配`/api/service1/**`。
- **Method**：请求方法必须是GET。
- **Header**：请求头`X-Request-Id`必须存在且值为数字（通过正则表达式`\d+`匹配）。

2. **Route2**：
- **Path**：请求路径必须匹配`/api/service2/**`。
- **Query**：请求的查询参数`version`必须等于`v1`。

3. **Route3**：
- **Path**：请求路径必须匹配`/api/service3/**`。
- **Header**：请求头`User-Agent`必须包含字符串`Chrome`。

4. **Route4**：
- **Path**：请求路径必须匹配`/api/service3/**`。
- **Header**：请求头`User-Agent`必须包含字符串`Firefox`。

### 匹配逻辑

1. **多个断言同时满足**：如果一个路由规则中有多个断言，则需要同时满足才能匹配。例如：
- 请求路径为`/api/service1/data`，方法为GET，且请求头`X-Request-Id`为`123`，则匹配`Route1`。
- 请求路径为`/api/service2/info`，

好的，我们继续详细说明匹配逻辑和实际请求示例。

### 匹配逻辑（续）

1. **多个断言同时满足**（续）：
- 请求路径为`/api/service2/info`，且查询参数`version`为`v1`，则匹配`Route2`。
- 请求路径为`/api/service3/data`，且`User-Agent`包含`Chrome`，则匹配`Route3`。
- 请求路径为`/api/service3/data`，且`User-Agent`包含`Firefox`，则匹配`Route4`。

2. **第一个匹配成功**：如果一个请求可以匹配多个路由，则映射第一个匹配成功的路由。例如：
- 请求路径为`/api/service3/data`，且`User-Agent`包含`Chrome`，则匹配`Route3`，即使`Route4`也满足条件，因为`Route3`在配置文件中靠前。
- 请求路径为`/api/service3/data`，且`User-Agent`包含`Firefox`，则匹配`Route4`，因为`Route3`不满足条件。

### 实际请求示例

1. **匹配Route1**：
```http
GET /api/service1/data HTTP/1.1
Host: gateway.local
X-Request-Id: 123
```

- 路径：`/api/service1/data`
- 方法：GET
- 请求头：`X-Request-Id`为`123`

2. **匹配Route2**：
```http
GET /api/service2/info?version=v1 HTTP/1.1
Host: gateway.local
```

- 路径：`/api/service2/info`
- 查询参数：`version=v1`

3. **匹配Route3**：
```http
GET /api/service3/data HTTP/1.1
Host: gateway.local
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3
```

- 路径：`/api/service3/data`
- 请求头：`User-Agent`包含`Chrome`

4. **匹配Route4**：
```http
GET /api/service3/data HTTP/1.1
Host:

============
请求路径为/api/service3/data，且User-Agent包含Chrome，则匹配Route3，即使Route4也满足条件，因为Route3在配置文件中靠前。包含Chrome为什么说即使Route4也满足条件？4要firefox啊！

您说得对，我之前的解释确实有误。感谢您的指正。让我们重新理清这个逻辑。

### 匹配逻辑

1. **多个断言同时满足**：如果一个路由规则中有多个断言，则需要同时满足才能匹配。例如：
- 请求路径为`/api/service1/data`，方法为GET，且请求头`X-Request-Id`为`123`，则匹配`Route1`。
- 请求路径为`/api/service2/info`，且查询参数`version`为`v1`，则匹配`Route2`。
- 请求路径为`/api/service3/data`，且`User-Agent`包含`Chrome`，则匹配`Route3`。
- 请求路径为`/api/service3/data`，且`User-Agent`包含`Firefox`，则匹配`Route4`。

2. **第一个匹配成功**：如果一个请求可以匹配多个路由，则映射第一个匹配成功的路由。例如：
- 请求路径为`/api/service3/data`，且`User-Agent`包含`Chrome`，则匹配`Route3`，不会匹配`Route4`，因为`Route4`要求`User-Agent`包含`Firefox`。
- 请求路径为`/api/service3/data`，且`User-Agent`包含`Firefox`，则匹配`Route4`，因为`Route3`不满足条件。

### 实际请求示例

1. **匹配Route1**：
```http
GET /api/service1/data HTTP/1.1
Host: gateway.local
X-Request-Id: 123
```

- 路径：`/api/service1/data`
- 方法：GET
- 请求头：`X-Request-Id`为`123`

2. **匹配Route2**：
```http
GET /api/service2/info?version=v1 HTTP/1.1
Host: gateway.local
```

- 路径：`/api/service2/info`
- 查询参数：`version=v1`

3. **匹配Route3**：
```http
GET /api/service3/data HTTP/1.1
Host: gateway.local
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.

===================
第一个匹配成功：如果一个请求可以匹配多个路由，则映射第一个匹配成功的路由。例如：
请求路径为/api/service3/data，且User-Agent包含Chrome，则匹配Route3，不会匹配Route4，因为Route4要求User-Agent包含Firefox。
请求路径为/api/service3/data，且User-Agent包含Firefox，则匹配Route4，因为Route3不满足条件。——————————————————这个能叫第一个成功吗》都只有一个

您说得对，之前的解释有些混淆。让我们重新整理一下，明确解释“第一个匹配成功”的概念。
第一个匹配成功
“第一个匹配成功”指的是，当一个请求可以同时匹配多个路由时，Spring Cloud Gateway会选择配置文件中第一个匹配成功的路由进行处理，而不是尝试匹配所有可能的路由。
举个更明确的例子：
配置文件示例
yaml
Copy
spring:
cloud:
gateway:
routes:
- id: route1
uri: http://service1.local
predicates:
- Path=/api/service1/**
- id: route2
uri: http://service2.local
predicates:
- Path=/api/service2/**
- id: route3
uri: http://service3.local
predicates:
- Path=/api/service3/**
- Header=User-Agent, .*Chrome.*
- id: route4
uri: http://service3.local
predicates:
- Path=/api/service3/**
- Header=User-Agent, .*Firefox.*
实际请求示例
匹配Route3：
http
Copy
GET /api/service3/data HTTP/1.1
Host: gateway.local
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3
路径：/api/service3/data
请求头：User-Agent包含Chrome
在这种情况下，请求路径/api/service3/data和请求头User-Agent包含Chrome，同时满足Route3和Route4的路径断言，但因为Route3在配置文件中靠前，并且第一个匹配成功，所以请求会被路由到Route3。
匹配Route4：
http
Copy
GET /api/service3/data HTTP/1.1
Host: gateway.local
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Firefox/58.0.3029.110 Safari/537.3
路径：/api/service3/data
请求头：

============
route4要firefox，包含Chrome的能满足4吗？

您说得对，包含`Chrome`的请求头无法满足`Route4`的断言。让我们重新整理这个逻辑，并举例说明“第一个匹配成功”的概念。

### 配置文件示例

```yaml
spring:
cloud:
gateway:
routes:
- id: route1
uri: http://service1.local
predicates:
- Path=/api/service1/**
- id: route2
uri: http://service2.local
predicates:
- Path=/api/service2/**
- id: route3
uri: http://service3.local
predicates:
- Path=/api/service3/**
- Header=User-Agent, .*Chrome.*
- id: route4
uri: http://service3.local
predicates:
- Path=/api/service3/**
- Header=User-Agent, .*Firefox.*
```

### 实际请求示例

1. **匹配Route3**：
```http
GET /api/service3/data HTTP/1.1
Host: gateway.local
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3
```

- 路径：`/api/service3/data`
- 请求头：`User-Agent`包含`Chrome`

在这种情况下，请求路径`/api/service3/data`和请求头`User-Agent`包含`Chrome`，满足`Route3`的所有断言。虽然路径也满足`Route4`的路径断言，但请求头不满足`Route4`的要求，因此只会匹配`Route3`。

2. **匹配Route4**：
```http
GET /api/service3/data HTTP/1.1
Host: gateway.local
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Firefox/58.0.3029.110 Safari/537.3
```

- 路径：`/api/service3/data`
- 请求头：`User-Agent`包含`Firefox`

在这种情况下，请求路径`/api/service3/data`和请求头`User-Agent`包含`Firefox`，满足`Route4`的所有断言。虽然路径也满足`Route3`的路径断言，但请求头

=========
演示了多个满足了吗？

好的，让我们演示一个请求可以同时满足多个路由的情况，来更好地说明“第一个匹配成功”的概念。

### 配置文件示例

### 实际请求示例

1. **请求匹配多个路由**：
```http
GET /api/service3/data HTTP/1.1
Host: gateway.local
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Browser/58.0.3029.110 Safari/537.3
```

- 路径：`/api/service3/data`
- 请求头：`User-Agent`包含`Browser`

### 匹配逻辑

在这种情况下，请求路径`/api/service3/data`和请求头`User-Agent`包含`Browser`，同时满足`Route3`和`Route4`的路径断言：

- **Route3**：
- Path：`/api/service3/**`
- Header：`User-Agent`包含`Chrome`

- **Route4**：
- Path：`/api/service3/**`
- Header：`User-Agent`包含`Browser`

虽然请求路径`/api/service3/data`和请求头`User-Agent`包含`Browser`同时满足`Route3`和`Route4`的路径断言，但因为`Route4`在配置文件中靠前，并且第一个匹配成功，所以请求会被路由到`Route4`。

### 解释

在这个例子中，请求路径`/api/service3/data`和请求头`User-Agent`包含`Browser`同时满足了`Route3`和`Route4`的断言，但因为`Route4`在配置文件中靠前，并且第一个匹配成功，所以请求会被路由

===============
靠前？4不是在3后面吗

您说得对，我之前的表述有误。正确的逻辑应该是根据配置文件中路由的顺序，第一个匹配成功的路由将会被选择。让我们重新整理并演示一个请求可以同时满足多个路由的情况。

### 配置文件示例

```yaml
spring:
cloud:
gateway:
routes:
- id: route1
uri: http://service1.local
predicates:
- Path=/api/service1/**
- id: route2
uri: http://service2.local
predicates:
- Path=/api/service2/**
- id: route3
uri: http://service3.local
predicates:
- Path=/api/service3/**
- Header=User-Agent, .*Browser.*
- id: route4
uri: http://service4.local
predicates:
- Path=/api/service3/**
- Header=User-Agent, .*Chrome.*
```

### 实际请求示例

- 路径：`/api/service3/data`
- 请求头：`User-Agent`包含`Chrome`和`Browser`

### 匹配逻辑

在这种情况下，请求路径`/api/service3/data`和请求头`User-Agent`包含`Chrome`和`Browser`，同时满足`Route3`和`Route4`的路径断言：

- **Route3**：
- Path：`/api/service3/**`
- Header：`User-Agent`包含`Browser`

- **Route4**：
- Path：`/api/service3/**`
- Header：`User-Agent`包含`Chrome`

由于请求路径`/api/service3/data`和请求头`User-Agent`包含`Chrome`和`Browser`同时满足了`Route3`和`Route4`的断言，但因为`Route3`在配置文件中靠前，并且第一个匹配成功，所以请求会被路由到`Route3`。

### 解释

在这个例子中，请求路径`/api/service3/data`和请求

================
3还是4？

非常抱歉，之前的解释有些混乱。让我们重新整理并明确说明“第一个匹配成功”的概念。

### 配置文件示例

```yaml
spring:
cloud:
gateway:
routes:
- id: route1
uri: http://service1.local
predicates:
- Path=/api/service1/**
- id: route2
uri: http://service2.local
predicates:
- Path=/api/service2/**
- id: route3
uri: http://service3.local
predicates:
- Path=/api/service3/**
- Header=User-Agent, .*Chrome.*
- id: route4
uri: http://service4.local
predicates:
- Path=/api/service3/**
- Header=User-Agent, .*Browser.*
```