ServerWebExcahnge的解释如下：

Contract for an HTTP request-response interaction. Provides access to the HTTP request and response and also exposes additional server-side processing related properties and features such as request attributes.

大概是说：ServerWebExchange是一个HTTP请求-响应交互的契约。提供对HTTP请求和响应的访问，并公开额外的服务器端处理相关属性和特性，如请求属性，有点像Context的角色。

在 HTTP 协议中，请求头和请求体是请求的重要组成部分，ServerWebExchange 提供了丰富的方法来对其进行处理。

请求数据读取

例如，可以通过 ServerWebExchange.getRequest().getHeaders() 方法获取请求头：

<code>ServerHttpRequest request = exchange.getRequest();

HttpHeaders headers = request.getHeaders();

String userAgent = headers.getFirst(HttpHeaders.USER_AGENT);

可以通过 ServerWebExchange.getRequest().getBody() 方法获取请求体：

ServerHttpRequest request = exchange.getRequest();

Mono<String> requestBody = request.getBody().map(dataBuffer -> {

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

dataBuffer.read(buffer);

DataBufferUtils.release(dataBuffer);

Charset charset = Charset.forName("UTF-8");

return new String(buffer, charset);

});

这里使用 BodyExtractors.toMono(String.class) 也可以获取请求体，但是这种方式只适用于请求体是 JSON、XML 等文本格式的情况。而如果请求体是二进制文件，则需要使用上面的方式来获取。

简单的理解是，ServerWebExcahnge包含了http请求的请求数据(ServerHttpRequest)，返回数据(ServerHttpResponse)。

从新封装请求

       ServerHttpRequest是一个只读类，对于读多写少的场景，这种设计模式是值得借鉴的。但是有时候我们也需要修改。则可以通过以下实现修改：

ServerHttpRequest serverHttpRequest = exchange.getRequest().mutate().path(newPath).method(HttpMethod.GET).build();

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

return chain.filter(exchange);

     但是请求中的body参数流(inputstream)只能被读取一次，但是，我们通常由很多个过滤器，所以可能需要读取多次消息。解决这个办法需要用到官方提供的：ContentCachingRequestWrapper类。

public ContentCachingRequestWrapper(HttpServletRequest request) {

    super(request);

    int contentLength = request.getContentLength();

    this.cachedContent = new ByteArrayOutputStream(contentLength >= 0 ? contentLength : 1024);

    this.contentCacheLimit = null;

}

包装ContentCachingRequestWrapper，主要就做了一件事儿，感知request里面内容的长度，为自己开一个同样大小的输出流cachedContent。然后重写其中的方法：

//重写方法getInputStream

@Override

public ServletInputStream getInputStream() throws IOException {

    if (this.inputStream == null) {

        this.inputStream = new ContentCachingInputStream(getRequest().getInputStream());

    }

    return this.inputStream;

}

//重写java.io.InputStream#read()方法

@Override

public int read() throws IOException {

int ch = this.is.read();

if (ch != -1 && !this.overflow) {

if (contentCacheLimit != null && cachedContent.size() == contentCacheLimit) {

this.overflow = true;

handleContentOverflow(contentCacheLimit);

}

else {

cachedContent.write(ch);

}

}

return ch;

}

//重写方法inputStream中的read(byte b[], int off, int len)

@Override

public int read(final byte[] b, final int off, final int len) throws IOException {

int count = this.is.read(b, off, len);

writeToCache(b, off, count);

return count;

}

总之，ContentCachingRequestWrapper通过覆盖inpuStream方法，通过移花接木的方式，将每次调用inputStream读的时候都将其放置到输出流当中。这样后续inputStream流被关闭了，我们还可以通过使用cachedContent内容读取入参内容。

构造返回数据

private void doResponse(ServletResponse servletResponse) throws IOException{

servletResponse.setContentType(MediaType.APPLICATION_JSON_UTF8_VALUE);

HttpServletResponse httpServletResponse = (HttpServletResponse)servletResponse;

httpServletResponse.setStatus(401);

PrintWriter writer = servletResponse.getWriter();

writer.write("xxxxx");

}

private void doFileResponse(ServletResponse servletResponse) throws IOException{

//1. 用于读取文件

FileInputStream fis = new FileInputStream("d://xxx/xxx/a.jpg");

//2. 获取response字节输出流

ServletOutputStream os = servletResponse.getOutputStream();

//3. 完成流的复制

byte[] buff = new byte[1024];

int len = 0;

while ((len = fis.read(buff))!= -1){

os.write(buff,0,len);

}

fis.close();

}

读取返回数据：

https://www.cnblogs.com/fdzang/p/11812348.html