spring boot 整合 HttpClient

最新推荐文章于 2024-04-20 16:38:15 发布
最新推荐文章于 2024-04-20 16:38:15 发布
阅读量1.9k 收藏 4
点赞数
分类专栏： htpClient 文章标签： httpClient
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/woshixiazaizhe/article/details/83027129
版权

第一步：引入HttpClient 的jar包

1、 httpClient 5.0 开始支持异步（Async）请求；

2、httpclient 版本过低上传文件会出，原因是 org.apache.http.entity.ContentType 没有方法 withParameters(final NameValuePair... params)；

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

第二步：创建一个httpClient的配置类

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;
	}
	
}

第三步：创建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;
	}
	
}

第四步：创建HttpClient无效连接清除类

/**
 * 定期清理无效的http连接
 * @author viruser
 *
 */
package com.123.lenovo.adapter.se.common;

import java.util.concurrent.TimeUnit;

import javax.annotation.PreDestroy;

import org.apache.http.conn.HttpClientConnectionManager;

/**
 * 定期清理无效的http连接
 * @author viruser
 *
 */
public class IdleConnectionEvictor extends Thread {

	private final HttpClientConnectionManager manager;
	
	private Integer waitTime;
	
	private Integer idleConTime;
	
	private volatile boolean shutdown = true;
	
	public IdleConnectionEvictor(HttpClientConnectionManager manager, Integer waitTime, Integer idleConTime) {
		this.manager = manager;
		this.waitTime = waitTime;
		this.idleConTime = idleConTime;
		this.start();
	}
	
	@Override
	public void run() {
		try {
			if (shutdown) {
				synchronized (this) {
					wait(waitTime);
					manager.closeIdleConnections(idleConTime, TimeUnit.SECONDS);
					// 关闭失效的连接
					manager.closeExpiredConnections();
				}
			}
		} catch (Exception e) {
			
		}
	}
	
	@PreDestroy
	public void shutdown() {
		shutdown = false;
		synchronized (this) {
			notifyAll();
		}
	}
	
}

 

