Uso simple de spring-cloud-gateway

Others 2021-03-21 10:20:23 views: null

A diferencia de zuul (basado en servlet), spring-cloud-gateway se basa en webflux

1. Uso de spring-cloud-gateway basado en zookeeper como centro de registro y descubrimiento de servicios

Utilice zookeeper como centro de registro de servicios, consulte este artículo mío. Spring-cloud utiliza zookeeper como centro de descubrimiento de registro de servicios (el proyecto creado en este artículo se utilizará a continuación)

Pasarela de nuevo proyecto

<groupId>com.wl.springcloud</groupId>
<artifactId>gateway</artifactId>
<version>1.0-SNAPSHOT</version>

pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.wl.springcloud</groupId>
  <artifactId>gateway</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>gateway</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <spring-cloud-config-version>2.0.3.RELEASE</spring-cloud-config-version>
    <spring-cloud-eureka-server>2.0.3.RELEASE</spring-cloud-eureka-server>
    <spring-boot-version>2.0.8.RELEASE</spring-boot-version>
    <spring-cloud-zuul-version>2.0.3.RELEASE</spring-cloud-zuul-version>

    <spring-cloud-eureka-client-version>2.0.3.RELEASE</spring-cloud-eureka-client-version>
    <MainClass>com.wl.springcloud.gateway.GatewayApplication</MainClass>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-webflux</artifactId>
      <version>${spring-boot-version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-autoconfigure</artifactId>
      <version>${spring-boot-version}</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-netflix-eureka-client -->
    <!--<dependency>-->
    <!--<groupId>org.springframework.cloud</groupId>-->
    <!--<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>-->
    <!--<version>${spring-cloud-eureka-client-version}</version>-->
    <!--</dependency>-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-actuator</artifactId>
      <version>${spring-boot-version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-config</artifactId>
      <version>${spring-cloud-config-version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-zookeeper-discovery</artifactId>
      <version>2.0.0.RELEASE</version>
      <exclusions>
        <exclusion>
          <groupId>org.apache.httpcomponents</groupId>
          <artifactId>httpclient</artifactId>
        </exclusion>
        <exclusion>
          <groupId>org.apache.zookeeper</groupId>
          <artifactId>zookeeper</artifactId>
        </exclusion>

      </exclusions>
    </dependency>

    <dependency>
      <groupId>org.apache.zookeeper</groupId>
      <artifactId>zookeeper</artifactId>
      <version>3.4.10</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-gateway -->
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-gateway</artifactId>
      <version>2.0.3.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>io.netty</groupId>
      <artifactId>netty-all</artifactId>
      <version>4.1.32.Final</version>
    </dependency>


    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <version>${spring-boot-version}</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <!-- Package as an executable jar -->
  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        <version>${spring-boot-version}</version>
        <configuration>
          <mainClass>${MainClass}</mainClass>
          <layout>JAR</layout>
        </configuration>
        <!-- repackage  生成两个 jar.original -->
        <executions>
          <execution>
            <goals>
              <goal>repackage</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
      <!-- 指定maven 打包java 版本 -->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.1</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
    </plugins>
    <!-- maven  编译打包resource 和 java 目录下所有文件  maven默认资源路径是resources -->
    <resources>
      <resource>
        <directory>src/main/resources</directory>
        <includes>
          <include>**/*.*</include>
          <include>*.*</include>
        </includes>
      </resource>
      <resource>
        <directory>src/main/java</directory>
        <includes>
          <include>**/*.*</include>
          <include>*.*</include>
        </includes>
      </resource>
    </resources>
  </build>

</project>

Tenga en cuenta que la dependencia netty-all se importa manualmente aquí. Si no existe tal dependencia, se informará Causado por: java.lang.ClassNotFoundException: io.netty.resolver.DefaultAddressResolverGroup

application.yml (modificó la identificación del servicio del proyecto zookeeper a zookeeper1, y el StripPrefix no es válido cuando la identificación del servicio es la misma que la ruta)

server:
  port: 8080
spring:
  cloud:
    zookeeper:
      connect-string: 192.168.245.130:2181
    gateway:
      discovery:
        locator:
          enabled: true
      routes:
      - id: zookeeper1
        uri: lb://zookeeper1
        predicates:
        - Path= /zookeeper/**
        filters:
        - StripPrefix=0
        #配置多个路由
#      - id: clientId
#        uri: lb://clientId
#        predicates:
#        - Path= /zookeeper/*
#        filters:
#        - StripPrefix=0

1.spring.cloud.gateway.discovery.locator.enable = true significa que el componente de descubrimiento de registro de servicio está habilitado (puede ser reenviado por el ID de servicio), el valor predeterminado es falso

2.id representa la identificación de la instancia de servicio registrada en zookeeper, es decir, spring-application-name

3. La configuración de la URL en uri y zuul es básicamente la misma, puede ser una ruta http o una identificación de servicio. A diferencia de zuul que usa la identificación del servicio directamente, spring-cloud-gateway debe escribirse como lb: // id de servicio

4. La ruta es la misma que la ruta en zuul. Esto significa que la ruta que comienza con / zookeeper se reenviará al servicio zookeeper1

5. StripPrefix representa el número de prefijos eliminados. Por ejemplo, si StripPrefix = 1, la ruta que solicita / name / bar / foo se reenvía al servicio de destino es / bar / foo. Si el valor es 2 por analogía, la ruta reenviada al servicio de destino es / foo. Tenga en cuenta que StripPrefix = 0 es equivalente a stripPrefix = false en zuul, y StripPrefix = 1 es equivalente a stripPrefix = true en zuul

6. Predicados (modo de enrutamiento), configuración de filtros (filtro). El filtro se explicará en detalle a continuación. Estas dos configuraciones son principalmente para las clases en org.springframework.cloud.gateway.filter.factory y org.springframework.cloud.gateway.handler.predicate. Path y StripPrefix son los prefijos de PathRoutePredicateFactory y StripPrefixGatewayFilterFactory respectivamente, y por supuesto hay más pridicado y filtrado

Comenzar la clase

package com.wl.springcloud.gateway;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration;

/**
 * Created by Administrator on 2019/4/22.
 */
@SpringBootApplication(exclude = {
        DataSourceAutoConfiguration.class,
        DataSourceTransactionManagerAutoConfiguration.class,
        HibernateJpaAutoConfiguration.class,             //不使用数据库
        GsonAutoConfiguration.class                      //spring-boot2.0.0以上版本需要引入高版本的gson依赖，如果不引用gson依赖需要加此属性
},scanBasePackages = "com.wl")
public class GatewayApplication {
    private static final Logger logger = LoggerFactory.getLogger(GatewayApplication.class);

    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class);
    }
}

Inicie la puerta de enlace y el guardián del zoológico (preste atención para modificar el proyecto spring.application.name = zookeeper1)

Ingrese al navegador http: // localhost: 8080 / zookeeper / zookeeper

 Filtro 2.spring-cloud-gateway

2.1 Filtro de puerta de enlace

      GatewayFilter es un filtro vinculado a la ruta y solo se ejecutará en la ruta vinculada

      Hay dos formas de personalizar GatewayFilter: 1. Implementando GatewayFilter 2. Personalizando GatewayFilterFactory y luego cargando en la cadena de filtros a través del método loadGatewayFilters en la clase RouteDefinitionRouteLocator

método uno

filtrar

package com.wl.springcloud.gateway.filter;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.core.Ordered;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.ipc.netty.ByteBufFlux;

import java.util.HashMap;
import java.util.Map;

/**
 * Created by Administrator on 2019/4/22.
 */
public class AuthGateWayFilter implements GatewayFilter,Ordered {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        String token = request.getQueryParams().getFirst("token");
        if(token != null && !token.equals("")){
            return chain.filter(exchange);
        }
        
        ServerHttpResponse response = exchange.getResponse();
        //设置http响应状态码
        response.setStatusCode(HttpStatus.BAD_REQUEST);
        //设置响应头信息Content-Type类型
        response.getHeaders().add("Content-Type","application/json");
        //设置返回json数据
        return response.writeAndFlushWith(Flux.just(ByteBufFlux.just(response.bufferFactory().wrap(getWrapData()))));
        //直接返回（没有返回数据）
//        return response.setComplete().then();
        //设置返回的数据（非json格式）
//        return response.writeWith(Flux.just(response.bufferFactory().wrap("".getBytes())));

    }

    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE;
    }

    private byte[] getWrapData() {
        Map<String,String> map = new HashMap<>();
        map.put("code","1");
        map.put("msg","token is empty or illegal");
        try {
            return new ObjectMapper().writeValueAsString(map).getBytes();
        } catch (JsonProcessingException e) {
            //
        }
        return "".getBytes();
    }
}

