4.SpringCloud Gateway获取post请求体(request body)不完整解决方案

墨蓝 2022-01-27 23:07 515阅读 0赞

Spring Cloud Gateway做为网关服务，通过gateway进行请求转发，在请求到达后端服务前我们可以通过filter进行一些预处理如：请求的合法性，商户验证等。  
如我们在请求体中添加商户ID（merId）和商户KEY（merkey），通过此来验证请求的合法性。但是如果我们请求内容太长如转为base64的文件存储请求。此时我们在filter获取body内容就会被截取(太长的 Body 会被截断)。目前网上也没有好的解决方式。  
springboot及Cloud版本如下；

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>版本</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>springboot</td> 
   <td>2.0.8.RELEASE</td> 
  </tr> 
  <tr> 
   <td>springcloud</td> 
   <td>Finchley.SR2</td> 
  </tr> 
 </tbody> 
</table>

这里提供一种解决方式，相关代码如下：  
**1.Requestfilter**  
我们采用Gateway网关的Gobalfilter，建立我们的第一个过滤器过滤所有请求。  
1).通过Spring 5 的 [WebFlux][]我们使用bodyToMono方法把响应内容转换成类 String的对象，最终得到的结果是 Mono对象  
2).bodyToMono方法我们可以拿到完整的body内容，并返回String。  
3).我们生成唯一的token（通过UUID），并将token放入请求的header中。  
4).将获取到的完整body内容，存放到redis中。

@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;
    	}
    }

**2.MerchantAuthFilter**  
建立商户认证过滤器，相关代码如下：  
1).获取存储在headers中的token。  
2).通过token获取我们存储在redis中的body内容(WebFlux 中不能使用阻塞的操作，目前想到的是通过这种方式实现)。  
3).获取到完整的body内容后我们就可以进行相应的商户认证操作。  
4).认证通过，将信息重新写入，不通过则返回异常信息。

@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;
    }

另外我们还可以通过GlobalFilter实现请求过滤，OAUTH授权，相关代码如下：  
请求方式验证过滤器（RequestAuthFilter）：

@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);
    	}

OAUTH授权过滤器（OAuthSignatureFilter）：

/**授权访问用户名*/
    @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);
    }

--------------------

欢迎关注公众号： **编码是个技术活**

![在这里插入图片描述][20210219162337578.jpg_pic_center]

[WebFlux]: https://www.ibm.com/developerworks/cn/java/spring5-webflux-reactive/index.html
[20210219162337578.jpg_pic_center]: /images/20220128/719abb5ee4ae4227bb7e505dba38e34a.png