异步的AsyncHttpClient使用详解

2023-10-27

背景

前面的一篇文章【同步的HttpClient使用详解】中，提到了服务端通进行网络请求的方式。也讲述了在并发量大的情况下使用HttpClient的连接池来提高性能。此方法虽然很有效果，但是当访问量极大或网络不好的情况下也会出现某些网络请求慢导致其它请求阻塞的情况，为此本文引入了异步的HttpClient包，将网络请求变成一个异步的请求，不影响其它的请求。

异步httpClient需要的jar包

 <!-- httpclient -->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.1</version>
        </dependency>
        
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpcore</artifactId>
            <version>4.4.6</version>
        </dependency>
        
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpmime</artifactId>
            <version>4.3.1</version>
        </dependency>

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

注意：由于异步的HttpClient比较新，所以尽量使用该文中的版本jar包，或以上版本

使用方法

为了更好的使用，在这里简单的使用了工厂模式。将同步的httpclient与异步的httpclient通过工厂进行实例化

1、定义异步的httpclient

package com.studyproject.httpclient;

import java.nio.charset.CodingErrorAction;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;

import javax.net.ssl.SSLContext;

import org.apache.http.Consts;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthSchemeProvider;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.MalformedChallengeException;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.client.config.AuthSchemes;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.config.ConnectionConfig;
import org.apache.http.config.Lookup;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.ssl.SSLContexts;
import org.apache.http.impl.auth.BasicSchemeFactory;
import org.apache.http.impl.auth.DigestSchemeFactory;
import org.apache.http.impl.auth.KerberosSchemeFactory;
import org.apache.http.impl.auth.NTLMSchemeFactory;
import org.apache.http.impl.auth.SPNegoSchemeFactory;
import org.apache.http.impl.client.BasicCookieStore;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.nio.client.CloseableHttpAsyncClient;
import org.apache.http.impl.nio.client.HttpAsyncClients;
import org.apache.http.impl.nio.conn.PoolingNHttpClientConnectionManager;
import org.apache.http.impl.nio.reactor.DefaultConnectingIOReactor;
import org.apache.http.impl.nio.reactor.IOReactorConfig;
import org.apache.http.nio.conn.NoopIOSessionStrategy;
import org.apache.http.nio.conn.SchemeIOSessionStrategy;
import org.apache.http.nio.conn.ssl.SSLIOSessionStrategy;
import org.apache.http.nio.reactor.ConnectingIOReactor;
import org.apache.http.nio.reactor.IOReactorException;

/**
 * 异步的HTTP请求对象，可设置代理
 */
public class HttpAsyncClient {

	private static int socketTimeout = 5000;// 设置等待数据超时时间5秒钟 根据业务调整

	private static int connectTimeout = 2000;// 连接超时

	private static int poolSize = 3000;// 连接池最大连接数

	private static int maxPerRoute = 1500;// 每个主机的并发最多只有1500，如果后端保有一台应用机就配置3000

	// http代理相关参数
	private String host = "";
	private int port = 0;
	private String username = "";
	private String password = "";

	// 异步httpclient
	private CloseableHttpAsyncClient asyncHttpClient;

	// 异步加代理的httpclient
	private CloseableHttpAsyncClient proxyAsyncHttpClient;