Este es un filtro de verificación de token personalizado. Si el token está vacío, devolverá {"msg": "token está vacío o es ilegal", "code": "1"} datos json

1. Si no necesita devolver datos, directamente response.setComplete ()

2. Si los datos devueltos no están en formato json, response.writeWith (Flux.just (response.bufferFactory (). Wrap (data))) o response.writeWith (Mono.just (response.bufferFactory (). Wrap (data )))

3. Si los datos devueltos tienen el formato application / json, response.writeAndFlushWith (Flux.just (ByteBufFlux.just (response.bufferFactory (). Wrap (getWrapData ())))) o

response.writeAndFlushWith (Mono.just (ByteBufMono.just (response.bufferFactory (). wrap (getWrapData ()))))

4. Consulte https://www.jianshu.com/p/611f3667c4d2 para conocer la diferencia entre Flux y Mono

5. Preste atención a la diferencia genérica entre los parámetros writeWith y writeAndFlushWith, por lo que debe usar el empaquetado Flux dos veces en writeAndFlushWith

Vincular el filtro a una ruta determinada

package com.wl.springcloud.gateway.config;

import com.wl.springcloud.gateway.filter.AuthGateWayFilter;
import org.springframework.cloud.gateway.route.Route;
import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.GatewayFilterSpec;
import org.springframework.cloud.gateway.route.builder.PredicateSpec;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.cloud.gateway.route.builder.UriSpec;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.function.Function;

