<!--特别注意：在 gateway 网关服务中不能引入 spring-boot-starter-web 的依赖，否则会报错-->
<!-- Spring cloud gateway 网关依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
 编写配置文件
server:
port: 9527
spring:
application:
  name: gateway
cloud:
  gateway: #网关路由配置
    routes:
      #将service5提供的服务隐藏起来，不暴露给客户端，只给客户端暴露API网关的地址9527
      - id: service5_routh   #路由id,没有固定规则，但唯一，建议与服务名对应
        uri: lb://service5   #动态路由匹配后提供服务的路由地址：lb://${服务名}
        predicates:
          #以下是断言条件，必选全部符合条件
          - Path=/api/v1/service5/**               #断言，路径匹配 注意：Path 中 P 为大写
eureka:
instance:
  instance-id: spring-cloud-gateway
  prefer-ip-address: true
  lease-expiration-duration-in-seconds: 15 #服务过期时间，如果超过这个时间没有检测到心跳，就将这个实例剔除
  lease-renewal-interval-in-seconds: 5 #client发送心跳给server端的频率
client:
  registry-fetch-interval-seconds: 5
  service-url:
    defaultZone: http://eureka1001.com:1001/eureka/,http://eureka2001.com:2001/eureka/
默认情况下，Spring Cloud Gateway 会根据服务注册中心（例如 Eureka Server）中维护的服务列表，以服务名（spring.application.name）作为路径创建动态路由进行转发，从而实现动态路由功能。
我们可以在配置文件中，将 Route 的 uri 地址修改为以下形式：lb://service-name 以上配置说明如下：
• lb（loadBalance）：uri 的协议，表示开启 Spring Cloud Gateway 的负载均衡功能。
• service-name：服务名，Spring Cloud Gateway 会根据它获取到具体的微服务地址
 启动类添加注解
@SpringBootApplication
@EnableEurekaClient
public class GatewayApplication {
public static void main(String[] args) {
SpringApplication.run(GatewayApplication.class, args);
}
}

@Component
public class GlobalFilter1 implements GlobalFilter, Ordered {
  @Override
  public int getOrder() {
      return Integer.MIN_VALUE;
  }
  @Override
  public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
      System.out.println("通过参数过滤器");
      //1.对于特定路由的放行逻辑
      URI uri = exchange.getRequest().getURI();
      if ("/api/v1/service8".equals(uri.getPath())) {
          return chain.filter(exchange);
      }
      //2.获取URL参数
      MultiValueMap<String, String> queryParams = exchange.getRequest().getQueryParams();
      //3.其他路由进行权限校验
      if (null == queryParams.get("p1")) {
          exchange.getResponse().setStatusCode(HttpStatus.BAD_REQUEST);
          return exchange.getResponse().writeWith(Flux.just(exchange.getResponse().bufferFactory()
                  .wrap("请填写请求参数p1".getBytes())));
      } else {
          return chain.filter(exchange);
      }
  }
}

@Component
public class GatewayFilter2 implements GatewayFilter, Ordered {
  @Override
  public int getOrder() {
      return Integer.MIN_VALUE + 1;
  }
  @Override
  public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
      System.out.println("通过特定过滤器2");
      //1.获取POST请求体参数
      Mono<Void> postBody = DataBufferUtils.join(exchange.getRequest().getBody()).flatMap(dataBuffer -> {
          //2.获取请求体参数
          byte[] bytes = new byte[dataBuffer.readableByteCount()];
          dataBuffer.read(bytes);
          String bodyString = new String(bytes, StandardCharsets.UTF_8);
          //TODO 3.在这里可以对请求体参数为所欲为了
          System.out.println("bodyString:" + bodyString);
          //4.释放内存
          DataBufferUtils.release(dataBuffer);
          //5.以下操作为了将请求体再次封装写回到request里
          exchange.getAttributes().put("POST_BODY", bodyString);
          Flux<DataBuffer> cachedFlux = Flux.defer(() -> {
              DataBuffer buffer = exchange.getResponse().bufferFactory().wrap(bytes);
              return Mono.just(buffer);
          });
          //6.将请求体再次封装写回到request里，传到下一级，否则，由于请求体已被消费，后续的服务将取不到值
          ServerHttpRequest mutatedRequest = new ServerHttpRequestDecorator(exchange.getRequest()) {
              @Override
              public Flux<DataBuffer> getBody() {
                  return cachedFlux;
              }
          };
          //7.封装request，传给下一级
          return chain.filter(exchange.mutate().request(mutatedRequest).build());
      });
      //8.返回
      return postBody;
  }
}

@Configuration
public class GatewayConfig {
  @Bean
  public RouteLocator appRouteLocator(RouteLocatorBuilder builder) {
      return builder.routes().route(r -> r.path("/api/v1/service5/**")
              .filters(f -> f.filter(new GatewayFilter2()))
              .uri("lb://service5")
              .id("service5_routh"))
              .build();
  }
}

@Component
public class AfterGlobalFilter implements GlobalFilter, Ordered {
  @Override
  public int getOrder() {
      return NettyWriteResponseFilter.WRITE_RESPONSE_FILTER_ORDER;
  }
  @Override
  public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
      //1.获取字节工厂
      DataBufferFactory bufferFactory = exchange.getResponse().bufferFactory();
      //3.获取响应体
      final ServerHttpResponseDecorator serverHttpResponseDecorator = new ServerHttpResponseDecorator(exchange.getResponse()) {
          @Override
          public Mono<Void> writeWith(Publisher<? extends DataBuffer> body) {
              if (body instanceof Flux) {
                  //4.返回响应
                  Flux<? extends DataBuffer> fluxBody = (Flux<? extends DataBuffer>) body;
                  return super.writeWith(fluxBody.map(dataBuffer -> {
                      //5.读取字节
                      byte[] content = new byte[dataBuffer.readableByteCount()];
                      dataBuffer.read(content);
                      //6.释放掉内存
                      DataBufferUtils.release(dataBuffer);
                      //7.这段代码我们可以自由发挥
                      String responseStr = new String(content, StandardCharsets.UTF_8);
                      super.setStatusCode(HttpStatus.valueOf(Integer.parseInt(responseStr)));
                      //8.返回
                      return bufferFactory.wrap(content);
                  }));
              }
              return super.writeWith(body);
          }
      };
      //2.返回
      System.out.println("通过响应过滤器");
      return chain.filter(exchange.mutate().response(serverHttpResponseDecorator).build());
  }
}