# Spring Cloud Gateway

@Slf4j
public class AuthFilter implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        log.info("前执行");
        // String token = exchange.getRequest().getQueryParams().getFirst("authToken");
        String token = exchange.getRequest().getHeaders().getFirst("authToken");
        if (token == null || token.isEmpty()) {
            ServerHttpResponse response = exchange.getResponse();
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            response.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
            // wrap内返回封装对象即可
            return response.writeWith(Mono.just(response.bufferFactory().wrap("无权限".getBytes())));
        }
       // 这样获取请求参数或则 RequestParamsFilter 这个
        Map<String, Object> data = exchange.getAttribute("cachedRequestBodyObject");
        return chain.filter(exchange).then(Mono.fromRunnable(() -> log.info("后执行")));
    }

    @Override
    public int getOrder() {
        return -100;
    }
}

/**
 * @Description: 配置类的方式加载filter
 * @author: LinQin
 * @date: 2020/01/11
 */
@Configuration
@Slf4j
public class AutoFilter {
    @Bean
    public GlobalFilter authFilter(){
        return new AuthFilter();
    }
}

 @Bean
public RouteLocator customerRouteLocator(RouteLocatorBuilder builder) {
    return builder.routes()
        .route(r -> r.path("/test/prefix/**")
               .filters(f -> f.stripPrefix(2)
                        .filter(new CustomFilter())
                        .addResponseHeader("X-Response-test", "test"))
               .uri("lb://SC-CONSUMER")
               .order(0)
               .id("test_consumer_service")
              )
        .build();
}

/**
 * 获取请求体  ModifyRequestBodyGatewayFilterFactory  预言类 ReadBodyPredicateFactory
 * @author 
 */
@Slf4j
public class RequestParamsFilter implements GlobalFilter, Ordered {

    private final List<HttpMessageReader<?>> messageReaders = HandlerStrategies.withDefaults().messageReaders();

    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // ServerRequest serverRequest = new DefaultServerRequest(exchange);
        ServerRequest serverRequest = new DefaultServerRequest(exchange, messageReaders);
        // mediaType
        MediaType mediaType = exchange.getRequest().getHeaders().getContentType();
        // read & modify body
        Mono<String> modifiedBody = serverRequest.bodyToMono(String.class)
                                                 .flatMap(body -> {
                                                     if (MediaType.APPLICATION_FORM_URLENCODED.isCompatibleWith(mediaType)) {

                                                         // origin body map
                                                         Map<String, Object> bodyMap = decodeBody(body);

                                                         // decrypt & auth

                                                         // new body map
                                                         Map<String, Object> newBodyMap = new HashMap<>();

                                                         return Mono.just(encodeBody(newBodyMap));
                                                     }

                                                     if (MediaType.APPLICATION_JSON
                                                             .isCompatibleWith(mediaType) || MediaType.APPLICATION_JSON_UTF8
                                                             .isCompatibleWith(mediaType)) {
                                                         // 获取请求体
                                                         log.info(body);
                                                     }
                                                     return Mono.empty();
                                                 });

        BodyInserter bodyInserter = BodyInserters.fromPublisher(modifiedBody, String.class);
        HttpHeaders headers = new HttpHeaders();
        headers.putAll(exchange.getRequest().getHeaders());

        // the new content type will be computed by bodyInserter
        // and then set in the request decorator
        headers.remove(HttpHeaders.CONTENT_LENGTH);