/**
 * Created by Administrator on 2019/4/23.
 */
@Configuration
public class GatewayFilterConfig {

    @Bean
    public RouteLocator customerRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes().route(new Function<PredicateSpec, Route.AsyncBuilder>() {
            @Override
            public Route.AsyncBuilder apply(PredicateSpec predicateSpec) {
                return predicateSpec.path("/zookeeper/**").filters(new Function<GatewayFilterSpec, UriSpec>() {
                    @Override
                    public UriSpec apply(GatewayFilterSpec gatewayFilterSpec) {
                        return gatewayFilterSpec.filter(new AuthGateWayFilter()).stripPrefix(0);
                    }
                }).uri("lb://zookeeper1").order(0).id("zookeeper1");

            }
        }).build();
    }
}

Aquí el filtro está vinculado a la ruta / guardián del zoológico / **

Ingrese al navegador http: // localhost: 8080 / zookeeper / zookeeper

Ingrese al navegador http: // localhost: 8080 / zookeeper / zookeeper? Token = 123

 

Método 2: Utilice GatewayFilterFactory consulte StripPrefixGatewayFilterFactory

package com.wl.springcloud.gateway.filter.factory;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.ipc.netty.ByteBufFlux;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Created by Administrator on 2019/4/23.
 */
@Component
public class AuthGatewayFilterFactory extends AbstractGatewayFilterFactory<AuthGatewayFilterFactory.Config> {

    private final String KEY = "token";

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

    @Override
    public List<String> shortcutFieldOrder() {
        return Arrays.asList("enabled");
    }


    @Override
    public GatewayFilter apply(Config config) {
        return new GatewayFilter() {
            @Override
            public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
                if(!config.enabled){
                    return chain.filter(exchange);
                }
                ServerHttpRequest request = exchange.getRequest();
                String token = request.getQueryParams().getFirst(KEY);
                if(token != null && !token.equals("")){
                    return chain.filter(exchange);
                }

                ServerHttpResponse response = exchange.getResponse();
                //设置http响应状态码
                response.setStatusCode(HttpStatus.BAD_REQUEST);
                //设置响应头信息Content-Type类型
                response.getHeaders().add("Content-Type","application/json");
                //设置返回json数据
                return response.writeAndFlushWith(Flux.just(ByteBufFlux.just(response.bufferFactory().wrap(getWrapData()))));
                //直接返回（没有返回数据）
//        return response.setComplete().then();
                //设置返回的数据（非json格式）
//        return response.writeWith(Flux.just(response.bufferFactory().wrap("".getBytes())));
            }
            private byte[] getWrapData() {
                Map<String,String> map = new HashMap<>();
                map.put("code","1");
                map.put("msg","token is empty or illegal");
                try {
                    return new ObjectMapper().writeValueAsString(map).getBytes();
                } catch (JsonProcessingException e) {
                    //
                }
                return "".getBytes();
            }
        };

    }

    public static class Config {
        private boolean enabled;

        public boolean isEnabled() {
            return enabled;
        }

        public void setEnabled(boolean enabled) {
            this.enabled = enabled;
        }
    }
}

