[Spring Cloud] Explicación detallada de las reglas de aserción de enrutamiento en Gateway Gateway

confiar

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

tres componentes

1. enrutamiento

2. Afirmación

3. filtrar

enrutamiento

La composición básica de una puerta de enlace consiste en una ID, una URL de destino, una afirmación y un filtro. Si la afirmación es verdadera, la ruta coincidirá

Afirmación

Solo la solicitud afirmada con éxito coincidirá con la ruta

filtrar

Puede manejar solicitudes o respuestas.

El primer uso del pequeño Demo Gateway

Cree un nuevo módulo de servicio, proporcionando @GetMapping("/say") @GetMapping("/say/one") dos asignaciones de solicitud

@RestController
public class HelloController {

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

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

}

Crear un nuevo módulo de puerta de enlace

Establecer la siguiente configuración

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

iniciar dos servicios

Primero probamos si se puede acceder normalmente sin pasar por el servicio de acceso de la puerta de enlace.

Luego pruebe enrutar el servicio a través de la puerta de enlace

Hasta el momento, se completó una demostración del servicio de enrutamiento de puerta de enlace.

principio de funcionamiento

El siguiente diagrama proporciona una descripción general de alto nivel de cómo funciona Spring Gateway:

El cliente envía una solicitud a la puerta de enlace. Si la solicitud de asignación procesada por la puerta de enlace coincide con la ruta, la solicitud de asignación se entrega al administrador web de la puerta de enlace para que la procese. El administrador luego pasa la solicitud al servicio real para que la ejecute a través del correspondiente cadena de filtros, y finalmente regresa

El filtro se puede ejecutar antes de que se envíe la solicitud de proxy, o se puede ejecutar después de la solicitud de proxy.

Configurar aserciones de ruta y filtros

Hay dos formas de configurar la puerta de enlace

1. Puerta de enlace de configuración de accesos directos

Las configuraciones de acceso directo se identifican con el nombre del filtro seguido de un signo igual = y los valores de los parámetros separados por comas (,).

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

2. Expandir todos los parámetros

Los parámetros completamente expandidos se parecen más a la configuración estándar de yaml con pares de nombre/valor. Por lo general, habrá una clave de nombre y una clave de argumentos. La clave args es un mapa de pares clave-valor que configuran la aserción o el filtro.

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

Reglas de aserción de enrutamiento

1. Tiempo como regla de enrutamiento coincidente Después Antes Entre

1.1 La fábrica de predicados después de la ruta

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

Cuando el tiempo solicitado sea posterior al tiempo de afirmación, la ruta se emparejará

La hora que configuramos es 2022-03-20T21:02:47.789 antes de la hora actual 2022-03-20 21:07

Es decir, el tiempo de solicitud actual puede coincidir con la ruta después del tiempo 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]

La hora actual es 03-20 y la hora que afirmamos es 03-21, la solicitud no puede coincidir con la ruta actual

1.2 La fábrica de predicados antes de la ruta

Mirando el ejemplo después del tiempo anterior, debe comprender de inmediato lo que sucedió antes del tiempo.

Exactamente lo contrario de Después

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]

La hora de la solicitud es posterior a la hora establecida por la aserción, no se puede hacer coincidir la solicitud actual y no se pueden hacer coincidir todas las rutas

Establezca el tiempo de afirmación a la hora actual y vuelva a probarlo

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 Comparación entre el antes y el después

1.4 La fábrica de predicados entre rutas

Especifique dos horas, separadas por comas, si la hora de solicitud está entre estas dos horas, la ruta se emparejará

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]

En este momento, el tiempo de solicitud es

Se puede enrutar normalmente si el tiempo de solicitud no está dentro del rango de tiempo establecido

no coincide con la ruta

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. Cocine como una cookie para las reglas de enrutamiento coincidentes

2.1 La fábrica de predicados de rutas de cookies

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

Si el nombre en la cookie de solicitud es token y el valor es 123, coincidirá con la ruta actual

Si hay una diferencia entre el nombre y el valor, no se puede enrutar correctamente

Si el nombre y el valor son iguales, la ruta se puede enrutar con éxito

3. El encabezado de la solicitud se utiliza como la regla de enrutamiento coincidente Encabezado

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

Si hay un token de nombre en el encabezado de solicitud del objeto de solicitud y el valor es 123, coincidirá con la ruta actual

Use pruebas de cartero en su lugar

Como se muestra en el encabezado de la solicitud de prueba, si no hay información de encabezado de solicitud con un nombre de valor de token de 123, la ruta no puede coincidir.

Cuando hay información de encabezado de solicitud con nombre como token y valor de 123 en el encabezado de solicitud, se puede hacer coincidir la ruta actual

4.Host como la regla de enrutamiento coincidente Host

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

Modifique primero el archivo del host local

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

Visite http://qq.haha.com:81/say para hacer coincidir la ruta

Cambiar a cn no coincidirá con la ruta

5. El método de solicitud se utiliza como método de regla de enrutamiento coincidente

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

Tanto las solicitudes GET como PUT pueden coincidir con la ruta

Si cambiamos a solicitud PUT, no puede coincidir con la ruta

6. Ruta como la regla de enrutamiento coincidente Ruta

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

Acceder /decir puede coincidir con la ruta

Agregar una ruta de nivel más no coincidirá con la ruta

Se puede cambiar a /decir/**

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

En este punto, no importa si accede a /say o /say/one, la ruta puede coincidir

7. Los parámetros de consulta se utilizan como reglas de enrutamiento coincidentes Consulta

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

Si solo se escribe un parámetro, significa que el parámetro de consulta tiene skuID y coincide con la ruta actual

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

Si dos parámetros están separados por comas, significa que el parámetro de consulta es skuID y el valor es 11 para coincidir con la ruta actual

Tenga en cuenta que se deben cumplir ambas condiciones y que el método de solicitud es consistente con la forma en que se asigna la solicitud de servicio

Si el skuID no es 11, no puede coincidir con la ruta actual

8. Peso como regla de enrutamiento coincidente 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

Hay dos ID de enrutamiento. Ambas rutas están en un grupo ponderado y el peso es 5. El cincuenta por ciento de las solicitudes que coinciden con /say/** se envían al puerto 80 y el resto se envía al puerto 8081.

Copie un servicio e imprima el número de puerto del servicio actual

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";
    }

}