作为网关，日志记录是必不可少的功能，可以在网关出增加requestId来查询整个请求链的调用执行情况等等。

打印请求日志

打印请求日志最重要的就是打印请求参数这些东西，不过RequestBody通常情况下在被读取一次之后就会失效，这样的话，下游的服务就不能正常获取到请求参数了。所以我们需要重写下请求体。

具体方法呢有很多，这里说一下我用的两种：

第一种

代码如下：

package com.lifengdi.gateway.filter;

import com.lifengdi.gateway.constant.HeaderConstant;

import com.lifengdi.gateway.constant.OrderedConstant;

import com.lifengdi.gateway.log.Log;

import com.lifengdi.gateway.log.LogHelper;

import com.lifengdi.gateway.utils.GenerateIdUtils;

import com.lifengdi.gateway.utils.IpUtils;

import io.netty.buffer.UnpooledByteBufAllocator;

import lombok.extern.slf4j.Slf4j;

import org.apache.commons.lang.StringUtils;

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

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

import org.springframework.core.Ordered;

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

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

import org.springframework.http.HttpHeaders;

import org.springframework.http.MediaType;

import org.springframework.http.server.reactive.ServerHttpRequest;

import org.springframework.http.server.reactive.ServerHttpRequestDecorator;

import org.springframework.stereotype.Component;

import org.springframework.util.StopWatch;

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.net.URI;

import java.util.Objects;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.concurrent.atomic.AtomicReference;

import java.util.function.Consumer;

/**

 * 请求日志打印

 */

@Component

@Slf4j

public class RequestLogFilter implements GlobalFilter, Ordered {

    @Override

    public int getOrder() {

        return OrderedConstant.REQUEST_FILTER;

    }

    @Override

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

        StopWatch stopWatch = new StopWatch();

        stopWatch.start();

        long startTime = System.currentTimeMillis();

        try {

            ServerHttpRequest request = exchange.getRequest();

            // 设置X-Request-Id

            AtomicReference<String> requestId = new AtomicReference<>(GenerateIdUtils.requestIdWithUUID());

            Consumer<HttpHeaders> httpHeadersConsumer = httpHeaders -> {

                String headerRequestId = request.getHeaders().getFirst(HeaderConstant.REQUEST_ID);

                if (StringUtils.isBlank(headerRequestId)) {

                    httpHeaders.set(HeaderConstant.REQUEST_ID, requestId.get());

                } else {

                    requestId.set(headerRequestId);

                }

                httpHeaders.set(HeaderConstant.START_TIME_KEY, String.valueOf(startTime));

            };

            ServerRequest serverRequest = ServerRequest.create(exchange,

                    HandlerStrategies.withDefaults().messageReaders());

            URI requestUri = request.getURI();

            String uriQuery = requestUri.getQuery();

            String url = requestUri.getPath() + (StringUtils.isNotBlank(uriQuery) ? "?" + uriQuery : "");

            HttpHeaders headers = request.getHeaders();

            MediaType mediaType = headers.getContentType();

            String method = request.getMethodValue().toUpperCase();

            // 原始请求体

            final AtomicReference<String> requestBody = new AtomicReference<>();

            final AtomicBoolean newBody = new AtomicBoolean(false);

            if (Objects.nonNull(mediaType) && LogHelper.isUploadFile(mediaType)) {

                requestBody.set("上传文件");

            } else {

                if (method.equals("GET")) {

                    if (StringUtils.isNotBlank(uriQuery)) {

                        requestBody.set(uriQuery);

                    }

                } else {

                    newBody.set(true);

                }

            }

            final Log logDTO = new Log();

            logDTO.setLevel(Log.LEVEL.INFO);

            logDTO.setRequestUrl(url);

            logDTO.setRequestBody(requestBody.get());

            logDTO.setRequestMethod(method);

            logDTO.setRequestId(requestId.get());

            logDTO.setIp(IpUtils.getClientIp(request));

            ServerHttpRequest serverHttpRequest = exchange.getRequest().mutate().headers(httpHeadersConsumer).build();

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

            return build.getSession().flatMap(webSession -> {

                logDTO.setSessionId(webSession.getId());

                if (newBody.get() && headers.getContentLength() > 0) {

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

                    return bodyToMono.flatMap(reqBody -> {

                        logDTO.setRequestBody(reqBody);

                        // 重写原始请求

                        ServerHttpRequestDecorator requestDecorator = new ServerHttpRequestDecorator(exchange.getRequest()) {

                            @Override

                            public Flux<DataBuffer> getBody() {

                                NettyDataBufferFactory nettyDataBufferFactory = new NettyDataBufferFactory(new UnpooledByteBufAllocator(false));

                                DataBuffer bodyDataBuffer = nettyDataBufferFactory.wrap(reqBody.getBytes());

                                return Flux.just(bodyDataBuffer);

                            }

                        };

                        return chain.filter(exchange.mutate()

                                .request(requestDecorator)

                                .build()).then(LogHelper.doRecord(logDTO));

                    });

                } else {

                    return chain.filter(exchange).then(LogHelper.doRecord(logDTO));

                }

            });

        } catch (Exception e) {

            log.error("请求日志打印出现异常", e);

            return chain.filter(exchange);

        }

    }

}

