HttpClient高级进阶-ConnectionManager

简述

本文介绍HttpClient的链接管理，主要介绍使用BasichttpClientConnectionManager和PoolingHttpClientConnectionManager来实现强制安全，协议兼容和有效使用HTTP链接。

用于单线程链接的BasicHttpClientConnectionManager

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

获取低级别链接的链接请求（HttpClientConnection）

BasicHttpClientConnectionManager connManager
 = new BasicHttpClientConnectionManager();
HttpRoute route = new HttpRoute(new HttpHost("http://localhost:8080", 80));
ConnectionRequest connRequest = connManager.requestConnection(route, null);

复制代码

该requestConnection方法从connManager获得的链接池的特定路线来链接。该路线参数指定的“代理跳”到目标主机或目标主机自己的路由。

能够直接使用HttpClientConnection执行请求，但请记住，这种低级方法很冗长且难以管理。低级链接对于socket和http（如超时和目标主机信息）颇有用，但对于标准执行，HttpClient是一个更容易使用的API。

使用PoolingHttpClientConnectionManager获取和管理多线程链接池

该PoolingHttpClientConnectionManager将建立并管理咱们使用的每一个路线或目标主机的链接池。首先，让咱们看看如何在一个简单的HttpClient上设置这个链接管理器：

在HttpClient上设置PoolingHttpClientConnectionManager

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

接下来，让咱们看看两个不一样线程中运行的两个HttpClient如何使用相同的ConnectionManager：

使用两个HttpClient链接到每一个目标主机

HttpGet get1 = new HttpGet("");
HttpGet get2 = new HttpGet(""); 
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();
复制代码

请注意，咱们使用的是一个很是简单的自定义线程实现，这里是：

自定义线程执行 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）调用，必须使用响应的所有内容（实体），以便manager能够将链接释放回池中。

配置ConnectionManager

ConnectionManager默认配置选择很好，可是，根据你的使用状况，会存在可能过小的状况，那么，让咱们来看看咱们如何配置：

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

增长能够打开和管理的链接数超出默认限制

PoolingHttpClientConnectionManager connManager 
  = new PoolingHttpClientConnectionManager();
connManager.setMaxTotal(5);
connManager.setDefaultMaxPerRoute(4);
HttpHost host = new HttpHost("www.baeldung.com", 80);
connManager.setMaxPerRoute(new HttpRoute(host), 5);
复制代码

让咱们回顾一下API：

• setMaxTotal（int max）：设置最大总打开链接数。
• setDefaultMaxPerRoute（int max）：设置每条路由的最大并发链接数，默认为2。
• setMaxPerRoute（int max）：设置指向特定路由的并发链接总数，默认为2。

所以，在不更改默认值的状况下，咱们将很容易地达到链接管理器的限制 。让咱们看看它是如何看起来的：

使用线程执行链接

HttpGet get = new HttpGet("http://localhost:8080");

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个链接。

让咱们来看看日志 - 咱们有三个线程正在运行，但只有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
复制代码

长链接策略

引用HttpClient 4.3.3。reference：“ 若是Keep-Alive响应中没有标头，HttpClient假定链接能够无限期保持活动。”。

为了解决这个问题，而且可以管理死链接，咱们须要一个自定义的策略实现并将其构建到HttpClient中。

自定义保持长链接策略

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();
复制代码

链接持久性/重用

HTTP / 1.1规范规定，若是链接还没有关闭，则能够从新使用链接 - 这称为链接持久性。

一旦管理员发布链接，它就会保持开放状态以便重复使用。使用只能管理单个链接的BasicHttpClientConnectionManager时，必须先释放链接，而后再将其从新租用：

BasicHttpClientConnectionManager 链接重用

BasicHttpClientConnectionManager basicConnManager = 
    new BasicHttpClientConnectionManager();
HttpClientContext context = HttpClientContext.create();
 
// low level
HttpRoute route = new HttpRoute(new HttpHost("", 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("", 80)));
HttpGet get = new HttpGet("");
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容许透明地链接重用，而无需隐式释放链接：

PoolingHttpClientConnectionManager：从新使用与线程的链接

HttpGet get = new HttpGet("");
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策略配置客户端。

使用Connection Manager配置超时-Socket

配置链接管理器时惟一能够设置的超时是Socket：

将Socket超时设置为5秒

HttpRoute route = new HttpRoute(new HttpHost("http://localhost:8080", 80));
PoolingHttpClientConnectionManager connManager 
  = new PoolingHttpClientConnectionManager();
connManager.setSocketConfig(route.getTargetHost(),SocketConfig.custom().
    setSoTimeout(5000).build());
复制代码

链接监控

链接断开用于检测空闲和过时链接并关闭它们 ; 有两种选择能够作到这一点。

在执行请求以前依赖HttpClient来检查链接是否异常。这是一个耗时的选择，并不老是最优的。

建立监视器线程以关闭空闲和/或关闭的链接。

设置HttpClient以检查过期链接

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

使用异常的链接监视器线程

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();
        }
    }
}
复制代码

链接关闭

能够正常关闭链接（尝试在关闭以前刷新输出缓冲区），或经过调用shutdown方法（未刷新输出缓冲区）强制关闭链接。

要正确关闭链接，咱们须要执行如下全部操做：

• 消耗并关闭响应（若是能够关闭）
• 关闭客户端
• 关闭并关闭链接管理器

关闭链接和释放资源

connManager = new PoolingHttpClientConnectionManager();
CloseableHttpClient client = HttpClients.custom()
  .setConnectionManager(connManager).build();
HttpGet get = new HttpGet("");
CloseableHttpResponse response = client.execute(get);
 
EntityUtils.consume(response.getEntity());
response.close();
client.close();
connManager.close();
复制代码

若是管理器在没有链接关闭的状况下关闭，全部链接都将关闭并释放全部资源。

重要的是要记住，这不会刷新现有链接可能正在进行的任何数据。

结论

在本文中，咱们讨论了如何使用HttpClient的HTTP ConnectionManager API来处理管理链接的整个过程，从打开和分配链接，管理多个代理的并发使用，到最终关闭它们。

咱们看到BasicHttpClientConnectionManager是一个处理单个链接的简单解决方案，以及它如何管理低级链接。咱们还了解了PoolingHttpClientConnectionManager如何与HttpClient API 结合使用，以提供HTTP链接的高效且协议兼容的使用。