异步请求工具类支持CompletableFuture

最新推荐文章于 2024-04-27 08:30:40 发布
置顶 最新推荐文章于 2024-04-27 08:30:40 发布
阅读量790 收藏 4
点赞数 2
分类专栏： java 文章标签： http
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qichangleixin/article/details/116458195
版权

AsyncHttpClient（AHC）库允许Java应用程序轻松执行HTTP请求并异步处理HTTP响应。 该库还支持WebSocket协议。它的请求处理机制基于netty。作者@TomGranot

基于AsyncHttpClient和CompletableFuture，我编写了一个工具类。
AsyncHttpClient：异步执行请求
CompletableFuture：异步处理结果，并可聚合多个请求结果
完整代码已上传httpAsync

引入

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.asynchttpclient</groupId>
            <artifactId>async-http-client-bom</artifactId>
            <version>LATEST_VERSION</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <dependency>
    	<groupId>org.asynchttpclient</groupId>
    	<artifactId>async-http-client</artifactId>
    </dependency>
</dependencies>

异步http工具类

工具类包含一个客户端【HttpAsyncClient】和一个工具类【HttpAsyncUtil】

package com.isszwy.zhyq.util.httpAsync;

import static org.asynchttpclient.Dsl.asyncHttpClient;

import java.io.IOException;

import io.netty.channel.EventLoopGroup;
import io.netty.channel.epoll.EpollEventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;

import org.asynchttpclient.AsyncHttpClient;
import org.asynchttpclient.AsyncHttpClientConfig;
import org.asynchttpclient.DefaultAsyncHttpClientConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


public class HttpAsyncClient {
	
	private static Logger log = LoggerFactory.getLogger(HttpAsyncClient.class);
	
    private static final int connectTimeoutMilliseconds = 5000;
    private static final int requestTimeoutMilliseconds = 5000;
    private static final int readTimeoutTimeoutMilliseconds = 5000;
    private static final int maxRequestRetry = 2;
    private static EventLoopGroup eventLoopGroup;

    private static AsyncHttpClient asyncHttpClient;
    
    
    private HttpAsyncClient() {
    }

    public static AsyncHttpClient getInstance() {
        if (asyncHttpClient == null) {
            synchronized (AsyncHttpClient.class) {
                if (asyncHttpClient == null) {
                	asyncHttpClient = asyncHttpClient(initConfig());
                	log.info("===HttpAsyncClient初始化完成===");
                }
            }
        }
        return asyncHttpClient;
    }
    

    private static AsyncHttpClientConfig initConfig() {
    	
        String osName = System.getProperty("os.name");
        if ("Linux".equalsIgnoreCase(osName)) {
            eventLoopGroup = new EpollEventLoopGroup();
        } else {
            eventLoopGroup = new NioEventLoopGroup();
        }
        AsyncHttpClientConfig asyncHttpClientConfig = new DefaultAsyncHttpClientConfig
                .Builder()
                .setConnectTimeout(connectTimeoutMilliseconds)
                .setRequestTimeout(requestTimeoutMilliseconds)
                .setReadTimeout(readTimeoutTimeoutMilliseconds)
                .setEventLoopGroup(eventLoopGroup)
                //设置信任所有ssl
                .setUseInsecureTrustManager(true)
                .setMaxRequestRetry(maxRequestRetry)
                .build();
        return asyncHttpClientConfig;
    }

    
    public static void shutdown() {
        if (asyncHttpClient != null) {
            try {
                asyncHttpClient.close();
                eventLoopGroup.shutdownGracefully();
            } catch (IOException exception) {
            	log.error("===HttpAsyncClient关闭异常===",exception);
            }
        }
    }

    
}


package com.isszwy.zhyq.util.httpAsync;

import static io.netty.handler.codec.http.HttpHeaderValues.APPLICATION_JSON;
import static org.asynchttpclient.Dsl.*;
import io.netty.handler.codec.http.DefaultHttpHeaders;
import io.netty.handler.codec.http.HttpHeaders;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.function.Function;