上面的核心代码是：

// 重写原始请求

ServerHttpRequestDecorator requestDecorator = new ServerHttpRequestDecorator(exchange.getRequest()) {

    @Override

    public Flux<DataBuffer> getBody() {

        NettyDataBufferFactory nettyDataBufferFactory = new NettyDataBufferFactory(new UnpooledByteBufAllocator(false));

        DataBuffer bodyDataBuffer = nettyDataBufferFactory.wrap(reqBody.getBytes());

        return Flux.just(bodyDataBuffer);

    }

};

return chain.filter(exchange.mutate()

        .request(requestDecorator)

        .build()).then(LogHelper.doRecord(logDTO));

如果不需要对session进行操作，可以直接调用这块就行。

关于请求时间，我这里采用的是将时间戳放进请求头中，等到打印日志的时候再从请求头中读取然后计算出时间。否则如果单独在某个filter中计算请求时间，会造成时间不太准确。当然这样时间也不是很准确，毕竟还有Spring本身的filter等业务逻辑，不过时间相差不是很大，大概十几毫秒的样子。

第二种

第二种就是自己缓存下请求体，读取的时候读取缓存内容。

代码如下：

package com.lifengdi.gateway.log;

import com.lifengdi.gateway.constant.HeaderConstant;

import com.lifengdi.gateway.utils.IpUtils;

import io.netty.buffer.UnpooledByteBufAllocator;

import lombok.extern.slf4j.Slf4j;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang.StringUtils;

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

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

import org.springframework.http.HttpHeaders;

import org.springframework.http.MediaType;

import org.springframework.http.server.reactive.ServerHttpRequest;

import org.springframework.http.server.reactive.ServerHttpRequestDecorator;

import reactor.core.publisher.Flux;

import reactor.core.scheduler.Schedulers;

import java.io.IOException;

import java.io.InputStream;

import java.net.URI;

import java.util.Objects;

/**

 * 对ServerHttpRequest进行二次封装，解决requestBody只能读取一次的问题

 * @author: Li Fengdi

 * @date: 2020-03-17 18:02

 */

@Slf4j

public class CacheServerHttpRequestDecorator extends ServerHttpRequestDecorator {

    private DataBuffer bodyDataBuffer;

    private int getBufferTime = 0;

    private byte[] bytes;

    public CacheServerHttpRequestDecorator(ServerHttpRequest delegate) {

        super(delegate);

    }

    @Override

    public Flux<DataBuffer> getBody() {

        if (getBufferTime == 0) {

            getBufferTime++;

            Flux<DataBuffer> flux = super.getBody();

            return flux.publishOn(Schedulers.single())

                    .map(this::cache)

                    .doOnComplete(() -> trace(getDelegate()));

        } else {

            return Flux.just(getBodyMore());

        }

    }

