Undertow反向代理读取HTTP请求体及内部响应遇死锁求助

Got it, let's break down this problem and fix it step by step. That UT000126 error is a classic Undertow gotcha—here's why it's happening and how to resolve it:

Why You're Seeing This Error #

Undertow enforces a strict separation between IO threads (lightweight, dedicated to fast non-blocking network operations) and worker threads (for heavy/blocking processing). When you try to do blocking IO (like reading the request input stream directly) from an IO thread, Undertow throws this exception to prevent thread starvation and deadlocks. IO threads are a limited resource—hogging them with blocking calls will grind your server to a halt.

Step 1: Move Request Body Reading to a Worker Thread #

First, offload the body-reading logic from the IO thread to a worker thread using exchange.dispatch(). This tells Undertow to run your code in a safe thread context:

// Instead of calling getBody directly in the IO thread
exchange.dispatch(exchange -> {
    String body = getBody(exchange);
    // Proceed with your proxy logic using the body
});

Step 2: Read the Body Safely (and Cache It for Proxy Forwarding) #

Your getBody method is likely using blocking reads, and since request bodies can only be read once, you need to cache the content so the reverse proxy can still forward it to the backend. Here's a corrected, thread-safe version:

private String getBody(HttpServerExchange exchange) {
    try {
        // Cache the request body to allow repeated reads
        CachedHttpRequest cachedRequest = CachedHttpRequest.cacheRequest(exchange);
        // Read from the cached stream (safe to do in a worker thread)
        String body = new String(IOUtils.readBytes(cachedRequest.getInputStream()), StandardCharsets.UTF_8);
        
        // Reset the exchange's request stream so the proxy can read it too
        exchange.setRequestInputStream(cachedRequest.getInputStream());
        return body;
    } catch (IOException e) {
        throw new RuntimeException("Failed to read request body", e);
    }
}

Note: Use Undertow's built-in IOUtils (from io.undertow.util) instead of custom stream readers for better compatibility.

Step 3: Add Response Headers Correctly in Reverse Proxy #

For modifying the backend response headers, don't mix this with body-reading logic. Use Undertow's ResponseListener to hook into the proxy lifecycle safely:

ReverseProxyClient proxyClient = // Your existing proxy client setup
ReverseProxyHandler proxyHandler = proxyClient.createProxyHandler(
    "http://your-backend-server",
    new ResponseListener() {
        @Override
        public void handleResponse(HttpServerExchange exchange, HttpResponseStatus status, HttpHeaders headers) {
            // Add your custom header here
            headers.add("X-Custom-Proxy-Header", "your-custom-value");
        }
    }
);

This listener runs at the right point in the proxy workflow, and Undertow ensures it's executed in a thread-safe context.

Key Takeaways #

• Avoid blocking IO on IO threads: Always dispatch heavy/blocking work to worker threads with exchange.dispatch().
• Cache request bodies: If you need to read the body and still forward it, use CachedHttpRequest to avoid consuming the stream once.
• Leverage Undertow's built-in APIs: They're designed to handle thread safety and stream lifecycle correctly—no need to reinvent the wheel.

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