Cambio de configuracion

server:
  port: 8080
spring:
  cloud:
    zookeeper:
      connect-string: 192.168.245.130:2181
    gateway:
      discovery:
        locator:
          enabled: true
      routes:
      - id: zookeeper1
        uri: lb://zookeeper1
        predicates:
        - Path= /zookeeper/**
        filters:
        - StripPrefix=0
        - Auth=true
        #配置多个路由
#      - id: zookeeper1
#        uri: lb://zookeeper1
#        predicates:
#        - Path= /zookeeper/**
#        filters:
#        - StripPrefix=0

Configuración agregada-Auth = true

Tenga en cuenta que StripPrefix y Auth en la configuración de filtros son los prefijos de StripPrefixGatewayFilterFactory y AuthGatewayFilterFactory, que representan los nombres de los dos GatewayFilterFactory respectivamente. Los siguientes valores 0 y true pasarán

@Override
public List<String> shortcutFieldOrder() {
    return Arrays.asList("enabled");
}
public static final String PARTS_KEY = "parts";
@Override
public List<String> shortcutFieldOrder() {
   return Arrays.asList(PARTS_KEY);
}

 

Pasado a las propiedades de su configuración de clase interna (el nombre de la propiedad es el mismo que la cadena en Arrays.asList ()), es decir, el nombre de propiedad parts en StripPrefixGatewayFilterFactory.Config es el mismo que PARTS_KEY en Arrays.asList (PARTS_KEY) ; el nombre de la propiedad en AuthGatewayFilterFactory.Config El nombre del atributo habilitado es el mismo que Arrays.asList ("habilitado")

Tenga cuidado de no olvidar la anotación @Component en la clase AuthGatewayFilterFactory

Configuración: después de Auth = true, se cargará en la cadena de filtros a través del método loadGatewayFilters en la clase RouteDefinitionRouteLocator.

Más GatewayFilterFactory en el paquete org.springframework.cloud.gateway.filter.factory

 

La configuración de los mismos predicados corresponde a la interfaz RoutePredicateFactory. Path es el prefijo de PathRoutePredicateFactory y representa el nombre de PathRoutePredicateFactory. El siguiente valor / zookeeper / ** pasará

@Override
public List<String> shortcutFieldOrder() {
   return Arrays.asList(PATTERN_KEY, MATCH_OPTIONAL_TRAILING_SEPARATOR_KEY);
}

Pasado al atributo de patrón de su clase interna Config. Puede ver que hay tres nombres de atributos en su clase interna correspondientes a los mismos nombres de parámetros en Arrays.asList (PATTERN_KEY, MATCH_OPTIONAL_TRAILING_SEPARATOR_KEY)

Más RoutePredicateFactory en org.springframework.cloud.gateway.handler.predicate

¡Otros RoutePredicateFactory y GatewayFilterFactory y así sucesivamente!

 Comenta el filtro anterior y reinicia la aplicación.

Ingrese al navegador http: // localhost: 8080 / zookeeper / zookeeper

 2.2GlobalFilter

Como su nombre lo indica, un filtro global

Personalizar GlobalFilter es muy simple, solo implemente GlobalFilter

package com.wl.springcloud.gateway.filter;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.ipc.netty.ByteBufFlux;

import java.util.HashMap;
import java.util.Map;

/**
 * Created by Administrator on 2019/4/24.
 */
@Component
public class GlobalAuthFilter implements GlobalFilter,Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        String token = request.getQueryParams().getFirst("token");
        if(token != null && !token.equals("")){
            return chain.filter(exchange);
        }

        ServerHttpResponse response = exchange.getResponse();
        //设置http响应状态码
        response.setStatusCode(HttpStatus.BAD_REQUEST);
        //设置响应头信息Content-Type类型
        response.getHeaders().add("Content-Type","application/json");
        //设置返回json数据
        return response.writeAndFlushWith(Flux.just(ByteBufFlux.just(response.bufferFactory().wrap(getWrapData()))));
        //直接返回（没有返回数据）