import org.asynchttpclient.Param;
import org.asynchttpclient.Request;
import org.asynchttpclient.RequestBuilder;
import org.asynchttpclient.Response;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HttpAsyncUtil {
	
	private static Logger log = LoggerFactory.getLogger(HttpAsyncUtil.class);
	
	
	/**
     * 发送application/x-www-form-urlencoded请求
     * @param url
     * @return CompletableFuture<String>
     */
    public static CompletableFuture<String> doGet(String url) {  
        return doGet(url, null,null);  
    }
    
	/**
     * 发送application/x-www-form-urlencoded请求
     * @param url
     * @param param
     * @param header
     * @return CompletableFuture<String>
     */
	public static CompletableFuture<String> doGet(String url, Map<String, String> param,Map<String, String> header) {
		log.info("### request url : {} , param : {} , header : {} !",url,param,header);
    	RequestBuilder request = get(url);
    	if (header != null) {
    		HttpHeaders headers = new DefaultHttpHeaders();
            for (String key : header.keySet()) {
                headers.add(key, header.get(key));
            }
            request.setHeaders(headers);
        } 
    	if (param != null) {
    		List<Param> paramList = new ArrayList<>();  
    		for (String key : param.keySet()) {
    			if(param.get(key) !=null){
    				paramList.add(new Param(key, String.valueOf(param.get(key))));
    			}
    		}
    		request.setFormParams(paramList);
    	}
    	CompletableFuture<String> resultFuture= HttpAsyncClient.getInstance().
	    		prepareRequest(request).execute().toCompletableFuture()
	    					.exceptionally(new Function<Throwable, Response>() {
	    		            	@Override
	    		            	public Response apply(Throwable throwable) {
	    		            		System.out.println("exceptionally - apply ：" + throwable.toString());
	    		            		log.error("### send get request error occured !", throwable);
	    		            		return null;
	    		            	}
	    		            })
	    		            .thenApply(response -> {
	    		               if (response.getStatusCode() == 200) { 
	    		            		return response.getResponseBody();
	    		               }else{
	    		            		log.error("### get response error occured !", response.getResponseBody());
		    		               return null;
	    		               }
	    		            });
		return resultFuture;
	}
	
	
	
    public static CompletableFuture<String> doPost(String url) {  
        return doPost(url, null, null);
    }
	
	/**
     * 发送application/octet-stream请求
     * @param url
     * @param param
     * @param header
     * @return CompletableFuture<String>
     */
    public static CompletableFuture<String> doPost(String url, Map<String, String> param,Map<String, String> header) {
    	log.info("### request url : {} , param : {} , header : {} !",url,param,header);
    	RequestBuilder request = post(url);
    	if (header != null) {
    		HttpHeaders headers = new DefaultHttpHeaders();
            for (String key : header.keySet()) {
                headers.add(key, header.get(key));
            }
            request.setHeaders(headers);
        } 
    	if (param != null) {
    		List<Param> paramList = new ArrayList<>();  
    		for (String key : param.keySet()) {
    			if(param.get(key) !=null){
    				paramList.add(new Param(key, String.valueOf(param.get(key))));
    			}
    		}
    		request.setFormParams(paramList);
    	}
    	CompletableFuture<String> resultFuture= HttpAsyncClient.getInstance().
	    		prepareRequest(request).execute().toCompletableFuture()
	    					.exceptionally(new Function<Throwable, Response>() {
	    		            	@Override
	    		            	public Response apply(Throwable throwable) {
	    		            		System.out.println("exceptionally - apply ：" + throwable.toString());
	    		            		log.error("### send Post request error occured !", throwable);
	    		            		return null;
	    		            	}
	    		            })
	    		            .thenApply(response -> {
	    		               if (response.getStatusCode() == 200) { 
	    		            		return response.getResponseBody();
	    		               }else{
	    		            		log.error("### get Post response error occured !", response.getResponseBody());
		    		               return null;
	    		               }
	    		            });
		return resultFuture;
    }
	
	/**
     * 发送application/json请求
     * @param url
     * @param json
     * @return CompletableFuture<String>
     */
	public static CompletableFuture<String> doPostJson(String url, String json){
        Request request = post(url).setBody(json).setHeader("content-type", APPLICATION_JSON).build();
	    CompletableFuture<String> resultFuture= HttpAsyncClient.getInstance().
	    		prepareRequest(request).execute().toCompletableFuture()
	    					.exceptionally(new Function<Throwable, Response>() {
	    		            	@Override
	    		            	public Response apply(Throwable throwable) {
	    		            		System.out.println("exceptionally - apply ：" + throwable.toString());
	    		            		log.error("### send PostJson request error occured !", throwable);
	    		            		return null;
	    		            	}
	    		            })
	    		            .thenApply(response -> {
	    		               if (response.getStatusCode() == 200) { 
	    		            		return response.getResponseBody();
	    		               }else{
	    		            		log.error("### get PostJson response error occured !", response.getResponseBody());
		    		               return null;
	    		               }
	    		            });
		return resultFuture;
	}

}

使用

CompletableFuture<String> resultHik = HttpAsyncUtil.doPostJson(HIKURL, JSON.toJSONString(paramsMap));
CompletableFuture<String> resultData = HttpAsyncUtil.doPost(url, paramMap, null);

示例

CompletableFuture<String> resultHik = HttpAsyncUtil.doPostJson(HIKURL, JSON.toJSONString(hikParamsMap));
CompletableFuture<String> resultData = HttpAsyncUtil.doPost(url, paramMap, null);


