异步httpclient(httpasyncclient)的使用与总结

最新推荐文章于 2024-08-23 15:02:01 发布
最新推荐文章于 2024-08-23 15:02:01 发布
阅读量654 收藏 1
点赞数
文章标签： java netty runtime
原文链接：http://www.cnblogs.com/aspirant/p/10333915.html
版权

参考：异步httpclient(httpasyncclient)的使用与总结

1. 前言
应用层的网络模型有同步与异步。同步意味当前线程是阻塞的，只有本次请求完成后才能进行下一次请求;异步意味着所有的请求可以同时塞入缓冲区,不阻塞当前的线程;

httpclient在4.x之后开始提供基于nio的异步版本httpasyncclient,httpasyncclient借助了Java并发库和nio进行封装(虽说NIO是同步非阻塞IO,但是HttpAsyncClient提供了回调的机制,与netty类似,所以可以模拟类似于AIO的效果),其调用方式非常便捷,但是其中也有许多需要注意的地方。

2. pom文件
本文依赖4.1.2,当前最新的客户端版本是4.1.3maven repository 地址

<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.5.2</version>
</dependency>

<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpcore</artifactId>
<version>4.4.5</version>
</dependency>

<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpcore-nio</artifactId>
<version>4.4.5</version>
</dependency>

