Springboot TomcatEmbeddedServletContainer KeepAliveTimeout不工作

Question

我已经将spring boot嵌入式tomcat服务器中的保持活动超时设置为30秒。因此，我在应用程序中使用下面的内容。JAVA

@Bean   
public EmbeddedServletContainerFactory getEmbeddedServletContainerFactory() {
    TomcatEmbeddedServletContainerFactory containerFactory = new TomcatEmbeddedServletContainerFactory();
    containerFactory
            .addConnectorCustomizers(new TomcatConnectorCustomizer() {
                @Override
                public void customize(Connector connector) {
                    ((AbstractProtocol) connector.getProtocolHandler())
                            .setKeepAliveTimeout(30000);
                }
            });

    return containerFactory;
}

然后我从我的Rest控制器Hibernate一个请求线程40秒。但是当我通过postman发出请求时，它成功返回HTTP状态代码200，而不是返回网关超时错误。

我尝试setConnectionTimeout和setKeepAliveTimeout，但它不起作用。

我错过了什么？

编辑问题：我最初的问题

让我解释一下我最初的问题，这使我提出了上述问题。

我有一个很长的投票过程，通常运行大约5分钟以上。

所以发生的事情是，当我调用的Rest API的长民意调查，2.2分钟后，我得到一个504超文本传输协议错误的浏览器。

我正在使用AWS环境，其中我有一个ELB和一个HAProxy，安装在AWS EC2实例中。

根据AWS文件，ELB的默认空闲连接超时为60秒。所以我把它增加到30分钟。

而且它说,，

如果使用HTTP和HTTPS侦听器，我们建议为EC2实例启用保活选项。您可以在Web服务器设置或EC2实例的内核设置中启用保活。

因此，将嵌入式tomcat保持存活超时（如上面的代码片段）增加到30.2分钟

所以现在我希望我的长投票请求可以完成，而不会出现504的错误。但我仍然得到504错误在浏览器？

参考： AWS开发指南

Answer 1

看起来您想关闭可能发生在移动设备上的废弃HTTP连接。

@RestController
@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @Bean
    public EmbeddedServletContainerFactory getEmbeddedServletContainerFactory() {
        TomcatEmbeddedServletContainerFactory containerFactory = new TomcatEmbeddedServletContainerFactory();
        containerFactory
                .addConnectorCustomizers(new TomcatConnectorCustomizer() {
                    @Override
                    public void customize(Connector connector) {
                        ((AbstractProtocol) connector.getProtocolHandler()).setConnectionTimeout(100);
                    }
                });

        return containerFactory;
    }

    @RequestMapping
    public String echo(@RequestBody String body) {
        return body;
    }
}

连接超时已设置为100毫秒，以便快速运行测试。数据分块发送。在每个区块之间，运行的线程将暂停x毫秒。

@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = DemoApplication.class)
@WebIntegrationTest("server.port:19000")
public class DemoApplicationTests {

    private static final int CHUNK_SIZE = 1;
    private static final String HOST = "http://localhost:19000/echo";

    @Rule
    public ExpectedException expectedException = ExpectedException.none();

    @Test
    public void slowConnection() throws Exception {
        final HttpURLConnection connection = openChunkedConnection();
        OutputStreamWriter out = new OutputStreamWriter(connection.getOutputStream());

        writeAndWait(500, out, "chunk1");
        writeAndWait(1, out, "chunk2");

        out.close();

        expectedException.expect(IOException.class);
        expectedException.expectMessage("Server returned HTTP response code: 400 for URL: " + HOST);

        assertResponse("chunk1chunk2=", connection);
    }

    @Test
    public void fastConnection() throws Exception {
        final HttpURLConnection connection = openChunkedConnection();
        OutputStreamWriter out = new OutputStreamWriter(connection.getOutputStream());

        writeAndWait(1, out, "chunk1");
        writeAndWait(1, out, "chunk2");

        out.close();

        assertResponse("chunk1chunk2=", connection);
    }

    private void assertResponse(String expected, HttpURLConnection connection) throws IOException {
        Scanner scanner = new Scanner(connection.getInputStream()).useDelimiter("\\A");
        Assert.assertEquals(expected, scanner.next());
    }

    private void writeAndWait(int millis, OutputStreamWriter out, String body) throws IOException, InterruptedException {
        out.write(body);
        Thread.sleep(millis);
    }

    private HttpURLConnection openChunkedConnection() throws IOException {
        final URL url = new URL(HOST);
        final HttpURLConnection  connection = (HttpURLConnection) url.openConnection();
        connection.setDoOutput(true);
        connection.setChunkedStreamingMode(CHUNK_SIZE);
        return connection;
    }
}

为包org设置日志级别。阿帕奇。卡塔琳娜。核心至调试

logging.level.org.apache.catalina.core=DEBUG

对于slowConnection测试，您可以看到一个SocketTimeoutException。

我不知道为什么您希望HTTP状态代码502作为错误响应状态。HTTP 502说：

502（坏网关）状态代码表示服务器在充当网关或代理时，从试图完成请求时访问的入站服务器收到了无效响应。

客户端Postman调用服务器应用程序。我没有看到中间有任何网关或代理。

如果你只是把你的问题浓缩到最低限度，在现实中你想建立一个你自己的代理，你可以考虑使用Netflix ZUUL。

更新日期：2016年3月23日：

这就是OP对Stackoverflow提出问题的根本原因：

我对longpolling所做的是，从服务api中，我让线程Hibernate一段时间，然后唤醒它，然后一次又一次地这样做，直到某个db状态完成。

该实现实际上阻止Tomcat工作线程处理新的HTTP请求。因此，每增加一次长时间运行的操作，您的请求吞吐量就会降低。

我建议将长时间运行的操作卸载到一个单独的线程中。客户端（浏览器）启动新请求以获取结果。根据处理状态，服务器返回结果或通知/错误/警告/。

这里有一个非常简单的例子：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import static org.springframework.http.HttpStatus.CREATED;
import static org.springframework.http.HttpStatus.NOT_FOUND;
import static org.springframework.http.HttpStatus.OK;

@RestController
@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    private ExecutorService executorService = Executors.newFixedThreadPool(10);
    private Map<String, String> results = new ConcurrentHashMap<>();

    @RequestMapping(path = "put/{key}", method = RequestMethod.POST)
    public ResponseEntity<Void> put(@PathVariable String key) {
        executorService.submit(() -> {
            try {
                //simulate a long running process
                Thread.sleep(10000);
                results.put(key, "success");
            } catch (InterruptedException e) {
                results.put(key, "error " + e.getMessage());
                Thread.currentThread().interrupt();
            }
        });
        return new ResponseEntity<>(CREATED);
    }

    @RequestMapping(path = "get/{key}", method = RequestMethod.GET)
    public ResponseEntity<String> get(@PathVariable String key) {
        final String result = results.get(key);
        return new ResponseEntity<>(result, result == null ? NOT_FOUND : OK);
    }
}