spring 请求等问题

1.post请求
/**
 * @desc: (gateway主要接收前端请求 ， 然后对请求的数据进行验证 ， 验证之后请求反向代理到服务器 。
 *当请求 method 为 GET 时 ， 可以顺利通过gateway 。 当请求 method 为 POST 时 ， gateway则会报如下错误 。
 *java.lang.IllegalStateException : Only one connection receive subscriber allowed.
 *实际上spring - cloud - gateway反向代理的原理是 ， 首先读取原请求的数据 ， 然后构造一个新的请求 ，
 *将原请求的数据封装到新的请求中 ， 然后再转发出去 。 然而我们在他封装之前读取了一次request body ，
 *而request body只能读取一次 。 因此就出现了上面的错误 。
 *解决方案 ： 读取request body的时候 ， 我们再封装一次request ， 转发出去)
 */
@Component
public class PostFilter extends AbstractNameValueGatewayFilterFactory implements Ordered {
    @Override
    public GatewayFilter apply(NameValueConfig nameValueConfig) {
        return (exchange, chain) -> {
            URI uri = exchange.getRequest().getURI();
            URI ex = UriComponentsBuilder.fromUri(uri).build(true).toUri();
            ServerHttpRequest request = exchange.getRequest().mutate().uri(ex).build();
            //封装我们的request
            if ("POST".equalsIgnoreCase(request.getMethodValue())) {//判断是否为POST请求
                Flux<DataBuffer> body = request.getBody();
                AtomicReference<String> bodyRef = new AtomicReference<>();//缓存读取的request body信息
                body.subscribe(dataBuffer -> {
                    CharBuffer charBuffer = StandardCharsets.UTF_8.decode(dataBuffer.asByteBuffer());
                    DataBufferUtils.release(dataBuffer);
                    bodyRef.set(charBuffer.toString());
                });//读取request body到缓存
                String bodyStr = bodyRef.get();//获取request body
                DataBuffer bodyDataBuffer = stringBuffer(bodyStr);
                Flux<DataBuffer> bodyFlux = Flux.just(bodyDataBuffer);
                request = new ServerHttpRequestDecorator(request) {
                    @Override
                    public Flux<DataBuffer> getBody() {
                        return bodyFlux;
                    }
                };
            }
            return chain.filter(exchange.mutate().request(request).build());
        };
    }

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

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

2.网关

@Component
@ConfigurationProperties("auth.skip.urls")
@Getter
@Setter
@Slf4j
public class AuthorizeFilter implements GlobalFilter, Ordered {
    /**
     * 令牌的名字
     */
    private static final String AUTHORIZE_TOKEN = "Authorization";
    private static final String APP_KEY = "joe-plat-dest";

    /**
     * Jwt解析的key
     */
    private static final String JWT_SECRET_KEY = "joemicroservice";

    /**
     * ACCESS_TOKEN key
     */
    private final static String ACCESS_TOKEN_REDIS_KEY = "USER:ACCESS_TOKEN:userInfo:";
    private final static String ACCESS_TOKEN_USERID_REDIS_KEY = "USER:ACCESS_TOKEN:userId:";

    /**
     * redis中access_token过期时间
     */
    private static final Long ACCESS_TOKEN_EXPIRE_TIME = 7 * 24 * 60 * 60 * 1000L;

    /**
     * 接口放行路径
     */
    private String[] skipAuthUrls;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 服务名
     */
    @Value("${spring.application.name}")
    private String applicationName;

    @Bean
    @ConditionalOnMissingBean
    public HttpMessageConverters messageConverters(ObjectProvider<HttpMessageConverter<?>> converters) {
        return new HttpMessageConverters(converters.orderedStream().collect(Collectors.toList()));
    }