        CachedBodyOutputMessage outputMessage = new CachedBodyOutputMessage(exchange, headers);
        return bodyInserter.insert(outputMessage,  new BodyInserterContext())
                           .then(Mono.defer(() -> {
                               ServerHttpRequestDecorator decorator = new ServerHttpRequestDecorator(
                                       exchange.getRequest()) {

                                   public HttpHeaders getHeaders() {
                                       long contentLength = headers.getContentLength();
                                       HttpHeaders httpHeaders = new HttpHeaders();
                                       httpHeaders.putAll(super.getHeaders());
                                       if (contentLength > 0) {
                                           httpHeaders.setContentLength(contentLength);
                                       } else {
                                           httpHeaders.set(HttpHeaders.TRANSFER_ENCODING, "chunked");
                                       }
                                       return httpHeaders;
                                   }


                                   public Flux<DataBuffer> getBody() {
                                       return outputMessage.getBody();
                                   }
                               };
                               return chain.filter(exchange.mutate().request(decorator).build());
                           }));
    }


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

    private Map<String, Object> decodeBody(String body) {
        return Arrays.stream(body.split("&"))
                     .map(s -> s.split("="))
                     .collect(Collectors.toMap(arr -> arr[0], arr -> arr[1]));
    }

    private String encodeBody(Map<String, Object> map) {
        String collect = map.entrySet().stream().map(e -> e.getKey() + "=" + e.getValue())
                            .collect(Collectors.joining("&"));
        log.info(collect);
        return collect;
    }
}

@Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        //@formatter:off
        return builder.routes()
                      /*
                    route1 是get请求，get请求使用readBody会报错
                    route2 是post请求，Content-Type是application/x-www-form-urlencoded，readbody为String.class
                    route3 是post请求，Content-Type是application/json,readbody为Object.class
                     */
                      .route("route1",
                              r -> r
                                      .method(HttpMethod.GET)
                                      .and()
                                      .path(SERVICE)
                                      .filters(f -> {
                                          // f.filter(requestFilter);
                                          return f;
                                      })
                                      .uri(URI))
                      .route("route2",
                              r -> r
                                      .header(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_FORM_URLENCODED_VALUE)
                                      .and()
                                      .method(HttpMethod.POST)
                                      .and()
                                      .readBody(String.class, readBody -> {
                                          log.info("request method POST, Content-Type is application/x-www-form-urlencoded, body  is:{}", readBody);
                                          return true;
                                      })
                                      .and()
                                      .path(SERVICE)
                                      .filters(f -> {
                                          // f.filter(requestFilter);
                                          return f;
                                      })
                                      .uri(URI))
                      .route("route3",
                              r -> r
                                      .header(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
                                      .and()
                                      .method(HttpMethod.POST)
                                      .and()
                                      .readBody(Object.class, readBody -> {
                                          log.info("request method POST, Content-Type is application/json, body  is:{}", readBody);
                                          return true;
                                      })
                                      .and()
                                      .path(SERVICE)
                                      .filters(f -> {
                                          // f.filter(requestFilter);
                                          return f;
                                      })
                                      .uri(URI))
                      .build();
        //@formatter:on
    }

Map<String, Object> data = exchange.getAttribute("cachedRequestBodyObject");

public class WrapperResponseFilter implements GlobalFilter, Ordered {
    @Override
    public int getOrder() {
        // -1 is response write filter, must be called before that
        return -2;
    }

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpResponse originalResponse = exchange.getResponse();
        DataBufferFactory bufferFactory = originalResponse.bufferFactory();
        ServerHttpResponseDecorator decoratedResponse = new ServerHttpResponseDecorator(originalResponse) {
            @Override
            public Mono<Void> writeWith(Publisher<? extends DataBuffer> body) {
                if (body instanceof Flux) {
                    Flux<? extends DataBuffer> fluxBody = (Flux<? extends DataBuffer>) body;
                    return super.writeWith(fluxBody.map(dataBuffer -> {
                        // probably should reuse buffers
                        byte[] content = new byte[dataBuffer.readableByteCount()];
                        dataBuffer.read(content);
                        // 释放掉内存
                        DataBufferUtils.release(dataBuffer);
                        String rs = new String(content, Charset.forName("UTF-8"));
                        Response response = new Response();
                        response.setCode("1");
                        response.setMessage("请求成功");
                        response.setData(rs);

                        byte[] newRs = JSON.toJSONString(response).getBytes(Charset.forName("UTF-8"));
                        originalResponse.getHeaders().setContentLength(newRs.length);//如果不重新设置长度则收不到消息。
                        return bufferFactory.wrap(newRs);
                    }));
                }
                // if body is not a flux. never got there.
                return super.writeWith(body);
            }
        };
        // replace response with decorator
        return chain.filter(exchange.mutate().response(decoratedResponse).build());
    }
}