HTTPS 客户端发送请求(四)

最新推荐文章于 2024-07-04 13:07:39 发布
原创 最新推荐文章于 2024-07-04 13:07:39 发布 · 1.1w 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#https #http #转换请求

本文介绍了如何在HTTP和HTTPS请求之间灵活转换，包括修改请求的port和设置无证书请求方式，通过使用Apache HttpClient库实现了HTTP、GET、PUT、DELETE和POST请求的发送，并处理了重定向情况。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

HTTP与HTTPS灵活转换请求



前言:在工作中我们可能不一定只用到https和http,有时候可能两者都会用到,那我们发送了一个连接的时候呢,我们如何灵活的转换两者的请求呢,此时我们的一个思路就是,首先是将请求的port修改,比如讲http://修改为了https://,第二部就是要讲https设置为无证书请求方式,这个地方我们用到了apache给我们提供的类进行转换,很好用的哦~~~


Maven管理


	<!-- httpclient begin -->
		<dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpclient</artifactId>
			<version>4.3.4</version>
		</dependency>
		<dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpasyncclient</artifactId>
			<version>4.0.2</version>
		</dependency>
		<dependency>
			<groupId>commons-httpclient</groupId>
			<artifactId>commons-httpclient</artifactId>
			<version>3.1</version>
		</dependency>
		<!-- httpclient end -->


转换类实现


package com.lives.platform.common.util;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

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

import org.apache.commons.httpclient.HttpStatus;
import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
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.ssl.SSLConnectionSocketFactory;
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.BasicHttpClientConnectionManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.apache.log4j.Logger;

public class HttpClientUtils {

	private static final String HTTPS_PROTOCOL = "https://";
	private static final int HTTPS_PROTOCOL_DEFAULT_PORT = 443;

	/**
	 * 默认编码格式
	 */
	private static final String DEFAULT_CHARSET = "UTF-8";

	private static Logger logger = Logger.getLogger(HttpClientUtils.class);

	private static int getPort(String url) {
		int startIndex = url.indexOf("://") + "://".length();
		String host = url.substring(startIndex);
		if (host.indexOf("/") != -1) {
			host = host.substring(0, host.indexOf("/"));
		}
		int port = HTTPS_PROTOCOL_DEFAULT_PORT;
		if (host.contains(":")) {
			int i = host.indexOf(":");
			port = new Integer(host.substring(i + 1));
		}
		return port;
	}

	private static List<NameValuePair> geneNameValPairs(
			Map<String, ?> params) {
		List<NameValuePair> pairs = new ArrayList<NameValuePair>();
		if (params == null) {
			return pairs;
		}
		for (String name : params.keySet()) {
			if (params.get(name) == null) {
				continue;
			}
			pairs.add(new BasicNameValuePair(name, params.get(name).toString()));
		}
		return pairs;
	}

	/**
	 * 发送GET请求
	 * @param url 请求地址
	 * @param charset 返回数据编码
	 * @return 返回数据
	 */
	public static String sendGetReq(final String url, String charset) {
		if (null == charset)
			charset = DEFAULT_CHARSET;
		CloseableHttpClient httpClient = HttpClientBuilder.create().build();
		HttpGet get = new HttpGet(url);
		if (url.toLowerCase().startsWith(HTTPS_PROTOCOL)) {
			initSSL(httpClient, getPort(url));
		}
		try {
			// 提交请求并以指定编码获取返回数据
			HttpResponse httpResponse = httpClient.execute(get);
			int statuscode = httpResponse.getStatusLine().getStatusCode();
	        if ((statuscode == HttpStatus.SC_MOVED_TEMPORARILY) ||
	            (statuscode == HttpStatus.SC_MOVED_PERMANENTLY) ||
	            (statuscode == HttpStatus.SC_SEE_OTHER) ||
	            (statuscode == HttpStatus.SC_TEMPORARY_REDIRECT)) {
	        	Header header = httpResponse.getFirstHeader("location");
	            if (header != null) {
	                String newuri = header.getValue();
	                if ((newuri == null) || (newuri.equals("")))
	                    newuri = "/";
	                try {
	    				httpClient.close();
	    			} catch (Exception e) {
	    				e.printStackTrace();
	    				httpClient = null;
	    			}
	                logger.info("重定向地址：" + newuri);
	                return sendGetReq(newuri, null);
	            }
	        }
			logger.info("请求地址：" + url + "；响应状态：" + httpResponse.getStatusLine());
			HttpEntity entity = httpResponse.getEntity();
			return EntityUtils.toString(entity, charset);
		} catch (ClientProtocolException e) {
			logger.error("协议异常,堆栈信息如下", e);
		} catch (IOException e) {
			logger.error("网络异常,堆栈信息如下", e);
		} finally {
			// 关闭连接，释放资源
			try {
				httpClient.close();
			} catch (Exception e) {
				e.printStackTrace();
				httpClient = null;
			}
		}
		return null;
	}