<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpasyncclient</artifactId>
<version>4.1.2</version>
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
3. 简单的实例
public class TestHttpClient {
public static void main(String[] args){

RequestConfig requestConfig = RequestConfig.custom()
.setConnectTimeout(50000)
.setSocketTimeout(50000)
.setConnectionRequestTimeout(1000)
.build();

//配置io线程
IOReactorConfig ioReactorConfig = IOReactorConfig.custom().
setIoThreadCount(Runtime.getRuntime().availableProcessors())
.setSoKeepAlive(true)
.build();
//设置连接池大小
ConnectingIOReactor ioReactor=null;
try {
ioReactor = new DefaultConnectingIOReactor(ioReactorConfig);
} catch (IOReactorException e) {
e.printStackTrace();
}
PoolingNHttpClientConnectionManager connManager = new PoolingNHttpClientConnectionManager(ioReactor);
connManager.setMaxTotal(100);
connManager.setDefaultMaxPerRoute(100);


final CloseableHttpAsyncClient client = HttpAsyncClients.custom().
setConnectionManager(connManager)
.setDefaultRequestConfig(requestConfig)
.build();


//构造请求
String url = "http://127.0.0.1:9200/_bulk";
HttpPost httpPost = new HttpPost(url);
StringEntity entity = null;
try {
String a = "{ \"index\": { \"_index\": \"test\", \"_type\": \"test\"} }\n" +
"{\"name\": \"上海\",\"age\":33}\n";
entity = new StringEntity(a);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
httpPost.setEntity(entity);

//start
client.start();

//异步请求
client.execute(httpPost, new Back());

while(true){
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

static class Back implements FutureCallback<HttpResponse>{

private long start = System.currentTimeMillis();
Back(){
}

public void completed(HttpResponse httpResponse) {
try {
System.out.println("cost is:"+(System.currentTimeMillis()-start)+":"+EntityUtils.toString(httpResponse.getEntity()));
} catch (IOException e) {
e.printStackTrace();
}
}

public void failed(Exception e) {
System.err.println(" cost is:"+(System.currentTimeMillis()-start)+":"+e);
}

public void cancelled() {

}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
4. 几个重要的参数
4.1 TimeOut(3个)的设置


ConnectTimeout : 连接超时,连接建立时间,三次握手完成时间。
SocketTimeout : 请求超时,数据传输过程中数据包之间间隔的最大时间。
ConnectionRequestTimeout : 使用连接池来管理连接,从连接池获取连接的超时时间。

在实际项目开发过程中,这三个值可根据具体情况设置。

(1) 下面针对ConnectionRequestTimeout的情况进行分析

实验条件:设置连接池最大连接数为1,每一个异步请求从开始到回调的执行时间在100ms以上;

实验过程:连续发送2次请求

public class TestHttpClient {
public static void main(String[] args){

RequestConfig requestConfig = RequestConfig.custom()
.setConnectTimeout(50000)
.setSocketTimeout(50000)
.setConnectionRequestTimeout(10)//设置为10ms
.build();

//配置io线程
IOReactorConfig ioReactorConfig = IOReactorConfig.custom().
setIoThreadCount(Runtime.getRuntime().availableProcessors())
.setSoKeepAlive(true)
.build();
//设置连接池大小
ConnectingIOReactor ioReactor=null;
try {
ioReactor = new DefaultConnectingIOReactor(ioReactorConfig);
} catch (IOReactorException e) {
e.printStackTrace();
}
PoolingNHttpClientConnectionManager connManager = new PoolingNHttpClientConnectionManager(ioReactor);
connManager.setMaxTotal(1);//最大连接数设置1
connManager.setDefaultMaxPerRoute(1);//per route最大连接数设置1


final CloseableHttpAsyncClient client = HttpAsyncClients.custom().
setConnectionManager(connManager)
.setDefaultRequestConfig(requestConfig)
.build();


//构造请求
String url = "http://127.0.0.1:9200/_bulk";
List<HttpPost> list = new ArrayList<HttpPost>();
for(int i=0;i<2;i++){
HttpPost httpPost = new HttpPost(url);
StringEntity entity = null;
try {
String a = "{ \"index\": { \"_index\": \"test\", \"_type\": \"test\"} }\n" +
"{\"name\": \"上海\",\"age\":33}\n";
entity = new StringEntity(a);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
httpPost.setEntity(entity);
list.add(httpPost);
}

client.start();

for(int i=0;i<2;i++){
client.execute(list.get(i), new Back());
}

while(true){
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

static class Back implements FutureCallback<HttpResponse>{

private long start = System.currentTimeMillis();
Back(){
}

public void completed(HttpResponse httpResponse) {
try {
System.out.println("cost is:"+(System.currentTimeMillis()-start)+":"+EntityUtils.toString(httpResponse.getEntity()));
} catch (IOException e) {
e.printStackTrace();
}
}

public void failed(Exception e) {
e.printStackTrace();
System.err.println(" cost is:"+(System.currentTimeMillis()-start)+":"+e);
}

public void cancelled() {

}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
实验结果 :
第一次请求执行时间在200ms左右
第二请求回调直接抛出TimeOutException


java.util.concurrent.TimeoutException
at org.apache.http.nio.pool.AbstractNIOConnPool.processPendingRequest(AbstractNIOConnPool.java:364)
at org.apache.http.nio.pool.AbstractNIOConnPool.processNextPendingRequest(AbstractNIOConnPool.java:344)
at org.apache.http.nio.pool.AbstractNIOConnPool.release(AbstractNIOConnPool.java:318)
at org.apache.http.impl.nio.conn.PoolingNHttpClientConnectionManager.releaseConnection(PoolingNHttpClientConnectionManager.java:303)
at org.apache.http.impl.nio.client.AbstractClientExchangeHandler.releaseConnection(AbstractClientExchangeHandler.java:239)
at org.apache.http.impl.nio.client.MainClientExec.responseCompleted(MainClientExec.java:387)
at org.apache.http.impl.nio.client.DefaultClientExchangeHandlerImpl.responseCompleted(DefaultClientExchangeHandlerImpl.java:168)
at org.apache.http.nio.protocol.HttpAsyncRequestExecutor.processResponse(HttpAsyncRequestExecutor.java:436)
at org.apache.http.nio.protocol.HttpAsyncRequestExecutor.inputReady(HttpAsyncRequestExecutor.java:326)
at org.apache.http.impl.nio.DefaultNHttpClientConnection.consumeInput(DefaultNHttpClientConnection.java:265)
at org.apache.http.impl.nio.client.InternalIODispatch.onInputReady(InternalIODispatch.java:81)
at org.apache.http.impl.nio.client.InternalIODispatch.onInputReady(InternalIODispatch.java:39)
at org.apache.http.impl.nio.reactor.AbstractIODispatch.inputReady(AbstractIODispatch.java:114)
at org.apache.http.impl.nio.reactor.BaseIOReactor.readable(BaseIOReactor.java:162)
at org.apache.http.impl.nio.reactor.AbstractIOReactor.processEvent(AbstractIOReactor.java:337)
at org.apache.http.impl.nio.reactor.AbstractIOReactor.processEvents(AbstractIOReactor.java:315)
at org.apache.http.impl.nio.reactor.AbstractIOReactor.execute(AbstractIOReactor.java:276)
at org.apache.http.impl.nio.reactor.BaseIOReactor.execute(BaseIOReactor.java:104)
at org.apache.http.impl.nio.reactor.AbstractMultiworkerIOReactor$Worker.run(AbstractMultiworkerIOReactor.java:588)
at java.lang.Thread.run(Thread.java:745)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
结果分析：由于连接池大小是1,第一次请求执行后连接被占用(时间在100ms),第二次请求在规定的时间内无法获取连接,于是直接连接获取的TimeOutException

(2) 修改ConnectionRequestTimeout

RequestConfig requestConfig = RequestConfig.custom()
.setConnectTimeout(50000)
.setSocketTimeout(50000)
.setConnectionRequestTimeout(1000)//设置为1000ms
.build();
1
2
3
4
5
上述两次请求正常执行。

下面进一步看一下代码中抛异常的地方：

 

 

从上面的代码中可以看到如果要设置永不ConnectionRequestTimeout，只需要将ConnectionRequestTimeout设置为小于0即可,当然后这种设置一定要慎用, 如果处理不当,请求堆积会导致OOM。

4.2 连接池大小的设置


ConnTotal:连接池中最大连接数;
ConnPerRoute(1000):分配给同一个route(路由)最大的并发连接数,route为运行环境机器到目标机器的一条线路,举例来说,我们使用HttpClient的实现来分别请求 www.baidu.com 的资源和 www.bing.com 的资源那么他就会产生两个route;

对于上述的实验,在一定程度上可以通过增大最大连接数来解决ConnectionRequestTimeout的问题！

后续：本文重点在于使用，后续会对源码进行分析与解读

HttpAsyncClient 的简单使用

下载地址：http://hc.apache.org/downloads.cgi

在NetBeans中导入以下jar文件：

1：一次请求：

复制代码 
 public static void oneReuest(){
        final CloseableHttpAsyncClient httpClient = HttpAsyncClients.createDefault();
        httpClient.start();
        final HttpGet request = new HttpGet("http://www.apache.org/");
        final Future future = httpClient.execute(request, null);
        try {
            HttpResponse response = (HttpResponse) future.get();
            System.out.println("Response:" + response.getStatusLine());
            System.out.println("Shutting down");
        } catch (Exception ex) {
            Logger.getLogger(Httpasyncclient.class.getName()).log(Level.SEVERE, null, ex);
        }finally{
            try {
                httpClient.close();
            } catch (IOException ex) {
                Logger.getLogger(Httpasyncclient.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        
        System.out.println("执行完毕");
    }
复制代码

2：多次异步请求：

复制代码 
 public static void moreRequest(){
        final RequestConfig requestConfitg = RequestConfig.custom()
                .setSocketTimeout(3000)
                .setConnectTimeout(3000).build();
        
        final CloseableHttpAsyncClient httpClient = HttpAsyncClients.custom()
                .setDefaultRequestConfig(requestConfitg)
                .build();
        
        httpClient.start();
        
        final HttpGet[] requests = new HttpGet[]{
            new HttpGet("http://www.apache.org/"),
            new HttpGet("http://www.baidu.com/"),
            new HttpGet("http://www.oschina.net/")
        };
        
        final CountDownLatch latch = new CountDownLatch(requests.length);
        for(final HttpGet request: requests){
            
                httpClient.execute(request, new FutureCallback(){
                    @Override
                    public void completed(Object obj) {
                       final HttpResponse response = (HttpResponse)obj;
                       latch.countDown();
                       System.out.println(request.getRequestLine() + "->" + response.getStatusLine());
                    }

                    @Override
                    public void failed(Exception excptn) {
                        latch.countDown();
                        System.out.println(request.getRequestLine() + "->" + excptn);
                    }

                    @Override
                    public void cancelled() {
                        latch.countDown();
                        System.out.println(request.getRequestLine() + "cancelled");
                    }
                });
         }       
        
        try {
            latch.await();
            System.out.println("Shutting Down");
        } catch (InterruptedException ex) {
            Logger.getLogger(Httpasyncclient.class.getName()).log(Level.SEVERE, null, ex);
        }finally{
            try {
                httpClient.close();
            } catch (IOException ex) {
                Logger.getLogger(Httpasyncclient.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        System.out.println("Finish!");
    }
复制代码

运行结果：

复制代码 
run:
GET http://www.baidu.com/ HTTP/1.1->HTTP/1.1 200 OK
GET http://www.oschina.net/ HTTP/1.1->HTTP/1.1 200 OK
GET http://www.apache.org/ HTTP/1.1->HTTP/1.1 200 OK
Shutting Down
Finish!
成功构建 (总时间: 2 秒)

可以看出是异步执行的！不是按照我们传入的URL参数顺序执行的！
复制代码

 

篇提到了高性能处理的关键是异步，而我们当中许多人依旧在使用同步模式的HttpClient访问第三方Web资源，我认为原因之一是：异步的HttpClient诞生较晚，许多人不知道；另外也可能是大多数Web程序其实不在意这点性能损失了。

而要自己实现一个异步的HttpClient则比较困难，通常都是自己开一个新的工作线程，利用HttpClient的同步去访问，完成后再回调这种形式，这样做其实不是真正的异步，因为依旧会有一个线程处于阻塞中，等待着第三方Web资源的返回。

而如今访问第三方Web资源的情景越来越多，最典型就是使用第三方登录平台，如QQ或微信等，我们需要访问腾讯的服务器去验证登录者的身份，根据我的经验，这个过程可能会阻塞好几秒钟，可看作是一个“长时间调用”，所以最好要使用异步方式。

OK，废话少说，要使用异步的HttpClient，请Maven中带上：

        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpasyncclient</artifactId>
            <version>4.1.1</version>
        </dependency>

接下来是一个完整的Demo代码：

复制代码 
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.concurrent.FutureCallback;
import org.apache.http.impl.nio.client.CloseableHttpAsyncClient;
import org.apache.http.impl.nio.client.HttpAsyncClients;
import org.apache.http.util.EntityUtils;

import java.io.IOException;
import java.util.concurrent.CountDownLatch;

public class Main {
    public static void main(String[] argv) {
        CloseableHttpAsyncClient httpclient = HttpAsyncClients.createDefault();
        httpclient.start();

        final CountDownLatch latch = new CountDownLatch(1);
        final HttpGet request = new HttpGet("https://www.alipay.com/");

        System.out.println(" caller thread id is : " + Thread.currentThread().getId());

        httpclient.execute(request, new FutureCallback<HttpResponse>() {

            public void completed(final HttpResponse response) {
                latch.countDown();
                System.out.println(" callback thread id is : " + Thread.currentThread().getId());
                System.out.println(request.getRequestLine() + "->" + response.getStatusLine());
                try {
                    String content = EntityUtils.toString(response.getEntity(), "UTF-8");
                    System.out.println(" response content is : " + content);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            public void failed(final Exception ex) {
                latch.countDown();
                System.out.println(request.getRequestLine() + "->" + ex);
                System.out.println(" callback thread id is : " + Thread.currentThread().getId());
            }

            public void cancelled() {
                latch.countDown();
                System.out.println(request.getRequestLine() + " cancelled");
                System.out.println(" callback thread id is : " + Thread.currentThread().getId());
            }

        });
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        try {
            httpclient.close();
        } catch (IOException ignore) {

        }
    }
}
复制代码

 呃……代码很简单，好像也没什么好说的了，稍作封装就可以实现如“getJson()”这样的方法。

也许你还注意到了，这个HttpClient跟同步的版本一样，直接支持https，但如果网站的证书是自签的，默认还是不行的，解决方法当然有，但代码有些麻烦，我觉得还不如直接买张证书来得简单，如果网站是你管的话。

参考：Java的异步HttpClient

参考：HttpAsyncClient 的简单使用

转载于:https://www.cnblogs.com/aspirant/p/10333915.html

diaopai5230
关注
SpringBoot整合ES（异步HttpClient和Http连接池）
IT_但丁的博客
07-30 3219
目录知识点一、引入pom二、配置文件 application-local.yml三、config包1、ElasticSearchProperty2、ElasticSearchConfig3、HttpClientPoolConfig4、同步HttpClient5、WebServerConfiguration三、utils包1、EsUtils四、批量更新和下载左右1、Service 知识点 RestHighLevelClient使用 异步HttpClient创建 HTTP连接池 ES 游标使用 一、引入p
异步HttpClient
04-21
一个工作时写的工具包。实现了Java版的Promise 和 HttpClient。HttpClient 支持同步和异步两种方式，也支持多种不同实现。目前有Netty 和 Apache Compoenet两种实现。本次上传移除了Netty实现。主要解决生产环境中同步httpclient造成的IO阻塞问题。同步http请求将导致 tomcat 的业务线程被阻塞。一旦某接口网络出现问题，可能会阻塞tomcat业务线程，从而无法处理正常业务。很多公司使用另开线程池的方式进行异步调用来解决tomcat线程阻塞问题。但由于本系统中接口网络太不稳定，使用线程池也将导致线程池中的线程不断加大，不管使用怎样的线程池策略，最终要么线程池线程全部挂起，要么部分任务被延迟执行，要么丢失部分任务。这在我们的系统中仍然不能接受。因此才有了这个组件的开发。该组件是单线程非阻塞式的，类似于JS中的ajax请求。都使用单线程异步回调的方式。目前该组件已经初步测试通过。如果大家也需要这样的组件，可以下载尝试一下。所有关键注释都已经写了，如有不明白可以发送邮件 ath.qu.trues@gmail.com 代码分为3个maven模块。 commons-ext : 实现Promise commons-tools： 实现 异步httpclient commons-parent：父模块 测试代码在 commons-tools/src/test/java/HttpTest.java 中. 要求至少Java 8 版本。 注释已经写好。这里贴出异步的http部分测试代码。 /** * 异步方法的Fluent写法 */ public void testAsyncHttpFluent() { SimpleRequest.Get("http://www.baidu.com") .header("h1", "hv1") .header("h2", "hv2") .parameter("p1", "pv1") .parameter("p2", "pv2") .chartUTF8() .build() .asyncExecute() .then(SimpleAsyncHttpClient::asString) .then(html -> { System.out.println(html); }) .catching(Throwable::printStackTrace);//如果有异常，则打印异常 }
HttpAsyncClient的连接池使用
weixin_34168880的博客
05-09 495
代码示例 public static void main(String[] args) throws Exception { ConnectingIOReactor ioReactor = new DefaultConnectingIOReactor(); PoolingNHttpClientConnectionManager cm = new P...
AsyncHttpClient 用法
最新发布
qq_33240556的博客
08-23 517
是一个非阻塞的 HTTP 客户端库，用于 Java 和 Android 平台。它允许你异步地发送 HTTP 请求，这对于提高应用程序性能和响应性非常有用。以下是使用 AsyncHttpClient 的一些基本示例。
Java的异步HttpClient
anw53724的博客
05-05 160
上篇提到了高性能处理的关键是异步，而我们当中许多人依旧在使用同步模式的HttpClient访问第三方Web资源，我认为原因之一是：异步的HttpClient诞生较晚，许多人不知道；另外也可能是大多数Web程序其实不在意这点性能损失了。 而要自己实现一个异步的HttpClient则比较困难，通常都是自己开一个新的工作线程，利用HttpClient的同步去访问，完成后再回调这种形式，这样做...
HttpAsyncClient
java 学习路
12-16 194
参考： [url]http://wangxinchun.iteye.com/blog/2136254[/url] [url]http://wangxinchun.iteye.com/blog/2156660[/url] [url]http://wangxinchun.iteye.com/blog/2166837[/url] 调用http接口，是否可以异步？ 答案当然是可以。 方...
HttpAsyncClient 异步httpClient和同步httpClient连接池的工具类 包含jar
03-22
HttpAsyncClient连接池的使用,项目中频繁发送http请求,同步http阻塞主线程,影响性能,使用 HttpAsyncClient可使性能提高,这里配合连接池使用,效果更好,同时还附带同步httpClient的连接池使用
HttpAsyncClient 4.1 异步HttpCLient
07-21
HttpAsyncClient基于事件驱动的编程模型，使用非阻塞 I/O 模型。HttpAsyncClient 并不是要替换 Apache 的 HttpClient ，二者是互补关系，在一些需要进行大量并发连接的客户端以及对性能要求比较高的场景下，...
java实现HttpClient异步请求资源的方法
09-03
本篇文章将详细介绍如何使用Java的HttpClient实现异步请求资源。 首先，让我们了解什么是异步请求。在同步请求中，调用一个API或发送一个HTTP请求后，程序会等待响应返回，然后继续执行后续代码。而异步请求则不同...
HttpAsyncClient异步http工具包
12-17
HttpAsyncClient是Apache HttpClient项目的一部分，它是一个强大的Java库，用于执行HTTP请求，特别是强调异步非阻塞I/O操作。这个工具包被设计用来处理大量并发请求，这对于现代Web应用和服务来说非常重要，因为它们...
HttpClient异步请求
07-11
HttpClient，发送异步请求，get、post请求
使用HttpClient异步请求数据
07-23
HttpClient与Asynctask与服务器的结合使用
java之httpclient的一些破事
iteye_14356的博客
01-06 521
本文偏重使用，简单讲述httpclient，其实在网络编程中，基于java的实现几乎都是包装了socket的通信，然后来模拟各种各样的协议；httpclient其实就是模拟浏览器发起想服务器端的请求，而这种更加类似于JS的请求或页面的POST、GET，不过这种数据的返回一般需要得到有意义的数据，才方便做其他的交互，否则得到一个页面结果，全是标签了，毕竟不是浏览器，所以我们用httpclie...
HttpAsynClient 使用
fengxing_2的专栏
12-05 2479
1、引入maven依赖 <!-- httpclient - httpasyncclient --> <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpclie...
异步httpclient---HttpAsyncClient的使用
java的平凡之路
06-26 4322
这两天研究了一下异步的httpclient ---- httpAsyncClient原来使用httpclient都是同步的,如果项目中有大量的httpclient的话,可能会造成阻塞,如果使用异步请求的话可以避免这些问题可以用在调用第三方接口或者不需要知道请求返回结果的场景下于是写了一个工具类来封装了同步异步httpclientgithub地址：https://github.com/a638817...
异步的AsyncHttpClient使用详解
热门推荐
只有想不到没有做不到，程序的力量。。。
02-16 4万+
背景        前面的一篇文章【同步的HttpClient使用详解】中，提到了服务端通进行网络请求的方式。也讲述了在并发量大的情况下使用HttpClient的连接池来提高性能。此方法虽然很有效果，但是当访问量极大或网络不好的情况下也会出现某些网络请求慢导致其它请求阻塞的情况，为此本文引入了异步的HttpClient包，将网络请求变成一个异步的请求，不影响其它的请求。 异步httpClien...
httpclient 池化，异步化
小小程序猿
11-12 1297
import lombok.extern.slf4j.Slf4j; import org.apache.http.client.config.RequestConfig; import org.apache.http.impl.nio.client.CloseableHttpAsyncClient; import org.apache.http.impl.nio.client.HttpAsy...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值