    private DataBuffer getBodyMore() {

        NettyDataBufferFactory nettyDataBufferFactory = new NettyDataBufferFactory(new UnpooledByteBufAllocator(false));

        bodyDataBuffer = nettyDataBufferFactory.wrap(bytes);

        return bodyDataBuffer;

    }

    private DataBuffer cache(DataBuffer buffer) {

        try {

            InputStream dataBuffer = buffer.asInputStream();

            bytes = IOUtils.toByteArray(dataBuffer);

            NettyDataBufferFactory nettyDataBufferFactory = new NettyDataBufferFactory(new UnpooledByteBufAllocator(false));

            bodyDataBuffer = nettyDataBufferFactory.wrap(bytes);

            return bodyDataBuffer;

        } catch (IOException e) {

            e.printStackTrace();

        }

        return null;

    }

    private void trace(ServerHttpRequest request) {

        URI requestUri = request.getURI();

        String uriQuery = requestUri.getQuery();

        String url = requestUri.getPath() + (StringUtils.isNotBlank(uriQuery) ? "?" + uriQuery : "");

        HttpHeaders headers = request.getHeaders();

        MediaType mediaType = headers.getContentType();

        String schema = requestUri.getScheme();

        String method = request.getMethodValue().toUpperCase();

        if ((!"http".equals(schema) && !"https".equals(schema))) {

            return;

        }

        String reqBody = null;

        if (Objects.nonNull(mediaType) && LogHelper.isUploadFile(mediaType)) {

            reqBody = "上传文件";

        } else {

            if (method.equals("GET")) {

                if (StringUtils.isNotBlank(uriQuery)) {

                    reqBody = uriQuery;

                }

            } else if (headers.getContentLength() > 0) {

                reqBody = LogHelper.readRequestBody(request);

            }

        }

        final Log logDTO = new Log();

        logDTO.setLevel(Log.LEVEL.INFO);

        logDTO.setRequestUrl(url);

        logDTO.setRequestBody(reqBody);

        logDTO.setRequestMethod(method);

        logDTO.setRequestId(headers.getFirst(HeaderConstant.REQUEST_ID));

        logDTO.setIp(IpUtils.getClientIp(request));

        log.info(LogHelper.toJsonString(logDTO));

    }

}

filter这里就简单写下：

package com.lifengdi.gateway.filter;

import com.lifengdi.gateway.constant.OrderedConstant;

import com.lifengdi.gateway.log.CacheServerHttpRequestDecorator;

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

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

import org.springframework.core.Ordered;

import org.springframework.web.server.ServerWebExchange;

import reactor.core.publisher.Mono;

/**

 * @author: Li Fengdi

 * @date: 2020-03-17 18:17

 */

//@Component

public class LogFilter implements GlobalFilter, Ordered {

    @Override

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

        CacheServerHttpRequestDecorator cacheServerHttpRequestDecorator = new CacheServerHttpRequestDecorator(exchange.getRequest());

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

    }

    @Override

    public int getOrder() {

        return OrderedConstant.LOGGING_FILTER;

    }

}

工具类也贴下：

package com.lifengdi.gateway.log;

import com.fasterxml.jackson.core.JsonProcessingException;

import com.fasterxml.jackson.databind.ObjectMapper;

import com.lifengdi.gateway.constant.HeaderConstant;

import lombok.extern.slf4j.Slf4j;

import org.apache.commons.lang.StringUtils;

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

import org.springframework.http.HttpHeaders;

import org.springframework.http.MediaType;

import org.springframework.http.server.reactive.ServerHttpRequest;

import org.springframework.lang.NonNull;

import org.springframework.lang.Nullable;

import reactor.core.publisher.Mono;

import java.nio.charset.Charset;

import java.nio.charset.StandardCharsets;

import java.util.Objects;

import java.util.concurrent.atomic.AtomicReference;

@Slf4j

public class LogHelper {

    private final static ObjectMapper objectMapper = new ObjectMapper();

    /**

     * Log转JSON

     * @param dto Log

     * @return JSON字符串

     */

    public static String toJsonString(@NonNull Log dto) {

        try {

            return objectMapper.writeValueAsString(dto);

        } catch (JsonProcessingException e) {

            log.error("Log转换JSON异常", e);

            return null;

        }

    }