	/**
	 * 发送put请求
	 * @param url		请求地址
	 * @param params	请求参数
	 * @param charset	返回数据编码
	 * @return
	 */
	public static String sendPutReq(String url, Map<String, Object> params, String charset) {
		if (null == charset)
			charset = DEFAULT_CHARSET;
		CloseableHttpClient httpClient = HttpClientBuilder.create().build();
		HttpPut put = new HttpPut(url);

		// 封装请求参数
		List<NameValuePair> pairs = geneNameValPairs(params);
		try {
			put.setEntity(new UrlEncodedFormEntity(pairs, charset));
			if (url.startsWith(HTTPS_PROTOCOL)) {
				initSSL(httpClient, getPort(url));
			}
			// 提交请求并以指定编码获取返回数据
			HttpResponse httpResponse = httpClient.execute(put);

			logger.info("请求地址：" + url + "；响应状态：" + httpResponse.getStatusLine());
			HttpEntity entity = httpResponse.getEntity();
			return EntityUtils.toString(entity, charset);
		} catch (ClientProtocolException e) {
			logger.error("协议异常,堆栈信息如下", e);
		} catch (IOException e) {
			logger.error("网络异常,堆栈信息如下", e);
		} finally {
			// 关闭连接，释放资源
			try {
				httpClient.close();
			} catch (Exception e) {
				e.printStackTrace();
				httpClient = null;
			}
		}
		return null;
	}

	/**
	 * 发送delete请求
	 * @param url		请求地址
	 * @param charset	返回数据编码
	 * @return
	 */
	public static String sendDelReq(String url, String charset) {
		if (null == charset)
			charset = DEFAULT_CHARSET;
		CloseableHttpClient httpClient = HttpClientBuilder.create().build();
		HttpDelete del = new HttpDelete(url);
		if (url.toLowerCase().startsWith(HTTPS_PROTOCOL)) {
			initSSL(httpClient, getPort(url));
		}
		try {
			// 提交请求并以指定编码获取返回数据
			HttpResponse httpResponse = httpClient.execute(del);
			logger.info("请求地址：" + url + "；响应状态：" + httpResponse.getStatusLine());
			HttpEntity entity = httpResponse.getEntity();
			return EntityUtils.toString(entity, charset);
		} catch (ClientProtocolException e) {
			logger.error("协议异常,堆栈信息如下", e);
		} catch (IOException e) {
			logger.error("网络异常,堆栈信息如下", e);
		} finally {
			// 关闭连接，释放资源
			try {
				httpClient.close();
			} catch (Exception e) {
				e.printStackTrace();
				httpClient = null;
			}
		}
		return null;
	}

