HttpClient高级进阶ConnectionManager

  • Z时代
  • 2024-01-10
  • 分类：综合

编程

简述

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

用于单线程连接的BasicHttpClientConnectionManager

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

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

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

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

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

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

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

在HttpClient上设置PoolingHttpClientConnectionManager

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

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

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

HttpGet get1 =newHttpGet("");
HttpGet get2 =newHttpGet("");
PoolingHttpClientConnectionManager connManager 
=newPoolingHttpClientConnectionManager();
CloseableHttpClient client1 
= HttpClients.custom().setConnectionManager(connManager).build();
CloseableHttpClient client2 
= HttpClients.custom().setConnectionManager(connManager).build();
MultiHttpClientConnThread thread1
=newMultiHttpClientConnThread(client1, get1);
MultiHttpClientConnThread thread2
=newMultiHttpClientConnThread(client2, get2);
thread1.start();
thread2.start();
thread1.join();
thread2.join();

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

自定义线程执行 GET请求

publicclassMultiHttpClientConnThread extends Thread {
privateCloseableHttpClient client;
privateHttpGetget;
// standard constructors
publicvoidrun(){
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 
=newPoolingHttpClientConnectionManager();
connManager.setMaxTotal(5);
connManager.setDefaultMaxPerRoute(4);
HttpHost host =newHttpHost("www.baeldung.com",80);
connManager.setMaxPerRoute(newHttpRoute(host),5);

让我们回顾一下API：

  • setMaxTotal（int max）：设置最大总打开连接数。

  • setDefaultMaxPerRoute（int max）：设置每条路由的最大并发连接数，默认为2。

  • setMaxPerRoute（int max）：设置指向特定路由的并发连接总数，默认为2。

因此，在不更改默认值的情况下，我们将很容易地达到连接管理器的限制 。让我们看看它是如何看起来的：

使用线程执行连接

HttpGetget=newHttpGet("http://localhost:8080");
PoolingHttpClientConnectionManager connManager 
=newPoolingHttpClientConnectionManager();
CloseableHttpClient client = HttpClients.custom().
setConnectionManager(connManager).build();
MultiHttpClientConnThread thread1 
=newMultiHttpClientConnThread(client,get);
MultiHttpClientConnThread thread2 
=newMultiHttpClientConnThread(client,get);
MultiHttpClientConnThread thread3 
=newMultiHttpClientConnThread(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 =newConnectionKeepAliveStrategy(){
    @Override
publiclonggetKeepAliveDuration(HttpResponse response,HttpContext context){
HeaderElementIterator it =newBasicHeaderElementIterator
(response.headerIterator(HTTP.CONN_KEEP_ALIVE));
while(it.hasNext()){
HeaderElement he = it.nextElement();
String param = he.getName();
Stringvalue= he.getValue();
if(value!=null&& param.equalsIgnoreCase
("timeout")){
return Long.parseLong(value)*1000;
}
}
return5*1000;
}
};

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

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

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

连接持久性/重用

HTTP / 1.1规范规定，如果连接尚未关闭，则可以重新使用连接 - 这称为连接持久性。

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

BasicHttpClientConnectionManager 连接重用

BasicHttpClientConnectionManager basicConnManager =
newBasicHttpClientConnectionManager();
HttpClientContext context = HttpClientContext.create();
// low level
HttpRoute route =newHttpRoute(newHttpHost("",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 =newHttpRequestExecutor();
context.setTargetHost((newHttpHost("",80)));
HttpGetget=newHttpGet("");
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：重新使用与线程的连接

HttpGetget=newHttpGet("");
PoolingHttpClientConnectionManager connManager 
=newPoolingHttpClientConnectionManager();
connManager.setDefaultMaxPerRoute(5);
connManager.setMaxTotal(5);
CloseableHttpClient client = HttpClients.custom()
.setConnectionManager(connManager)
.build();
MultiHttpClientConnThread[] threads 
=newMultiHttpClientConnThread[10];
for(int i =0; i < threads.length; i++){
    threads[i]=newMultiHttpClientConnThread(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 =newHttpRoute(newHttpHost("http://localhost:8080",80));
PoolingHttpClientConnectionManager connManager 
=newPoolingHttpClientConnectionManager();
connManager.setSocketConfig(route.getTargetHost(),SocketConfig.custom().
setSoTimeout(5000).build());

连接监控

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

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

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

设置HttpClient以检查过时连接

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

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

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

该IdleConnectionMonitorThread 类列举如下：

publicclassIdleConnectionMonitorThreadextendsThread{
privatefinalHttpClientConnectionManager connMgr;
privatevolatileboolean shutdown;
publicIdleConnectionMonitorThread(
PoolingHttpClientConnectionManager connMgr){
super();
this.connMgr = connMgr;
}
@Override
publicvoidrun(){
try{
while(!shutdown){
synchronized(this){
wait(1000);
                    connMgr.closeExpiredConnections();
                    connMgr.closeIdleConnections(30,TimeUnit.SECONDS);
}
}
}catch(InterruptedException ex){
shutdown();
}
}
publicvoidshutdown(){
        shutdown =true;
synchronized(this){
notifyAll();
}
}
}

连接关闭

可以正常关闭连接（尝试在关闭之前刷新输出缓冲区），或通过调用shutdown方法（未刷新输出缓冲区）强制关闭连接。

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

  • 消耗并关闭响应（如果可以关闭）

  • 关闭客户端

  • 关闭并关闭连接管理器

关闭连接和释放资源

connManager =newPoolingHttpClientConnectionManager();
CloseableHttpClient client = HttpClients.custom()
.setConnectionManager(connManager).build();
HttpGet get =newHttpGet("");
CloseableHttpResponse response = client.execute(get);
EntityUtils.consume(response.getEntity());
response.close();
client.close();
connManager.close();

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

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

结论

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

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



作者：油腻的Java


链接：https://www.jianshu.com/p/d88c08fd0581


来源：简书


著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

以上是 HttpClient高级进阶ConnectionManager 的全部内容， 来源链接： utcz.com/z/518711.html

回到顶部