    /**

     * 根据MediaType获取字符集，如果获取不到，则默认返回<tt>UTF_8</tt>

     * @param mediaType MediaType

     * @return Charset

     */

    public static Charset getMediaTypeCharset(@Nullable MediaType mediaType) {

        if (Objects.nonNull(mediaType) && mediaType.getCharset() != null) {

            return mediaType.getCharset();

        } else {

            return StandardCharsets.UTF_8;

        }

    }

    /**

     * 记录日志（后期可扩展为通过MQ将日志发送到ELK系统）

     * @param dto Log

     * @return Mono.empty()

     */

    public static Mono<Void> doRecord(Log dto) {

        log.info(toJsonString(dto));

        return Mono.empty();

    }

    /**

     * 从HttpHeaders获取请求开始时间

     * <p>

     *     要求请求头中必须要有参数{@link HeaderConstant#START_TIME_KEY}，否则将返回当前时间戳

     * </p>

     * @param headers HttpHeaders请求头

     * @return 开始时间时间戳（Mills）

     */

    public static long getStartTime(HttpHeaders headers) {

        String startTimeStr = headers.getFirst(HeaderConstant.START_TIME_KEY);

        return StringUtils.isNotBlank(startTimeStr) ? Long.parseLong(startTimeStr) : System.currentTimeMillis();

    }

    /**

     * 根据HttpHeaders请求头获取请求执行时间

     * <p>

     *     要求请求头中必须要有参数{@link HeaderConstant#START_TIME_KEY}

     * </p>

     * @param headers HttpHeaders请求头

     * @return 请求执行时间

     */

    public static long getHandleTime(HttpHeaders headers) {

        String startTimeStr = headers.getFirst(HeaderConstant.START_TIME_KEY);

        long startTime = StringUtils.isNotBlank(startTimeStr) ? Long.parseLong(startTimeStr) : System.currentTimeMillis();

        return System.currentTimeMillis() - startTime;

    }

    /**

     * 读取请求体内容

     * @param request ServerHttpRequest

     * @return 请求体

     */

    public static String readRequestBody(ServerHttpRequest request) {

        HttpHeaders headers = request.getHeaders();

        MediaType mediaType = headers.getContentType();

        String method = request.getMethodValue().toUpperCase();

        if (Objects.nonNull(mediaType) && mediaType.equals(MediaType.MULTIPART_FORM_DATA)) {

            return "上传文件";

        } else {

            if (method.equals("GET")) {

                if (!request.getQueryParams().isEmpty()) {

                    return request.getQueryParams().toString();

                }

                return null;

            } else {

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

                request.getBody().subscribe(buffer -> {

                    byte[] bytes = new byte[buffer.readableByteCount()];

                    buffer.read(bytes);

                    DataBufferUtils.release(buffer);

                    bodyString.set(new String(bytes, getMediaTypeCharset(mediaType)));

                });

                return bodyString.get();

            }

        }

    }

    /**

     * 判断是否是上传文件

     * @param mediaType MediaType

     * @return Boolean

     */

    public static boolean isUploadFile(@Nullable MediaType mediaType) {

        if (Objects.isNull(mediaType)) {

            return false;

        }

        return mediaType.equals(MediaType.MULTIPART_FORM_DATA)

                || mediaType.equals(MediaType.IMAGE_GIF)

                || mediaType.equals(MediaType.IMAGE_JPEG)

                || mediaType.equals(MediaType.IMAGE_PNG)

                || mediaType.equals(MediaType.MULTIPART_MIXED);

    }

}

打印响应报文

响应报文需要在Spring重写了响应体之后才能获取到，所以对filter的执行顺序有要求，需要在

NettyWriteResponseFilter.WRITE_RESPONSE_FILTER_ORDER之前执行。代码如下：

package com.lifengdi.gateway.filter;

import com.lifengdi.gateway.constant.HeaderConstant;

import com.lifengdi.gateway.constant.OrderedConstant;

import com.lifengdi.gateway.log.Log;

import com.lifengdi.gateway.log.LogHelper;

import com.lifengdi.gateway.utils.IpUtils;

