HttpClient性能优化方案

最新推荐文章于 2024-04-26 21:01:05 发布
最新推荐文章于 2024-04-26 21:01:05 发布
阅读量3.5k 收藏 9
点赞数 1
分类专栏： 主流框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FKJGFK/article/details/104004105
版权

Java的复杂应用开发过程中经常遇到跨系统的数据访问活动（例如业务系统访问基础数据、校验票据、验证身份等等），系统和系统之间的数据连接和传输是制约服务器响应速度的关键。

1.前言

       目前HTTP 协议可能是现在 Internet 上使用得最多、最重要的协议了，越来越多的 Java 应用程序需要直接通过 HTTP 协议来访问网络资源。HttpClient 是 Apache Jakarta Common 下的子项目，用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。简单业务访问时，一般的每次请求时会初创建一个httpclient，执行httpPost对象或者httpGet对象，然后从返回结果取出entity，最后关闭response释放链接。然而在高并发业务请求时，这个过程无疑会消耗大量资源，需要对HttpClient进行优化，提高服务器响应速度。

2.优化策略:

1)       Httpclient是一个线程安全的类，没必要每次请求时都重新创建，使用单例模式创建一个全局的HttpClient即可。

2)       tcp的三次握手与四次挥手过程，在高频次的情况下消耗实在太大，可以采用Http连接池减少这部分时间损耗。同时能够合理利用资源，支持更大的并发，综合提升系统响应速度。

3)       创建监测线程，及时关闭被服务器单向断开的连接。

3.代码分析

package com.ceshi.common.util;

import com.alibaba.fastjson.JSON;
import com.xdja.pcs.common.exception.ServiceException;
import org.apache.http.*;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.EntityBuilder;
import org.apache.http.client.methods.CloseableHttpResponse;
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.client.utils.URIBuilder;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.ConnectionKeepAliveStrategy;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.LayeredConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContextBuilder;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.entity.BasicHttpEntity;
import org.apache.http.entity.BufferedHttpEntity;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.mime.HttpMultipartMode;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicHeaderElementIterator;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;
import org.apache.http.protocol.HttpContext;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.net.ssl.SSLContext;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.charset.Charset;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.Map;
import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * EffectiveHttp
 *
 * @author xx
 * @date 2019/3/1 1:15
 */
public class EffectiveHttp {

	/**
	 * static logger
	 */
	private static final Logger logger = LoggerFactory.getLogger(EffectiveHttp.class);

	/**
	 * 保活时间
	 */
	private static int keepAlive = 30;

	/**
	 * 连接池最大连接数
	 */
	private static final int maxTotal = 1000;

	/**
	 * 路由的默认最大连接
	 */
	private static final int defaultMaxPerRoute = 400;

	/**
	 * 连接超时时间
	 */
	private static final int maxIdleTime = 30000;

	/**
	 * 请求超时时间
	 */
	private static final int connectTimeout = 30000;

	/**
	 * 获取数据超时时间
	 */
	private static final int socketTimeout = 30000;

	/**
	 * 保活连接策略
	 */
	private static ConnectionKeepAliveStrategy keepAliveStrategy;

	/**
	 * Http连接池
	 */
	private static PoolingHttpClientConnectionManager connectionManager;

	/**
	 * clientBuilder
	 */
	private static HttpClientBuilder clientBuilder;

	/**
	 * httpClient
	 */
	private volatile static CloseableHttpClient httpClient;

	/**
	 * monitor Thread
	 */
	private static ScheduledExecutorService monitorExecutor;

	/**
	 * 创建get请求
	 *
	 * @param url url
	 * @return get工具
	 */
	public static EffectiveHttp.GetUtil createGet(String url) {
		return new EffectiveHttp.GetUtil(url);
	}

	/**
	 * 创建post请求
	 *
	 * @param url url
	 * @return post请求工具
	 */
	public static EffectiveHttp.PostUtil createPost(String url) {
		return new EffectiveHttp.PostUtil(url);
	}

	/**
	 * 创建post请求
	 *
	 * @param url url
	 * @return post请求工具
	 */
	public static EffectiveHttp.PostUtil createPost(String url, ContentType contentType) {
		return new EffectiveHttp.PostUtil(url, contentType);
	}

	/**
	 * 创建form表单请求
	 *
	 * @param url url
	 * @return form表单工具
	 */
	public static EffectiveHttp.FormUtil createForm(String url) {
		return new EffectiveHttp.FormUtil(url);
	}

