原文地址
描述
先上源码
private enum State {NEW, COMMITTING, COMMIT_ACTION_FAILED, COMMITTED}
//...
@Override
public HttpHeaders getHeaders() {
if (this.readOnlyHeaders != null) {
return this.readOnlyHeaders;
}
else if (this.state.get() == State.COMMITTED) {
this.readOnlyHeaders = HttpHeaders.readOnlyHttpHeaders(this.headers);
return this.readOnlyHeaders;
}
else {
return this.headers;
}
}
//...
我们可以看到，在COMMITTED状态中HttpHeaders会变为只读，那么此时就无法对于response进行操作，State会在doFinally，then等操作前被置为COMMITTED
@Override
public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
//...
return chain.filter(exchange).doFinally(signalType -> {
//org.springframework.http.server.reactive.AbstractServerHttpResponse.getHeaders
//response is close, can't operate body or cookie message
});
}
@Override
public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
//...
return chain.filter(exchange).then(Mono.fromRunnable(() -> {
//org.springframework.http.server.reactive.AbstractServerHttpResponse.getHeaders
//response is close, can't operate body or cookie message
}));
}
此时就会触发org.springframework.http.ReadOnlyHttpHeaders中UnsupportedOperationException异常
解决方案
我们可以在org.springframework.http.server.reactive.AbstractServerHttpResponse中找到
/**
* Apply {@link #beforeCommit(Supplier) beforeCommit} actions, apply the
* response status and headers/cookies, and write the response body.
* @param writeAction the action to write the response body (may be {@code null})
* @return a completion publisher
*/
protected Mono<Void> doCommit(@Nullable Supplier<? extends Mono<Void>> writeAction) {
Flux<Void> allActions = Flux.empty();
if (this.state.compareAndSet(State.NEW, State.COMMITTING)) {
if (!this.commitActions.isEmpty()) {
allActions = Flux.concat(Flux.fromIterable(this.commitActions).map(Supplier::get))
.doOnError(ex -> {
if (this.state.compareAndSet(State.COMMITTING, State.COMMIT_ACTION_FAILED)) {
getHeaders().clearContentHeaders();
}
});
}
}
else if (this.state.compareAndSet(State.COMMIT_ACTION_FAILED, State.COMMITTING)) {
// Skip commit actions
}
else {
return Mono.empty();
}
allActions = allActions.concatWith(Mono.fromRunnable(() -> {
applyStatusCode();
applyHeaders();
applyCookies();
this.state.set(State.COMMITTED);
}));
if (writeAction != null) {
allActions = allActions.concatWith(writeAction.get());
}
return allActions.then();
}
我们可以在请求前置流程中设置一个beforeCommit的回调，然后在请求后就会先执行回调再执行COMMIT，此时我们就可以处理response中的内容了
@Override
public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
ServerHttpResponse response = exchange.getResponse();
//org.springframework.http.server.reactive.AbstractServerHttpResponse.doCommit(
// java.util.function.Supplier<? extends reactor.core.publisher.Mono<java.lang.Void>>)
// need operate in this method, which call before request commit
response.beforeCommit(requestPostCallback(exchange));
return chain.filter(exchange).doFinally(signalType -> {
//org.springframework.http.server.reactive.AbstractServerHttpResponse.getHeaders
//response is close, can't operate body or cookie message
});
}
private Supplier<Mono<Void>> requestPostCallback(ServerWebExchange exchange) {
return () -> {
ServerHttpRequest request = exchange.getRequest();
ServerHttpResponse response = exchange.getResponse();
//change response...
return Mono.empty();
};
}
拓展
所以如果我们需要在请求后处理response相关信息，必须让处理方法在处理在提交前触发，那么首先我们应该如何获取response的信息呢？一般情况下我们需要获得的是body的内容，如果希望在webfilter，gatewayFilter中获取的话，一般的能检索到的方法是How to get Original response body in Spring cloud gateway (Webflux) Post filter
import lombok.extern.log4j.Log4j2;
import org.apache.commons.io.IOUtils;
import org.reactivestreams.Publisher;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.context.annotation.Configuration;
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.DefaultDataBuffer;
import org.springframework.core.io.buffer.DefaultDataBufferFactory;
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.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.core.scheduler.Schedulers;
import java.io.ByteArrayOutputStream;
import java.nio.channels.Channels;
import java.nio.charset.StandardCharsets;
@Configuration
@Log4j2
public class RequestResponseModifyFilter implements GatewayFilter/WebFilter, Ordered {
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
String path = exchange.getRequest().getPath().toString();
ServerHttpResponse response = exchange.getResponse();
ServerHttpRequest request = exchange.getRequest();
DataBufferFactory dataBufferFactory = response.bufferFactory();
// log the request body
ServerHttpRequest decoratedRequest = getDecoratedRequest(request);
// log the response body
ServerHttpResponseDecorator decoratedResponse = getDecoratedResponse(path, response, request, dataBufferFactory);
return chain.filter(exchange.mutate().request(decoratedRequest).response(decoratedResponse).build());
}
private ServerHttpResponseDecorator getDecoratedResponse(String path, ServerHttpResponse response, ServerHttpRequest request, DataBufferFactory dataBufferFactory) {
return new ServerHttpResponseDecorator(response) {
@Override
public Mono<Void> writeWith(final Publisher<? extends DataBuffer> body) {
if (body instanceof Flux) {
Flux<? extends DataBuffer> fluxBody = (Flux<? extends DataBuffer>) body;
return super.writeWith(fluxBody.buffer().map(dataBuffers -> {
DefaultDataBuffer joinedBuffers = new DefaultDataBufferFactory().join(dataBuffers);
byte[] content = new byte[joinedBuffers.readableByteCount()];
joinedBuffers.read(content);
String responseBody = new String(content, StandardCharsets.UTF_8);//MODIFY RESPONSE and Return the Modified response
log.debug("requestId: {}, method: {}, url: {}, \nresponse body :{}", request.getId(), request.getMethodValue(), request.getURI(), responseBody);
return dataBufferFactory.wrap(responseBody.getBytes());
})).onErrorResume(err -> {
log.error("error while decorating Response: {}",err.getMessage());
return Mono.empty();
});
}
return super.writeWith(body);
}
};
}
private ServerHttpRequest getDecoratedRequest(ServerHttpRequest request) {
return new ServerHttpRequestDecorator(request) {
@Override
public Flux<DataBuffer> getBody() {
log.debug("requestId: {}, method: {} , url: {}", request.getId(), request.getMethodValue(), request.getURI());
return super.getBody().publishOn(Schedulers.boundedElastic()).doOnNext(dataBuffer -> {
try (ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) {
Channels.newChannel(byteArrayOutputStream).write(dataBuffer.asByteBuffer().asReadOnlyBuffer());
String requestBody = IOUtils.toString(byteArrayOutputStream.toByteArray(), StandardCharsets.UTF_8.toString());//MODIFY REQUEST and Return the Modified request
log.debug("for requestId: {}, request body :{}", request.getId(), requestBody);
} catch (Exception e) {
log.error(e.getMessage());
}
});
}
};
}
@Override
public int getOrder() { return -2;}
}
这种方法确实太不优雅了，一般webflux都是网关项目，所以我们其实可以选择更优雅的处理方法6.13 The ModifyResponseBody GatewayFilter Factory，在路由中处理修改response body部分
public RouteLocator routes(RouteLocatorBuilder builder) {
return builder.routes()
.route("rewrite_response_upper", r -> r.host("*.rewriteresponseupper.org")
.filters(f -> f.prefixPath("/httpbin")
.modifyResponseBody(String.class, String.class,
(exchange, s) -> Mono.just(s.toUpperCase()))).uri(uri))
.build();
}
所以如果是网关项目希望修改回调信息对象的话，我们可以在路由里面直接设置规则，而不需要再通过过滤器进行处理了
sa-token的相关处理
如果我们只希望在网关引入sa-token，拒绝sa-token侵入其他项目的话，我们的登录信息塞到cookie中这一步就需要在请求的后置流程中完成，毕竟我们需要请求用户中心成功再塞数据嘛。所以我们这里的处理就是首先在modifyResponseBody中将body内容获取，然后再执行登录操作，但这个时候会提示没有办法找到spring context的上下文，那么我们需要重新将sa-token进行初始化
//re-init sa-token context
SaRequest requestSa = new SaRequestForReactor(exchange.getRequest());
SaResponse responseSa = new SaResponseForReactor(exchange.getResponse());
SaStorage storageSa = new SaStorageForReactor(exchange);
SaTokenContextForThreadLocalStorage.setBox(requestSa, responseSa, storageSa);
扫一扫
1668
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
