Apache HttpClient 连接管理

codingman included in HTTP Client-Side

2019-09-04 2905 words 6 minutes

Contents

1. 概述

在本文中，我们将介绍 HttpClient 4 中连接管理的基础知识。

我们将介绍使用BasichttpClientConnectionManager和PoolingHttpClientConnectionManager来强制安全、符合协议和高效地使用 HTTP 连接。

2. 用于低级单线程连接的BasicHttpClientConnectionManager

BasicHttpClientConnectionManager自 HttpClient 4.3.3 起作为 HTTP 连接管理器的最简单实现可用。它用于创建和管理一次只能由一个线程使用的单个连接。

2.1. **获取低级连接的连接请求（HttpClientConnection）**

BasicHttpClientConnectionManager connManager
 = new BasicHttpClientConnectionManager();
HttpRoute route = new HttpRoute(new HttpHost("www.blogdemo.com", 80));
ConnectionRequest connRequest = connManager.requestConnection(route, null);

requestConnection方法从管理器获取连接池，用于连接特定route。route参数指定到目标主机或目标主机本身的“代理跃点”路由。

可以直接使用HttpClientConnection执行请求，但请记住，这种低级方法很冗长且难以管理。低级连接对于访问套接字和连接数据（例如超时和目标主机信息）很有用，但对于标准执行，HttpClient是一个更容易处理的 API。

3. 使用PoolingHttpClientConnectionManager获取和管理多线程连接池

PoolingHttpClientConnectionManager将为我们使用的每个路由或目标主机创建和管理一个连接池。管理器可以打开的并发连接池的默认大小是**每个路由或目标主机为 2，打开的连接总数为 20 。**首先——让我们看看如何在一个简单的 HttpClient 上设置这个连接管理器：

3.1. 在 HttpClient 上设置 PoolingHttpClientConnectionManager

HttpClientConnectionManager poolingConnManager
  = new PoolingHttpClientConnectionManager();
CloseableHttpClient client
 = HttpClients.custom().setConnectionManager(poolingConnManager)
 .build();
client.execute(new HttpGet("/"));
assertTrue(poolingConnManager.getTotalStats().getLeased() == 1);

接下来——让我们看看在两个不同线程中运行的两个 HttpClient 是如何使用同一个连接管理器的：

3.2. 使用两个 HttpClient 分别连接到一个目标主机

HttpGet get1 = new HttpGet("/");
HttpGet get2 = new HttpGet("http://google.com"); 
PoolingHttpClientConnectionManager connManager 
  = new PoolingHttpClientConnectionManager(); 
CloseableHttpClient client1 
  = HttpClients.custom().setConnectionManager(connManager).build();
CloseableHttpClient client2 
  = HttpClients.custom().setConnectionManager(connManager).build();
MultiHttpClientConnThread thread1
 = new MultiHttpClientConnThread(client1, get1); 
MultiHttpClientConnThread thread2
 = new MultiHttpClientConnThread(client2, get2); 
thread1.start();
thread2.start();
thread1.join();
thread2.join();

请注意，我们正在使用一个非常简单的自定义线程实现——这里是：

3.3. **执行GET 请求的自定义线程**

public class MultiHttpClientConnThread extends Thread {
    private CloseableHttpClient client;
    private HttpGet get;
    
    // standard constructors
    public void run(){
        try {
            HttpResponse response = client.execute(get);  
            EntityUtils.consume(response.getEntity());
        } catch (ClientProtocolException ex) {    
        } catch (IOException ex) {
        }
    }
}

请注意**EntityUtils.consume(response.getEntity)调用 - 需要消耗响应（实体）的全部内容，以便管理器可以将连接释放回池。

4. 配置连接管理器

池连接管理器的默认值选择得很好，但是——取决于你的用例——可能太小了。所以 - 让我们看看我们如何配置：

连接总数
每条（任何）路由的最大连接数
每条特定路由的最大连接数

4.1. 在默认限制之外增加可以打开和管理的连接数

PoolingHttpClientConnectionManager connManager 
  = new PoolingHttpClientConnectionManager();
connManager.setMaxTotal(5);
connManager.setDefaultMaxPerRoute(4);
HttpHost host = new HttpHost("www.blogdemo.com", 80);
connManager.setMaxPerRoute(new HttpRoute(host), 5);

让我们回顾一下 API：

setMaxTotal(int max)：设置总打开连接的最大数量。
setDefaultMaxPerRoute(int max)：设置每个路由的最大并发连接数，默认为 2。
setMaxPerRoute(int max)：设置特定路由的并发连接总数，默认为2。

因此，在不更改默认值的情况下，我们将很容易达到连接管理器的极限——让我们看看它是什么样子的：

4.2. 使用线程执行连接