	/**
	 * 初始化参数
	 */
	static {
		init();
	}

	/**
	 * 初始化Http配置
	 */
	private static void init() {
		logger.debug("@EffectiveHttp-------初始化Http连接池配置......");

		connectionManager = new PoolingHttpClientConnectionManager(getRegistry());
		connectionManager.setMaxTotal(maxTotal);
		connectionManager.setDefaultMaxPerRoute(defaultMaxPerRoute);

		keepAliveStrategy = getKeepAliveStrategy();

		clientBuilder = createClientBuilder();
	}

	/**
	 * 创建 HttpClient实例(单例模式)
	 */
	public static CloseableHttpClient getInstance() {

		if (httpClient == null) {
			synchronized (EffectiveHttp.class) {
				if (httpClient == null) {
					httpClient = clientBuilder.build();
					//开启监控线程,对异常和空闲线程进行关闭
					monitorExecutor = Executors.newScheduledThreadPool(1);
					monitorExecutor.scheduleAtFixedRate(new TimerTask() {
						@Override
						public void run() {
							//关闭异常连接
							connectionManager.closeExpiredConnections();
							//关闭空闲的连接
							connectionManager.closeIdleConnections(maxIdleTime, TimeUnit.SECONDS);
						}
					}, 30, 30, TimeUnit.SECONDS);
				}
			}
		}
		return httpClient;
	}

	/**
	 * 执行http请求
	 *
	 * @param requestBase request请求
	 * @return 封装好的请求结果
	 */
	private static EffectiveHttp.ResponseWrap exec(HttpRequestBase requestBase) {
		EffectiveHttp.ResponseWrap responseWrap = null;
		try {
			httpClient = getInstance();
			HttpClientContext context = HttpClientContext.create();
			CloseableHttpResponse execute = httpClient.execute(requestBase, context);
			responseWrap = new EffectiveHttp.ResponseWrap(execute);
		} catch (IOException e) {
			e.printStackTrace();
		}
		return responseWrap;
	}

	/**
	 * HttpClientBuilder
	 */
	public static HttpClientBuilder createClientBuilder() {
		HttpClientBuilder clientBuilder = HttpClients.custom()
				.setConnectionManager(connectionManager)
				.setKeepAliveStrategy(keepAliveStrategy);
		return clientBuilder;
	}

