记录 一下HttpClientUtil

已于 2022-12-30 19:28:28 修改
阅读量114 收藏
点赞数
分类专栏： JAVA 文章标签： https http
于 2021-05-17 16:58:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ITnuo/article/details/116939424
版权

需要用到的maven路径

<!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient -->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.13</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpmime -->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpmime</artifactId>
            <version>4.5.13</version>
        </dependency>

直接上代码，觉得好用的可以拿去

package com.link800.guilinBank.util;

import org.apache.commons.lang.StringUtils;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.AuthSchemes;
import org.apache.http.client.config.CookieSpecs;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.entity.StringEntity;
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.BasicNameValuePair;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

/**
 * http请求工具类
 * 
 * @author zhuzhe
 * @date 2018/5/3 11:46
 */
public class HttpClientUtil {

	/**
	 * get
	 *
	 * @param host
	 * @param path
	 *
	 * @param headers
	 * @param querys
	 * @return
	 * @throws Exception
	 */
	public static HttpResponse doGet(String host, String path, Map<String, String> headers, Map<String, String> querys)
			throws Exception {
		HttpClient httpClient = wrapClient(host, path);
		HttpGet request = new HttpGet(buildUrl(host, path, querys));
		for (Map.Entry<String, String> e : headers.entrySet()) {
			request.addHeader(e.getKey(), e.getValue());
		}
		return httpClient.execute(request);
	}

	/**
	 * post form
	 *
	 * @param host
	 * @param path
	 *
	 * @param headers
	 * @param querys
	 * @param bodys
	 * @return
	 * @throws Exception
	 */
	public static HttpResponse doPost(String host, String path, Map<String, String> headers, Map<String, String> querys,
			Map<String, String> bodys) throws Exception {
		HttpClient httpClient = wrapClient(host, path);
		HttpPost request = new HttpPost(buildUrl(host, path, querys));
		for (Map.Entry<String, String> e : headers.entrySet()) {
			request.addHeader(e.getKey(), e.getValue());
		}
		if (bodys != null) {
			List<NameValuePair> nameValuePairList = new ArrayList<NameValuePair>();

			for (String key : bodys.keySet()) {
				nameValuePairList.add(new BasicNameValuePair(key, bodys.get(key)));
			}
			UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(nameValuePairList, "utf-8");
			formEntity.setContentType("application/x-www-form-urlencoded; charset=UTF-8");
			request.setEntity(formEntity);
		}
		return httpClient.execute(request);
	}

	/**
	 * Post String
	 *
	 * @param host
	 * @param path
	 *
	 * @param headers
	 * @param querys
	 * @param body
	 * @return
	 * @throws Exception
	 */
	public static HttpResponse doPost(String host, String path, Map<String, String> headers, Map<String, String> querys,
			String body) throws Exception {
		HttpClient httpClient = wrapClient(host, path);
		HttpPost request = new HttpPost(buildUrl(host, path, querys));
		for (Map.Entry<String, String> e : headers.entrySet()) {
			request.addHeader(e.getKey(), e.getValue());
		}
		if (StringUtils.isNotBlank(body)) {
			request.setEntity(new StringEntity(body, "utf-8"));
		}
		return httpClient.execute(request);
	}

	/**
	 * Post stream
	 *
	 * @param host
	 * @param path
	 *
	 * @param headers
	 * @param querys
	 * @param body
	 * @return
	 * @throws Exception
	 */
	public static HttpResponse doPost(String host, String path, Map<String, String> headers, Map<String, String> querys,
			byte[] body) throws Exception {
		HttpClient httpClient = wrapClient(host, path);
		HttpPost request = new HttpPost(buildUrl(host, path, querys));
		for (Map.Entry<String, String> e : headers.entrySet()) {
			request.addHeader(e.getKey(), e.getValue());
		}
		if (body != null) {
			request.setEntity(new ByteArrayEntity(body));
		}
		return httpClient.execute(request);
	}

