springCloud gateway修改下游服务返回的HTTP状态

最新推荐文章于 2024-08-03 17:06:41 发布

真-酸辣土豆丝

最新推荐文章于 2024-08-03 17:06:41 发布

阅读量2.1k

点赞数

分类专栏： java 原创文章标签： spring cloud gateway http

本文链接：https://blog.csdn.net/qq_18630487/article/details/122499016

版权

java 同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

原创

6 篇文章 0 订阅

订阅专栏

有些场景需要对下游服务返回的响应进行包装，格式化返回。不把具体异常暴露给上游服务。此时可以通过创建修改返回内容和返回状态的Filter来实现。

如下

修改状态：

package com.jieshun.open.fiter;


import com.jieshun.open.bean.ApiContext;
import com.jieshun.open.bean.SopConstants;
import com.jieshun.open.param.ApiParam;
import com.jieshun.open.result.ResultExecutor;
import com.jieshun.open.util.ServerWebExchangeUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.reactivestreams.Publisher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.cloud.gateway.filter.NettyWriteResponseFilter;
import org.springframework.cloud.gateway.filter.factory.rewrite.CachedBodyOutputMessage;
import org.springframework.cloud.gateway.filter.factory.rewrite.MessageBodyEncoder;
import org.springframework.cloud.gateway.support.BodyInserterContext;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DataBufferFactory;
import org.springframework.core.io.buffer.DataBufferUtils;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseCookie;
import org.springframework.http.client.reactive.ClientHttpResponse;
import org.springframework.http.codec.ServerCodecConfigurer;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.http.server.reactive.ServerHttpResponseDecorator;
import org.springframework.lang.Nullable;
import org.springframework.util.MultiValueMap;
import org.springframework.web.reactive.function.BodyInserter;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.client.ClientResponse;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.core.scheduler.Schedulers;

import javax.annotation.PostConstruct;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

import static java.util.function.Function.identity;
import static org.springframework.cloud.gateway.support.ServerWebExchangeUtils.ORIGINAL_RESPONSE_CONTENT_TYPE_ATTR;

/**
 * 修改返回结果
 *
 * @author yyk
 */
@Slf4j
public class ChangeHttpStatusFilter implements GlobalFilter, Ordered {

    @Autowired
    private ServerCodecConfigurer codecConfigurer;
    @Autowired
    private Set<MessageBodyEncoder> bodyEncoders;

    private Map<String, MessageBodyEncoder> messageBodyEncoders;

    @Override
    @SuppressWarnings("unchecked")
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        HttpStatus statusCode = exchange.getResponse().getStatusCode();
        Object routeDefinition = exchange.getAttribute(SopConstants.CACHE_ROUTE_INFO);
        ApiParam apiParam = ServerWebExchangeUtil.getApiParam(exchange);
        log.info("请求ID：{},请求信息---{}", apiParam.fetchRequestId(),routeDefinition);
        //修改返回Response
        ServerHttpResponseDecorator responseDecorator = new ServerHttpResponseDecorator(exchange.getResponse()) {
            @Override
            public boolean setStatusCode(@Nullable HttpStatus status){
                log.info("请求原HTTP状态:{}", status.toString());

                return this.getDelegate().setStatusCode(HttpStatus.OK);
            }
            @Override
            public Mono<Void> writeAndFlushWith(Publisher<? extends Publisher<? extends DataBuffer>> body) {
                return writeWith(Flux.from(body)
                        .flatMapSequential(p -> p));
            }
        };
        
        ServerWebExchange webExchange = exchange.mutate().response(responseDecorator).build();
        return chain.filter(webExchange);
    }
    

    @Override
    public int getOrder() {
        return NettyWriteResponseFilter.WRITE_RESPONSE_FILTER_ORDER - 3;
    }

    public class ResponseAdapter implements ClientHttpResponse {

        private final Flux<DataBuffer> flux;
        private final HttpHeaders headers;

        public ResponseAdapter(Publisher<? extends DataBuffer> body, HttpHeaders headers) {
            this.headers = headers;
            if (body instanceof Flux) {
                flux = (Flux) body;
            } else {
                flux = ((Mono) body).flux();
            }
        }

        @Override
        public Flux<DataBuffer> getBody() {
            return flux;
        }

        @Override
        public HttpHeaders getHeaders() {
            return headers;
        }

        @Override
        public HttpStatus getStatusCode() {
            return null;
        }

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

        @Override
        public MultiValueMap<String, ResponseCookie> getCookies() {
            return null;
        }
    }


}