	/**
	 * 连接策略
	 *
	 * @return
	 */
	private static ConnectionKeepAliveStrategy getKeepAliveStrategy() {
		ConnectionKeepAliveStrategy keepAliveStrategy = 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 && "timeout".equalsIgnoreCase
							(param)) {
						return Long.parseLong(value) * 1000;
					}
				}
				return keepAlive * 1000;
			}
		};
		return keepAliveStrategy;
	}

	/**
	 * @return
	 */
	private static Registry getRegistry() {
		Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
				.register("https", getSSLSocketFactory())
				.register("http", new PlainConnectionSocketFactory())
				.build();
		return socketFactoryRegistry;
	}

	/**
	 * 构建sslSocketFactory
	 *
	 * @return sslFactory
	 */
	private static LayeredConnectionSocketFactory getSSLSocketFactory() {
		try {
			SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
				//信任所有
				@Override
				public boolean isTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
					return true;
				}
			}).build();
			return new SSLConnectionSocketFactory(sslContext, SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
		} catch (NoSuchAlgorithmException | KeyStoreException | KeyManagementException e) {
			throw new RuntimeException(e.getMessage(), e);
		}
	}

	/**
	 * get请求工具类
	 */
	public static class GetUtil {
		/**
		 * 请求参数
		 */
		private HttpGet httpGet;
		/**
		 * get url builder
		 */
		private URIBuilder uriBuilder;
		/**
		 * request config builder
		 */
		private RequestConfig.Builder requestConfigBuilder;

		private GetUtil(String url) {
			httpGet = new HttpGet(url);
			uriBuilder = new URIBuilder().setPath(httpGet.getURI().toString());
			uriBuilder.setCharset(Charset.forName("UTF-8"));
			requestConfigBuilder = RequestConfig.custom().setConnectTimeout(connectTimeout).setSocketTimeout(socketTimeout);
		}

		/**
		 * 添加header
		 *
		 * @param name  name
		 * @param value value
		 * @return this
		 */
		public EffectiveHttp.GetUtil addHeader(String name, String value) {
			httpGet.addHeader(name, value);
			return this;
		}

		/**
		 * 添加请求参数
		 *
		 * @param param param
		 * @param value value
		 * @return this
		 */
		public EffectiveHttp.GetUtil addParameter(String param, String value) {
			uriBuilder.setParameter(param, value);
			return this;
		}

		/**
		 * 设置超时时间(该模块待抽象出去)
		 *
		 * @param timeout timeOut mills
		 * @return this
		 */
		public EffectiveHttp.GetUtil setConnectTimeOut(int timeout) {
			requestConfigBuilder.setConnectTimeout(timeout);
			return this;
		}

		/**
		 * 设置socketTimeOut(该模块待抽象出去)
		 *
		 * @param timeout timeout mills
		 * @return this
		 */
		public EffectiveHttp.GetUtil setSocketTimeout(int timeout) {
			requestConfigBuilder.setSocketTimeout(timeout);
			return this;
		}

		/**
		 * 执行并返回结果
		 */
		public EffectiveHttp.ResponseWrap execute() {
			try {
				URI uri = new URI(uriBuilder.build().toString().replace("%3F", "?"));// replace %3F -> ?
				httpGet.setURI(uri);
				httpGet.setConfig(requestConfigBuilder.build());
			} catch (URISyntaxException e) {
				logger.error(e.getMessage(), e);
			}

			return exec(httpGet);
		}
	}

	/**
	 * post请求
	 */
	public static class PostUtil {
		/**
		 * 请求参数
		 */
		private HttpPost httpPost;
		/**
		 * entityBuilder
		 */
		private EntityBuilder entityBuilder;
		/**
		 * request config builder
		 */
		private RequestConfig.Builder requestConfigBuilder;

		public PostUtil(String url) {
			httpPost = new HttpPost(url);
			entityBuilder = EntityBuilder.create().setParameters(new ArrayList<NameValuePair>());
			requestConfigBuilder = RequestConfig.custom().setConnectTimeout(connectTimeout).setSocketTimeout(socketTimeout);
		}

		/**
		 * 带contentType的post
		 *
		 * @param url         url
		 * @param contentType 类型
		 */
		public PostUtil(String url, ContentType contentType) {
			this(url);
			entityBuilder.setContentType(contentType);
		}

		/**
		 * 设置超时时间(该模块待抽象出去)
		 *
		 * @param timeout timeOut mills
		 * @return this
		 */
		public EffectiveHttp.PostUtil setConnectTimeOut(int timeout) {
			requestConfigBuilder.setConnectTimeout(timeout);
			return this;
		}

		/**
		 * 设置socketTimeOut(该模块待抽象出去)
		 *
		 * @param timeout timeout mills
		 * @return this
		 */
		public EffectiveHttp.PostUtil setSocketTimeout(int timeout) {
			requestConfigBuilder.setSocketTimeout(timeout);
			return this;
		}

		/**
		 * 添加header
		 *
		 * @param name  name
		 * @param value value
		 * @return this
		 */
		public EffectiveHttp.PostUtil addHeader(String name, String value) {
			httpPost.addHeader(name, value);
			return this;
		}

		/**
		 * 添加请求参数
		 *
		 * @param param param
		 * @param value value
		 * @return this
		 */
		public EffectiveHttp.PostUtil addParameter(String param, String value) {
			entityBuilder.getParameters().add(new BasicNameValuePair(param, value));
			return this;
		}

		/**
		 * 添加请求参数列表
		 *
		 * @param parameters 参数列表
		 * @return this
		 */
		public EffectiveHttp.PostUtil addParameters(Map<String, String> parameters) {
			for (Map.Entry<String, String> e : parameters.entrySet()) {
				addParameter(e.getKey(), e.getValue());
			}
			return this;
		}

		/**
		 * 添加jsonBody
		 *
		 * @param object object
		 * @return this
		 */
		public EffectiveHttp.PostUtil addJsonBody(Object object) {
			entityBuilder.setContentType(ContentType.APPLICATION_JSON);
			entityBuilder.setContentEncoding("utf-8");
			try {
				entityBuilder.setBinary(JSON.toJSONString(object).getBytes("UTF-8"));
			} catch (Exception e) {
				throw new RuntimeException("@EffectiveHttp-------charset error!");
			}
			return this;
		}

		/**
		 * 添加二进制body
		 *
		 * @param bytes bytes
		 * @return postUtil
		 */
		public EffectiveHttp.PostUtil addBody(byte[] bytes) {
			entityBuilder.setBinary(bytes);
			return this;
		}

		/**
		 * 执行 请求
		 *
		 * @return responseWrap
		 */
		public EffectiveHttp.ResponseWrap execute() {
			HttpEntity httpEntity = entityBuilder.build();
			httpPost.setEntity(httpEntity);
			httpPost.setConfig(requestConfigBuilder.build());
			return exec(httpPost);
		}
	}

	/**
	 * form表单提交
	 */
	public static class FormUtil {
		/**
		 * httpPost
		 */
		private HttpPost httpPost;
		/**
		 * form builder
		 */
		private MultipartEntityBuilder builder;

		public FormUtil(String url) {
			httpPost = new HttpPost(url);
			builder = MultipartEntityBuilder.create();
			builder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
		}

		/**
		 * 添加普通参数
		 *
		 * @param name  name
		 * @param value value
		 * @return this
		 */
		public EffectiveHttp.FormUtil addParameter(String name, String value) {
			builder.addTextBody(name, value, ContentType.TEXT_PLAIN.withCharset(Charset.forName("UTF-8")));
			return this;
		}

		/**
		 * 添加普通参数list
		 *
		 * @param parameters normal parameter list
		 * @return this
		 */
		public EffectiveHttp.FormUtil addParameters(Map<String, String> parameters) {
			for (Map.Entry<String, String> e : parameters.entrySet()) {
				addParameter(e.getKey(), e.getValue());
			}
			return this;
		}

		/**
		 * 添加字节流
		 *
		 * @param name  name
		 * @param bytes 字节流
		 * @return this
		 */
		public EffectiveHttp.FormUtil addParameter(String name, byte[] bytes) {
			builder.addBinaryBody(name, bytes);
			return this;
		}

		/**
		 * 添加二进制流
		 *
		 * @param name        参数名称
		 * @param bytes       参数值
		 * @param contentType 参数类型
		 * @param filename    文件名
		 * @return this
		 */
		public EffectiveHttp.FormUtil addParameter(String name, byte[] bytes, ContentType contentType, String filename) {
			builder.addBinaryBody(name, bytes, contentType, filename);
			return this;
		}

		/**
		 * 添加文件
		 *
		 * @param name        参数名称
		 * @param file        文件
		 * @param contentType contentType
		 * @param fileName    文件名称
		 * @return this
		 */
		public EffectiveHttp.FormUtil addParameter(String name, File file, ContentType contentType, String fileName) {
			builder.addBinaryBody(name, file, contentType, fileName);
			return this;
		}

		/**
		 * 添加 boundary
		 *
		 * @param boundary boundary
		 * @return this
		 */
		public EffectiveHttp.FormUtil setBoundary(String boundary) {
			builder.setBoundary(boundary);
			return this;
		}

		/**
		 * 执行请求
		 *
		 * @return 封装返回参数
		 */
		public EffectiveHttp.ResponseWrap execute() {
			HttpEntity httpEntity = builder.build();
			httpPost.setEntity(httpEntity);
			return exec(httpPost);
		}
	}

	/**
	 * 响应包装
	 */
	public static class ResponseWrap {
		private CloseableHttpResponse response;
		private HttpEntity entity;

		ResponseWrap(CloseableHttpResponse response) {
			this.response = response;

			try {
				HttpEntity entity = response.getEntity();
				if (null != entity) {
					this.entity = new BufferedHttpEntity(entity);
				} else {
					this.entity = new BasicHttpEntity();
				}
				//释放连接
				EntityUtils.consume(entity);
				this.response.close();
			} catch (IOException e) {
				logger.error(e.getMessage(), e);
			}
		}

		/**
		 * 获取响应文本信息
		 *
		 * @return
		 */
		public String getString() {
			try {
				return EntityUtils.toString(entity, Consts.UTF_8);
			} catch (IOException e) {
				throw new RuntimeException(e.getMessage(), e);
			}
		}

		public byte[] getBytes() {
			try {
				return EntityUtils.toByteArray(entity);
			} catch (ParseException | IOException e) {
				throw new RuntimeException(e.getMessage(), e);
			}
		}

		/**
		 * 获取Http响应码
		 *
		 * @return
		 */
		public int statusCode() {
			return response.getStatusLine().getStatusCode();
		}

		/**
		 * 获取InputStream
		 *
		 * @return
		 */
		public InputStream getInputStream() {
			try {
				return entity.getContent();
			} catch (IOException e) {
				throw new RuntimeException(e.getMessage(), e);
			}
		}

		/**
		 * 获取Response
		 */
		public CloseableHttpResponse getResponse() {
			return this.response;
		}

	}
}

