spring boot 整合 HttpClient实现线程池连接

最新推荐文章于 2024-04-06 12:46:24 发布
最新推荐文章于 2024-04-06 12:46:24 发布
阅读量2.4k 收藏 7
点赞数 1
分类专栏： java 文章标签： spring boot 后端 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43360488/article/details/131874339
版权

1.HttpClient介绍

HTTP 协议是现在 Internet 上使用得最多、最重要的协议，越来越多的 Java 应用程序需要直接通过 HTTP 协议来访问网络资源。虽然在 JDK 的 java net包中已经提供了访问 HTTP 协议的基本功能，但是对于大部分应用程序来说，JDK 库本身提供的功能还不够丰富和灵活。HttpClient 是 Apache Jakarta Common 下的子项目，用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。HttpClient 已经应用在很多的项目中，比如 Apache Jakarta 上很著名的另外两个开源项目 Cactus 和 HTMLUnit 都使用了 HttpClient。

2.SpringBoot整合HttpClient

2.1.导入jar包

5.0后开始出现异步，要使用这两个Jar包

<dependency>
	<groupId>org.apache.httpcomponents</groupId>
	<artifactId>httpclient</artifactId>
</dependency>
<!-- httpClient文件上传需要 -->
<dependency>
	<groupId>org.apache.httpcomponents</groupId>
	<artifactId>httpmime</artifactId>
</dependency

2.2 配置文件httpclient.properties

#最大连接数
http_max_total= 1000
#并发数
http_default_max_perRoute = 80
#创建连接的最长时间
http_validate_after_inactivity=5000
#从连接池中获取到连接的最长时间
http_connection_request_timeout=500
http_connection_timeout = 10000
#数据传输的最长时间
http.socketTimeout=10000
waitTime = 30000
idleConTime = 3
retryCount = 3

2.3 配置类

@Configuration	//注解--配置类
@PropertySource(value="classpath:/properties/httpClient.properties")
package com.123.lenovo.adapter.se.config;
 
import java.security.KeyStore;
import javax.net.ssl.SSLContext;
 
import org.apache.http.HeaderElement;
import org.apache.http.HeaderElementIterator;
import org.apache.http.HttpResponse;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.conn.ConnectionKeepAliveStrategy;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.TrustAllStrategy;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.DefaultHttpRequestRetryHandler;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicHeaderElementIterator;
import org.apache.http.protocol.HTTP;
import org.apache.http.protocol.HttpContext;
import org.apache.http.ssl.SSLContexts;
import org.elasticsearch.Build;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
import com.123.lenovo.adapter.se.common.IdleConnectionEvictor;
 
@Configuration
public class HttpClientConfig {
 
	@Value("${http_max_total}")
	private int maxTotal = 800;
	
	@Value("${http_default_max_perRoute}")
	private int defaultMaxPerRoute = 80;
	
	@Value("${http_validate_after_inactivity}")
	private int validateAfterInactivity = 1000;
	
	@Value("${http_connection_request_timeout}")
	private int connectionRequestTimeout = 5000;
	
	@Value("${http_connection_timeout}")
	private int connectTimeout = 10000;
	
	@Value("${http_socket_timeout}")
	private int socketTimeout = 20000;
	
	@Value("${waitTime}")
	private int waitTime = 30000;
	
	@Value("${idleConTime}")
	private int idleConTime = 3;
	
	@Value("${retryCount}")
	private int retryCount = 3;
	
	@Bean
	public PoolingHttpClientConnectionManager createPoolingHttpClientConnectionManager() {
		PoolingHttpClientConnectionManager poolmanager = new PoolingHttpClientConnectionManager();
		poolmanager.setMaxTotal(maxTotal);
		poolmanager.setDefaultMaxPerRoute(defaultMaxPerRoute);
		poolmanager.setValidateAfterInactivity(validateAfterInactivity);
		return poolmanager;
	}
	