HttpGet get = new HttpGet("http://www.blogdemo.com");
PoolingHttpClientConnectionManager connManager 
  = new PoolingHttpClientConnectionManager();
CloseableHttpClient client = HttpClients.custom().
    setConnectionManager(connManager).build();
MultiHttpClientConnThread thread1 
  = new MultiHttpClientConnThread(client, get);
MultiHttpClientConnThread thread2 
  = new MultiHttpClientConnThread(client, get);
MultiHttpClientConnThread thread3 
  = new MultiHttpClientConnThread(client, get);
thread1.start();
thread2.start();
thread3.start();
thread1.join();
thread2.join();
thread3.join();

正如我们已经讨论过的，每个主机的连接限制默认为 2。所以，在这个例子中，我们试图让 3 个线程向同一个主机发出 3 个请求，但只会并行分配 2 个连接。

让我们看一下日志——我们有 3 个线程在运行，但只有 2 个租用连接：

[Thread-0] INFO  o.b.h.c.MultiHttpClientConnThread
 - Before - Leased Connections = 0
[Thread-1] INFO  o.b.h.c.MultiHttpClientConnThread
 - Before - Leased Connections = 0
[Thread-2] INFO  o.b.h.c.MultiHttpClientConnThread
 - Before - Leased Connections = 0
[Thread-2] INFO  o.b.h.c.MultiHttpClientConnThread
 - After - Leased Connections = 2
[Thread-0] INFO  o.b.h.c.MultiHttpClientConnThread
 - After - Leased Connections = 2

5. 连接保活策略

引用 HttpClient 4.3.3。参考：“如果Keep-Alive响应中不存在标头，则HttpClient假定连接可以无限期地保持活动状态。” （请参阅 HttpClient 参考）。

为了解决这个问题，并且能够管理死连接，我们需要一个定制的策略实现并将其构建到HttpClient中。

5.1. 自定义保持活动策略

ConnectionKeepAliveStrategy myStrategy = new ConnectionKeepAliveStrategy() {
    @Override
    public long getKeepAliveDuration(HttpResponse response, HttpContext context) {
        HeaderElementIterator it = new BasicHeaderElementIterator
            (response.headerIterator(HTTP.CONN_KEEP_ALIVE));
        while (it.hasNext()) {
            HeaderElement he = it.nextElement();
            String param = he.getName();
            String value = he.getValue();
            if (value != null && param.equalsIgnoreCase
               ("timeout")) {
                return Long.parseLong(value) * 1000;
            }
        }
        return 5 * 1000;
    }
};

此策略将首先尝试应用标头中说明的主机的Keep-Alive策略。如果响应标头中不存在该信息，它将保持活动连接 5 秒。

现在——让我们用这个自定义策略创建一个客户端：

PoolingHttpClientConnectionManager connManager 
  = new PoolingHttpClientConnectionManager();
CloseableHttpClient client = HttpClients.custom()
  .setKeepAliveStrategy(myStrategy)
  .setConnectionManager(connManager)
  .build();

6. 连接持久性/重用

HTTP/1.1 规范指出，如果连接没有关闭，则可以重新使用它们——这被称为连接持久性。

管理器释放连接后，它会保持打开状态以供重复使用。当使用只能管理单个连接的BasicHttpClientConnectionManager 时，必须在重新租回之前释放连接：

6.1. BasicHttpClientConnectionManager连接重用

BasicHttpClientConnectionManager basicConnManager = 
    new BasicHttpClientConnectionManager();
HttpClientContext context = HttpClientContext.create();
// low level
HttpRoute route = new HttpRoute(new HttpHost("www.blogdemo.com", 80));
ConnectionRequest connRequest = basicConnManager.requestConnection(route, null);
HttpClientConnection conn = connRequest.get(10, TimeUnit.SECONDS);
basicConnManager.connect(conn, route, 1000, context);
basicConnManager.routeComplete(conn, route, context);
HttpRequestExecutor exeRequest = new HttpRequestExecutor();
context.setTargetHost((new HttpHost("www.blogdemo.com", 80)));
HttpGet get = new HttpGet("http://www.blogdemo.com");
exeRequest.execute(get, conn, context);
basicConnManager.releaseConnection(conn, null, 1, TimeUnit.SECONDS);
// high level
CloseableHttpClient client = HttpClients.custom()
  .setConnectionManager(basicConnManager)
  .build();
client.execute(get);

让我们来看看会发生什么。

首先——请注意，我们首先使用的是低级连接，以便我们可以完全控制何时释放连接，然后是使用 HttpClient 的普通高级连接。复杂的低级逻辑在这里不是很相关——我们唯一关心的是releaseConnection调用。这释放了唯一可用的连接并允许它被重用。

然后，客户端再次成功执行 GET 请求。如果我们跳过释放连接，我们将从 HttpClient 获得 IllegalStateException：

