SpringBoot中使用RequestDispatcher forward后如何获取请求响应字符串

方案一：使用Spring自带的缓存Wrapper结合拦截器（解决空指针问题） #

Servlet API的RequestDispatcher#forward会直接将响应写入客户端，导致无法直接捕获响应内容。Spring提供的ContentCachingRequestWrapper和ContentCachingResponseWrapper可以缓存请求/响应体，同时避免自定义Wrapper可能引发的上下文空指针问题。

1. 实现HandlerInterceptor捕获请求响应 #

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.util.ContentCachingRequestWrapper;
import org.springframework.web.util.ContentCachingResponseWrapper;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class RequestResponseCaptureInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        // 包装请求，缓存请求体
        if (!(request instanceof ContentCachingRequestWrapper)) {
            request = new ContentCachingRequestWrapper(request);
        }
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws IOException {
        // 获取缓存的请求体
        ContentCachingRequestWrapper wrappedRequest = (ContentCachingRequestWrapper) request;
        String requestBody = new String(wrappedRequest.getContentAsByteArray(), wrappedRequest.getCharacterEncoding());

        // 包装响应并获取缓存的响应体
        ContentCachingResponseWrapper wrappedResponse = new ContentCachingResponseWrapper(response);
        String responseBody = new String(wrappedResponse.getContentAsByteArray(), wrappedResponse.getCharacterEncoding());

        // 将请求响应存入数据库
        saveRequestResponse(request.getRequestURI(), requestBody, responseBody);

        // 必须调用此方法，将缓存的响应写回原响应，确保客户端能收到结果
        wrappedResponse.copyBodyToResponse();
    }

    private void saveRequestResponse(String uri, String requestBody, String responseBody) {
        // 实现你的数据库持久化逻辑，比如调用JPA Repository
    }
}

2. 注册拦截器到Spring上下文 #

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new RequestResponseCaptureInterceptor())
                .addPathPatterns("/your-forward-path"); // 指定需要拦截的路径
    }
}

关键注意点 #

• 确保拦截器被Spring容器管理（通过@Configuration注册），避免上下文空指针。
• afterCompletion中必须调用copyBodyToResponse()，否则客户端无法收到响应。

方案二：替换RequestDispatcher为RestTemplate/WebClient（更简单可靠） #

如果业务允许，直接用Spring的HTTP客户端调用远程服务，能直接获取请求和响应内容，完全规避Servlet层面的上下文问题：

import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class RemoteServiceHandler {

    private final RestTemplate restTemplate;

    public RemoteServiceHandler(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    public String handleForward(String requestBody, String remoteServiceUrl) {
        // 构建请求头
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(org.springframework.http.MediaType.APPLICATION_JSON);
        HttpEntity<String> requestEntity = new HttpEntity<>(requestBody, headers);

        // 调用远程服务
        ResponseEntity<String> responseEntity = restTemplate.exchange(
                remoteServiceUrl,
                HttpMethod.POST,
                requestEntity,
                String.class
        );
        String responseBody = responseEntity.getBody();

        // 存入数据库
        saveRequestResponse(remoteServiceUrl, requestBody, responseBody);

        return responseBody;
    }

    private void saveRequestResponse(String url, String requestBody, String responseBody) {
        // 数据库持久化逻辑
    }
}

优势 #

• 完全脱离Servlet API限制，代码更符合SpringBoot开发习惯。
• 无需处理上下文空指针问题，维护成本更低。
• 能灵活控制请求参数、超时、重试等逻辑。

方案三：自定义ServletResponseWrapper（适配特殊场景） #

如果必须用自定义Wrapper，要确保在Spring上下文内使用，避免空指针：

import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.PrintWriter;

public class CapturingResponseWrapper extends HttpServletResponseWrapper {
    private final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    private PrintWriter writer;

    public CapturingResponseWrapper(HttpServletResponse response) {
        super(response);
    }

    @Override
    public PrintWriter getWriter() throws IOException {
        if (writer == null) {
            writer = new PrintWriter(outputStream);
        }
        return writer;
    }

    public String getCapturedResponse() {
        if (writer != null) {
            writer.flush();
        }
        return outputStream.toString(getCharacterEncoding());
    }
}

在Controller中使用时，先包装响应再执行forward：

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.RequestDispatcher;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@RestController
public class ForwardController {

    @PostMapping("/forward")
    public void forward(HttpServletRequest request, HttpServletResponse response) throws IOException {
        // 捕获请求体（同样可以用ContentCachingRequestWrapper）
        String requestBody = new String(request.getInputStream().readAllBytes(), request.getCharacterEncoding());

        // 包装响应
        CapturingResponseWrapper responseWrapper = new CapturingResponseWrapper(response);

        // 执行forward
        RequestDispatcher dispatcher = request.getRequestDispatcher("/remote-service");
        dispatcher.forward(request, responseWrapper);

        // 获取响应内容并存库
        String responseBody = responseWrapper.getCapturedResponse();
        saveToDatabase(request.getRequestURI(), requestBody, responseBody);

        // 将响应写回客户端
        response.getWriter().write(responseBody);
        response.getWriter().flush();
    }
}

内容的提问来源于stack exchange，提问作者AdvMaple