作为网关，日志记录是必不可少的功能，可以在网关出增加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- ...

随机推荐

spring security梳理
核心服务:AuthenticationManager,UserDetailsService和AccessDecisionManager The AuthenticationManager, Provi ...
python可变类型和不可变类型，深拷贝vs浅拷贝
转载:https://www.cnblogs.com/huamingao/p/5809936.html 核心提示: 可变类型 Vs 不可变类型可变类型(mutable):列表,字典不可变类型(un ...
ajax 接受后台中文数据出现"?"(疑问号)解决方案
把后端要返回的数据转成一个JSONObject类型返回,返回String 类型数据使用JSONObject来封装然后返回,绝对不会出现???了, 要是返回的是一个实体类的话,需要在前端或者后端做转换成 ...
radar chart
多变量数据雷达图radar chart 如上图可知,雷达图的缺点是看不清,此时可采用线性变换(相差小)or对数变换(相差大)的方法使得图像展开. 但是第一幅图用于比价种类比较鲜明,而第二幅图虽然比较 ...
VMware虚拟机克隆CentOS6.5后修改网卡
在学习zk伪分布式集群对的时候,第一次注意到克隆虚拟机后修改eth的ip地址,发现ip不是自己修改的ip,进而在询问下发现,当我们第一次登陆查看我们克隆的虚拟机ip时:我们看到的ip不是et ...
lvs/dr+keepalived搭建成功后，开启防火墙，虚拟IP不能访问，但是真实IP却可以访问
lvs/dr+keepalived搭建成功后,开启防火墙,虚拟IP不能访问,但是真实IP却可以访问,如果关闭防火墙虚拟IP就可以访问网站了,这个问题肯定是防火墙在作怪. 经过这两的不懈奋斗和大家的帮助 ...
hexo创建新文章的正确方法
起因之前我一直是通过复制以前的文章的形式来创建一个新的文档,但是这一次似乎遇到了一些问题.我将文章写完之后,准备进行预览,输入hexo s命令.在预览页面却没有显示出新的文章,还是和之前的页面是一样 ...
Redis：slave flush old data造成实例不可用
一.问题描述 2019-02-22凌晨02:42分前后,收到集群中 [10.32.52.8:6500] 实例不可用告警,登陆管理界面查看此实例在正常运行状态,期间未出现机器宕机或实例直接挂掉的现象. ...
微信小程序采坑之scroll-view
当设置了scroll-y为true之后,纵向是没有问题的,会出现滚动条. Android上一切都是那么的祥和, ios上你会发现如果你scroll-view里面的东西超过横向的宽度时,就会隐藏了. 也 ...
AF（操作者框架）系列（3）-创建第一个Actor的程序
这节课的内容,语言描述基本是无趣的,就是一个纯程序编写,直接上图了. 如果想做其他练习,可参考前面的文章: https://zhuanlan.zhihu.com/p/105133597 1．新建一个 ...

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

打印请求日志

第一种

第二种

打印响应报文

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

随机推荐

热门专题