	public HttpAsyncClient() {
		try {
			this.asyncHttpClient = createAsyncClient(false);
			this.proxyAsyncHttpClient = createAsyncClient(true);
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

	public CloseableHttpAsyncClient createAsyncClient(boolean proxy)
			throws KeyManagementException, UnrecoverableKeyException,
			NoSuchAlgorithmException, KeyStoreException,
			MalformedChallengeException, IOReactorException {

		SSLContext sslcontext = SSLContexts.createDefault();

		UsernamePasswordCredentials credentials = new UsernamePasswordCredentials(
				username, password);

		CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
		credentialsProvider.setCredentials(AuthScope.ANY, credentials);

		// 设置协议http和https对应的处理socket链接工厂的对象
		Registry<SchemeIOSessionStrategy> sessionStrategyRegistry = RegistryBuilder
				.<SchemeIOSessionStrategy> create()
				.register("http", NoopIOSessionStrategy.INSTANCE)
				.register("https", new SSLIOSessionStrategy(sslcontext))
				.build();

		// 配置io线程
		IOReactorConfig ioReactorConfig = IOReactorConfig.custom()
				.setIoThreadCount(Runtime.getRuntime().availableProcessors())
				.build();
		// 设置连接池大小
		ConnectingIOReactor ioReactor;
		ioReactor = new DefaultConnectingIOReactor(ioReactorConfig);
		PoolingNHttpClientConnectionManager conMgr = new PoolingNHttpClientConnectionManager(
				ioReactor, null, sessionStrategyRegistry, null);

		if (poolSize > 0) {
			conMgr.setMaxTotal(poolSize);
		}

        //每个主机最大的并发量
		if (maxPerRoute > 0) {
			conMgr.setDefaultMaxPerRoute(maxPerRoute);
		} else {
			conMgr.setDefaultMaxPerRoute(10);
		}
       
        //连接相关配置
		ConnectionConfig connectionConfig = ConnectionConfig.custom()
				.setMalformedInputAction(CodingErrorAction.IGNORE)
				.setUnmappableInputAction(CodingErrorAction.IGNORE)
				.setCharset(Consts.UTF_8).build();

		//请求相关配置
		RequestConfig requestConfig = RequestConfig.custom()
				.setConnectTimeout(connectTimeout)
				.setSocketTimeout(socketTimeout).build();

       
		Lookup<AuthSchemeProvider> authSchemeRegistry = RegistryBuilder
				.<AuthSchemeProvider> create()
				.register(AuthSchemes.BASIC, new BasicSchemeFactory())
				.register(AuthSchemes.DIGEST, new DigestSchemeFactory())
				.register(AuthSchemes.NTLM, new NTLMSchemeFactory())
				.register(AuthSchemes.SPNEGO, new SPNegoSchemeFactory())
				.register(AuthSchemes.KERBEROS, new KerberosSchemeFactory())
				.build();
		conMgr.setDefaultConnectionConfig(connectionConfig);

		if (proxy) {
			return HttpAsyncClients.custom().setConnectionManager(conMgr)
					.setDefaultCredentialsProvider(credentialsProvider)
					.setDefaultAuthSchemeRegistry(authSchemeRegistry)
					.setProxy(new HttpHost(host, port))
					.setDefaultCookieStore(new BasicCookieStore())
					.setDefaultRequestConfig(requestConfig).build();
		} else {
			return HttpAsyncClients.custom().setConnectionManager(conMgr)
					.setDefaultCredentialsProvider(credentialsProvider)
					.setDefaultAuthSchemeRegistry(authSchemeRegistry)
					.setDefaultCookieStore(new BasicCookieStore()).build();
		}

	}

	public CloseableHttpAsyncClient getAsyncHttpClient() {
		return asyncHttpClient;
	}

	public CloseableHttpAsyncClient getProxyAsyncHttpClient() {
		return proxyAsyncHttpClient;
	}
}

2、定义同步的httpclient

package com.studyproject.httpclient;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.charset.Charset;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.List;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import org.apache.commons.lang.StringUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpVersion;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.PoolingClientConnectionManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.CoreConnectionPNames;
import org.apache.http.params.CoreProtocolPNames;
import org.apache.http.params.HttpParams;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 同步的HTTP请求对象，支持post与get方法以及可设置代理
 */
public class HttpSyncClient {

	private Logger logger = LoggerFactory.getLogger(HttpSyncClient.class);

	private static int socketTimeout = 1000;// 设置等待数据超时时间5秒钟 根据业务调整

	private static int connectTimeout = 2000;// 连接超时

	private static int maxConnNum = 4000;// 连接池最大连接数

	private static int maxPerRoute = 1500;// 每个主机的并发最多只有1500

	private static PoolingClientConnectionManager cm;

	private static HttpParams httpParams;

	private static final String DEFAULT_ENCODING = Charset.defaultCharset()
			.name();

	// proxy代理相关配置
	private String host = "";
	private int port = 0;
	private String username = "";
	private String password = "";

	private DefaultHttpClient httpClient;

	private DefaultHttpClient proxyHttpClient;

	// 应用启动的时候就应该执行的方法
	public HttpSyncClient() {

		this.httpClient = createClient(false);

		this.proxyHttpClient = createClient(true);
	}

	public DefaultHttpClient createClient(boolean proxy) {

		SchemeRegistry sr = new SchemeRegistry();
		sr.register(new Scheme("http", 80, PlainSocketFactory
				.getSocketFactory()));
		SSLSocketFactory sslFactory;
		try {
			SSLContext sslContext = SSLContext.getInstance("SSL");
			X509TrustManager tm = new X509TrustManager() {
				@Override
				public void checkClientTrusted(X509Certificate[] chain,
						String authType) throws CertificateException {
				}

				@Override
				public void checkServerTrusted(X509Certificate[] chain,
						String authType) throws CertificateException {
				}

				@Override
				public X509Certificate[] getAcceptedIssuers() {
					return null;
				}
			};
			sslContext.init(null, new TrustManager[] { tm },
					new java.security.SecureRandom());
			sslFactory = new SSLSocketFactory(sslContext,
					SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
			sr.register(new Scheme("https", 443, sslFactory));
		} catch (Exception e) {
			e.printStackTrace();
		}
		// 初始化连接池
		cm = new PoolingClientConnectionManager(sr);
		cm.setMaxTotal(maxConnNum);
		cm.setDefaultMaxPerRoute(maxPerRoute);
		httpParams = new BasicHttpParams();
		httpParams.setParameter(CoreProtocolPNames.PROTOCOL_VERSION,
				HttpVersion.HTTP_1_1);
		httpParams.setIntParameter(CoreConnectionPNames.CONNECTION_TIMEOUT,
				connectTimeout);// 请求超时时间
		httpParams.setIntParameter(CoreConnectionPNames.SO_TIMEOUT,
				socketTimeout);// 读取数据超时时间
		// 如果启用了NoDelay策略，httpclient和站点之间传输数据时将会尽可能及时地将发送缓冲区中的数据发送出去、而不考虑网络带宽的利用率，这个策略适合对实时性要求高的场景
		httpParams.setBooleanParameter(CoreConnectionPNames.TCP_NODELAY, true);
		httpParams.setBooleanParameter(
				CoreConnectionPNames.STALE_CONNECTION_CHECK, true);

		DefaultHttpClient httpclient = new DefaultHttpClient(cm, httpParams);

		if (proxy) {
			httpclient.getCredentialsProvider().setCredentials(
					new AuthScope(host, port),
					new UsernamePasswordCredentials(username, password));
		}

		return httpclient;

	}

	public DefaultHttpClient getHttpClient() {
		return httpClient;
	}

	public DefaultHttpClient getProxyClient() {
		return proxyHttpClient;
	}

	public String httpGet(String url, List<BasicNameValuePair> parameters) {

		DefaultHttpClient client = getHttpClient();// 默认会到池中查询可用的连接，如果没有就新建
		HttpGet getMethod = null;
		String returnValue = "";
		try {
			getMethod = new HttpGet(url);

			if (null != parameters) {
				String params = EntityUtils.toString(new UrlEncodedFormEntity(
						parameters, DEFAULT_ENCODING));
				getMethod.setURI(new URI(getMethod.getURI().toString() + "?"
						+ params));
				logger.debug("httpGet-getUrl:{}", getMethod.getURI());
			}

			HttpResponse response = client.execute(getMethod);
			int statusCode = response.getStatusLine().getStatusCode();

			if (statusCode == 200) {
				HttpEntity he = response.getEntity();
				returnValue = new String(EntityUtils.toByteArray(he),
						DEFAULT_ENCODING);
				return returnValue;
			}

		} catch (UnsupportedEncodingException e) {
			logger.error(Thread.currentThread().getName()
					+ "httpGet Send Error,Code error:" + e.getMessage());
		} catch (ClientProtocolException e) {
			logger.error(Thread.currentThread().getName()
					+ "httpGet Send Error,Protocol error:" + e.getMessage());
		} catch (IOException e) {
			logger.error(Thread.currentThread().getName()
					+ "httpGet Send Error,IO error:" + e.getMessage());
		} catch (URISyntaxException e) {
			logger.error(Thread.currentThread().getName()
					+ "httpGet Send Error,IO error:" + e.getMessage());
		} finally {// 释放连接,将连接放回到连接池
			getMethod.releaseConnection();

		}
		return returnValue;

	}

	public String httpPost(String url, List<BasicNameValuePair> parameters,
			String requestBody) {

		DefaultHttpClient client = getHttpClient();// 默认会到池中查询可用的连接，如果没有就新建
		HttpPost postMethod = null;
		String returnValue = "";
		try {
			postMethod = new HttpPost(url);

			if (null != parameters) {
				String params = EntityUtils.toString(new UrlEncodedFormEntity(
						parameters, DEFAULT_ENCODING));
				postMethod.setURI(new URI(postMethod.getURI().toString() + "?"
						+ params));
				logger.debug("httpPost-getUrl:{}", postMethod.getURI());
			}

			if (StringUtils.isNotBlank(requestBody)) {
				StringEntity se = new StringEntity(requestBody,
						DEFAULT_ENCODING);
				postMethod.setEntity(se);
			}

			HttpResponse response = client.execute(postMethod);
			int statusCode = response.getStatusLine().getStatusCode();

			if (statusCode == 200) {
				HttpEntity he = response.getEntity();
				returnValue = new String(EntityUtils.toByteArray(he),
						DEFAULT_ENCODING);
				return returnValue;
			}

		} catch (UnsupportedEncodingException e) {
			logger.error(Thread.currentThread().getName()
					+ "httpPost Send Error,Code error:" + e.getMessage());
		} catch (ClientProtocolException e) {
			logger.error(Thread.currentThread().getName()
					+ "httpPost Send Error,Protocol error:" + e.getMessage());
		} catch (IOException e) {
			logger.error(Thread.currentThread().getName()
					+ "httpPost Send Error,IO error:" + e.getMessage());
		} catch (URISyntaxException e) {
			logger.error(Thread.currentThread().getName()
					+ "httpPost Send Error,IO error:" + e.getMessage());
		} finally {// 释放连接,将连接放回到连接池
			postMethod.releaseConnection();
			// 释放池子中的空闲连接
			// client.getConnectionManager().closeIdleConnections(30L,
			// TimeUnit.MILLISECONDS);
		}
		return returnValue;

	}
}

3、定义httpClient工厂类

package com.studyproject.httpclient;

/**
 * 
 * httpclient 工厂类
 * */
public class HttpClientFactory {

	private static HttpAsyncClient httpAsyncClient = new HttpAsyncClient();

	private static HttpSyncClient httpSyncClient = new HttpSyncClient();

	private HttpClientFactory() {
	}

	private static HttpClientFactory httpClientFactory = new HttpClientFactory();

	public static HttpClientFactory getInstance() {

		return httpClientFactory;

	}

	public HttpAsyncClient getHttpAsyncClientPool() {
		return httpAsyncClient;
	}

	public HttpSyncClient getHttpSyncClientPool() {
		return httpSyncClient;
	}

}

4、定义httpclient业务逻辑处理类,对外的方法可以通过这个类来封装

package com.studyproject.httpclient;

import java.io.IOException;
import java.net.URI;
import java.util.List;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.ParseException;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpRequestBase;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.concurrent.FutureCallback;
import org.apache.http.impl.client.BasicCookieStore;
import org.apache.http.impl.nio.client.CloseableHttpAsyncClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 
 * http client 业务逻辑处理类
 * */
public class HttpClientService {

	private static Logger LOG = LoggerFactory
			.getLogger(HttpClientService.class);

	protected void exeAsyncReq(String baseUrl, boolean isPost,
			List<BasicNameValuePair> urlParams,
			List<BasicNameValuePair> postBody, FutureCallback callback)
			throws Exception {

		if (baseUrl == null) {
			LOG.warn("we don't have base url, check config");
			throw new Exception("missing base url");
		}

		HttpRequestBase httpMethod;
		CloseableHttpAsyncClient hc = null;

		try {
			hc = HttpClientFactory.getInstance().getHttpAsyncClientPool()
					.getAsyncHttpClient();

			hc.start();

			HttpClientContext localContext = HttpClientContext.create();
			BasicCookieStore cookieStore = new BasicCookieStore();

			if (isPost) {
				httpMethod = new HttpPost(baseUrl);

				if (null != postBody) {
					LOG.debug("exeAsyncReq post postBody={}", postBody);
					UrlEncodedFormEntity entity = new UrlEncodedFormEntity(
							postBody, "UTF-8");
					((HttpPost) httpMethod).setEntity(entity);
				}

				if (null != urlParams) {

					String getUrl = EntityUtils
							.toString(new UrlEncodedFormEntity(urlParams));

					httpMethod.setURI(new URI(httpMethod.getURI().toString()
							+ "?" + getUrl));
				}

			} else {

				httpMethod = new HttpGet(baseUrl);

				if (null != urlParams) {

					String getUrl = EntityUtils
							.toString(new UrlEncodedFormEntity(urlParams));

					httpMethod.setURI(new URI(httpMethod.getURI().toString()
							+ "?" + getUrl));
				}
			}

			System.out.println("exeAsyncReq getparams:" + httpMethod.getURI());

			localContext.setAttribute(HttpClientContext.COOKIE_STORE,
					cookieStore);

			hc.execute(httpMethod, localContext, callback);

		} catch (Exception e) {
			e.printStackTrace();
		}

	}

	protected String getHttpContent(HttpResponse response) {

		HttpEntity entity = response.getEntity();
		String body = null;

		if (entity == null) {
			return null;
		}

		try {

			body = EntityUtils.toString(entity, "utf-8");

		} catch (ParseException e) {

			LOG.warn("the response's content inputstream is corrupt", e);
		} catch (IOException e) {

			LOG.warn("the response's content inputstream is corrupt", e);
		}
		return body;
	}
}

5、使用httpclient，这里只介绍了异步的用法

package com.studyproject.httpclient;

import java.util.ArrayList;
import java.util.List;

import org.apache.http.HttpResponse;
import org.apache.http.client.utils.HttpClientUtils;
import org.apache.http.concurrent.FutureCallback;
import org.apache.http.message.BasicNameValuePair;

/**
 * http client 使用
 * */
public class HttClientUseDemo extends HttpClientService {

	public static void main(String[] args) {

		new HttClientUseDemo().getConfCall();
	}

	public void getConfCall() {

		String url = "http://220.181.14.110/xxxxx/xxxxx/searchbyappid.do";

		List<BasicNameValuePair> urlParams = new ArrayList<BasicNameValuePair>();
		urlParams.add(new BasicNameValuePair("appid", "2"));
		exeHttpReq(url, false, urlParams, null, new GetConfCall());
	}

	public void exeHttpReq(String baseUrl, boolean isPost,
			List<BasicNameValuePair> urlParams,
			List<BasicNameValuePair> postBody,
			FutureCallback<HttpResponse> callback) {

		try {
			System.out.println("enter exeAsyncReq");
			exeAsyncReq(baseUrl, isPost, urlParams, postBody, callback);
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

	/**
	 * 被回调的对象，给异步的httpclient使用
	 * 
	 * */
	class GetConfCall implements FutureCallback<HttpResponse> {

		/**
		 * 请求完成后调用该函数
		 */
		@Override
		public void completed(HttpResponse response) {

			System.out.println(response.getStatusLine().getStatusCode());
			System.out.println(getHttpContent(response));

			HttpClientUtils.closeQuietly(response);

		}

		/**
		 * 请求取消后调用该函数
		 */
		@Override
		public void cancelled() {

		}

		/**
		 * 请求失败后调用该函数
		 */
		@Override
		public void failed(Exception e) {

		}

	}
}

上述代码中的有些参数，在使用的过程中需要替换。

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

服务器

Java EE

HttpClient

异步

CloseableHttpAsyncCl

异步的AsyncHttpClient使用详解的相关文章

2023下半年软考「单独划线」合格标准公布

中国计算机技术职业资格网发布了关于2023年度下半年计算机软件资格考试单独划线地区合格标准的通告 2023下半年软考单独划线地区合格标准各科目均为42分 01 官方通告关于2023年度下半年计算机软件资格考试单独划线地区合格标准的通告
Android 1.6 中捆绑了哪个版本的 Apache HTTP 客户端？

我想要一个单独的项目在普通 JVM 中运行我的服务器通信代码以进行集成测试此代码使用这些内置于 Android 框架中的库 http developer android com reference org apache http cl
响应正文为空，状态为 200

我正在使用 Angular 的新 HttpClient 来处理请求当我使用旧的 http 时我的组件返回正文文本很好但现在正文文本为空我不明白服务器正在发送它但我总是收到 null 作为正文响应的所有其他部分都是正常的状态
错误：Angular2 中没有 HttpHandler 的提供者

我正在尝试通过拦截器实现 HttpCache 以下是caching interceptor service ts import HttpRequest HttpResponse HttpInterceptor HttpHandler Htt
Android 和客户端证书

我已经寻找这个问题几个星期了似乎无法在任何地方找到答案我正在尝试为 Android 执行以下操作此代码来自我编写的 C 应用程序但我正在将其移植到 Android Web 端点需要将证书附加到相互身份验证的请求中才能进行 Web 服
无法建立 SSL 连接

我正在使用第三方库 Splunk C SDK http dev splunk com csharp 在我的 ASP NET Core 应用程序中我尝试通过此 SDK 连接到我的本地主机 Splunk 服务但出现异常 System Net
服务器端对云服务执行多个请求

我正在编写一个使用多个 Web API 的 Web 应用程序对于单个用户的单个请求我的应用程序可能需要对其他站点执行最多 30 个 HTTP 请求包含网络应用程序的网站可以拥有数百个并发用户我一直在四处寻找试图找出应该使用哪个库
当互联网断开连接时，HttpClient PostAsync 不响应

我有一个 xamarin 表单应用程序该应用程序执行PostAsync调用将图像作为多部分内容上传问题是在 iOS 设备中当我在 PostAsync 调用期间关闭 wifi 移动数据时 HttpClient 不会进入 catch 块来
HttpClientHandler / HttpClient 内存泄漏

我有 10 150 个长期存在的类对象它们调用使用 HttpClient 执行简单 HTTPS API 调用的方法 PUT 调用示例 using HttpClientHandler handler new HttpClientHandle
Android JSON HttpClient 使用 HttpResponse 将数据发送到 PHP 服务器

我目前正在尝试从 Android 应用程序发送一些数据到 php 服务器两者都由我控制应用程序中的表单上收集了大量数据这些数据被写入数据库这一切都有效在我的主代码中首先我创建一个 JSONObject 在本例中我已将其删减 JS
在 REST Assured 中，如何设置超时？

我正在使用 RestAssured 2 8 0 我正在尝试设置自己的超时用于网关超时因此如果我在 X 毫秒后没有得到响应我想中止 I tried public static ValidatableResponse postWithC
如何在 C# HttpClient 中循环调用分页 URL 以从 JSON 结果下载所有页面

我的第一个问题所以请友善我正在使用C HttpClient调用作业 API 端点这是端点 Jobs API Endpoint 不需要密钥点击即可 http service dice com api rest jobsearch v1
在 Angular 中发生 httpClient 超时时调用函数 [重复]

这个问题在这里已经有答案了我有一个函数在服务器上发送一些超时请求每个请求如下 this httpClient get url headers headers timeout 30000 subscribe response gt err
在 Android 中使用带有 post 参数的 HttpClient 和 HttpPost

我正在为一个 Android 应用程序编写代码该应用程序应该获取数据将其打包为 Json 并将其发布到 Web 服务器而 Web 服务器又应该使用 json 进行响应使用 GET 请求工作正常但由于某种原因使用 POST 时所有
通过 Java 企业代理的 Twilio SMS 呼叫失败并出现以下错误

按照 Twilio 网站中的步骤操作参考链接 https www twilio com docs libraries java custom http clients java https www twilio com docs libr
有没有办法将 java.net.http.HttpClient 与 Oauth2 一起使用？

你好我从RestTemplate to HttpClient来自 java 11 我想从OAuth2RestTemplate to HttpClient也从 java 11 开始我找不到任何有关使用的材料HttpClient与 OAut
初始化后将 HttpMessageHandler 设置为 HttpClient 的实例

我想分享一个实例HttpClient在不同的请求之间幸运的是这个类可以安全地同时使用但我需要设置HttpMessageHandler对于每个单独的请求因为它们可能有不同的 ClientCertificates 显然这只能通过构造函数来
(Flutter) HTTPClient 参数无效：URI 中未指定主机

目前正在开发一个小应用程序允许用户查看存储在 Heroku 上的数据库但是在使用数据库的 URL herokuapp com api 时我遇到了上述问题 var client createHttpClient var response
Angular 7 将文件内容发布为 multipart/form-data

我在字符串变量中提供了要发布的内容我想使用 import HttpClient from angular common http 为了达到与以下相同的效果 curl F email protected cdn cgi l email pr
NameResolutionFailure 与 ConnectFailure 问题

这是一个相当奇怪的问题但仍然是一个非常糟糕的问题当用户在没有互联网的情况下进入我们的应用程序时我们会返回一个NameResolutionFailure作为尝试通过以下方式进行 API 调用的错误消息HttpClient 好吧没关系

随机推荐

arduino+esp8266+onenet+mqtt_4G模块（EC20）连接MQTT服务器(EMQ X)

上面的示意图也是这篇推文的主题使用三个客户端EC20 ESP8266 MQTTX通过MQTT协议连接上我们搭建的EMQ X服务器最后完成消息的发布和订阅概述其中ESP826大家都有认识那么相对陌生的EC20是一个4G模块 MQTTX
vika+obsidian快速进入一个研究领域

目的是快速熟悉一个陌生的研究领域写出文献综述步骤检索相关文献100篇以上在vika中建表格表头如下所示阅读100篇论文的题目关键词摘要填充vika表格并找出需要精度的文献10篇左右中文综述优先精度10篇论文并用ob
《程序员面试宝典》第6章宏和const

一用一个宏定义FIND求一个结构体struc里某个变量相对struc的偏移量 int a char b 20 double cc FIND student a 0 FIND student b 4 FIND student cc 4 20
vscode 如何自动补全react和jsx代码？

补全react代码文件首选项设置打开之后搜索emmet includeLanguages 添加javascript javascriptreact属性重启即可生效补全jsx代码在原来的搜索位置搜索emmet trigger
《游戏测试精通》观后感

第I部分游戏测试简介第一章游戏测试的两条原则 1 不要恐慌 2 不要相信任何人在第一章第一节的学习中我了解到了作为一名测试工作者不论是不是新手还是一个资深的老人在处于以下场景时都会或多或少的出现恐慌的情况不熟悉环境或业
PCI-E

PCI E 1 简介 PCI E PCI Express的所写是最新的总线和接口标准它原来的名称为 3GIO 是由英特尔提出的很明显英特尔的意思是它代表着下一代I O接口标准交由PCI SIG PCI特殊兴趣组织认证发布后才改名为
1. 两数之和 C++

给定一个整数数组 nums 和一个整数目标值 target 请你在该数组中找出和为目标值 target 的那两个整数并返回它们的数组下标你可以假设每种输入只会对应一个答案但是数组中同一个元素在答案里不能重复出现你可以按任意顺
一文搞懂OC门、OD门及其作用

我们先给出OC门 OD门的定义然后从原理出发介绍OC门 OD门的作用 1 什么是OC门 OD门 OC门 Open Collector Gate 集电极开路门如图1所示当N1导通时输出低电平当N1截止时输出高阻态电路的一种输出
火狐安装网页视频下载插件（Video DownloadHelper）

Video DownloadHelper是一款以最简单的方式下载网页视频的chrome插件基本上火狐浏览器能够加载出视频流并正常播放的视频该插件都能够抓取可以说该插件对于网页视频下载还是十分快捷并且使用场景广泛的本地安装后的版本 Vi
字节数组的妙用

在计算机高级语言中字节属于最小单位例如在Java中 int占用4个字节 long占用8个字节等基本上所有基本类型包括String 都可以转换成字节那么这到底有何作用本篇博客主要是记录了我使用字节数组的经验希望可以给大家提供一些
volatile详解（任何人都能懂的那种）

volatile 看了好多篇博客终于明白这个关键字到底是干嘛的让我综合所有的博客写一篇大家都能理解它的博客要点赞呦 volatile是一个类型修饰符作用是作为指令关键字一般都是和const对应确保本条指令不会被编译器的优化而忽略
怎么将将 Python 的安装目录添加到了系统的环境变量路径中

要在 Windows 系统中将 Python 的安装目录添加到环境变量路径中请按照以下步骤操作 1 打开控制面板 2 选择系统和安全 3 选择系统 4 在系统属性中选择高级系统设置 5 在高级选项卡中选择环境变量 6
【微信小程序】微信小程序支付功能实现

1 前言微信小程序支付开启新一代便捷支付新时代随着互联网技术的不断发展微信小程序支付已经成为了人们日常生活中不可或缺的一部分微信小程序是一种无需下载安装即可使用的应用用户可以通过微信扫描或搜索关键词来打开并使用而微信小程序支付
javascript面试题--持续更新

前端HTML篇前端CSS篇 Vue篇 TypeScript篇 React篇微信小程序篇前端面试题汇总大全含答案超详细 HTML JS CSS汇总篇持续更新前端面试题汇总大全二含答案超详细 Vue TypeScript Reac
pytorch量化库使用（2）

FX Graph Mode量化模式训练后量化有多种量化类型仅权重动态和静态配置通过qconfig mapping prepare fx函数的参数完成 FXPTQ API 示例 import torch from torch ao
高可用系统的设计与维护

author skate time 2011 02 11 高可用系统的设计与维护对于一个高可用的系统评价主要体现在架构功能性能安全维护兼容性等方面如何设计维护这样一个高可用系统的 1 一个提供7 24服务的网站架构系统要避
mysql主从读写_mysql主从-读写分离

一个完整的MySQL读写分离环境包括以下几个部分应用程序client database proxy database集群在本次实战中应用程序client基于c3p0连接后端的database proxy database proxy负
最新RAD Studio 11.3亚历山大版本上市

By Marco Cantu February 27 2023 Embarcadero很高兴地宣布RAD Studio 11 Alexandria Release 3的发布也被称为RAD Studio 11 3 同时发布的还有Delphi
k8s集群PHP环境使用

一环境介绍 k8s版本 1 15 2 存储阿里云NAS 测试代码 wordpress 二下载wordpress和创建好数据库等 1 下载wordpress wget https cn wordpress org latest zh C
异步的AsyncHttpClient使用详解

背景前面的一篇文章同步的HttpClient使用详解中提到了服务端通进行网络请求的方式也讲述了在并发量大的情况下使用HttpClient的连接池来提高性能此方法虽然很有效果但是当访问量极大或网络不好的情况下也会出现某些网络请求

异步的AsyncHttpClient使用详解

异步的AsyncHttpClient使用详解 的相关文章

随机推荐

热门标签

异步的AsyncHttpClient使用详解的相关文章