    /**
     * 全局拦截
     *
     * @param exchange
     * @param chain
     * @return
     */
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        val traceId = UUID.randomUUID().toString().replace("-", "");
        MDC.put("traceId", traceId);
        MDC.put("requestId", UUID.randomUUID().toString().replace("-", ""));
        Object uriObj = exchange.getAttributes().get(GATEWAY_REQUEST_URL_ATTR);
        if (uriObj != null) {
            URI uri = (URI) uriObj;
            uri = this.upgradeConnection(uri, "http");
            exchange.getAttributes().put(GATEWAY_REQUEST_URL_ATTR, uri);
        }
        ServerHttpRequest request = exchange.getRequest();
        ServerHttpResponse response = exchange.getResponse();
        String url = exchange.getRequest().getURI().getPath();
        if (!(url.startsWith("berData") || url.endsWith("/push"))) {
            log.info("接受到的url路径为:" + url);
        }
        StringBuffer sb = new StringBuffer();
        String urlPrefix = sb.append("/").append(applicationName).toString();
        if (url.startsWith(urlPrefix)) {
            url = url.substring(applicationName.length() + 1);
            log.info("截取到的url路径为:" + url);
        }
        //跳过不需要验证的路径
        if (checkSkipAuthUrls(Arrays.asList(skipAuthUrls), url)) {
            return chain.filter(exchange.mutate().request(exchange.getRequest().mutate()
                    .header("X-TraceId", traceId).build()).build());
        }
        //获取用户令牌信息
        //头文件中
        log.info("-----------------------获取请求头中的令牌---------------------");
        final String token = request.getHeaders().getFirst(AUTHORIZE_TOKEN);
        final String appId = request.getHeaders().getFirst(APP_KEY);
        //如果没有令牌,则拦截
        if (StringUtils.isEmpty(token)) {
            log.info("-----------------------未获取到token令牌---------------------");
            //设置没有权限的状态码401
            return unAuth(exchange, "登录失效，请重新登录", null);
        }
        //如果有令牌,则检验令牌是否有效
        try {
            String accessTokenRedisKey = ACCESS_TOKEN_USERID_REDIS_KEY + token;
            Boolean isExistKey = stringRedisTemplate.hasKey(accessTokenRedisKey);
            String redisKey = ACCESS_TOKEN_REDIS_KEY + token;
            Boolean isExistFlag = stringRedisTemplate.hasKey(redisKey);
            if (BooleanUtils.isTrue(isExistKey) || BooleanUtils.isTrue(isExistFlag)) {
                //判断用户是否有效，如果无效，返回指定状态码，跳出登陆
                if (Boolean.FALSE.equals(stringRedisTemplate.hasKey(ACCESS_TOKEN_USERID_REDIS_KEY + token))) {
                    log.info("客户登陆状态无效，返回401");
                    return unAuth(exchange, "登录失效，请重新登录", null);
                }
                if (BooleanUtils.isFalse(JwtUtils.validateToken(token))) {
                    log.info("客户登陆状态无效，返回403");
                    return unAuth(exchange, "登录失效，请重新登录", 403);
                }
//                stringRedisTemplate.expire(accessTokenRedisKey, ACCESS_TOKEN_EXPIRE_TIME, TimeUnit.MILLISECONDS);
//                stringRedisTemplate.expire(redisKey, ACCESS_TOKEN_EXPIRE_TIME, TimeUnit.MILLISECONDS);
            } else {
                return unAuth(exchange, "登录失效，请重新登录", null);
            }
        } catch (Exception e) {
            log.error("客户登陆失败, e:", e);
            return unAuth(exchange, "登录失效，请重新登录", null);
        }
        //将令牌封装到头文件中
        Consumer<HttpHeaders> httpHeaders = httpHeader -> {
            httpHeader.set(AUTHORIZE_TOKEN, token);
            httpHeader.set(APP_KEY, appId);
        };
        ServerHttpRequest serverHttpRequest = exchange.getRequest().mutate().headers(httpHeaders).build();
        exchange.mutate().request(serverHttpRequest).build();
        //有效,放行
        return chain.filter(exchange.mutate().request(exchange.getRequest().mutate()
                .header("X-TraceId", traceId).build()).build());
    }

    private Boolean checkSkipAuthUrls(List<String> skipAuthUrls, String url) {
        if (skipAuthUrls.contains(url)) {
            return true;
        }
        List<String> superSkipUrlList = skipAuthUrls.stream().filter(x -> x.contains("**")).collect(Collectors.toList());
        if (!CollectionUtils.isEmpty(superSkipUrlList)) {
            for (String x : superSkipUrlList) {
                if (url.startsWith(x.substring(0, x.indexOf("**")))) {
                    return true;
                }
            }
        }
        return false;
    }

    private Mono<Void> unAuth(ServerWebExchange exchange, String msg, Integer errCode) {
        ServerHttpResponse response = exchange.getResponse();
        response.getHeaders().setContentType(MediaType.APPLICATION_JSON);
        response.setStatusCode(HttpStatus.OK);
        log.error("[鉴权异常处理]请求路径:{} ，状态码：{}", exchange.getRequest().getPath(),
                errCode == null ? HttpStatus.UNAUTHORIZED.value() : errCode);
        return response.writeWith(Mono.fromSupplier(() -> {
            DataBufferFactory bufferFactory = response.bufferFactory();
            return bufferFactory.wrap(JSON.toJSONBytes(ResponseResult.fail(
                    errCode == null ? HttpStatus.UNAUTHORIZED.value() : errCode, msg)));
        }));
    }

    @Override
    public int getOrder() {
        return 0;
    }

    private URI upgradeConnection(URI uri, String scheme) {
        UriComponentsBuilder uriComponentsBuilder = UriComponentsBuilder.fromUri(uri).scheme(scheme);
        if (uri.getRawQuery() != null) {
            uriComponentsBuilder.replaceQuery(uri.getRawQuery().replace("+", "%20"));
        }
        return uriComponentsBuilder.build(true).toUri();
    }

}