	/**
	 * 发送POST请求，支持HTTP与HTTPS
	 * @param url 请求地址
	 * @param params 请求参数
	 * @param charset 返回数据编码
	 * @return 返回数据
	 */
	public static String sendPostReq(String url, Map<String, ?> params, String charset) {
		if (null == charset)
			charset = DEFAULT_CHARSET;
		CloseableHttpClient httpClient = HttpClientBuilder.create().build();
		RequestConfig reqConf = RequestConfig.DEFAULT;
		HttpPost httpPost = new HttpPost(url);
		// 封装请求参数
		List<NameValuePair> pairs = geneNameValPairs(params);
		try {
			httpPost.setEntity(new UrlEncodedFormEntity(pairs, charset));
			// 对HTTPS请求进行处理
			if (url.toLowerCase().startsWith(HTTPS_PROTOCOL)) {
				initSSL(httpClient, getPort(url));
			}
			// 提交请求并以指定编码获取返回数据
			httpPost.setConfig(reqConf);
			HttpResponse httpResponse = httpClient.execute(httpPost);
			int statuscode = httpResponse.getStatusLine().getStatusCode();
	        if ((statuscode == HttpStatus.SC_MOVED_TEMPORARILY) ||
	            (statuscode == HttpStatus.SC_MOVED_PERMANENTLY) ||
	            (statuscode == HttpStatus.SC_SEE_OTHER) ||
	            (statuscode == HttpStatus.SC_TEMPORARY_REDIRECT)) {
	        	Header header = httpResponse.getFirstHeader("location");
	            if (header != null) {
	                String newuri = header.getValue();
	                if ((newuri == null) || (newuri.equals("")))
	                    newuri = "/";
	                try {
	    				httpClient.close();
	    			} catch (Exception e) {
	    				e.printStackTrace();
	    				httpClient = null;
	    			}
	                return sendGetReq(newuri, null);
	            }
	        }

			logger.info("请求地址：" + url + "；响应状态：" + httpResponse.getStatusLine());
			HttpEntity entity = httpResponse.getEntity();
			return EntityUtils.toString(entity, charset);
		} catch (UnsupportedEncodingException e) {
			logger.error("不支持当前参数编码格式[" + charset + "],堆栈信息如下", e);
		} catch (ClientProtocolException e) {
			logger.error("协议异常,堆栈信息如下", e);
		} catch (IOException e) {
			logger.error("网络异常,堆栈信息如下", e);
		} finally {
			// 关闭连接，释放资源
			try {
				httpClient.close();
			} catch (Exception e) {
				e.printStackTrace();
				httpClient = null;
			}
		}
		return null;
	}

	/**
	 * 发送POST请求，支持HTTP与HTTPS, 参数放入请求体方式
	 * @param url 请求地址
	 * @param params 请求参数
	 * @param charset 返回数据编码
	 * @return 返回数据
	 */
	public static String sendPost(String url, String content, String charset) {
		if (null == charset)
			charset = DEFAULT_CHARSET;
		CloseableHttpClient httpClient = HttpClientBuilder.create().build();
		RequestConfig reqConf = RequestConfig.DEFAULT;
		HttpPost httpPost = new HttpPost(url);
		try {
			httpPost.setEntity(new StringEntity(content, charset));
			// 对HTTPS请求进行处理
			if (url.toLowerCase().startsWith(HTTPS_PROTOCOL)) {
				initSSL(httpClient, getPort(url));
			}
			// 提交请求并以指定编码获取返回数据
			httpPost.setConfig(reqConf);
			HttpResponse httpResponse = httpClient.execute(httpPost);
			int statuscode = httpResponse.getStatusLine().getStatusCode();
			if ((statuscode == HttpStatus.SC_MOVED_TEMPORARILY) ||
					(statuscode == HttpStatus.SC_MOVED_PERMANENTLY) ||
					(statuscode == HttpStatus.SC_SEE_OTHER) ||
					(statuscode == HttpStatus.SC_TEMPORARY_REDIRECT)) {
				Header header = httpResponse.getFirstHeader("location");
				if (header != null) {
					String newuri = header.getValue();
					if ((newuri == null) || (newuri.equals("")))
						newuri = "/";
					try {
						httpClient.close();
					} catch (Exception e) {
						e.printStackTrace();
						httpClient = null;
					}
					return sendGetReq(newuri, null);
				}
			}

			logger.info("请求地址：" + url + "；响应状态：" + httpResponse.getStatusLine());
			HttpEntity entity = httpResponse.getEntity();
			return EntityUtils.toString(entity, charset);
		} catch (UnsupportedEncodingException e) {
			logger.error("不支持当前参数编码格式[" + charset + "],堆栈信息如下", e);
		} catch (ClientProtocolException e) {
			logger.error("协议异常,堆栈信息如下", e);
		} catch (IOException e) {
			logger.error("网络异常,堆栈信息如下", e);
		} finally {
			// 关闭连接，释放资源
			try {
				httpClient.close();
			} catch (Exception e) {
				e.printStackTrace();
				httpClient = null;
			}
		}
		return null;
	}