java.lang.IllegalStateException: Connection is still allocated
  at o.a.h.u.Asserts.check(Asserts.java:34)
  at o.a.h.i.c.BasicHttpClientConnectionManager.getConnection
    (BasicHttpClientConnectionManager.java:248)

请注意，现有连接并未关闭，只是释放然后被第二个请求重新使用。

与上面的示例相比，PoolingHttpClientConnectionManager允许透明地重用连接，而无需隐式释放连接：

6.2. PoolingHttpClientConnectionManager :重用线程连接

HttpGet get = new HttpGet("http://echo.200please.com");
PoolingHttpClientConnectionManager connManager 
  = new PoolingHttpClientConnectionManager();
connManager.setDefaultMaxPerRoute(5);
connManager.setMaxTotal(5);
CloseableHttpClient client = HttpClients.custom()
  .setConnectionManager(connManager)
  .build();
MultiHttpClientConnThread[] threads 
  = new  MultiHttpClientConnThread[10];
for(int i = 0; i < threads.length; i++){
    threads[i] = new MultiHttpClientConnThread(client, get, connManager);
}
for (MultiHttpClientConnThread thread: threads) {
     thread.start();
}
for (MultiHttpClientConnThread thread: threads) {
     thread.join(1000);     
}

上面的例子有 10 个线程，执行 10 个请求但只共享 5 个连接。

当然，这个例子依赖于服务器的Keep-Alive超时。为确保连接在重新使用之前不会中断，建议使用Keep-Alive策略配置客户端。

7. 配置超时——使用连接管理器的套接字超时

配置连接管理器时唯一可以设置的超时是套接字超时：

7.1. 将套接字超时设置为 5 秒

HttpRoute route = new HttpRoute(new HttpHost("www.blogdemo.com", 80));
PoolingHttpClientConnectionManager connManager 
  = new PoolingHttpClientConnectionManager();
connManager.setSocketConfig(route.getTargetHost(),SocketConfig.custom().
    setSoTimeout(5000).build());

有关 HttpClient 中的超时的更深入讨论 -请参阅此。

8. 连接驱逐

连接驱逐用于检测空闲和过期的连接并关闭它们；有两种选择可以做到这一点。

依赖HttpClient在执行请求之前检查连接是否过时。这是一个昂贵的选择，并不总是可靠的。
创建一个监控线程来关闭空闲和/或关闭的连接。

8.1. **设置HttpClient以检查陈旧的连接**

PoolingHttpClientConnectionManager connManager 
  = new PoolingHttpClientConnectionManager();
CloseableHttpClient client = HttpClients.custom().setDefaultRequestConfig(
    RequestConfig.custom().setStaleConnectionCheckEnabled(true).build()
).setConnectionManager(connManager).build();

8.2. 使用陈旧的连接监视器线程

PoolingHttpClientConnectionManager connManager 
  = new PoolingHttpClientConnectionManager();
CloseableHttpClient client = HttpClients.custom()
  .setConnectionManager(connManager).build();
IdleConnectionMonitorThread staleMonitor
 = new IdleConnectionMonitorThread(connManager);
staleMonitor.start();
staleMonitor.join(1000);

下面列出了IdleConnectionMonitorThread类：

public class IdleConnectionMonitorThread extends Thread {
    private final HttpClientConnectionManager connMgr;
    private volatile boolean shutdown;
    public IdleConnectionMonitorThread(
      PoolingHttpClientConnectionManager connMgr) {
        super();
        this.connMgr = connMgr;
    }
    @Override
    public void run() {
        try {
            while (!shutdown) {
                synchronized (this) {
                    wait(1000);
                    connMgr.closeExpiredConnections();
                    connMgr.closeIdleConnections(30, TimeUnit.SECONDS);
                }
            }
        } catch (InterruptedException ex) {
            shutdown();
        }
    }
    public void shutdown() {
        shutdown = true;
        synchronized (this) {
            notifyAll();
        }
    }
}

9. 连接关闭

可以优雅地关闭连接（尝试在关闭之前刷新输出缓冲区），或者通过调用关闭方法强制关闭（不刷新输出缓冲区）。

要正确关闭连接，我们需要执行以下所有操作：

消费并关闭响应（如果可关闭）
关闭客户端
关闭并关闭连接管理器

9.1. 关闭连接并释放资源

connManager = new PoolingHttpClientConnectionManager();
CloseableHttpClient client = HttpClients.custom()
  .setConnectionManager(connManager).build();
HttpGet get = new HttpGet("http://google.com");
CloseableHttpResponse response = client.execute(get);
EntityUtils.consume(response.getEntity());
response.close();
client.close();
connManager.close();

如果管理器在没有关闭连接的情况下关闭 - 所有连接都将关闭并释放所有资源。

请务必记住，这不会刷新现有连接可能正在进行的任何数据。