Analysis and Solutions for java.io.IOException: Broken Pipe in Jetty and Spring MVC

Exception Phenomenon and Background

During the migration of legacy applications from Glassfish to Jetty, we encountered a typical network connection exception. The stack trace shows that the exception originates from org.eclipse.jetty.io.EofException, with the ultimate root cause being java.io.IOException: Broken pipe. Notably, these exceptions are always triggered by 404 requests, specifically manifested in Spring MVC's DispatcherServlet.noHandlerFound method.

Root Cause Analysis

The essence of the Broken pipe exception is that one party in the communication closes the connection before data transmission is complete. In typical client-server architecture, when a client (such as a browser) unexpectedly closes the connection while the server is still sending responses, this exception is triggered. This situation is particularly common in the following scenarios:

// Simulating client premature connection closure scenario
SocketChannel clientChannel = SocketChannel.open();
clientChannel.connect(new InetSocketAddress("localhost", 8080));
// Client closes connection before receiving complete response
clientChannel.close();
// Server will throw Broken pipe exception when attempting to write data

In load balancing environments, connection timeout settings of proxy servers (like Nginx) can also cause similar issues. When the proxy server does not receive a response from the backend server within the specified time, it actively closes the connection, triggering Broken pipe when the backend server attempts to continue writing.

Local Reproduction Methods

To reproduce this exception, create a simple test scenario:

@Test
public void testBrokenPipeScenario() throws Exception {
    // Start Jetty server
    Server server = new Server(8080);
    ServletContextHandler context = new ServletContextHandler();
    context.setContextPath("/");
    
    // Add a Servlet with delayed response
    context.addServlet(new ServletHolder(new HttpServlet() {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
            throws ServletException, IOException {
            // Simulate long processing request
            Thread.sleep(5000);
            resp.getWriter().write("Response data");
        }
    }), "/*");
    
    server.setHandler(context);
    server.start();
    
    // Client closes connection before server response completion
    URL url = new URL("http://localhost:8080/test");
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.setConnectTimeout(1000);
    connection.setReadTimeout(1000); // Set short timeout
    
    try {
        connection.getResponseCode();
    } catch (SocketTimeoutException e) {
        // Expected timeout exception
    }
    
    server.stop();
}

Solutions and Best Practices

For Broken pipe exceptions, we provide the following solutions:

1. Connection Timeout Optimization

Adjust connection timeout parameters in proxy server configuration. Using Nginx as an example:

location / {
    proxy_pass http://backend_server;
    proxy_read_timeout 120s;  // Increase read timeout
    proxy_connect_timeout 60s; // Increase connection timeout
}

2. Exception Handling Mechanism

Add global exception handlers at the application level:

@ControllerAdvice
public class GlobalExceptionHandler {
    
    private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
    
    @ExceptionHandler(ClientAbortException.class)
    public void handleClientAbort(ClientAbortException ex) {
        // Log warning instead of error to avoid log flooding
        logger.warn("Client connection aborted: {}", ex.getMessage());
    }
    
    @ExceptionHandler(IOException.class)
    public void handleIOExceptions(IOException ex) {
        if (ex.getMessage() != null && ex.getMessage().contains("Broken pipe")) {
            logger.warn("Broken pipe detected, client likely closed connection");
            return; // Silent handling to avoid stack trace flooding
        }
        logger.error("Unexpected IO exception", ex);
    }
}

3. Log Configuration Optimization

Reduce Broken pipe exception log output through log configuration:

# logback.xml configuration
<logger name="org.eclipse.jetty" level="WARN"/>
<logger name="org.springframework.web.servlet" level="WARN"/>

Performance Impact and Monitoring

In high-concurrency scenarios, frequent Broken pipe exceptions can significantly impact server performance. Each exception generates a complete stack trace, involving expensive I/O operations. Recommendations:

• Monitor exception frequency and set threshold alerts
• Optimize response size to reduce transmission time
• Implement connection pool management to reuse healthy connections

Conclusion

Broken pipe exceptions are common network issues in distributed systems, typically caused by client behavior or network conditions. Through reasonable timeout configuration, comprehensive exception handling mechanisms, and optimized logging strategies, their impact can be effectively mitigated. When migrating or maintaining web applications, understanding the root causes of these exceptions and implementing appropriate protective measures is crucial.