CompletableFuture<List<Map<String,Object>>> endResult = resultData.thenCombine(resultHik, (res1, res2) -> {
	Map<String,Object> hikResult = JSON.parseMap(res2);
	
	Map<String,Object> dataResult = JSON.parseMap(res1);
	List<Map<String,Object>> result = null;
	if(hikResult!= null && "0".equals(hikResult.get("code")) 
			&& dataResult!= null && "200".equals(dataResult.get("code"))){
		Map<String, Object> data = (Map<String, Object>) hikResult.get("data");
		List<Map<String,Object>> hikList = (List<Map<String,Object>>) data.get("list");

		Map<String,Object> dataDa = (Map<String,Object>) dataResult.get("data");
		List<Map<String,Object>> dataList =(List<Map<String, Object>>) dataDa.get("data");
		for(Map<String,Object> hikObj:hikList){
			for(Map<String,Object> dataObj:dataList){
				if(hikObj.get("cameraIndexCode").equals(dataObj.get("CAMERAINDEXCODE"))){
					hikObj.put("altitude", dataObj.get("LATITUDE"));
					hikObj.put("longitude", dataObj.get("LONGITUDE"));
				}
			}
		}
		result = hikList;
	}
	return result;
});

性能测试

一个主线程循环执行1、2、3、10、20、30次（N）请求，异步和同步请求的响应时间（单位ms，包含结果逻辑处理的时间）。请求执行一次响应时间没有明显变化，请求执行多次，性能有明显提升。

请求次数异步同步性能提升
14048ms4688ms14%
24928ms8484ms42%
35970ms11043ms46%
1013583ms33147ms59%
2022873ms65358ms65%
3038014ms96989ms61%

https://github.com/AsyncHttpClient/async-http-client
https://zhuanlan.zhihu.com/p/363832799