	/**
	 * Put String
	 * 
	 * @param host
	 * @param path
	 *
	 * @param headers
	 * @param querys
	 * @param body
	 * @return
	 * @throws Exception
	 */
	public static HttpResponse doPut(String host, String path, Map<String, String> headers, Map<String, String> querys,
			String body) throws Exception {
		HttpClient httpClient = wrapClient(host, path);
		HttpPut request = new HttpPut(buildUrl(host, path, querys));
		for (Map.Entry<String, String> e : headers.entrySet()) {
			request.addHeader(e.getKey(), e.getValue());
		}
		if (StringUtils.isNotBlank(body)) {
			request.setEntity(new StringEntity(body, "utf-8"));
		}
		return httpClient.execute(request);
	}

	/**
	 * Put stream
	 * 
	 * @param host
	 * @param path
	 *
	 * @param headers
	 * @param querys
	 * @param body
	 * @return
	 * @throws Exception
	 */
	public static HttpResponse doPut(String host, String path, Map<String, String> headers, Map<String, String> querys,
			byte[] body) throws Exception {
		HttpClient httpClient = wrapClient(host, path);
		HttpPut request = new HttpPut(buildUrl(host, path, querys));
		for (Map.Entry<String, String> e : headers.entrySet()) {
			request.addHeader(e.getKey(), e.getValue());
		}
		if (body != null) {
			request.setEntity(new ByteArrayEntity(body));
		}
		return httpClient.execute(request);
	}

	/**
	 * Delete
	 *
	 * @param host
	 * @param path
	 *
	 * @param headers
	 * @param querys
	 * @return
	 * @throws Exception
	 */
	public static HttpResponse doDelete(String host, String path, Map<String, String> headers,
			Map<String, String> querys) throws Exception {
		HttpClient httpClient = wrapClient(host, path);
		HttpDelete request = new HttpDelete(buildUrl(host, path, querys));
		for (Map.Entry<String, String> e : headers.entrySet()) {
			request.addHeader(e.getKey(), e.getValue());
		}
		return httpClient.execute(request);
	}

	/**
	 * 构建请求的 url
	 * 
	 * @param host
	 * @param path
	 * @param querys
	 * @return
	 * @throws UnsupportedEncodingException
	 */
	private static String buildUrl(String host, String path, Map<String, String> querys)
			throws UnsupportedEncodingException {
		StringBuilder sbUrl = new StringBuilder();
		if (!StringUtils.isBlank(host)) {
			sbUrl.append(host);
		}
		if (!StringUtils.isBlank(path)) {
			sbUrl.append(path);
		}
		if (null != querys) {
			StringBuilder sbQuery = new StringBuilder();
			for (Map.Entry<String, String> query : querys.entrySet()) {
				if (0 < sbQuery.length()) {
					sbQuery.append("&");
				}
				if (StringUtils.isBlank(query.getKey()) && !StringUtils.isBlank(query.getValue())) {
					sbQuery.append(query.getValue());
				}
				if (!StringUtils.isBlank(query.getKey())) {
					sbQuery.append(query.getKey());
					if (!StringUtils.isBlank(query.getValue())) {
						sbQuery.append("=");
						sbQuery.append(URLEncoder.encode(query.getValue(), "utf-8"));
					}
				}
			}
			if (0 < sbQuery.length()) {
				sbUrl.append("?").append(sbQuery);
			}
		}
		return sbUrl.toString();
	}

	/**
	 * 获取 HttpClient
	 * 
	 * @param host
	 * @param path
	 * @return
	 */
	private static HttpClient wrapClient(String host, String path) {
		HttpClient httpClient = HttpClientBuilder.create().build();
		if (host != null && host.startsWith("https://")) {
			return sslClient();
		} else if (StringUtils.isBlank(host) && path != null && path.startsWith("https://")) {
			return sslClient();
		}
		return httpClient;
	}

