Spring Boot模拟服务实现无响应断连的方案求助

Got it, let's break this down. The core issue here is that Spring Boot's default request handling pipeline will always try to send some kind of response—even if you throw an exception, the exception handler kicks in and sends an error payload. To simulate a sudden crash where the connection drops with zero response, you need to bypass that pipeline entirely and directly manipulate the underlying HTTP connection.

Here are two reliable approaches depending on whether you're using Spring MVC (Servlet stack) or Spring WebFlux (Reactive stack):

For Spring MVC (Servlet Stack) #

The trick is to grab the raw HttpServletResponse and close the output stream (or force-close the connection for extra thoroughness) before Spring can generate a response. This tells the server to drop the connection immediately without sending any headers or body.

Controller-Based Approach #

@RestController
@RequestMapping("/simulate-crash")
public class CrashSimulationController {

    @GetMapping
    public void simulateUnexpectedCrash(HttpServletResponse response) throws IOException {
        // Close the output stream to terminate the response early
        response.getOutputStream().close();
        
        // Optional: For Tomcat users, force the connection to close (more aggressive)
        if (response instanceof org.apache.catalina.connector.Response) {
            var coyoteResponse = ((org.apache.catalina.connector.Response) response).getCoyoteResponse();
            coyoteResponse.action(org.apache.coyote.ActionCode.CLOSE, null);
        }
    }
}

Filter-Based Approach (More Isolated) #

If you want to keep this logic separate from your controllers, use a Filter to intercept the request and drop the connection before it reaches the controller:

@Component
public class CrashSimulationFilter implements Filter {

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException {
        HttpServletRequest httpReq = (HttpServletRequest) request;
        if ("/simulate-crash".equals(httpReq.getRequestURI())) {
            // Close the response stream immediately
            response.getOutputStream().close();
            
            // Optional Tomcat-specific connection close
            if (response instanceof org.apache.catalina.connector.Response) {
                ((org.apache.catalina.connector.Response) response).getCoyoteResponse()
                    .action(org.apache.coyote.ActionCode.CLOSE, null);
            }
            return; // Skip the rest of the filter chain and controller logic
        }
        chain.doFilter(request, response);
    }
}

For Spring WebFlux (Reactive Stack) #

In the reactive world, you need to interact with the underlying server connection directly. If you're using Netty (the default WebFlux server), you can grab the connection and dispose of it to simulate a crash:

@RestController
@RequestMapping("/simulate-crash")
public class CrashSimulationController {

    @GetMapping
    public Mono<Void> simulateUnexpectedCrash(ServerWebExchange exchange) {
        // Get the Netty connection from the exchange attributes
        Connection connection = exchange.getRequiredAttribute(Connection.class);
        
        // Dispose the connection to drop it immediately
        connection.dispose();
        
        // Return an empty Mono so Spring doesn't attempt to send a response
        return Mono.empty();
    }
}

Key Notes: #

• Why exceptions don't work: Spring's exception handling mechanism is designed to catch exceptions and convert them into valid HTTP responses (like 500 Internal Server Error). To get a silent drop, you need to avoid triggering this mechanism entirely.
• Container Compatibility: The Tomcat-specific connection close is optional but ensures a more aggressive disconnect. For Jetty or Undertow, you'd need to use their respective APIs, but the standard response.getOutputStream().close() works across most containers.
• Mock Service Stability: Neither of these approaches will crash your mock service—you're just telling the server to terminate a single connection, not shutting down the entire application context.

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