import io.netty.buffer.UnpooledByteBufAllocator;

import lombok.extern.slf4j.Slf4j;

import org.apache.commons.lang.StringUtils;

import org.reactivestreams.Publisher;

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

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

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.core.io.buffer.NettyDataBufferFactory;

import org.springframework.http.HttpHeaders;

import org.springframework.http.HttpStatus;

import org.springframework.http.MediaType;

import org.springframework.http.server.reactive.ServerHttpRequest;

import org.springframework.http.server.reactive.ServerHttpRequestDecorator;

import org.springframework.http.server.reactive.ServerHttpResponse;

import org.springframework.http.server.reactive.ServerHttpResponseDecorator;

import org.springframework.stereotype.Component;

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.net.URI;

import java.nio.charset.Charset;

import java.util.Objects;

import java.util.concurrent.atomic.AtomicReference;

/**

 * 请求响应日志打印

 */

@Component

@Slf4j

public class ResponseLogFilter implements GlobalFilter, Ordered {

    @Override

    public int getOrder() {

        return OrderedConstant.LOGGING_FILTER;

    }

    @Override

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

        try {

            ServerHttpRequest request = exchange.getRequest();

            ServerRequest serverRequest = ServerRequest.create(exchange,

                    HandlerStrategies.withDefaults().messageReaders());

            URI requestUri = request.getURI();

            String uriQuery = requestUri.getQuery();

            HttpHeaders headers = request.getHeaders();

            MediaType mediaType = headers.getContentType();

            String schema = requestUri.getScheme();

            String method = request.getMethodValue().toUpperCase();

            // 只记录http、https请求

            if ((!"http".equals(schema) && !"https".equals(schema))) {

                return chain.filter(exchange);

            }

            final AtomicReference<String> requestBody = new AtomicReference<>();// 原始请求体

            // 排除流文件类型,比如上传的文件contentType.contains("multipart/form-data")

            if (Objects.nonNull(mediaType) && LogHelper.isUploadFile(mediaType)) {

                requestBody.set("上传文件");

                return chain.filter(exchange);

            } else {

                if (method.equals("GET")) {

                    if (StringUtils.isNotBlank(uriQuery)) {

                        requestBody.set(uriQuery);

                    }

                } else if (headers.getContentLength() > 0){

                    return serverRequest.bodyToMono(String.class).flatMap(reqBody -> {

                        requestBody.set(reqBody);

                        // 重写原始请求

                        ServerHttpRequestDecorator requestDecorator = new ServerHttpRequestDecorator(exchange.getRequest()) {

                            @Override

                            public HttpHeaders getHeaders() {

                                HttpHeaders httpHeaders = new HttpHeaders();

                                httpHeaders.putAll(super.getHeaders());

                                return httpHeaders;

                            }

                            @Override

                            public Flux<DataBuffer> getBody() {

                                NettyDataBufferFactory nettyDataBufferFactory = new NettyDataBufferFactory(new UnpooledByteBufAllocator(false));

                                DataBuffer bodyDataBuffer = nettyDataBufferFactory.wrap(reqBody.getBytes());

                                return Flux.just(bodyDataBuffer);

//                                return Flux.just(reqBody).map(bx -> exchange.getRequest().bufferFactory().wrap(bx.getBytes()));

                            }

                        };

                        ServerHttpResponseDecorator responseDecorator = getServerHttpResponseDecorator(exchange,

                                requestBody);

                        return chain.filter(exchange.mutate()

                                .request(requestDecorator)

                                .response(responseDecorator)

                                .build());

                    });

                }

                ServerHttpResponseDecorator decoratedResponse = getServerHttpResponseDecorator(exchange,

                        requestBody);

                return chain.filter(exchange.mutate()

                        .response(decoratedResponse)

                        .build());

            }

        } catch (Exception e) {

            log.error("请求响应日志打印出现异常", e);

            return chain.filter(exchange);

        }

    }

    private ServerHttpResponseDecorator getServerHttpResponseDecorator(ServerWebExchange exchange,

                                                                       AtomicReference<String> requestBody) {

        // 获取response的返回数据

        ServerHttpResponse originalResponse = exchange.getResponse();

        DataBufferFactory bufferFactory = originalResponse.bufferFactory();

        HttpStatus httpStatus = originalResponse.getStatusCode();

        ServerHttpRequest request = exchange.getRequest();

        URI requestUri = request.getURI();

        String uriQuery = requestUri.getQuery();

        String url = requestUri.getPath() + (StringUtils.isNotBlank(uriQuery) ? "?" + uriQuery : "");

        HttpHeaders headers = request.getHeaders();

        String method = request.getMethodValue().toUpperCase();

        String requestId = headers.getFirst(HeaderConstant.REQUEST_ID);

        // 封装返回体

        return new ServerHttpResponseDecorator(originalResponse) {

            @Override

            public Mono<Void> writeWith(Publisher<? extends DataBuffer> body) {

                if (body instanceof Flux) {

                    Flux<? extends DataBuffer> fluxBody = Flux.from(body);

                    return super.writeWith(fluxBody.buffer().map(dataBuffers -> {

                        DataBuffer join = bufferFactory.join(dataBuffers);

                        byte[] content = new byte[join.readableByteCount()];

                        join.read(content);

                        DataBufferUtils.release(join);

                        Charset charset = LogHelper.getMediaTypeCharset(originalResponse.getHeaders().getContentType());

                        String responseBody = new String(content, charset);

                        long handleTime = LogHelper.getHandleTime(headers);

                        Log logDTO = new Log(Log.TYPE.RESPONSE);

                        logDTO.setLevel(Log.LEVEL.INFO);

                        logDTO.setRequestUrl(url);

                        logDTO.setRequestBody(requestBody.get());

                        logDTO.setResponseBody(responseBody);

                        logDTO.setRequestMethod(method);

                        if (Objects.nonNull(httpStatus)) {

                            logDTO.setStatus(httpStatus.value());

                        }

                        logDTO.setHandleTime(handleTime);

                        logDTO.setRequestId(requestId);

                        logDTO.setIp(IpUtils.getClientIp(request));

                        exchange.getSession().subscribe(webSession -> {

                            logDTO.setSessionId(webSession.getId());

                        });

                        log.info("url:{},method:{},请求内容:{},响应内容:{},status:{},handleTime:{},requestId:{}",

                                url, method, requestBody.get(), responseBody, httpStatus,

                                handleTime, requestId);

                        log.info(LogHelper.toJsonString(logDTO));

                        return bufferFactory.wrap(content);

                    }));

                }

                return super.writeWith(body);

            }

        };

    }

}