//        return response.setComplete().then();
        //设置返回的数据（非json格式）
//        return response.writeWith(Flux.just(response.bufferFactory().wrap("".getBytes())));
    }

    private byte[] getWrapData() {
        Map<String,String> map = new HashMap<>();
        map.put("code","1");
        map.put("msg","token is empty or illegal");
        map.put("filter","global");
        try {
            return new ObjectMapper().writeValueAsString(map).getBytes();
        } catch (JsonProcessingException e) {
            //
        }
        return "".getBytes();
    }

    @Override
    public int getOrder() {
        return 0;
    }
}

Configurar para agregar una ruta de / abc / **

server:
  port: 8080
spring:
  cloud:
    zookeeper:
      connect-string: 192.168.245.130:2181
    gateway:
      discovery:
        locator:
          enabled: true
      routes:
      - id: zookeeper1
        uri: lb://zookeeper1
        predicates:
        - Path= /zookeeper/**
        filters:
        - StripPrefix=0
        - Auth=true
        #配置多个路由
      - id: zookeeper1
        uri: lb://zookeeper1
        predicates:
        - Path= /abc/**
        filters:
        - StripPrefix=1

Entrada del navegador

http: // localhost: 8080 / abc / zookeeper / zookeeper

 Agregar token

3. Fusión y degradación del servicio de configuración de HystrixGatewayFilterFactory (se puede ver por el nombre que es el filtro que une la ruta)

Agregar dependencia

    <!-- 熔断、降级 -->
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
      <version>2.0.3.RELEASE</version>
    </dependency>

Cambio de configuracion

server:
  port: 8080
spring:
  cloud:
    zookeeper:
      connect-string: 192.168.245.130:2181
    gateway:
      discovery:
        locator:
          enabled: true
      routes:
      - id: zookeeper1
        uri: lb://zookeeper1
        predicates:
        - Path= /zookeeper/**
        filters:
        - StripPrefix=0
        - Auth=true
        - name: Hystrix
          args:
            name: fallbackcmd
            fallbackUri: forward:/fallbackUri
        #配置多个路由
      - id: zookeeper1
        uri: lb://zookeeper1
        predicates:
        - Path= /abc/**
        filters:
        - StripPrefix=1
        - name: Hystrix
          args:
            name: fallbackcmd
            fallbackUri: forward:/fallbackUri

fallbackUri es la ruta a la que se accede después de que se degrada el servicio

package com.wl.springcloud.gateway.fallback;

import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.server.ServerWebExchange;

/**
 * Created by Administrator on 2019/5/24.
 */
@RestController
public class GatewayFallback  {

    @RequestMapping(value = "/fallbackUri",produces = {MediaType.APPLICATION_JSON_VALUE})
    public Object fallbackUri(ServerWebExchange exchange){

        return "服务降级";
    }


}

configuración del tiempo de espera de hystrix

hystrix:
  command:
    fallbackcmd:
      execution:
        isolation:
          strategy: SEMAPHORE
          thread:
            timeoutInMilliseconds: 2000
            shareSecurityContext: true

Después del comando, fallbackcmd está vinculado al nombre en los argumentos de Hystrix anteriores

 

Spring-cloud-gateway Más referencia de GatewayFilterFactory https://www.cnblogs.com/liukaifeng/p/10055863.html

Referencia de configuración de enrutamiento dinámico Spring Cloud GateWay https://blog.csdn.net/lazasha/article/details/84942823

Utilice eureka como un centro de descubrimiento de registro de servicios. Consulte mi otro artículo sobre el uso de spring-cloud-starter-netflix-zuul (anteriormente spring-cloud-starter-zuul)

Supongo que te gusta

Origin blog.csdn.net/name_is_wl/article/details/89460817
Recomendado
Clasificación
Diario
Más
2024-04-27(28)
2024-04-26(22)
2024-04-25(34)
2024-04-24(31)
2024-04-23(29)
2024-04-22(5)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)

Code World

© 2018 codetd.com