SpringCloud gateway request的body验证或修改方式

org.springframework.cloud.gateway.filter.headers.RemoveHopByHopHeadersFilter

spring:

   cloud:

       filter:

         remove-hop-by-hop:

           headers:

             - connection

             - keep-alive

             - te

             - trailer

             - proxy-authorization

             - proxy-authenticate

             - x-application-context

             - upgrade

import org.springframework.cloud.gateway.filter.GatewayFilter;

import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;

import org.springframework.cloud.gateway.support.BodyInserterContext;

import org.springframework.core.io.buffer.DataBuffer;

import org.springframework.http.HttpHeaders;

import org.springframework.http.codec.HttpMessageReader;

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.BodyInserter;

import org.springframework.web.reactive.function.BodyInserters;

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;

import java.util.List;

import java.util.concurrent.atomic.AtomicReference;

import java.util.function.BiFunction;

/**

  * @author chenws

  * @date 2019/12/12 09:33:53

  */

@Component

public class CModifyRequestBodyGatewayFilterFactory extends AbstractGatewayFilterFactory {

     private final List<HttpMessageReader<?>> messageReaders;

     public CModifyRequestBodyGatewayFilterFactory() {

         this .messageReaders = HandlerStrategies.withDefaults().messageReaders();

     }

     @Override

     @SuppressWarnings ( "unchecked" )

     public GatewayFilter apply(Object config) {

         return (exchange, chain) -> {

             ServerRequest serverRequest = ServerRequest.create(exchange,

                     this .messageReaders);

             Mono<String> modifiedBody = serverRequest.bodyToMono(String. class )

                     .flatMap(originalBody -> modifyBody()

                             .apply(exchange,Mono.just(originalBody)));

             BodyInserter bodyInserter = BodyInserters.fromPublisher(modifiedBody,

                     String. class );

             HttpHeaders headers = new HttpHeaders();

             headers.putAll(exchange.getRequest().getHeaders());

             headers.remove(HttpHeaders.CONTENT_LENGTH);

             CachedBodyOutputMessage outputMessage = new CachedBodyOutputMessage(exchange,

                     headers);

             return bodyInserter.insert(outputMessage, new BodyInserterContext())

                     .then(Mono.defer(() -> {

                         ServerHttpRequest decorator = decorate(exchange, headers,

                                 outputMessage);

                         return chain.filter(exchange.mutate().request(decorator).build());

                     }));

         };

     }

     /**

      * 修改body

      * @return apply 返回Mono<String>，数据是修改后的body

      */

     private BiFunction<ServerWebExchange,Mono<String>,Mono<String>> modifyBody(){

         return (exchange,json)-> {

             AtomicReference<String> result = new AtomicReference<>();

             json.subscribe(

                     value -> {

                         //value 即为请求body，在此处修改

                         result.set(value);

                         System.out.println(result.get());

                     },

                     Throwable::printStackTrace

             );

             return Mono.just(result.get());

         };

     }

     private ServerHttpRequestDecorator decorate(ServerWebExchange exchange, HttpHeaders headers,

                                         CachedBodyOutputMessage outputMessage) {

         return new ServerHttpRequestDecorator(exchange.getRequest()) {

             @Override

             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;

             }

             @Override

             public Flux<DataBuffer> getBody() {

                 return outputMessage.getBody();

             }

         };

     }

}

@Component

public class RequestFilter implements GlobalFilter, Ordered {

     @Autowired

     private RedisClientTemplate redisClientTemplate;

     @Override

     public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {

         DefaultServerRequest req = new DefaultServerRequest( exchange );

         String token = UUID.randomUUID().toString();

         //向headers中放入token信息

         ServerHttpRequest serverHttpRequest =exchange.getRequest().mutate().header( "token" , token)

                 .build();

         //将现在的request变成change对象

         ServerWebExchange build = exchange.mutate().request( serverHttpRequest ).build();

         return req.bodyToMono( String. class ).map( str -> {

             redisClientTemplate.setObjex( "microservice:gateway:" .concat( token ), 180 , str );

             MySlf4j.textInfo( "请求参数:{0}" , str );

             return str;

         } ).then( chain.filter( build ) );

     }

     @Override

     public int getOrder() {

         return 0 ;

     }

}

@Override

