如何实现无JSON-POJO映射的REST请求全量转发？支持Spring及其他框架

嘿，这个需求Spring完全能搞定，甚至不用折腾JSON和POJO的映射，直接做纯透传转发就可以！我给你几个实用的实现方案，你可以根据自己的项目情况选：

这种方式适合传统的Spring MVC项目，直接操作原始请求/响应的字节流，完全跳过对象转换步骤：

@RestController
@RequestMapping("/proxy")
public class ProxyController {

    private final RestTemplate restTemplate;
    private final String backendBaseUrl = "http://your-backend-service";

    // 构造注入RestTemplate（记得在配置类里实例化RestTemplate）
    public ProxyController(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    // 匹配所有HTTP方法和路径
    @RequestMapping(value = "/**", method = {RequestMethod.GET, RequestMethod.POST, RequestMethod.PUT, RequestMethod.DELETE})
    public void proxyRequest(HttpServletRequest request, HttpServletResponse response) throws IOException {
        // 拼接后端目标URL：去掉/proxy前缀，保留原始路径和查询参数
        String requestPath = request.getRequestURI().replace("/proxy", "");
        String targetUrl = backendBaseUrl + requestPath;
        if (request.getQueryString() != null) {
            targetUrl += "?" + request.getQueryString();
        }

        // 用RestTemplate的execute方法做字节流透传
        restTemplate.execute(targetUrl, HttpMethod.valueOf(request.getMethod()),
                // 处理请求：复制原始请求头和请求体
                clientHttpRequest -> {
                    // 复制请求头
                    Enumeration<String> headerNames = request.getHeaderNames();
                    while (headerNames.hasMoreElements()) {
                        String headerName = headerNames.nextElement();
                        clientHttpRequest.getHeaders().add(headerName, request.getHeader(headerName));
                    }
                    // 复制请求体到RestTemplate的请求中
                    try (InputStream inputStream = request.getInputStream();
                         OutputStream outputStream = clientHttpRequest.getBody()) {
                        inputStream.transferTo(outputStream);
                    }
                },
                // 处理响应：复制后端响应头和响应体到客户端
                clientHttpResponse -> {
                    // 复制响应头
                    clientHttpResponse.getHeaders().forEach((key, values) -> {
                        values.forEach(value -> response.addHeader(key, value));
                    });
                    // 设置响应状态码
                    response.setStatus(clientHttpResponse.getStatusCode().value());
                    // 复制响应体到客户端输出流
                    try (InputStream inputStream = clientHttpResponse.getBody();
                         OutputStream outputStream = response.getOutputStream()) {
                        inputStream.transferTo(outputStream);
                    }
                    return null;
                });
    }
}

这种方式的核心就是直接操作InputStream和OutputStream，完全不涉及任何JSON序列化/反序列化，请求和响应都是原样透传。

如果你的项目用了Spring WebFlux，或者需要更高的并发性能，用WebClient的响应式处理会更高效：

@RestController
@RequestMapping("/proxy")
public class ProxyController {

    private final WebClient webClient;
    private final String backendBaseUrl = "http://your-backend-service";

    public ProxyController(WebClient.Builder webClientBuilder) {
        this.webClient = webClientBuilder.baseUrl(backendBaseUrl).build();
    }

    @RequestMapping(value = "/**", method = {RequestMethod.GET, RequestMethod.POST, RequestMethod.PUT, RequestMethod.DELETE})
    public Mono<Void> proxyRequest(HttpServletRequest request, ServerHttpResponse response) {
        // 拼接目标路径
        String requestPath = request.getRequestURI().replace("/proxy", "");
        String targetPath = request.getQueryString() != null ? requestPath + "?" + request.getQueryString() : requestPath;

        // 复制原始请求头
        HttpHeaders headers = new HttpHeaders();
        Enumeration<String> headerNames = request.getHeaderNames();
        while (headerNames.hasMoreElements()) {
            String headerName = headerNames.nextElement();
            headers.add(headerName, request.getHeader(headerName));
        }

        // 读取原始请求体为响应式DataBuffer
        Mono<DataBuffer> requestBody = DataBufferUtils.readInputStream(
                request::getInputStream, new DefaultDataBufferFactory(), 4096);

        // 转发请求并透传响应
        return webClient.method(HttpMethod.valueOf(request.getMethod()))
                .uri(targetPath)
                .headers(httpHeaders -> httpHeaders.addAll(headers))
                .body(requestBody, DataBuffer.class)
                .exchangeToMono(clientResponse -> {
                    // 复制响应状态码和响应头
                    response.setStatusCode(clientResponse.statusCode());
                    clientResponse.headers().asHttpHeaders().forEach((key, values) -> {
                        values.forEach(value -> response.getHeaders().add(key, value));
                    });
                    // 透传响应体到客户端
                    return response.writeWith(clientResponse.bodyToFlux(DataBuffer.class));
                });
    }
}

WebClient用响应式的DataBuffer处理字节流，性能比RestTemplate更好，同样能做到完全透传。

如果你的核心需求就是做API网关代理，那Spring Cloud Gateway是最适合的，甚至不用写一行业务代码，配置就能搞定：

在application.yml里添加配置：

spring:
  cloud:
    gateway:
      routes:
        - id: backend-proxy-route
          uri: http://your-backend-service
          predicates:
            - Path=/proxy/**  # 匹配所有/proxy开头的请求
          filters:
            - StripPrefix=1   # 去掉请求路径中的/proxy前缀，再转发到后端

这样所有访问/proxy/**的请求都会被自动转发到后端服务，请求头、请求体、响应头、响应体都是完全原样透传，连代码都不用写，非常省心。

• 请求头过滤：有些请求头（比如Host、Connection）可能不需要转发，你可以在代码或网关配置中添加过滤逻辑，避免后端服务出现异常。
• 文件上传下载：上面的所有方案都支持文件传输，因为都是直接处理字节流，不会破坏任何数据格式。
• 异常处理：可以在代码中添加try-catch块，捕获后端服务不可达等异常，返回友好的错误响应给客户端；用Gateway的话可以配置全局异常过滤器。

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