[Spring Cloud] Explicação detalhada das regras de declaração de roteamento no Gateway Gateway

contar com

		 <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>

Três componentes

1. roteamento

2. Afirmação

3. filtro

roteamento

A composição básica de um gateway consiste em um ID, uma URL de destino, uma declaração e um filtro. Se a declaração for verdadeira, a rota será correspondida

Afirmação

Somente a solicitação declarada bem-sucedida corresponderá à rota

filtro

Pode lidar com solicitações ou respostas

O primeiro uso do pequeno Demo Gateway

Crie um novo módulo de serviço, fornecendo @GetMapping("/say") @GetMapping("/say/one") dois mapeamentos de solicitação

@RestController
public class HelloController {

    @GetMapping("/say")
    public String say()
    {
        return "HelloWord";
    }

    @GetMapping("/say/one")
    public String sayOne()
    {
        return "HelloWord one";
    }

}

Criar um novo módulo de gateway

Defina a seguinte configuração

server:
  port: 81
spring:
  cloud:
    gateway:
      routes:   # 配置路由，是一个集合
        - id: apptest          # 路由的ID, 没有固定规则但要求唯一，建议配合服务名
          uri: http://localhost:8080  # 匹配后提供服务的路由地址
          predicates:
            - Path=/say/**

iniciar dois serviços

Primeiro testamos se ele pode ser acessado normalmente sem passar pelo serviço de acesso ao gateway

Em seguida, teste o roteamento do serviço pelo gateway

Até agora, uma demonstração do serviço de roteamento de gateway foi concluída.

princípio de trabalho

O diagrama a seguir fornece uma visão geral de alto nível de como o Spring Gateway funciona:

O cliente envia uma solicitação ao gateway. Se a solicitação de mapeamento processada pelo gateway corresponder à rota, a solicitação de mapeamento será entregue ao GateWay Web Handler para processamento. cadeia de filtro e, finalmente, retorna

O filtro pode ser executado antes do envio da solicitação de proxy ou pode ser executado após a solicitação de proxy

Configurar asserções e filtros de rota

Há duas maneiras de configurar o gateway

1. Gateway de configuração de atalho

As configurações de atalho são identificadas pelo nome do filtro seguido de um sinal de igual =, e os valores dos parâmetros separados por vírgulas (,).

spring:
  cloud:
    gateway:
      routes:
      - id: after_route
        uri: https://example.org
        predicates:
        - Cookie=mycookie,mycookievalue

2. Expanda todos os parâmetros

Os parâmetros totalmente expandidos se parecem mais com a configuração yaml padrão com pares de nome/valor. Normalmente, haverá uma chave de nome e uma chave args. A chave args é um mapa de pares chave-valor que configuram a asserção ou filtro

spring:
  cloud:
    gateway:
      routes:
      - id: after_route
        uri: https://example.org
        predicates:
        - name: Cookie
          args:
            name: mycookie
            regexp: mycookievalue

Regras de Asserção de Roteamento

1. Tempo como regra de roteamento correspondente Depois Antes Entre

1.1 A Fábrica de Predicados Após Rota

spring:
  cloud:
    gateway:
      routes:   # 配置路由，是一个集合
        - id: apptest          # 路由的ID, 没有固定规则但要求唯一，建议配合服务名
          uri: http://localhost:8080  # 匹配后提供服务的路由地址
          predicates:
            - After=2022-03-20T21:02:47.789-07:00[Asia/Shanghai]

Quando o horário solicitado for posterior ao horário de asserção, a rota será correspondida

A hora que configuramos é 2022-03-20T21:02:47.789 antes da hora atual 2022-03-20 21:07

Ou seja, o tempo de solicitação atual pode corresponder à rota após o tempo em que afirmamos

spring:
  cloud:
    gateway:
      routes:   # 配置路由，是一个集合
        - id: apptest          # 路由的ID, 没有固定规则但要求唯一，建议配合服务名
          uri: http://localhost:8080  # 匹配后提供服务的路由地址
          predicates:
            - After=2022-03-21T21:02:47.789-07:00[Asia/Shanghai]

A hora atual é 03-20 e a hora que afirmamos é 03-21, a solicitação não pode corresponder à rota atual

1.2 A Fábrica de Predicados Antes da Rota

Olhando para o exemplo após o tempo acima, você deve entender imediatamente o que aconteceu antes do tempo.

Exatamente o oposto de Depois

server:
  port: 81
spring:
  cloud:
    gateway:
      routes:   # 配置路由，是一个集合
        - id: apptest          # 路由的ID, 没有固定规则但要求唯一，建议配合服务名
          uri: http://localhost:8080  # 匹配后提供服务的路由地址
          predicates:
            - Before=2022-03-20T21:02:47.789-07:00[Asia/Shanghai]

A hora da solicitação é posterior à hora definida pela asserção, a solicitação atual não pode ser correspondida e todas as rotas não podem ser correspondidas

Defina o tempo de afirmação para o tempo atual e teste-o novamente

server:
  port: 81
spring:
  cloud:
    gateway:
      routes:   # 配置路由，是一个集合
        - id: apptest          # 路由的ID, 没有固定规则但要求唯一，建议配合服务名
          uri: http://localhost:8080  # 匹配后提供服务的路由地址
          predicates:
            - Before=2022-03-22T21:02:47.789-07:00[Asia/Shanghai]

1.3. Comparação entre Depois e Antes

1.4 A Fábrica de Predicados de Rota Entre

Especifique dois horários, separados por vírgulas, se o horário da solicitação estiver entre esses dois horários, a rota será correspondida

server:
  port: 81
spring:
  cloud:
    gateway:
      routes:   # 配置路由，是一个集合
        - id: apptest          # 路由的ID, 没有固定规则但要求唯一，建议配合服务名
          uri: http://localhost:8080  # 匹配后提供服务的路由地址
          predicates:
            - Between=2022-03-19T21:02:47.789-07:00[Asia/Shanghai],2022-03-22T21:02:47.789-07:00[Asia/Shanghai]

Neste momento, o tempo de solicitação é

Pode ser roteado normalmente se o horário da solicitação não estiver dentro do intervalo de tempo definido

não corresponde à rota

server:
  port: 81
spring:
  cloud:
    gateway:
      routes:   # 配置路由，是一个集合
        - id: apptest          # 路由的ID, 没有固定规则但要求唯一，建议配合服务名
          uri: http://localhost:8080  # 匹配后提供服务的路由地址
          predicates:
            - Between=2022-03-22T21:02:47.789-07:00[Asia/Shanghai],2022-03-23T21:02:47.789-07:00[Asia/Shanghai]

2.Cozinhe como um cookie para combinar as regras de roteamento

2.1 A Fábrica de Predicados da Rota do Cookie

server:
  port: 81
spring:
  cloud:
    gateway:
      routes:   # 配置路由，是一个集合
        - id: apptest          # 路由的ID, 没有固定规则但要求唯一，建议配合服务名
          uri: http://localhost:8080  # 匹配后提供服务的路由地址
          predicates:
            - Cookie=token,123

Se o nome no cookie de solicitação for token e o valor for 123, ele corresponderá à rota atual

Se houver uma diferença entre o nome e o valor, ele não poderá ser roteado com sucesso

Se o nome e o valor forem iguais, a rota pode ser roteada com sucesso

3. O cabeçalho da solicitação é usado como o cabeçalho da regra de roteamento correspondente

server:
  port: 81
spring:
  cloud:
    gateway:
      routes:   # 配置路由，是一个集合
        - id: apptest          # 路由的ID, 没有固定规则但要求唯一，建议配合服务名
          uri: http://localhost:8080  # 匹配后提供服务的路由地址
          predicates:
            - Header=token,123

Se houver um token de nome no cabeçalho da solicitação do objeto de solicitação e o valor for 123, ele corresponderá à rota atual

Use testes de carteiro em vez disso

Conforme mostrado no cabeçalho de solicitação de teste, se não houver informações de cabeçalho de solicitação com um nome de valor de token de 123, a rota não poderá ser correspondida.

Quando há informações de cabeçalho de solicitação com nome como token e valor de 123 no cabeçalho de solicitação, a rota atual pode ser correspondida

4.Host como o host da regra de roteamento correspondente

server:
  port: 81
spring:
  cloud:
    gateway:
      routes:   # 配置路由，是一个集合
        - id: apptest          # 路由的ID, 没有固定规则但要求唯一，建议配合服务名
          uri: http://localhost:8080  # 匹配后提供服务的路由地址
          predicates:
            - Host=**.haha.com:81

Modifique o arquivo do host local primeiro

127.0.0.1   qq.haha.com
127.0.0.1   qq.haha.cn

Visite http://qq.haha.com:81/say para combinar a rota

Alterar para cn não corresponderá à rota

5. O método de solicitação é usado como a regra de roteamento correspondente.

server:
  port: 81
spring:
  cloud:
    gateway:
      routes:   # 配置路由，是一个集合
        - id: apptest          # 路由的ID, 没有固定规则但要求唯一，建议配合服务名
          uri: http://localhost:8080  # 匹配后提供服务的路由地址
          predicates:
            - Method=GET,POST

As solicitações GET e PUT podem corresponder à rota

Se mudarmos para a solicitação PUT, ela não poderá corresponder à rota

6. Caminho como a regra de roteamento correspondente Caminho

server:
  port: 81
spring:
  cloud:
    gateway:
      routes:   # 配置路由，是一个集合
        - id: apptest          # 路由的ID, 没有固定规则但要求唯一，建议配合服务名
          uri: http://localhost:8080  # 匹配后提供服务的路由地址
          predicates:
            - Path=/say

Access /say pode corresponder à rota

Adicionar mais um caminho de nível não corresponderá à rota

Pode ser alterado para /dizer/**

server:
  port: 81
spring:
  cloud:
    gateway:
      routes:   # 配置路由，是一个集合
        - id: apptest          # 路由的ID, 没有固定规则但要求唯一，建议配合服务名
          uri: http://localhost:8080  # 匹配后提供服务的路由地址
          predicates:
            - Path=/say/**

Neste ponto, independentemente de acessar /say ou /say/one, a rota pode ser correspondida

7. Os parâmetros de consulta são usados ​​como regras de roteamento correspondentes Consulta

server:
  port: 81
spring:
  cloud:
    gateway:
      routes:   # 配置路由，是一个集合
        - id: apptest          # 路由的ID, 没有固定规则但要求唯一，建议配合服务名
          uri: http://localhost:8080  # 匹配后提供服务的路由地址
          predicates:
            - Query=skuID

Se apenas um parâmetro for escrito, significa que o parâmetro de consulta tem skuID e corresponde à rota atual

server:
  port: 81
spring:
  cloud:
    gateway:
      routes:   # 配置路由，是一个集合
        - id: apptest          # 路由的ID, 没有固定规则但要求唯一，建议配合服务名
          uri: http://localhost:8080  # 匹配后提供服务的路由地址
          predicates:
            - Query=skuID,11

Se dois parâmetros estiverem separados por vírgulas, significa que o parâmetro de consulta é skuID e o valor é 11 para corresponder à rota atual

Observe que ambas as condições devem ser atendidas e o método de solicitação é consistente com a maneira como a solicitação de serviço é mapeada

Se o skuID não for 11, ele não poderá corresponder à rota atual

8. Peso como regra de roteamento correspondente Peso

server:
  port: 81
spring:
  cloud:
    gateway:
      routes:   # 配置路由，是一个集合
        - id: apptest1         # 路由的ID, 没有固定规则但要求唯一，建议配合服务名
          uri: http://localhost:80  # 匹配后提供服务的路由地址
          predicates:
            - Path=/say/**
            - Weight=group,5
        - id: apptest2          # 路由的ID, 没有固定规则但要求唯一，建议配合服务名
          uri: http://localhost:8081  # 匹配后提供服务的路由地址
          predicates:
            - Path=/say/**
            - Weight=group,5

Há dois IDs de roteamento. Ambas as rotas estão em um grupo ponderado e o peso é 5. Cinquenta por cento das solicitações correspondentes a /say/** são enviadas para a porta 80 e o restante é enviado para a porta 8081.

Copie um serviço e imprima o número da porta do serviço atual

package gateway.controller;

import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author sz
 * @DATE 2022/3/20  20:15
 */

@Data
@RestController
public class HelloController {

    @Value("${server.port}")
    public String serverPort;

    @GetMapping("/say")
    public String say()
    {
        return "HelloWord   "+serverPort;
    }

    @GetMapping("/say/one")
    public String sayOne()
    {
        return "HelloWord one";
    }

}