I checked because the response was strange when debugging with Tomcat 8

When I was debugging a web application accessing the server with ajax, the response was strange for some reason. Neither the response body nor the HTTP header is returned as expected. I investigated the cause, so I summarized it.

Execution environment

• Tomcat8.0
• SpringMVC --Run Tomcat in Eclipse for debugging --For the time being, the process was to access the Web application with ajax and fetch a fixed value response to check the operation.

Test.java

@RestController
public class TestController {

    @RequestMapping(value = "/test.do", produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
    public String test(HttpServletRequest request) throws Exception {
        return "{ \"success\" : true }";
    }
}

ajax.js

var req = new XMLHttpRequest();
req.open("POST", "test.do");
req.send();

Status

--Because I was able to break in the test method of TestController, there is no URL error etc. --HTTP status 200 is returned --I also checked Filter and Interceptor, but there is no process that changes the response. Rather, the expected content was stored in the response object. --There is no difference between browsers. Weird response is returned in every browser --Sometimes a normal response is returned

Cause

When I went deeper and deeper in the step execution, an exception was thrown in `` `NioChannel.class``` in tomcat-coyote.jar.

NioChannel.class

/**
 * This method should be used to check the interrupt status before
 * attempting a write.
 *
 * If a thread has been interrupted and the interrupt has not been cleared
 * then an attempt to write to the socket will fail. When this happens the
 * socket is removed from the poller without the socket being selected. This
 * results in a connection limit leak for NIO as the endpoint expects the
 * socket to be selected even in error conditions.
 */
protected void checkInterruptStatus() throws IOException {
    if (Thread.interrupted()) {
         throw new IOException(sm.getString("channel.nio.interrupted"));
    }
}

This exception was caught in the upper layer and rewritten as a response for the error.

• Thread.interrupted () * is a method that returns `` `true``` when a thread is interrupted. There is no particular process that causes an interrupt, so speaking of interrupts that can occur in this situation ... ** Break by debugger **. When I tried it, it surely gave a strange response only when it broke.

Afterword

I had a stack trace of this exception on the console every time, but I was ignoring it because it returned 200. If it looks like an error, you can't ignore it. But I think it's a terrible trap.