	/**
	 * 在调用SSL之前需要重写验证方法，取消检测SSL 创建ConnectionManager，添加Connection配置信息
	 * 
	 * @return HttpClient 支持https
	 */
	private static HttpClient sslClient() {
		try {
			// 在调用SSL之前需要重写验证方法，取消检测SSL
			X509TrustManager trustManager = new X509TrustManager() {
				@Override
				public X509Certificate[] getAcceptedIssuers() {
					return null;
				}

				@Override
				public void checkClientTrusted(X509Certificate[] xcs, String str) {
				}

				@Override
				public void checkServerTrusted(X509Certificate[] xcs, String str) {
				}
			};
			SSLContext ctx = SSLContext.getInstance(SSLConnectionSocketFactory.TLS);
			ctx.init(null, new TrustManager[] { trustManager }, null);
			SSLConnectionSocketFactory socketFactory = new SSLConnectionSocketFactory(ctx,
					NoopHostnameVerifier.INSTANCE);
			// 创建Registry
			RequestConfig requestConfig = RequestConfig.custom().setCookieSpec(CookieSpecs.STANDARD_STRICT)
					.setExpectContinueEnabled(Boolean.TRUE)
					.setTargetPreferredAuthSchemes(Arrays.asList(AuthSchemes.NTLM, AuthSchemes.DIGEST))
					.setProxyPreferredAuthSchemes(Arrays.asList(AuthSchemes.BASIC)).build();
			Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
					.register("http", PlainConnectionSocketFactory.INSTANCE).register("https", socketFactory).build();
			// 创建ConnectionManager，添加Connection配置信息
			PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(
					socketFactoryRegistry);
			CloseableHttpClient closeableHttpClient = HttpClients.custom().setConnectionManager(connectionManager)
					.setDefaultRequestConfig(requestConfig).build();
			return closeableHttpClient;
		} catch (KeyManagementException ex) {
			throw new RuntimeException(ex);
		} catch (NoSuchAlgorithmException ex) {
			throw new RuntimeException(ex);
		}
	}
}

这个工具类还是挺全的支持访问https,记一下双向验证的还未记录，有空把它找出来记录记录