public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {

     /** 验证商户是否有权限访问 */

     ServerHttpRequest serverHttpRequest = exchange.getRequest();

     String token = serverHttpRequest.getHeaders().get( "token" ).get( 0 );

        String bodyStr = (String) redisClientTemplate.getObj( "microservice:gateway:" .concat(token));

     BaseReqVo baseReqVo = JsonUtil.fromJson( bodyStr, BaseReqVo. class );

     try {

         // 商户认证

         BaseRespVo<?> baseRespVo = merchantAuthService.checkMerchantAuth( baseReqVo );

         if (MicroserviceConstantParamUtils.RESULT_CODE_SUCC.equals( baseRespVo.getCode() )) {

                // 若验证成功，将信息重新写入避免request信息消费后后续无法从request获取信息的问题

                URI uri = serverHttpRequest.getURI();

                ServerHttpRequest request = serverHttpRequest.mutate().uri(uri).build();

                DataBuffer bodyDataBuffer = stringBuffer(bodyStr);

                Flux<DataBuffer> bodyFlux = Flux.just(bodyDataBuffer);

                request = new ServerHttpRequestDecorator(request) {

                    @Override

                    public Flux<DataBuffer> getBody() {

                        return bodyFlux;

                    }

                };

             // 封装request，传给下一级

                return chain.filter(exchange.mutate().request(request).build());

         } else {

             // 若验证不成功，返回提示信息

             return gatewayResponse( baseRespVo.getCode(), baseRespVo.getMessage(), exchange );

         }

     } catch (MicroserviceServiceException ex) {

         // 若验证不成功，返回提示信息

         MySlf4j.textError( "商户访问权限验证异常，异常代码:{0},异常信息:{1}, 异常{2}" , ex.getCode(), ex.getMessage(), ex );

         return gatewayResponse( ex.getCode(), ex.getMessage(), exchange );

     } catch (Exception ex) {

         MySlf4j.textError( "商户访问权限验证服务异常:{0}" , LogUtil.ExceptionToString( ex ) );

         return gatewayResponse( MicroserviceException.ERR_100000, "系统异常" , exchange );

     } finally {

         redisClientTemplate.del( "microservice:gateway:" .concat( token ) );

     }

}

/**数据流处理方法*/

private DataBuffer stringBuffer(String value) {

     byte [] bytes = value.getBytes( StandardCharsets.UTF_8 );

     NettyDataBufferFactory nettyDataBufferFactory = new NettyDataBufferFactory( ByteBufAllocator.DEFAULT );

     DataBuffer buffer = nettyDataBufferFactory.allocateBuffer( bytes.length );

     buffer.write( bytes );

     return buffer;

}

/**网关请求响应*/

private Mono<Void> gatewayResponse(String code, String message, ServerWebExchange exchange) {

     // 若验证不成功，返回提示信息

     ServerHttpResponse response = exchange.getResponse();

     BaseRespVo<T> baseRespVo = ResponseUtils.responseMsg( code, message, null );

     byte [] bits = JsonUtil.toJson( baseRespVo ).getBytes( StandardCharsets.UTF_8 );

     DataBuffer buffer = response.bufferFactory().wrap( bits );

     response.setStatusCode( HttpStatus.UNAUTHORIZED );

     // 指定编码，否则在浏览器中会中文乱码

     response.getHeaders().add( "Content-Type" , "text/plain;charset=UTF-8" );

     return response.writeWith( Mono.just( buffer ) );

}

@Override

public int getOrder() {

     return 1 ;

}

@Override

public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {

  ServerHttpRequest serverHttpRequest = exchange.getRequest();

  String method = serverHttpRequest.getMethodValue();

  if (! "POST" .equals(method)) {

   ServerHttpResponse response = exchange.getResponse();

   BaseRespVo<T> baseRespVo = ResponseUtils.responseMsg(MicroserviceException.ERR_100008, "非法请求" , null );

   byte [] bits = JsonUtil.toJson(baseRespVo).getBytes(StandardCharsets.UTF_8);

   DataBuffer buffer = response.bufferFactory().wrap(bits);

   response.setStatusCode(HttpStatus.UNAUTHORIZED);

   //指定编码，否则在浏览器中会中文乱码

   response.getHeaders().add( "Content-Type" , "text/plain;charset=UTF-8" );

   return response.writeWith(Mono.just(buffer));

  }

  return chain.filter(exchange);

  }

/**授权访问用户名*/

@Value ( "${spring.security.user.name}" )

private String securityUserName;

/**授权访问密码*/

@Value ( "${spring.security.user.password}" )

private String securityUserPassword;

@Override

public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {

  /**oauth授权*/

  String auth = securityUserName.concat( ":" ).concat(securityUserPassword);

  String encodedAuth = new sun.misc.BASE64Encoder().encode(auth.getBytes(Charset.forName( "US-ASCII" )));

  String authHeader = "Basic " + encodedAuth;

  //向headers中放授权信息

  ServerHttpRequest serverHttpRequest = exchange.getRequest().mutate().header( "Authorization" , authHeader)

    .build();

  //将现在的request变成change对象

  ServerWebExchange build = exchange.mutate().request(serverHttpRequest).build();

  return chain.filter(build);

}