@Bean
  public RouteLocator vmRouteLocator(RouteLocatorBuilder builder) {
    return builder.routes()
        .route(r -> r.method(HttpMethod.POST).and()
            .readBody(Object.class, requestBody -> {
              //相當于緩存了body信息，在filter 中可以這么獲取 exchange.getAttribute("cachedRequestBodyObject");
              log.info("requestBody is {}", requestBody);
              return true;
            })
            .and().path("/terminal/**")
            .filters(f -> f.filter(terminalSignFilter()))
            .uri("lb://TERMINAL-SERVICE")
            .order(0)
            .id("terminal-service")
        )
        .route(r -> r.method(HttpMethod.GET).and()
            .path("/terminal/**")
            .filters(f -> f.filter(terminalSignFilter()))
            .uri("lb://TERMINAL-SERVICE")
            .order(1)
            .id("terminal-service")
        )
        .build();
  }

import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DataBufferUtils;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpRequestDecorator;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.server.HandlerStrategies;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

@Component
@Slf4j
public class CacheBodyParamsFilter implements GlobalFilter, Ordered {

  @Override
  public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    if (ParamsUtil.logBody(exchange)) {
      return DataBufferUtils.join(exchange.getRequest().getBody())
          .flatMap(dataBuffer -> {
            byte[] bytes = new byte[dataBuffer.readableByteCount()];
            dataBuffer.read(bytes);
            DataBufferUtils.release(dataBuffer);
            Flux<DataBuffer> cachedFlux = Flux.defer(() -> {
              DataBuffer buffer = exchange.getResponse().bufferFactory().wrap(bytes);
              DataBufferUtils.retain(buffer);
              return Mono.just(buffer);
            });
            ServerHttpRequest mutatedRequest = new ServerHttpRequestDecorator(exchange.getRequest()) {
              @Override
              public Flux<DataBuffer> getBody() {
                return cachedFlux;
              }
            };
            ServerWebExchange mutatedExchange = exchange.mutate().request(mutatedRequest).build();
            return ServerRequest.create(mutatedExchange, HandlerStrategies.withDefaults().messageReaders())
                .bodyToMono(String.class)
                .doOnNext(objectValue -> {
                  //在此處,將body中的params值獲取到,并存放在本次請求的attributes屬性中,這樣就可以在本次請求中的所有地方進行使用了              

                  mutatedExchange.getAttributes().put(CommonConstant.PARAMS, ParamsUtil.buildParams(mutatedRequest,objectValue));
                                  }).then(chain.filter(mutatedExchange));
          });
    }
    return chain.filter(exchange);
  }

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