IT丶诺
关注
专栏目录
[工具类]HttpClientUtil简单工具
Yihy的博客
09-17 1987
[工具类]HttpClientUtil简单工具简单的封装了POST、GET、上传、下载功能代码片package cc.yihy.jsoup.utils;import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.io.UnsupportedEncodingException
记录常用的代码工具(一)--HttpClient
小浩子的博客
01-17 597
在企业环境中，httpclient基本是http最常用的工具，根据自己的开发经历，整合了一个通用的工具类 包： <dependency> <groupId>commons-httpclient</groupId> <artifactId>commons-httpclient</artifactId> <version>3.1</version> </dependency> 工具类： 单例模式 支持多种请
HttpClientUtil.java
10-23
构造一个http 请求的主体类，然后通过该类在java中模拟http请求
HttpClientUtil
weixin_34198762的博客
07-22 383
详细介绍及传参的方式： HTTP 协议可能是现在 Internet 上使用得最多、最重要的协议了，越来越多的 Java 应用程序需要直接通过 HTTP 协议来访问网络资源。虽然在 JDK 的 java net包中已经提供了访问 HTTP 协议的基本功能，但是对于大部分应用程序来说，JDK 库本身提供的功能还不够丰富和灵活。HttpClient 是 Apache Jak...
httpClientUtil工具类,简单,好用
lxf_superCSDN的博客
05-30 4298
1.引出httpClientmaven依赖 &lt;dependency&gt; &lt;groupId&gt;org.apache.httpcomponents&lt;/groupId&gt; &lt;artifactId&gt;httpclient&lt;/artifactId&gt; &lt;version&gt;4.4.1&lt;/version&gt; &
maven项目中使用HttpClient调用远端接口时报错
banxinggao9210的博客
09-01 705
我在项目中通过调用之前写好的HttpClient工具类请求远端POST接口，今天突然发现不好使了。报错org.apache.http.conn.socket.PlainConnectionSocketFactory.......，通过报错内容可以看出是http请求失败。我的HttpClient工具类在一个common-util项目中，通过maven依赖这个项目调用的http请求方法。最后...
http请求工具类HttpClientUtil，get，post请求（csdn）————程序.pdf
12-01
1. **HttpClientUtil 类结构**： 类中定义了一个静态的日志器 LOGGER，用于记录执行过程中的信息，使用的是 SLF4J 日志框架。此外，创建了一个静态的 `CloseableHttpClient` 实例 `client`，这是 HttpClient 的核心...
HttpClient框架所需的jar包和一个简单实例
10-07
4. `commons-logging.jar`：HttpClient使用了 Commons Logging API 进行日志记录，这个库是必需的。 5. `commons-codec.jar`：编码和解码库，如Base64编码，用于HTTP认证等。 以下是一个简单的HttpClient使用示例：...
HttpClient接口测试（详解加token传递实战）
sunnygao的博客
09-21 6329
文章目录HttpClient 接口测试1.Get请求 操作步骤1.1无参数2.Post请求2.1有Form形式的参数2.2JSON形式的参数3.注意事项4.排查思路5.HttpClient+Java+TestNG接口测试实战6、Java正则表达式Pattern和Matcher1.抓取文本内容（txt）2.抓取页面（html）HttpClient综合实战（token传递） HttpClient 接口测试 1.Get请求 操作步骤 ​ get请求第一种情况接受参数，第二种情况传参 1.1无参数 Stri
httpclient-4.5所需jar包
07-15
6. **commons-logging-x.x.jar**：这是一个日志抽象层，HTTPClient使用它来记录运行时信息。它允许开发者选择不同的日志实现，如log4j或java.util.logging。 7. **commons-codec-x.x.jar**：提供了常见的编码和解码...
httpClientUtil
11-13
自己做项目中用到的，以后保存下来以防以后用到。多多积累。
httpclient所需jar包
07-31
java开发用到的httpclientutil工具类，不用maven管理时，导入此jar包
HttpClient 4.5 封装的工具类 HttpUtil 可用于爬虫和模拟登陆
06-26
基于Apache HttpClient 4.5.2 封装的工具类 HttpUtil 可用于爬虫和模拟登陆。使用新的语法后比3.*版本的速度感觉有提升。使用后注意资源的释放 pom 部分，应该不全，需要用的根据代码的import去找maven资源即可。 org.apache.httpcomponents httpclient 4.5.2 org.apache.httpcomponents httpmime 4.5.1
Java_HttpClientUtil
致终将逝去的编程青春
12-04 709
Java发送HTTP请求访问接口: HttpClient 是apache 组织下面的一个用于处理HTTP 请求和响应的开源工具 1、HTTP-REQUEST-GET /** * HTTP-REQUEST-GET * @param url * @param dataMap * @return */ public static S
HttpClientUtils 工具类
bug先僧的博客
03-05 2123
maven项目需要在pom文件中添加相关的包依赖 &lt;dependency&gt; &lt;groupId&gt;top.jfunc.json&lt;/groupId&gt; &lt;artifactId&gt;Json-Gson&lt;/artifactId&gt; &lt;version&gt;1.0&lt;/...
HttpClientUtil工具类
weixin_43716343的博客
08-16 275
HTTP协议的特点如下： 1.支持客户/服务器模式。 2.简单快速：客户向服务器请求服务时，只需传送请求方法和路径。请求方法常用的有GET、HEAD、POST。每种方法规定了客户与服务器联系的类型不同。 由于HTTP协议简单，使得HTTP服务器的程序规模小，因而通信速度很快。 3.灵活：HTTP允许传输任意类型的数据对象。正在传输的类型由Content-Type加以标记。 4.无连接：无连接的含义是限制每次连接只处理一个请求。服务器处理完客户的请求，并收到客户的应答后，即断开连接。采用这种方式可以节省传输时
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值