是夜色太荒芜
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
AytchTeeTeePee:一个更好的、CompletableFuture 友好的 HTTPClient
06-14
AytchTeeTeePee 一个更好的、CompletableFuture 友好的 HTTPClient，用于非常简单的异步 HTTP 请求。 用法 首先，实例化一个新的 HTTP 客户端： HTTP client = new HTTP (); 然后，调用以下方法之一： client.get(String url) -> CompleteableFuture<Response> client.post(String url, Object body) -> CompleteableFuture<Response> client.put(String url, Object body) -> CompleteableFuture<Response> client.delete(String url) -> CompleteableFuture<Response> 对于po
CompletableFuture 批量异步请求、合并请求实现
zhaoyang10的专栏
12-19 3670
public static void test() { AtomicInteger total = new AtomicInteger(); List<Long> testList = new ArrayList<>(); for (int i = 0; i < 22; i++) { testList.add(Lon...
异步编程神器CompletableFuture使用总结【建议收藏】
最新发布
专注Java后端技术干货、项目源码总结分享，期待您的关注。
04-27 868
CompletableFuture 是 Java 8 引入的一种用于处理异步编程的工具。它提供了一种非常灵活而且易于使用的方式来处理并发任务，能够简化代码的编写，并提高程序的性能。
CompletableFuture异步请求远程资源
qq_1641486826的博客
11-10 265
package java8.completableFuture; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; /** * @program: javaCodeThink * @descrip
商品详情页使用CompletableFuture异步调用
远方的少年
09-09 160
通产在商品详情页需要根据商品id调用其他的服务，获取商品的其他信息，这时可以使用CompletableFuture来调用其他的服务，进行调用，最后把结果合起来，返回结果。例如如下: //1.获取商品的a信息 CompletableFuture<Object> aFuture = CompletableFuture.supplyAsync(() -> **); //2.获取商品的b信息 CompletableFuture<Object> bFuture ...
9.商品详情页及异步编排（CompletableFuture）
希冀
07-30 1618
1. 商品详情 当用户搜索到商品，肯定会点击查看，就会进入商品详情页，接下来我们完成商品详情页的展示。 商品详情浏览量比较大，并发高，我们会独立开启一个微服务，用来展示商品详情。 1.1. 创建module pom.xml依赖： <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSc
Android封装的http请求实用工具类
09-04
这个工具类通常在 Android 应用开发中用于与服务器进行数据交互，简化网络请求的编写工作。 首先，我们来看 `isOpenNetwork` 方法，这是用来检测设备当前是否连接到可用的网络。它通过 `Context` 的 `...
ajax 同步请求和异步请求的差异分析
09-05
对于异步请求，错误处理通常在回调函数中进行，而同步请求则可以在请求完成后立即检查状态并处理错误。 总的来说，理解AJAX的同步和异步请求的区别是开发高效、用户友好的Web应用的关键。选择合适的请求类型，结合...
实现PHP多线程异步请求的3种方法
10-26
在PHP中实现多线程异步...总之，虽然PHP不支持原生多线程，但通过各种策略和工具，开发者仍然可以实现异步请求，以满足不同场景下的并发处理需求。不断学习和探索新的技术方案，将有助于提升PHP应用的性能和响应能力。
详解XMLHttpRequest（一）同步请求和异步请求
09-01
在本文中，我们将深入探讨XMLHttpRequest的同步请求和异步请求。 首先，让我们理解同步请求。当XMLHttpRequest的`open()`方法的第三个参数`async`设置为`false`时，请求将以同步方式进行。这意味着浏览器会阻塞主线...
Java并发 CompletableFuture异步编程的实现
08-25
Java并发 CompletableFuture异步编程的实现 在 Java 中，...CompletableFuture 是一种非常有用的异步编程工具，它可以帮助开发者轻松地实现异步操作，提高性能，简化代码，并且使得代码更加易读、易维护。
HttpAsyncClient 4.1 异步HttpCLient
07-21
HttpAsyncClient基于事件驱动的编程模型，使用非阻塞 I/O 模型。HttpAsyncClient 并不是要替换 Apache 的 HttpClient ，二者是互补关系，在一些需要进行大量并发连接的客户端以及对性能要求比较高的场景下，HttpAsyncClient 更加适合。
Java8的CompletableFuture
hanyingzhong的专栏
03-09 716
Java8的CompletableFuture之一 2016-06-01 15:36 841人阅读 评论(0) 收藏 举报 分类： java（24） 目录(?)[+]       Java8提供了一种函数风格的异步和事件驱动编程模型CompletableFuture，该模型不同于以往Java版本，不会造成堵塞Blocking。过
《Java高并发程序设计》学习 --6.5 增强的Future：CompletableFuture
sunhaoning的专栏
03-29 1063
CompletableFuture是Java 8新增的一个超大型工具类。它实现了Future接口，也实现了CompletionStage接口。CompletionStage接口拥有多达40种方法，是为了函数式编程中的流式调用准备的。通过CompletionStage提供的接口，可以在一个执行结果上进行多次流式调用，以此可以得到最终结果。比如，可以在一个CompletionStage上进行如下调用：
【并发】强大的CompletableFuture
啤酒就辣条
03-02 195
引子 为了让程序更加高效，让CPU最大效率的工作，我们会采用异步编程。首先想到的是开启一个新的线程去做某项工作。再进一步，为了让新线程可以返回一个值，告诉主线程事情做完了，于是乎Future粉墨登场。然而Future提供的方式是主线程主动问询新线程，要是有个回调函数就爽了。所以，为了满足Future的某些遗憾，强大的CompletableFuture随着Java8一起来了。 Future 传统多...
异步编程CompletableFuture实现高并发系统优化之请求合并
weixin_30491641的博客
08-04 782
　　先说场景： 　　根据Redis官网介绍，单机版Redis的读写性能是12万/秒，批量处理可以达到70万/秒。不管是缓存或者是数据库，都有批量处理的功能。当我们的系统达到瓶颈的时候，我们考虑充分的压榨缓存和数据库的性能，应对更大的并发请求。适用于电商促销双十一，等特定高并发的场景，让系统可以支撑更高的并发。 　　思路： 一个用户请求到后台，我没有立即去处理，而是把请求堆积到队列中...
Java CompletableFuture 详解
chengqi5964的博客
06-14 226
Java CompletableFuture 详解 参考1：异步技巧之CompletableFuture 参考2：通过实例理解 JDK8 的 CompletableFuture 参考3：CompletableFuture 详解 参考4：多线程并发执行任务，取结果归集。终极总结：Future、F...
jdk1.8 CompletableFuture尝试
lx1095942457的博客
12-06 724
初识Future 忘了第一次是怎么接触CompletableFuture的了，因为是间接了解到的。首先了解到的是Future接口，朋友给我个人项目搭后台架构时用到的，我看代码时发现用到了这个这东西。在这之前，对它一无所知，就比较好奇，了解到是用于异步操作的。java方法也能异步调用？我觉得很酷，开了眼界，再结合js，觉得这东西很有价值，所以那时就有一个想法在心中萌芽，就是在实际的工作项目中，去使
跨服务同步数据（MYSQL），@Scheduled定时任务，HttpClient分批发送数据，JSONobject，策略模式+简单工厂，异步@Async+CompletableFuture使用
坤三岁的博客
11-18 1230
跨服务（数据库）同步数据（MYSQL），使用HttpClient Post请求分批发送数据，通过JSONobject获取，策略模式+简单工厂的使用，异步线程@Async+CompletableFuture的使用
completablefuture 封装工具类
09-28
CompletableFuture是Java 8中新增的一个类，它是用来处理异步任务的工具类。它可以封装一个任务，并可以使用回调机制处理任务完成后的结果。CompletableFuture提供了丰富的方法来处理异步任务，包括串行执行、并行...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值