	@Bean
	public CloseableHttpClient createHttpClient(PoolingHttpClientConnectionManager poolManager) {
		HttpClientBuilder httpClientBuilder = HttpClientBuilder.create().setConnectionManager(poolManager);
		httpClientBuilder.setKeepAliveStrategy(new ConnectionKeepAliveStrategy() {
			
			@Override
			public long getKeepAliveDuration(HttpResponse response, HttpContext context) {
				HeaderElementIterator iterator = new BasicHeaderElementIterator(response.headerIterator(HTTP.CONN_KEEP_ALIVE));
				while (iterator.hasNext()) {
					HeaderElement headerElement = iterator.nextElement();
					String param = headerElement.getName();
					String value = headerElement.getValue();
					if (null != value && param.equalsIgnoreCase("timeout")) {
						return Long.parseLong(value) * 1000;
					}
				}
				return 30 * 1000;
			}
		});
		httpClientBuilder.setRetryHandler(new DefaultHttpRequestRetryHandler(retryCount, false));
		return httpClientBuilder.build();
	}
	
	@Bean
	public SSLContext createSSLContext() throws Exception {
		return SSLContexts.custom().loadTrustMaterial(KeyStore.getInstance(KeyStore.getDefaultType()), new TrustAllStrategy()).build();
	}
	
	@Bean
	public SSLConnectionSocketFactory createSSLConnectionSocketFactory(SSLContext sslContext) {
		return new SSLConnectionSocketFactory(sslContext,
				new String[] { "TLSv1" },
                null,
                SSLConnectionSocketFactory.getDefaultHostnameVerifier());
	}
	
	@Bean
	public RequestConfig createRequestConfig() {
		return RequestConfig.custom()
				.setConnectionRequestTimeout(connectionRequestTimeout) 	// 从连接池中取连接的超时时间
				.setConnectTimeout(connectTimeout)						// 连接超时时间
				.setSocketTimeout(socketTimeout)						// 请求超时时间
				.build();
	}
	
	@Bean
	public IdleConnectionEvictor createIdleConnectionEvictor(PoolingHttpClientConnectionManager poolManager) {
		IdleConnectionEvictor idleConnectionEvictor = new IdleConnectionEvictor(poolManager, waitTime, idleConTime);
		return idleConnectionEvictor;
	}
	
}

2.4 创建httpClient的工具类

@Component
public class HttpClientHelper {
	
	private Logger LOGGER = LoggerFactory.getLogger(HttpClientHelper.class);
	
	@Autowired
	private CloseableHttpClient httpClient;
	
	@Autowired
	private RequestConfig requestConfig;
	
