简述
本文介绍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连接的高效且协议兼容的使用。
作者:油腻的Java
链接:https://www.jianshu.com/p/d88c08fd0581
来源:简书
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
来源:oschina
链接:https://my.oschina.net/newchaos/blog/4436564