一代键客
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring boot封装HttpClient的示例代码
08-28
Spring Boot 封装 HttpClient 的示例代码 Spring Boot 是一个基于 Java 的框架，用于快速构建生产级别的应用程序，而 HttpClient 则是一个流行的 HTTP 客户端库，用于发送 HTTP 请求。为了使 HttpClient 的使用更加...
SpringBoot使用HttpClient
weixin_57763462的博客
06-29 7444
一、HttpClient 两个系统间如何互相访问？两个tomcat上的项目如何互相访问 采用HttpClient实现跨系统的接口调用。 1 1.2、 什么是HttpClient 官网：http://hc.apache.org/index.html 特点： HttpClient别名：HttpComponents HttpClient可以发送get、post、put、delete、…等请求 1.3、 HttpClient入门案例 <dependency> <groupId&..
【HttpClient】在 SpringBoot 中使用 HttpClient 实现 HTTP 请求
热门推荐
sco5282的博客
11-25 1万+
越来越多的 Java 应用程序需要直接通过 HTTP 协议来访问网络资源。虽然在 JDK 的 java.net 包中已经提供了访问 HTTP 协议的基本功能，但是对于大部分应用程序来说，JDK 库本身提供的功能还不够丰富和灵活。 HttpClient 是 Apache Jakarta Common 下的子项目，用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。 ...
SpringBoot集成HttpClient
最新发布
qq_51773341的博客
04-20 1272
HttpClient 是Apache Jakarta Common 下的子项目，可以用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。发送HTTP请求接收响应数据当我们在使用扫描支付、查看地图、获取验证码、查看天气等功能时其实，应用程序本身并未实现这些功能，都是在应用程序里访问提供这些功能的服务，访问这些服务需要发送HTTP请求，并且接收响应数据，可通过HttpClient来实现。
springboot整合httpclient
yaoct的博客
12-04 2454
HttpClientConfig： package com.demo1.config; import org.apache.http.client.config.RequestConfig; import org.apache.http.impl.client.CloseableHttpClient; import org.apache.http.impl.client.HttpClientBuilder; import org.apache.http.impl.conn.PoolingHttpCli
Springboot——HttpClient入门（Get和Post）
apple_51927114的博客
11-29 1225
HttpClient 是Apache Jakarta Common 下的子项目，可以用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。发送HTTP请求接收响应数据当我们在使用扫描支付、查看地图、获取验证码、查看天气等功能时其实，应用程序本身并未实现这些功能，都是在应用程序里访问提供这些功能的服务，访问这些服务需要发送HTTP请求，并且接收响应数据，可通过HttpClient来实现。</</</</
SpringBoot ：SpringBoot 2.x 集成HttpClient
qq_31432773的博客
04-17 3346
目录 连接池的设置。 获取连接超时时间、建立连接超时时间、保持连接超时时间的设置。 长连接策略的设置。 连接逐出策略的设置。 重试机制的设置。 个性化请求参数的设置。 附录。 序 HttpClient可以用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。 使用HttpClient发送请求和接收响应的步骤： 创建CloseableHttpClient对象； 创建请求方法实例，并指定请求URL。例：如果要发送Get请求，创
Spring-boot httpclient mysql爬取京东数据
01-18
在本项目中，我们主要探讨如何使用Spring Boot集成HttpClient库来爬取京东网站的数据，并将这些数据存储到MySQL数据库中。这是一个非常适合初学者的技术实践，旨在帮助开发者了解Web爬虫的基本构建块以及如何在实际...
springboot整合httpClient代码实例
08-25
Spring Boot 整合 HttpClient 代码实例 在本文中，我们将介绍如何在 Spring Boot 项目中整合 HttpClient，提供了详细的代码实例，帮助开发者更好地理解和使用 HttpClient。 为什么需要 HttpClient 在实际开发中，...
Spring Boot全套教程.txt
08-16
------------------------课程介绍------------------------ ...14-SringBoot整合Redis、Httpclient、RabbitMQ 15-SpringBoot设置SpringMVC的配置 16-启动测试（解决一些问题） 17-SpringBoot发布到独立的tomcat
httpclient(springboot)demo
05-06
本篇将详细介绍如何在Spring Boot项目中整合HttpClient，以及这个整合的示例（demo）所涉及的关键知识点。 首先，让我们理解Spring Boot与HttpClient的整合过程： 1. **添加依赖**：在`pom.xml`文件中，你需要引入...
Spring Boot进阶(72)：【教程】用Spring Boot和HttpClient实现高效的HTTP请求
**My Coding Family**
06-29 4562
本文主要包括以下内容： 使用Spring Boot和HttpClient实现基础的HTTP请求 实现带有请求头和请求体的HTTP请求 实现HTTPS请求 借助于Apache HttpClient的高级特性，如连接池、请求重试、请求超时等 通过单元测试验证HTTP请求的正确性和可靠性
Spring 或 SpringBoot 整合HttpClient
weixin_42545531的博客
05-24 3772
------------------------------------httpclient ------------------------ 1.引入jar包 <!--httpclient--> <dependency> <groupId>org.apache.httpcomponents</groupId> <arti...
「HttpClient」在 SpringBoot 中使用 HttpClient 实现 HTTP 请求
wdj0311的博客
11-29 1063
越来越多的 Java 应用程序需要直接通过 HTTP 协议来访问网络资源。虽然在 JDK 的 java.net 包中已经提供了访问 HTTP 协议的基本功能，但是对于大部分应用程序来说，JDK 库本身提供的功能还不够丰富和灵活。 HttpClient 是 Apache Jakarta Common 下的子项目，用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。 新建一个SpringBoot工程，引入httpclient的 POM...
SpringBoot整合HttpClient
秋叶清风的博客
10-18 2186
参考 SpringBoot整合HttpClient
HttpClient常用操作及封装工具类
rqz__的博客
07-30 1533
HttpClient 是一个用于发送 HTTP 请求和接收 HTTP 响应的类库/模块，可以用于编写客户端应用程序，通过 HTTP 与服务器进行通信。 HttpClient 提供了一组方法和类，使得发送 HTTP 请求变得简单和方便。它支持各种 HTTP 方法，例如 GET、POST、PUT、DELETE 等，并可以设置请求的头部信息、请求参数、请求体等。
Spring Boot入门教程(五十): httpclient
人不风流枉少年
10-12 4131
引入依赖 &amp;amp;lt;dependency&amp;amp;gt; &amp;amp;lt;groupId&amp;amp;gt;org.apache.httpcomponents&amp;amp;lt;/groupId&amp;amp;gt; &amp;amp;lt;artifactId&amp;amp;gt;httpclient&amp;amp;lt;/artifactId&amp;amp;g

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值