代码已上传到git上，需要的可以去看看。

git代码地址：https://github.com/lifengdi/spring-cloud-gateway-demo

原文地址：https://www.lifengdi.com/archives/article/1778

从零搭建Spring Cloud Gateway网关（二）—— 打印请求响应日志的更多相关文章

从零搭建Spring Cloud Gateway网关（一）
新建Spring Boot项目怎么新建Spring Boot项目这里不再具体赘述,不会的可以翻看下之前的博客或者直接百度.这里直接贴出对应的pom文件. pom依赖如下: <?xml vers ...
从零搭建Spring Cloud Gateway网关（三）——报文结构转换
背景作为网关,有些时候可能报文的结构并不符合前端或者某些服务的需求,或者因为某些原因,其他服务修改报文结构特别麻烦.或者需要修改的地方特别多,这个时候就需要走网关单独转换一次. 实现话不多说,直接 ...
Spring Cloud gateway 网关服务二断言、过滤器
微服务当前这么火爆的程度,如果不能学会一种微服务框架技术.怎么能升职加薪,增加简历的筹码?spring cloud 和 Dubbo 需要单独学习.说没有时间?没有精力?要学俩个框架?而Spring C ...
Spring Cloud gateway 网关四动态路由
微服务当前这么火爆的程度,如果不能学会一种微服务框架技术.怎么能升职加薪,增加简历的筹码?spring cloud 和 Dubbo 需要单独学习.说没有时间?没有精力?要学俩个框架?而Spring C ...
Spring Cloud实战 | 第十一篇：Spring Cloud Gateway 网关实现对RESTful接口权限控制和按钮权限控制
一. 前言 hi,大家好,这应该是农历年前的关于开源项目的最后一篇文章了. 有来商城是基于 Spring Cloud OAuth2 + Spring Cloud Gateway + JWT实现的统 ...
.net core下，Ocelot网关与Spring Cloud Gateway网关的对比测试
有感于 myzony 发布的针对 Ocelot 网关的性能测试 ,并且公司下一步也需要对.net和java的应用做一定的整合,于是对Ocelot网关.Spring Cloud Gateway网关做个 ...
网关服务Spring Cloud Gateway（二）
上一篇文章服务网关 Spring Cloud GateWay 初级篇,介绍了 Spring Cloud Gateway 的相关术语.技术原理,以及如何快速使用 Spring Cloud Gateway ...
Spring Cloud gateway 网关服务一
之前我们介绍了 zuul网关服务,今天聊聊spring cloud gateway 作为spring cloud的亲儿子网关服务.很多的想法都是参照zuul,为了考虑zuul 迁移到gateway 提 ...
Spring Cloud Gateway（二）：Spring Cloud Gateway整合Eureka应用
Spring Cloud Gateway 应用概述下面的示例启动两个服务:gataway-server 和 user-service 都注册到注册中心 Eureka上,客户端请求后端服务[user- ...

随机推荐

JVM组成与作用
class loader 类加载器:加载类文件到内存.Class loader只管加载,只要符合文件结构就加载,至于能否运行,它不负责,那是有Exectution Engine 负责的.exectio ...
制作MACOSX 10.9Mavericks安装启动U盘教程
苹果OS X Mavericks发布了,不少朋友又开始制作系统安装U盘了.其实下面介绍的方法与之前介绍的方法可能有些不同,不过原理还是一样的.下面看看具体的操作步骤吧! 1. 首先你需要开启显示隐藏文 ...
dubbo分布式框架下web层调用业务层一直报空指针异常的解决办法
java.lang.NullPointerException............... 环境:SSM(通用mapper)+Dubbo 1.检查导包提示注解@Reference 应该导入 im ...
rancher1.6高可用集群搭建
rancher高可用集群搭建一.搭建环境 1.安装系统下载centos最新版, http://mirrors.sohu.com/centos/7/isos/x86_64/CentOS-7-x86_ ...
HTTP 协议的基本知识，包括请求流程、请求方法等
一.什么是http协议? HTTP是Hyper Text Transfer Protocol(超文本传输协议)的缩写.它的发展是万维网协会(World Wide Web Consortium)和Int ...
Python之路购物车
#coding:utf-8 wages=raw_input('what are your wages:') lise_commodity=[('apples',50),('orange',55),(' ...
Google在百慕大避税几十亿美金，为什么巨头和富豪都会选百慕大避税？
为什么"越有钱越有钱"?为什么富豪只要不自己"作",就能让自己的财富疯狂增加?除了经营意识之外,关键他们还可以利用自己的资源.实力等去做很多看似让人不齿,但其实 ...
Keepalived+Haproxy搭建高可用负载均衡
Keepalived 简单的是一个路由的软件用C写的这个项目的主要目标是提供简单而强大的设施的负载均衡和高可用性对Linux系统和基于Linux的基础设施.负载均衡架构依赖于众所周知的和广泛使用的Li ...
TensorFlow_Faster_RCNN中demo.py的运行(CPU Only)
GitHub项目地址,https://github.com/endernewton/tf-faster-rcnnTensorflow Faster RCNN for Object Detection. ...
zabbix监控mysql数据库信息脚本
---恢复内容开始--- 在/usr/local/zabbix/etc/zabbix_agentd.conf增加 # 获取mysql性能指标 UserParameter=mysql.status[*] ...

从零搭建Spring Cloud Gateway网关（二）—— 打印请求响应日志

打印请求日志

第一种

第二种

打印响应报文

从零搭建Spring Cloud Gateway网关（二）—— 打印请求响应日志的更多相关文章

随机推荐

热门专题