说明:

(1)http连接池策略适用于高并发访问同一主机(或同一个接口)的情况下。

(2)实际运用于项目进行jmeter压测，tps等能够显著提升.

(3)本文只是简单举例说明思想，工具扩展可以根据个人喜好重写。

FKJGFK
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HttpClient优化
weixin_30466421的博客
06-19 822
HttpClient优化思路： 1、池化 2、长连接 3、httpclient和httpget复用 4、合理的配置参数（最大并发请求数，各种超时时间，重试次数） 5、异步 6、多读源码 1.背景我们有个业务，会调用其他部门提供的一个基于http的服务，日调用量在千万级别。使用了httpclient来完成业务。之前因为qps上不去，就看了一下业务代码，并做...
高并发场景下的httpClient优化使用
weixin_30851867的博客
03-05 2998
1.背景 我们有个业务，会调用其他部门提供的一个基于http的服务，日调用量在千万级别。使用了httpclient来完成业务。之前因为qps上不去，就看了一下业务代码，并做了一些优化，记录在这里。 先对比前后：优化之前，平均执行时间是250ms；优化之后，平均执行时间是80ms，降低了三分之二的消耗，容器不再动不动就报警线程耗尽了，清爽~ 2.分析 项目的原实现比较粗略，就是每次请求时初始...
从‘海量请求’到‘丝滑响应’：巧解海量httpclient请求优化难题~
最新发布
BASK2311的博客
04-26 299
优化之路永无止境，每一个环节都可能存在更深层次的改进空间，希望上面的内容在当你遇到类似问题时，对你有所帮助~
Caused by: java.lang.NoSuchMethodError: org.apache.http.impl.client.HttpClientBuilder.evictIdleConne
llbb909的专栏
12-05 4947
Spring集成Solr7.5 Maven父模块引用的HttpClient是3.1 导致solr在调用HttpClientBuilder.evictIdleConnections找不到方法 换成HttpClient-4.5.3就没问题了 Caused by: org.springframework.beans.factory.BeanCreationException: Error creatin...
记一次调用时长优化之路，暨httpclient优化之路
zhudongdong123的专栏
03-06 2538
背景 由于公司部分业务是php开发，而我所在的部门是java开发，这之间就需要相互调用，于是就有了代理项目，负责java通过restful方式调用php接口服务， 随着业务量的增长rt时间越来越慢，于是开始了排查。 定位问题 通过pingpoint如下图 分析得知接口耗时主要花费在建立连接上。查看项目代码得知调用http使用的是http-client4.5.5，发现没用连...
WebApi系列~HttpClient的性能隐患
weixin_33755847的博客
10-19 236
回到目录 最近在进行开发过程中，基于都是接口开发，A站接口访问B接口接口来请求数据，而在这个过程中我们使用的是HttpClient这个框架，当然也是微软自己的框架，性能当前没有问题，但如果你直接使用官方的写法，在高并发时候，会有很大的性能隐患，因为它官方使用的是using的方式，而对于请求量比较大时，这种方法对TCP建立也会过高，即使用完马上释放也会有很多time_out的请求，所有决定把某个用...
httpclient 多线程高并发Get请求
热门推荐
Cumu Blog
10-21 2万+
最近公司需要对地址进行清洗，挑选了百度的LBS平台的Geocoding API v2接口，量级在千万级别。为了达到较高的效率，优化了下httpclient（版本：4.2.3）的get请求，具体的就是使用http的连接池，这样不需要每次get都需要3次握手，大大提高了并发能力，并且失败率降低了100倍，具体代码如下： public class HttpRequest {
httpClient组合包.zip
11-05
HttpCore的更新主要关注性能优化和错误修复，确保HttpClient的稳定性和效率。 3. **httpmime-4.5.13.jar**：这个库专门用于处理HTTP请求中的MIME类型数据，特别是当需要发送复杂或二进制数据时，如文件上传。它提供...
Android Asynchronous HTTPClient的实现和优化
07-23
总之，Android Asynchronous HTTPClient是实现异步网络请求的一种有效工具，但在实际项目中，开发者应根据需求选择最合适的网络库，并结合各种优化策略，确保应用的性能和用户体验。随着技术的发展，不断学习和尝试...
HttpClient 4.3教程.rar
04-04
在HttpClient 4.3版本中，这个库进行了许多改进和优化，使其更适用于复杂的网络通信需求。本教程将详细介绍HttpClient 4.3的主要特性和使用方法。 一、HttpClient简介 HttpClient是一个Java库，它允许开发人员执行...
httpclient4.3.4
01-03
总的来说，HttpClient 4.3.4及其相关组件构成了一个完整的HTTP客户端解决方案，涵盖了HTTP通信的各个方面，包括基本的HTTP请求和响应处理、缓存策略、底层网络通信以及多媒体内容的传输。对于任何需要通过HTTP与...
使用java的HttpClient实现多线程并发
09-01
主要介绍了使用java的HttpClient实现多线程并发的相关资料,需要的朋友可以参考下
httpclient-4.5jar包
07-20
版本4.5是HttpClient的一个稳定版本，提供了许多增强的功能和优化，使其成为Java开发者进行HTTP通信的重要工具。 一、HttpClient概述 HttpClient 4.5作为HTTP客户端API，提供了对HTTP协议的全面支持，包括标准方法...
HttpURLConnection与 HttpClient 区别/性能测试对比
weixin_33830216的博客
09-30 278
ttpClient是个开源框架，封装了访问http的请求头，参数，内容体，响应等等， HttpURLConnection是java的标准类，什么都没封装，用起来太原始，不方便 HttpClient实际上是对Java提供方法的一些封装， 在HttpURLConnection中的输入输出流操作， 在这个接口中被统一封装成了HttpPost(HttpGet)和HttpRespo...
Http请求优化
alibb20000的博客
12-13 309
Http请求优化 我们在做项目开发或多或少的都会使用SpringCloud,其中做远程调度的时候会将HTTP请求Http请求优化。 HTTP请求Client存在很多种。 JDK原生的URLConnection发送HTTP请求，没有连接池，是对每一个地址保持一个长连接，利用HTTP的persistenceconnection。这样极大的影响系统的并发性能。我们可以采用替换方案...
RestTemplate介绍使用,以及整合 HttpClient 连接池 配置长连接
zzhongcy的专栏
02-28 1万+
1、RestTemplate介绍 spring框架提供的RestTemplate类可用于在应用中调用rest服务，它简化了与http服务的通信方式，统一了RESTful的标准，封装了http链接，我们只需要传入url及返回值类型即可。相较于之前常用的httpClient，RestTemplate是一种更优雅的调用RESTful服务的方式。 RestTempla...
Httpclient默认连接数导致性能瓶颈问题
春哥的博客
08-16 8961
HttpConnectionManager httpConnectionManager = new MultiThreadedHttpConnectionManager();         HttpConnectionManagerParams params = httpConnectionManager.getParams();         params.setConnectionTi
httpclient的性能监控
09-13
HttpClient 是一个开源的 Java 库，用于进行 HTTP 请求和响应的处理。性能监控可以帮助我们了解 HttpClient 在实际应用中的性能表现，并进行性能优化。 要监控 HttpClient 的性能，可以考虑以下几个方面： 1. 请求响应时间：通过记录请求发起时间和接收到响应的时间，可以计算出请求的总耗时。可以使用 System.currentTimeMillis() 或者 System.nanoTime() 记录时间戳。 2. 并发连接数：HttpClient 支持多线程并发请求，可以通过统计当前活跃的连接数来了解并发情况。可以使用 HttpClient 的连接管理器类 ConnectionManager 来获取活跃连接数。 3. 请求成功率：通过统计成功的请求数和总请求数，可以计算出请求的成功率。可以在请求正常返回时统计成功数，或者根据返回状态码来判断是否成功。 4. 错误率和异常信息：统计请求过程中出现的错误数和异常信息，可以帮助排查问题。可以通过捕获 HttpClient 抛出的异常来统计错误数，并记录异常信息。 5. 请求速率：可以统计每秒钟的请求数，帮助了解系统的负载情况。可以使用计数器来统计请求数，并定期清零。 以上是一些常见的性能监控指标，可以根据具体需求进行扩展和调整。另外，还可以考虑使用性能测试工具，如 Apache JMeter 或者 Gatling，对 HttpClient 进行大规模压力测试和性能评估。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值