	public String get(String url, HashMap<String, Object> paramMap, HashMap<String, Object> header) {
		String result = null;
		if ("".equals(url)) {
			return result;
		}
		// 创建一个request对象
		HttpGet httpGet = new HttpGet(url);
		CloseableHttpResponse response = null;
		try {
			// 配置连接参数
			httpGet.setConfig(requestConfig);
			//设置参数  
			if (paramMap != null && paramMap.size() > 0) {
				List<NameValuePair> params = new ArrayList<>();
				for (Entry<String, Object> entry : paramMap.entrySet()) {
					params.add(new BasicNameValuePair(entry.getKey(), URLEncoder.encode(entry.getValue().toString(), "UTF-8")));
				}
				String strParams = EntityUtils.toString(new UrlEncodedFormEntity(params));
				// 防止多参数时，分隔符","被转义
				String realParams = URLDecoder.decode(strParams, "UTF-8");
				httpGet.setURI(new URI(httpGet.getURI().toString().indexOf("?") > 0 ? httpGet.getURI().toString() + "&" + realParams : httpGet.getURI().toString() + "?" + realParams));
			}
			// 设置头
			if (header != null && header.size() > 0) {
				for (Entry<String, Object> entry : header.entrySet()) {
					httpGet.addHeader(entry.getKey(), entry.getValue().toString());
				}
			}
			// 执行request请求
			response = httpClient.execute(httpGet);
			result = parseResponse(response);
			
		} catch (Exception e) {
			LOGGER.error("url : "+ url +", msg : " + e.getMessage());
			httpGet.abort();
		} finally {
			try {
				if (response != null) {
					response.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return result;
	}
	
	public String post(String url, HashMap<String, Object> paramMap, HashMap<String, Object> header) {
		String result = null;
		if ("".equals(url)) {
			return result;
		}
		// 创建一个request对象
		HttpPost httpPost = new HttpPost(url);
		CloseableHttpResponse response = null;
		try {
			// 配置连接参数
			httpPost.setConfig(requestConfig);
			// 设置参数
			if (paramMap != null && paramMap.size() > 0) {
				List<NameValuePair> params = new ArrayList<>();
				for (Entry<String, Object> entry : paramMap.entrySet()) {
					params.add(new BasicNameValuePair(entry.getKey(), entry.getValue().toString()));
				}
				HttpEntity entity = new UrlEncodedFormEntity(params);
				httpPost.setEntity(entity);
			}
			// 设置头
			if (header != null && header.size() > 0) {
				for (Entry<String, Object> entry : header.entrySet()) {
					httpPost.addHeader(entry.getKey(), entry.getValue().toString());
				}
			}
			// 执行request请求
			response = httpClient.execute(httpPost);
			result = reponseHandle(response);
		} catch (Exception e) {
			LOGGER.error("url : "+ url +", msg : " + e.getMessage());
			httpPost.abort();
		} finally {
			try {
				if (response != null) {
					response.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return result;
	}
	
	public String postJSON(String url, String json_str, HashMap<String, Object> header) {
		String result = null;
		if ("".equals(url)) {
			return result;
		}
		// 创建一个request对象
		HttpPost httpPost = new HttpPost(url);
		CloseableHttpResponse response = null;
		try {
			// 配置连接参数
			httpPost.setConfig(requestConfig);
			// 设置参数
			if (json_str != null && !"".equals(json_str)) {
				StringEntity entity = new StringEntity(json_str, ContentType.APPLICATION_JSON);
				entity.setContentEncoding("UTF-8");    
				entity.setContentType("application/json");
				httpPost.setEntity(entity);
			}
			// 设置头
			if (header != null && header.size() > 0) {
				for (Entry<String, Object> entry : header.entrySet()) {
					httpPost.addHeader(entry.getKey(), entry.getValue().toString());
				}
			}
			// 执行request请求
			response = httpClient.execute(httpPost);
			result = reponseHandle(response);
			
		} catch (Exception e) {
			LOGGER.error("url : "+ url +", msg : " + e.getMessage()+", param : " +json_str);
			httpPost.abort();
		} finally {
			try {
				if (response != null) {
					response.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return result;
	}
	
	public String uploadFile(String url, String filePath, String fileParam, Map<String, Object> params) {
		File file = new File(filePath);
		if (!(file.exists() && file.isFile())) {
			throw new RuntimeException("file : file is null");
		}
		String result = null;
		if ("".equals(url)) {
			return result;
		}
		// 创建一个request对象
		HttpPost httpPost = new HttpPost(url);
		CloseableHttpResponse response = null;
		try {
			// 配置连接参数
			httpPost.setConfig(requestConfig);
			MultipartEntityBuilder builder = MultipartEntityBuilder.create();
			builder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
			builder.addBinaryBody(fileParam, file, ContentType.DEFAULT_BINARY, file.getName());
			if (params != null && params.size() > 0) {
				for (Entry<String, Object> entry : params.entrySet()) {
					builder.addTextBody(entry.getKey(), entry.getValue().toString(), ContentType.create("text/plain", Consts.UTF_8));
				}
			}
			HttpEntity requestEntity = builder.build();
			httpPost.setEntity(requestEntity);
			// 执行request请求
			response = httpClient.execute(httpPost);
			result = reponseHandle(response);
			
		} catch (Exception e) {
			httpPost.abort();
		} finally {
			try {
				if (response != null) {
					response.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return result;
	}
	
	/**
	 * 解析 response数据
	 * @description
	 * @param response
	 * @return
	 * @author tangjingjing
	 * @date 2018年10月12日
	 */
	private String parseResponse(CloseableHttpResponse response) {
		String result = "";
		// 获取响应体
		HttpEntity httpEntity = null;
		InputStream inputStream = null;
		try {
			// 获取响应状态
			int statusCode = response.getStatusLine().getStatusCode();
			// 没有正常响应
			if (statusCode < HttpStatus.SC_OK || statusCode >= HttpStatus.SC_MULTIPLE_CHOICES) {
				throw new RuntimeException("statusCode : " + statusCode);
			}
			// 获取响应体
			httpEntity = response.getEntity();
			if (httpEntity != null) {
				inputStream = httpEntity.getContent();
				BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream,"UTF-8"));
				StringBuffer sb = new StringBuffer();
	            String line = "";
	            while((line=reader.readLine())!=null){
	                sb.append(line);
	            }
	            reader.close();
	            result = sb.toString();
			}
 
		} catch (Exception e) {
			LOGGER.error("HttpClientHelper parseResponse error", e);
		} finally {
			if (inputStream != null) {
				try {
					inputStream.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			// 如果httpEntity没有被完全消耗，那么连接无法安全重复使用，将被关闭并丢弃
			try {
				EntityUtils.consume(httpEntity);
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return result;
	}
	
	private String reponseHandle(CloseableHttpResponse response) {
		String result = "";
		// 获取响应体
		HttpEntity httpEntity = null;
		try {
			// 获取响应状态
			int statusCode = response.getStatusLine().getStatusCode();
			// 没有正常响应
			if (statusCode < HttpStatus.SC_OK || statusCode >= HttpStatus.SC_MULTIPLE_CHOICES) {
				throw new RuntimeException("statusCode : " + statusCode);
			}
			// 获取响应体
			httpEntity = response.getEntity();
			if (httpEntity !=null) {
				result = EntityUtils.toString(httpEntity);
			}
			
		} catch (Exception e) {
			LOGGER.error("HttpClientHelper reponseHandle error", e);
		} finally {
			// 如果httpEntity没有被完全消耗，那么连接无法安全重复使用，将被关闭并丢弃
			try {
				EntityUtils.consume(httpEntity);
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return result;
	}
	
}

2.5 创建HttpClient无效连接清除类

@Component
public class HttpClientHelper {
	
	private Logger LOGGER = LoggerFactory.getLogger(HttpClientHelper.class);
	
	@Autowired
	private CloseableHttpClient httpClient;
	
	@Autowired
	private RequestConfig requestConfig;
	
	public String get(String url, HashMap<String, Object> paramMap, HashMap<String, Object> header) {
		String result = null;
		if ("".equals(url)) {
			return result;
		}
		// 创建一个request对象
		HttpGet httpGet = new HttpGet(url);
		CloseableHttpResponse response = null;
		try {
			// 配置连接参数
			httpGet.setConfig(requestConfig);
			//设置参数  
			if (paramMap != null && paramMap.size() > 0) {
				List<NameValuePair> params = new ArrayList<>();
				for (Entry<String, Object> entry : paramMap.entrySet()) {
					params.add(new BasicNameValuePair(entry.getKey(), URLEncoder.encode(entry.getValue().toString(), "UTF-8")));
				}
				String strParams = EntityUtils.toString(new UrlEncodedFormEntity(params));
				// 防止多参数时，分隔符","被转义
				String realParams = URLDecoder.decode(strParams, "UTF-8");
				httpGet.setURI(new URI(httpGet.getURI().toString().indexOf("?") > 0 ? httpGet.getURI().toString() + "&" + realParams : httpGet.getURI().toString() + "?" + realParams));
			}
			// 设置头
			if (header != null && header.size() > 0) {
				for (Entry<String, Object> entry : header.entrySet()) {
					httpGet.addHeader(entry.getKey(), entry.getValue().toString());
				}
			}
			// 执行request请求
			response = httpClient.execute(httpGet);
			result = parseResponse(response);
			
		} catch (Exception e) {
			LOGGER.error("url : "+ url +", msg : " + e.getMessage());
			httpGet.abort();
		} finally {
			try {
				if (response != null) {
					response.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return result;
	}
	
	public String post(String url, HashMap<String, Object> paramMap, HashMap<String, Object> header) {
		String result = null;
		if ("".equals(url)) {
			return result;
		}
		// 创建一个request对象
		HttpPost httpPost = new HttpPost(url);
		CloseableHttpResponse response = null;
		try {
			// 配置连接参数
			httpPost.setConfig(requestConfig);
			// 设置参数
			if (paramMap != null && paramMap.size() > 0) {
				List<NameValuePair> params = new ArrayList<>();
				for (Entry<String, Object> entry : paramMap.entrySet()) {
					params.add(new BasicNameValuePair(entry.getKey(), entry.getValue().toString()));
				}
				HttpEntity entity = new UrlEncodedFormEntity(params);
				httpPost.setEntity(entity);
			}
			// 设置头
			if (header != null && header.size() > 0) {
				for (Entry<String, Object> entry : header.entrySet()) {
					httpPost.addHeader(entry.getKey(), entry.getValue().toString());
				}
			}
			// 执行request请求
			response = httpClient.execute(httpPost);
			result = reponseHandle(response);
		} catch (Exception e) {
			LOGGER.error("url : "+ url +", msg : " + e.getMessage());
			httpPost.abort();
		} finally {
			try {
				if (response != null) {
					response.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return result;
	}
	
	public String postJSON(String url, String json_str, HashMap<String, Object> header) {
		String result = null;
		if ("".equals(url)) {
			return result;
		}
		// 创建一个request对象
		HttpPost httpPost = new HttpPost(url);
		CloseableHttpResponse response = null;
		try {
			// 配置连接参数
			httpPost.setConfig(requestConfig);
			// 设置参数
			if (json_str != null && !"".equals(json_str)) {
				StringEntity entity = new StringEntity(json_str, ContentType.APPLICATION_JSON);
				entity.setContentEncoding("UTF-8");    
				entity.setContentType("application/json");
				httpPost.setEntity(entity);
			}
			// 设置头
			if (header != null && header.size() > 0) {
				for (Entry<String, Object> entry : header.entrySet()) {
					httpPost.addHeader(entry.getKey(), entry.getValue().toString());
				}
			}
			// 执行request请求
			response = httpClient.execute(httpPost);
			result = reponseHandle(response);
			
		} catch (Exception e) {
			LOGGER.error("url : "+ url +", msg : " + e.getMessage()+", param : " +json_str);
			httpPost.abort();
		} finally {
			try {
				if (response != null) {
					response.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return result;
	}
	
	public String uploadFile(String url, String filePath, String fileParam, Map<String, Object> params) {
		File file = new File(filePath);
		if (!(file.exists() && file.isFile())) {
			throw new RuntimeException("file : file is null");
		}
		String result = null;
		if ("".equals(url)) {
			return result;
		}
		// 创建一个request对象
		HttpPost httpPost = new HttpPost(url);
		CloseableHttpResponse response = null;
		try {
			// 配置连接参数
			httpPost.setConfig(requestConfig);
			MultipartEntityBuilder builder = MultipartEntityBuilder.create();
			builder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
			builder.addBinaryBody(fileParam, file, ContentType.DEFAULT_BINARY, file.getName());
			if (params != null && params.size() > 0) {
				for (Entry<String, Object> entry : params.entrySet()) {
					builder.addTextBody(entry.getKey(), entry.getValue().toString(), ContentType.create("text/plain", Consts.UTF_8));
				}
			}
			HttpEntity requestEntity = builder.build();
			httpPost.setEntity(requestEntity);
			// 执行request请求
			response = httpClient.execute(httpPost);
			result = reponseHandle(response);
			
		} catch (Exception e) {
			httpPost.abort();
		} finally {
			try {
				if (response != null) {
					response.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return result;
	}
	
	/**
	 * 解析 response数据
	 * @description
	 * @param response
	 * @return
	 * @author tangjingjing
	 * @date 2018年10月12日
	 */
	private String parseResponse(CloseableHttpResponse response) {
		String result = "";
		// 获取响应体
		HttpEntity httpEntity = null;
		InputStream inputStream = null;
		try {
			// 获取响应状态
			int statusCode = response.getStatusLine().getStatusCode();
			// 没有正常响应
			if (statusCode < HttpStatus.SC_OK || statusCode >= HttpStatus.SC_MULTIPLE_CHOICES) {
				throw new RuntimeException("statusCode : " + statusCode);
			}
			// 获取响应体
			httpEntity = response.getEntity();
			if (httpEntity != null) {
				inputStream = httpEntity.getContent();
				BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream,"UTF-8"));
				StringBuffer sb = new StringBuffer();
	            String line = "";
	            while((line=reader.readLine())!=null){
	                sb.append(line);
	            }
	            reader.close();
	            result = sb.toString();
			}
 
		} catch (Exception e) {
			LOGGER.error("HttpClientHelper parseResponse error", e);
		} finally {
			if (inputStream != null) {
				try {
					inputStream.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			// 如果httpEntity没有被完全消耗，那么连接无法安全重复使用，将被关闭并丢弃
			try {
				EntityUtils.consume(httpEntity);
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return result;
	}
	
	private String reponseHandle(CloseableHttpResponse response) {
		String result = "";
		// 获取响应体
		HttpEntity httpEntity = null;
		try {
			// 获取响应状态
			int statusCode = response.getStatusLine().getStatusCode();
			// 没有正常响应
			if (statusCode < HttpStatus.SC_OK || statusCode >= HttpStatus.SC_MULTIPLE_CHOICES) {
				throw new RuntimeException("statusCode : " + statusCode);
			}
			// 获取响应体
			httpEntity = response.getEntity();
			if (httpEntity !=null) {
				result = EntityUtils.toString(httpEntity);
			}
			
		} catch (Exception e) {
			LOGGER.error("HttpClientHelper reponseHandle error", e);
		} finally {
			// 如果httpEntity没有被完全消耗，那么连接无法安全重复使用，将被关闭并丢弃
			try {
				EntityUtils.consume(httpEntity);
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return result;
	}
	
}

说明，这定时器清除是通过构造类定时清除的，是在定义配置文件Bean的时候就已经调用了
另外使用合适的连接数要根据有多少并发量来合理的测试使用的线程数是多少

weihe_7306
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
项目体验：高并发httpclient和线程池的正确使用
蒲公英的约定
12-01 2万+
ExecutorService、Executors线程池使用不合理导致的性能问题
springboot 中使用httpclient连接池 HttpClientConnectionManager
c_firechicken的博客
02-19 4796
maven地址： &lt;!--HttpClient --&gt; &lt;dependency&gt; &lt;groupId&gt;org.apache.httpcomponents&lt;/groupId&gt; &lt;artifactId&gt;httpclient&lt;/artifactId&gt; &lt;version&gt;4.5.2&lt;/version&
Spring+Http请求+HttpClient实现传参
08-19
主要介绍了Spring+Http请求+HttpClient实现传参，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
spring boot封装HttpClient的示例代码
08-28
主要介绍了spring boot封装HttpClient的示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
SpringBoot整合HttpClient结合线程池，且简单模仿MyBatisPlus设计思想
最新发布
m0_59926335的博客
04-06 242
近期想写一个针对某高校系统的套壳系统，提高其安全与使用便利性，优化用户体验，使用的第三方库为HttpClient。且最近简单了解了MyBatisPlus在MyBatis 的基础上只做增强不做改变的设计，所以简单用HttpClient进行了设计，不再使用原始的设计为工具类。
Httpclient线程池的管理和利用
u010486495的专栏
04-04 3745
http协议时无连接的，本质上是需要和服务器建立连接的。对于需要从同一个站点抓取大量网页的程序，应该使用连接池，否则每次抓取都和Web站点建立连接、发送请求、获得响应、释放连接，一方面效率不高，另一方面稍不小心就会疏忽了某些资源的释放、导致站点拒绝连接（很多站点会拒绝同一个ip的大量连接、防止DOS攻击）。 packagetest.ffm83.commons.httpClient; importj...
双重检查单例模式的的HttpClient线程池实现
半斤米粉闯天下的博客
05-19 1301
单例模式（双重检查）的HttpClient线程池实现
HttpClient常用操作及封装工具类
rqz__的博客
07-30 1463
HttpClient 是一个用于发送 HTTP 请求和接收 HTTP 响应的类库/模块，可以用于编写客户端应用程序，通过 HTTP 与服务器进行通信。 HttpClient 提供了一组方法和类，使得发送 HTTP 请求变得简单和方便。它支持各种 HTTP 方法，例如 GET、POST、PUT、DELETE 等，并可以设置请求的头部信息、请求参数、请求体等。
RestTemplate介绍使用,以及整合 HttpClient 连接池 配置长连接
热门推荐
zzhongcy的专栏
02-28 1万+
1、RestTemplate介绍 spring框架提供的RestTemplate类可用于在应用中调用rest服务，它简化了与http服务的通信方式，统一了RESTful的标准，封装了http链接，我们只需要传入url及返回值类型即可。相较于之前常用的httpClient，RestTemplate是一种更优雅的调用RESTful服务的方式。 RestTempla...
http线程池配置
coldcp的博客
03-10 545
【代码】http线程池配置。
Spring 实现远程访问详解——httpclient
04-19
上两章我们分别利用Spring rmi和httpinvoker实现的远程访问功能，具体见《》和《》。本章将通过apache httpclient实现远程访问。说得简单就是直接通过spring requestmapping即请求映射url访问远程服务。 1. 远程访问流程 1) 服务器在控制器定义远程访问请求映射路径 2) 客户端通过apache httpclient的 httppost方式访问远程服务 2. Httpclient方式具体实现 1) 服务器在控制器定义远程访问请求映射路径
Java毕设项目-疫情数据查看(spring boot+httpclient)
07-20
Java毕设项目-疫情数据查看(spring boot+httpclient)
Spring-boot httpclient mysql爬取京东数据
01-18
简单写了一个使用Spring-boot httpclient 爬取信息 只做技术交流，适合新手，大神勿喷......
spring boot openfeign从此和httpClient说再见详析
08-27
主要给大家介绍了关于spring boot openfeign从此和httpClient说再见的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面来一起看看吧
SpringBoot之RestTemplate使用Apache的HttpClient连接池并解决中文乱码
Meta39的博客
08-29 1254
SpringBoot之RestTemplate使用Apache的HttpClient连接池并解决中文乱码
Springboot2.5集成HttpClient依赖，封装HTTP请求类并配置连接池
我思故我在的博客空间
12-10 5058
先看需要引入的依赖： <!--Http服务器的访问功能--> <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpasyncclient</artifactId> </dependency> <!-- http通信 --> <dependency> <groupId>o
spring boot 整合 HttpClient
一代键客的博客
10-12 1948
第一步：引入HttpClient 的jar包 1、httpClient 5.0 开始支持异步（Async）请求； 2、httpclient 版本过低上传文件会出，原因是org.apache.http.entity.ContentType 没有方法withParameters(final NameValuePair... params)； <dependency> &lt...
httpclient连接池管理
爱分享的淘金达人
03-22 428
随着微服务的留下，服务之间的http调用越来越多。在java里面我们可以使用httpclient这个开源工具类来进行处理，但若使用不当，可能性会比较差，尤其是连接池是否能正常使用，接下来会详细分析下httpclient的连接池原理。 （1）使用httpclient的好处 a）降低延迟：如果不采用连接池，每次连接发起http请求的时候都会重新建立tcp链接（经历三次握手），用完就会关闭连接（
spring boot项目中的ssrf漏洞代码实现
06-07
为了防止误导用户，我不会提供漏洞代码实现。SSRF漏洞是一种严重的安全问题，攻击者可以通过构造恶意的请求，让服务器执行未授权的网络请求，可能导致数据泄露、内网资产暴露等问题。如果您发现了项目中的SSRF漏洞，建议立即采取措施进行修复。 在代码实现层面，可以通过以下方式来防止SSRF漏洞： 1. 对用户输入进行严格的校验和过滤，避免用户输入的URL包含不安全的地址或参数。 2. 使用白名单机制，限制应用程序可以访问的外部地址和端口，避免攻击者利用SSRF漏洞访问内部网络。 3. 在后端代码中对发起的网络请求进行严格的限制，避免请求向内部网络发起。 4. 使用安全的HTTP客户端库，如Apache HttpComponents或OkHttp，避免使用不安全的HTTP客户端库，如HttpClient。 5. 针对敏感操作进行二次验证，如发送邮件等操作需要输入验证码或者短信验证等。 以上措施只是基本的防范方法，具体防范策略需要根据实际情况进行调整和优化。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值