	/**
	 * 初始化HTTPS请求服务
	 * @param httpClient HTTP客户端
	 */
	public static void initSSL(CloseableHttpClient httpClient, int port) {
		SSLContext sslContext = null;
		try {
			sslContext = SSLContext.getInstance("SSL");
			final X509TrustManager trustManager = new X509TrustManager() {
				public void checkClientTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {
				}

				public void checkServerTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {
				}

				public X509Certificate[] getAcceptedIssuers() {
					return null;
				}
			};
			// 使用TrustManager来初始化该上下文,TrustManager只是被SSL的Socket所使用
			sslContext.init(null, new TrustManager[] { trustManager }, null);
			ConnectionSocketFactory ssf = new SSLConnectionSocketFactory(sslContext);
			Registry<ConnectionSocketFactory> r = RegistryBuilder.<ConnectionSocketFactory>create().register("https", ssf).build();
			BasicHttpClientConnectionManager ccm = new BasicHttpClientConnectionManager(r);
			HttpClients.custom().setConnectionManager(ccm).build();
		} catch (KeyManagementException e) {
			e.printStackTrace();
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
	}
}


ESP8266-Arduino网络编程实例-HTTPS客户端数据请求
视觉与物联智能
10-07 2060
超文本传输协议安全 (HTTPS) 是 HTTP的安全版本，HTTP 是用于在 Web 浏览器和网站之间发送数据的主要协议。HTTPS 经过加密，以提高数据传输的安全性。当用户传输敏感数据（例如通过登录银行账户、电子邮件服务或健康保险提供商）时，这一点尤其重要。从技术上来讲，HTTPS 并不是独立于 HTTP 的协议。它只是在 HTTP 协议的基础上使用 TLS/SSL 加密。HTTPS 基于 TLS/SSL 证书的传输而发生，该证书验证特定提供商就是他们声称的身份。
java客户端调用https资源
11-17
用Java原生类库实现的https client，可用客户端的形式访问https链接。
HTTPS 客户端发送请求(一)
小程序
06-21 1万+
HTTPS 发送请求(一)   摘 要 JSSE是一个SSL和TLS的纯Java实现，通过JSSE可以很容易地编程实现对HTTPS站点的访问。但是，如果该站点的证书未经权威机构的验证，JSSE将拒绝信任该证书从而不能访问HTTPS站点。本文在简要介绍JSSE的基础上提出了两种解决该问题的方法。   引言 　　过去的十几年，网络上已经积累了大量的Web应用。如今，无论是整合原有的Web
HTTPS 客户端发送请求(二)
小程序
06-21 1万+
https 完整web开发 Tomcat 6.0 配置 1、生成安全访问的证书。 命令行下执行：keytool -genkey -alias tomcat -keyalg RSA -keystore c:\tomcat.keystore 然后按提示输入一些密码等信息： 输入keystore密码： 再次输入新密码: 您的名字与姓氏是什么？    [Unknown]：  t
linux下https连接本地站点
hu8471479的专栏
12-31 2394
接我上一篇看博客，生成的.keystore在我的用户根目录/home/liz下，然后编辑tomcat服务器的server.xml,开放https,端口默认是8443 <Connector port="8443" protocol="HTTP/1.1" SSLEnabled="true" maxThreads="150" scheme="https" secure="t
WebSocket安卓客户端实现详解(二)--客户端发送请求
08-06
WebSocket是Web应用中的一种实时通信协议，它允许服务器与客户端之间进行双向通信，即服务器可以主动向客户端推送数据，而不仅仅是响应客户端的请求。在安卓客户端实现WebSocket时，我们需要了解和掌握以下几个关键...
模拟客户端发送请求和服务端接收请求
z972065491的博客
11-16 925
如果项目后端直接作为服务端，别人作为客户端，向服务端发送请求，我们如何能够保证在不进行监听的情况下，直接接收到请求呢。在具体的项目中，一般前端都相当于客户端进行请求的发送，而后端的。打开浏览器，在网址栏输入http请求：点击回车。端口号则是要发送地址的端口号，这里为。层则相当于服务端，接收请求并处理。作为服务端，我们可以直接新建一个。ip地址通过查看本机ip地址获得。作为客户端发送http请求。，来试一下通过浏览器或者。层作为服务端是否能接收到。
声明式HTTP客户端API框架，让Java发送HTTP/HTTPS请求不再难
05-02
声明式HTTP客户端API框架，让Java发送HTTP/HTTPS请求不再难。它比OkHttp和HttpClient更高层，是封装调用第三方restful api client接口的好帮手，是retrofit和feign之外另一个选择。通过在接口上声明注解的方式配置...
VC++演示GET/POST发送请求的HTTP客户端
03-15
内容索引:VC/C++源码,网络相关,HTTP　　VC++演示GET/POST发送请求的HTTP客户端，为了演示HTTP的客户编写的，因此运行时必须在本机有开HTTP服务才行。程序会会自动发送用户选择的请求类型，并跟踪这个请求，并返回...
java发送http/https请求(get/post)代码
12-02
自己项目里的，可用
发送https请求
qq_42184571的博客
01-24 1783
发送https请求 package com.xzgx.thirdparty.util; import com.xzgx.common.exception.CustomException; import com.xzgx.common.utils.StringUtils; import lombok.extern.slf4j.Slf4j; import org.apache.http.HttpEntity; import org.apache.http.HttpResponse; import org.ap
HTTP、HTTPS的请求过程
w418856的博客
04-11 315
需要注意的是，HTTP是无状态的协议，也就是说每次请求都是独立的，服务器不会保存任何关于客户端的信息。如果需要保持客户端状态，可以使用Cookie技术来实现。通过以上步骤，HTTPS协议提供了一种安全保护机制，使得客户端和服务器之间的通信不会被窃听、篡改或伪造。
http(s)（一）发送请求
w_t_y_y的博客
09-03 1万+
post、get请求一般出现在前端调用后端接口的时候，现在如果希望java代码(非controller，controller调另一个controller可以redirect重定向)去调用controller接口，比如在job定时器中，达到某一条件需要返回给前端一条提示消息（如订单30分钟内未付款，已被自动取消），而前端只能调controler接口，所以这时可以用job去调controller接口，......
HTML请求与相应
weixin_30590285的博客
02-24 674
HTTP的请求与响应 HTTP通信由两部分组成： 客户端请求消息 与 服务器响应消息 浏览器发送HTTP请求的过程： 　　当用户在浏览器的地址栏中输入一个URL并按回车键之后，浏览器会向HTTP服务器发送HTTP请求。HTTP请求主要分为“Get”和“Post”两种方法。 当我们在浏览器输入URL http://www.baidu.com 的时候，浏览器发送一个Request请求去获...
SpringBoot实战（二十九）发送HTTP/HTTPS请求的五种实现方式【上篇】（HttpURLConnection、HttpClient）
最新发布
ACGkaka的博客
07-04 4137
SpringBoot实战（二十九）发送HTTP/HTTPS请求的五种实现方式【上篇】（HttpURLConnection、HttpClient）
java发送https请求_Java发送HTTPS请求
weixin_42332131的博客
02-12 1726
前言上篇文章介绍了 java 发送 http 请求，大家都知道发送http是不安全的。我也是由于对接了其他企业后总结了一套发送 https的工具。大家网上找方法很多的，但是可不是你粘过来就能用啊，我也是踩过坑的，所以我这个工具，只要粘贴到你们自己项目里就可以用。我的工具跟网上没什么区别，唯一的区别是我亲身实战过，把需要注意的细节列出来，不让大家浪费时间。正文本文只介绍 发送 post 请求，既然...
HTTPS协议的详细讲解（四次握手）
热门推荐
m0_52165864的博客
05-05 4万+
HTTPS 协议（HyperText Transfer Protocol over Secure Socket Layer）：可以理解为HTTP+SSL/TLS， 即 HTTP 下加入 SSL 层，HTTPS 的安全基础是 SSL，因此加密的详细内容就需要 SSL，用于安全的 HTTP 数据传输。HTTPS协议是在HTTP的基础上加上了一个协议。SSL（Secure Socket Layer，安全套接字层）
安卓WebSocket客户端请求发送机制解析
根据文件信息，本篇内容将围绕“WebSocket安卓客户端实现详解(二)--客户端发送请求”进行知识点的讲解。WebSocket是一种网络通信协议，它提供了在单个TCP连接上进行全双工通信的能力。对于Android开发而言，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值