关键是重写ServerHttpResponseDecorator的setStatusCode方法

需要注意filter的顺序，应该放在靠后的位置，避免其他异常处理的filter因为改了httpstatus而不生效。

修改内容filter：

package com.jieshun.open.fiter;


import com.jieshun.open.bean.ApiContext;
import com.jieshun.open.bean.SopConstants;
import com.jieshun.open.param.ApiParam;
import com.jieshun.open.result.ResultExecutor;
import com.jieshun.open.util.ServerWebExchangeUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.reactivestreams.Publisher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.cloud.gateway.filter.NettyWriteResponseFilter;
import org.springframework.cloud.gateway.filter.factory.rewrite.CachedBodyOutputMessage;
import org.springframework.cloud.gateway.filter.factory.rewrite.MessageBodyEncoder;
import org.springframework.cloud.gateway.support.BodyInserterContext;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DataBufferFactory;
import org.springframework.core.io.buffer.DataBufferUtils;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseCookie;
import org.springframework.http.client.reactive.ClientHttpResponse;
import org.springframework.http.codec.ServerCodecConfigurer;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.http.server.reactive.ServerHttpResponseDecorator;
import org.springframework.lang.Nullable;
import org.springframework.util.MultiValueMap;
import org.springframework.web.reactive.function.BodyInserter;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.client.ClientResponse;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.core.scheduler.Schedulers;

import javax.annotation.PostConstruct;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

import static java.util.function.Function.identity;
import static org.springframework.cloud.gateway.support.ServerWebExchangeUtils.ORIGINAL_RESPONSE_CONTENT_TYPE_ATTR;

/**
 * 修改返回结果
 *
 * @author yyk
 */
@Slf4j
public class GatewayModifyResponseGatewayFilter implements GlobalFilter, Ordered {

    @Autowired
    private ServerCodecConfigurer codecConfigurer;
    @Autowired
    private Set<MessageBodyEncoder> bodyEncoders;

    private Map<String, MessageBodyEncoder> messageBodyEncoders;

    @Override
    @SuppressWarnings("unchecked")
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        HttpStatus statusCode = exchange.getResponse().getStatusCode();
        Object routeDefinition = exchange.getAttribute(SopConstants.CACHE_ROUTE_INFO);
        ApiParam apiParam = ServerWebExchangeUtil.getApiParam(exchange);
        log.info("请求ID：{},请求信息---{}", apiParam.fetchRequestId(),routeDefinition);
        //修改返回Response
        ServerHttpResponseDecorator responseDecorator = new ServerHttpResponseDecorator(exchange.getResponse()) {

            @Override
            public Mono<Void> writeWith(Publisher<? extends DataBuffer> body) {
                String originalResponseContentType = exchange.getAttribute(ORIGINAL_RESPONSE_CONTENT_TYPE_ATTR);

                log.info("请求返回类型"+originalResponseContentType);
                // 如果是下载文件，直接放行，不合并结果
                if (StringUtils.containsIgnoreCase(originalResponseContentType, MediaType.APPLICATION_OCTET_STREAM_VALUE)) {
                    return chain.filter(exchange);
                }
                // rest请求，直接放行
                if (exchange.getAttribute(SopConstants.RESTFUL_REQUEST) != null) {
                    return chain.filter(exchange);
                }
                Class inClass = String.class;
                Class outClass = String.class;

                HttpHeaders httpHeaders = new HttpHeaders();
                // explicitly add it in this way instead of
                // 'httpHeaders.setContentType(originalResponseContentType)'
                // this will prevent exception in case of using non-standard media
                // types like "Content-Type: image"
                httpHeaders.add(HttpHeaders.CONTENT_TYPE, originalResponseContentType);
                ClientResponse clientResponse = prepareClientResponse(exchange, body, httpHeaders);
                //TODO: flux or mono
                Mono modifiedBody = clientResponse.bodyToMono(inClass)
                        // 修复微服务接口返回void网关不会返回code和msg问题
                        .switchIfEmpty(Mono.just(""))
                        //暂不合并结果
                        .flatMap(originalBody -> {
                            // 合并微服务传递过来的结果，变成最终结果
                            ResultExecutor resultExecutor = ApiContext.getApiConfig().getGatewayResultExecutor();
                            String ret = resultExecutor.mergeResult(exchange, String.valueOf(originalBody));
                            return Mono.just(ret);
                        });

                BodyInserter bodyInserter = BodyInserters.fromPublisher(modifiedBody,
                        outClass);
                CachedBodyOutputMessage outputMessage = new CachedBodyOutputMessage(exchange,
                        exchange.getResponse().getHeaders());
                return bodyInserter.insert(outputMessage, new BodyInserterContext())
                        .then(Mono.defer(() -> {
                            Mono<DataBuffer> messageBody = writeBody(getDelegate(),
                                    outputMessage, outClass);
                            HttpHeaders headers = getDelegate().getHeaders();
                            if (!headers.containsKey(HttpHeaders.TRANSFER_ENCODING)
                                    || headers.containsKey(HttpHeaders.CONTENT_LENGTH)) {
                                messageBody = messageBody.doOnNext(data -> headers
                                        .setContentLength(data.readableByteCount()));
                            }
                            // TODO: fail if isStreamingMediaType?
                            return getDelegate().writeWith(messageBody);
                        }));
            }

            @Override
            public Mono<Void> writeAndFlushWith(Publisher<? extends Publisher<? extends DataBuffer>> body) {
                return writeWith(Flux.from(body)
                        .flatMapSequential(p -> p));
            }
        };

        //修改HTTP状态为200成功
        responseDecorator.setStatusCode(HttpStatus.OK);
        responseDecorator.setRawStatusCode(200);
        ServerWebExchange webExchange = exchange.mutate().response(responseDecorator).build();
//        ServerWebExchange webExchange = ServerWebExchangeUtil.setHttpStatus(exchange,HttpStatus.OK);
        return chain.filter(webExchange);
    }


    private ClientResponse prepareClientResponse(
            ServerWebExchange exchange,
            Publisher<? extends DataBuffer> body,
            HttpHeaders httpHeaders
    ) {
        ClientResponse.Builder builder;
        builder = ClientResponse.create(exchange.getResponse().getStatusCode(), codecConfigurer.getReaders());
        return builder.headers(headers -> headers.putAll(httpHeaders))
                .body(Flux.from(body)).build();
    }

    private Mono<DataBuffer> writeBody(ServerHttpResponse httpResponse,
                                       CachedBodyOutputMessage message, Class<?> outClass) {
        Mono<DataBuffer> response = DataBufferUtils.join(message.getBody());
        if (byte[].class.isAssignableFrom(outClass)) {
            return response;
        }

        List<String> encodingHeaders = httpResponse.getHeaders()
                .getOrEmpty(HttpHeaders.CONTENT_ENCODING);
        for (String encoding : encodingHeaders) {
            MessageBodyEncoder encoder = messageBodyEncoders.get(encoding);
            if (encoder != null) {
                DataBufferFactory dataBufferFactory = httpResponse.bufferFactory();
                response = response.publishOn(Schedulers.parallel()).map(buffer -> {
                    byte[] encodedResponse = encoder.encode(buffer);
                    DataBufferUtils.release(buffer);
                    return encodedResponse;
                }).map(dataBufferFactory::wrap);
                break;
            }
        }

        return response;
    }

    @Override
    public int getOrder() {
        return NettyWriteResponseFilter.WRITE_RESPONSE_FILTER_ORDER - 1;
    }

    public class ResponseAdapter implements ClientHttpResponse {

        private final Flux<DataBuffer> flux;
        private final HttpHeaders headers;

        public ResponseAdapter(Publisher<? extends DataBuffer> body, HttpHeaders headers) {
            this.headers = headers;
            if (body instanceof Flux) {
                flux = (Flux) body;
            } else {
                flux = ((Mono) body).flux();
            }
        }

        @Override
        public Flux<DataBuffer> getBody() {
            return flux;
        }

        @Override
        public HttpHeaders getHeaders() {
            return headers;
        }

        @Override
        public HttpStatus getStatusCode() {
            return null;
        }

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

        @Override
        public MultiValueMap<String, ResponseCookie> getCookies() {
            return null;
        }
    }

    @PostConstruct
    public void after() {
        this.messageBodyEncoders = bodyEncoders == null ? Collections.emptyMap() : bodyEncoders.stream()
                .collect(Collectors.toMap(MessageBodyEncoder::encodingType, identity(),(a,b)->b));
    }
}