devbox
盐析白兔
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java发送HTTP/HTTPS请求工具类

作者：盐析白兔 | 2024-03-26 08:31:30

赞

踩

Java发送HTTP/HTTPS请求工具类

基于原生JDK的发送HTTP/HTTPS请求工具类。

  1. import java.io.BufferedReader;
  2. import java.io.BufferedWriter;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.io.InputStreamReader;
  6. import java.io.OutputStreamWriter;
  7. import java.io.UnsupportedEncodingException;
  8. import java.net.HttpURLConnection;
  9. import java.net.URL;
  10. import java.net.URLEncoder;
  11. import java.nio.charset.Charset;
  12. import java.security.KeyManagementException;
  13. import java.security.MessageDigest;
  14. import java.security.NoSuchAlgorithmException;
  15. import java.security.cert.CertificateException;
  16. import java.security.cert.X509Certificate;
  17. import java.util.Base64;
  18. import java.util.HashMap;
  19. import java.util.Map;
  20.  
  21. import javax.net.ssl.HostnameVerifier;
  22. import javax.net.ssl.HttpsURLConnection;
  23. import javax.net.ssl.SSLContext;
  24. import javax.net.ssl.SSLSession;
  25. import javax.net.ssl.TrustManager;
  26. import javax.net.ssl.X509TrustManager;
  27.  
  28. /**
  29.  * HTTP请求工具
  30.  *
  31.  */
  32. public class HttpUtil {
  33.  
  34. 	/**
  35. 	 * 发送简单GET请求
  36. 	 * 
  37. 	 * @param url 请求地址
  38. 	 * @return 请求结果，出现异常返回null
  39. 	 */
  40. 	public static Result get(String url) {
  41. 		try {
  42. 			return sendRequest(url, "GET", null, 0, 0, null, null, null, Charset.forName("UTF-8"),
  43. 					Charset.forName("UTF-8"), false);
  44. 		} catch (KeyManagementException | NoSuchAlgorithmException | IOException e) {
  45. 			// TODO
  46. 			e.printStackTrace();
  47. 		}
  48. 		return null;
  49. 	}
  50.  
  51. 	/**
  52. 	 * 发送简单POST请求
  53. 	 * 
  54. 	 * @param url  请求地址
  55. 	 * @param body 请求体
  56. 	 * @return 请求结果，出现异常返回null
  57. 	 */
  58. 	public static Result post(String url, String body) {
  59. 		try {
  60. 			return sendRequest(url, "POST", null, 0, 0, null, null, body, Charset.forName("UTF-8"),
  61. 					Charset.forName("UTF-8"), false);
  62. 		} catch (KeyManagementException | NoSuchAlgorithmException | IOException e) {
  63. 			// TODO
  64. 			e.printStackTrace();
  65. 		}
  66. 		return null;
  67. 	}
  68.  
  69. 	/**
  70. 	 * 发送简单POST请求
  71. 	 * 
  72. 	 * @param url         请求地址
  73. 	 * @param body        请求体
  74. 	 * @param contentType 请求体类型
  75. 	 * @return 请求结果，出现异常返回null
  76. 	 */
  77. 	public static Result post(String url, String body, String contentType) {
  78. 		Map<String, String> header = new HashMap<>();
  79. 		header.put("Content-Type", contentType);
  80. 		try {
  81. 			return sendRequest(url, "POST", null, 0, 0, header, null, body, Charset.forName("UTF-8"),
  82. 					Charset.forName("UTF-8"), false);
  83. 		} catch (KeyManagementException | NoSuchAlgorithmException | IOException e) {
  84. 			// TODO
  85. 			e.printStackTrace();
  86. 		}
  87. 		return null;
  88. 	}
  89.  
  90. 	/**
  91. 	 * 发送简单POST请求
  92. 	 * 
  93. 	 * @param url    请求地址
  94. 	 * @param body   请求体
  95. 	 * @param header 请求头
  96. 	 * @return 请求结果，出现异常返回null
  97. 	 */
  98. 	public static Result post(String url, String body, Map<String, String> header) {
  99. 		try {
  100. 			return sendRequest(url, "POST", null, 0, 0, header, null, body, Charset.forName("UTF-8"),
  101. 					Charset.forName("UTF-8"), false);
  102. 		} catch (KeyManagementException | NoSuchAlgorithmException | IOException e) {
  103. 			// TODO
  104. 			e.printStackTrace();
  105. 		}
  106. 		return null;
  107. 	}
  108.  
  109. 	/**
  110. 	 * 发送请求
  111. 	 * 
  112. 	 * @param url            请求地址
  113. 	 * @param methodType     请求类型,POST/GET
  114. 	 * @param protocol       HTTPS使用的加密协议，传入null则使用SSL协议
  115. 	 * @param connectTimeout 连接超时时间
  116. 	 * @param readTimeout    读回应超时时间
  117. 	 * @param header         请求头
  118. 	 * @param cookie         cookie
  119. 	 * @param body           请求体
  120. 	 * @param outCharset     发送请求采用的字符编码
  121. 	 * @param inCharset      读回应采用的字符编码
  122. 	 * @param useCahces      是否启用缓存，建议false
  123. 	 * @return 请求结果
  124. 	 * @throws IOException              网络流异常
  125. 	 * @throws KeyManagementException   证书异常
  126. 	 * @throws NoSuchAlgorithmException 加密协议无效
  127. 	 */
  128. 	public static Result sendRequest(String url, String methodType, String protocol, int connectTimeout,
  129. 			int readTimeout, Map<String, String> header, Map<String, String> cookie, String body, Charset outCharset,
  130. 			Charset inCharset, boolean useCahces) throws IOException, KeyManagementException, NoSuchAlgorithmException {
  131. 		if (isBlankStr(url)) {
  132. 			throw new RuntimeException("未传入有效URL！URL=" + url);
  133. 		}
  134. 		if (url.trim().toLowerCase().startsWith("http://")) {
  135. 			return Http.sendRequest(url, methodType, connectTimeout, readTimeout, header, cookie, body, outCharset,
  136. 					inCharset, useCahces);
  137. 		} else if (url.trim().toLowerCase().startsWith("https://")) {
  138. 			return Https.sendRequest(url, methodType, protocol, connectTimeout, readTimeout, header, cookie, body,
  139. 					outCharset, inCharset, useCahces);
  140. 		} else {
  141. 			throw new RuntimeException("不是HTTP或HTTPS地址！URL=" + url);
  142. 		}
  143. 	}
  144.  
  145. 	/**
  146. 	 * 判断字符串是否无内容
  147. 	 * 
  148. 	 * @param str
  149. 	 * @return 无内容返回true，否则返回false
  150. 	 */
  151. 	private static boolean isBlankStr(String str) {
  152. 		int strLen;
  153. 		if (str == null || (strLen = str.length()) == 0) {
  154. 			return true;
  155. 		}
  156. 		for (int i = 0; i < strLen; i++) {
  157. 			if (!Character.isWhitespace(str.charAt(i))) {
  158. 				return false;
  159. 			}
  160. 		}
  161. 		return true;
  162. 	}
  163.  
  164. 	/**
  165. 	 * base64加密
  166. 	 */
  167. 	public static String base64Encode(String original) {
  168. 		try {
  169. 			return new String(Base64.getEncoder().encode(original.getBytes("UTF-8")));
  170. 		} catch (UnsupportedEncodingException e) {
  171. 			e.printStackTrace();
  172. 		}
  173. 		return null;
  174. 	}
  175.  
  176. 	/**
  177. 	 * base64解密字
  178. 	 */
  179. 	public static String base64Decode(String ciphertext) {
  180. 		try {
  181. 			return new String(Base64.getDecoder().decode(ciphertext.getBytes("UTF-8")));
  182. 		} catch (UnsupportedEncodingException e) {
  183. 			e.printStackTrace();
  184. 		}
  185. 		return null;
  186. 	}
  187.  
  188. 	/***
  189. 	 * MD5加密
  190. 	 * 
  191. 	 * @param original 原文
  192. 	 * @return 密文，字母小写
  193. 	 */
  194. 	public static String md5(String original) {
  195. 		try {
  196. 			MessageDigest md5 = MessageDigest.getInstance("MD5");// 此 MessageDigest 类为应用程序提供信息摘要算法的功能
  197. 			byte[] digest = md5.digest(original.getBytes("UTF-8")); // 转换为MD5码
  198. 			StringBuilder resultHexString = new StringBuilder();
  199. 			String tempStr;
  200. 			for (byte b : digest) {
  201. 				tempStr = Integer.toHexString(b & 0xff); // 这里需要对b与0xff做位与运算，若b为负数，强制转换将高位位扩展会导致错误，故需要高位清零
  202. 				if (tempStr.length() == 1) { // 若转换后的十六进制数字只有一位，则在前补"0"
  203. 					resultHexString.append(0).append(tempStr);
  204. 				} else {
  205. 					resultHexString.append(tempStr);
  206. 				}
  207. 			}
  208. 			return resultHexString.toString();
  209. 		} catch (NoSuchAlgorithmException e) {
  210. 			e.printStackTrace();
  211. 		} catch (UnsupportedEncodingException e) {
  212. 			e.printStackTrace();
  213. 		}
  214. 		return null;
  215. 	}
  216.  
  217. 	/**
  218. 	 * 请求返回值模型
  219. 	 */
  220. 	public static class Result {
  221. 		private int code;// 请求返回的状态码
  222. 		private String content;// 请求返回的内容文本
  223.  
  224. 		public int getCode() {
  225. 			return code;
  226. 		}
  227.  
  228. 		public void setCode(int code) {
  229. 			this.code = code;
  230. 		}
  231.  
  232. 		public String getContent() {
  233. 			return content;
  234. 		}
  235.  
  236. 		public void setContent(String content) {
  237. 			this.content = content;
  238. 		}
  239.  
  240. 		@Override
  241. 		public String toString() {
  242. 			return "Result [code=" + code + ", content=" + content + "]";
  243. 		}
  244. 	}
  245.  
  246. 	/**
  247. 	 * HTTP请求实现
  248. 	 */
  249. 	public static class Http {
  250. 		/**
  251. 		 * @param url            请求地址
  252. 		 * @param methodType     请求类型,POST/GET
  253. 		 * @param connectTimeout 连接超时时间
  254. 		 * @param readTimeout    读回应超时时间
  255. 		 * @param header         请求头
  256. 		 * @param cookie         cookie
  257. 		 * @param body           请求体
  258. 		 * @param outCharset     发送请求采用的字符编码
  259. 		 * @param inCharset      读回应采用的字符编码
  260. 		 * @param useCahces      是否启用缓存，建议false
  261. 		 * @return 返回结果
  262. 		 * @throws IOException 网络流异常
  263. 		 */
  264. 		public static Result sendRequest(String url, String methodType, int connectTimeout, int readTimeout,
  265. 				Map<String, String> header, Map<String, String> cookie, String body, Charset outCharset,
  266. 				Charset inCharset, boolean useCahces) throws IOException {
  267. 			HttpURLConnection con = null;
  268.  
  269. //		// 添加请求参数
  270. //		if (params != null) {
  271. //			for (String headerKey : header.keySet()) {
  272. //				con.setRequestProperty(headerKey, header.get(headerKey));// 设置请求属性
  273. //			}
  274. //		}
  275.  
  276. 			URL urlObject = new URL(url);
  277. 			con = (HttpURLConnection) urlObject.openConnection(); // 得到连接对象
  278. 			con.setRequestMethod(methodType); // 设置请求类型
  279.  
  280. 			// 连接超时时间
  281. 			if (connectTimeout >= 0) {
  282. 				con.setConnectTimeout(connectTimeout);
  283. 			}
  284. 			// 读取超时时间
  285. 			if (readTimeout >= 0) {
  286. 				con.setReadTimeout(readTimeout);
  287. 			}
  288.  
  289. 			// 添加请求头
  290. 			if (header != null) {
  291. 				for (String headerKey : header.keySet()) {
  292. 					con.setRequestProperty(headerKey, header.get(headerKey));// 设置请求属性
  293. 				}
  294. 			}
  295.  
  296. 			// 添加cookie
  297. 			if (cookie != null) {
  298. 				StringBuilder c = new StringBuilder();
  299. 				for (String name : cookie.keySet()) {
  300. 					String value = cookie.get(name);
  301. 					if (value == null) {
  302. 						continue;
  303. 					}
  304. 					value = URLEncoder.encode(value, outCharset.name());
  305. 					c.append(name + "=" + value + ";");
  306. 				}
  307. 				c.deleteCharAt(c.length() - 2);
  308. 				con.setRequestProperty("Cookie", c.toString());// 设置请求属性
  309. 			}
  310.  
  311. 			con.setDoOutput(true); // 允许写出
  312. 			con.setDoInput(true); // 允许读入
  313. 			con.setUseCaches(useCahces);// 是否使用缓存
  314.  
  315. 			// 写入请求体
  316. 			if (body != null) {
  317. 				BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(con.getOutputStream(), outCharset));
  318. 				bw.write(body);
  319. 				bw.close();
  320. 			}
  321.  
  322. 			int responseCode = con.getResponseCode(); // 得到响应码
  323. 			Result result = new Result();
  324. 			InputStream is = null;
  325. 			if (responseCode == HttpURLConnection.HTTP_OK) { // 正常返回状态码
  326. 				is = con.getInputStream();
  327. 			} else { // 400、401等其他错误类型
  328. 				is = con.getErrorStream();
  329. 			}
  330. 			BufferedReader in = null;
  331. 			in = new BufferedReader(new InputStreamReader(is, inCharset));
  332. 			StringBuilder resultBuffer = new StringBuilder();// 将响应流转换成字符串
  333. 			String line = "";
  334. 			while ((line = in.readLine()) != null) {
  335. 				resultBuffer.append(line);
  336. 			}
  337. 			result.setCode(responseCode);
  338. 			result.setContent(resultBuffer.toString());
  339.  
  340. 			if (null != is) {
  341. 				is.close();
  342. 			}
  343. 			if (null != in) {
  344. 				in.close();
  345. 			}
  346. 			con.disconnect();// 关闭连接
  347. 			return result;
  348. 		}
  349.  
  350. 	}
  351.  
  352. 	/**
  353. 	 * HTTPS类型请求实现
  354. 	 */
  355. 	public static class Https {
  356. 		/**
  357. 		 * 发送请求
  358. 		 * 
  359. 		 * @param url            请求地址
  360. 		 * @param methodType     请求类型,POST/GET
  361. 		 * @param protocol       HTTPS使用的加密协议，传入null则使用SSL协议
  362. 		 * @param connectTimeout 连接超时时间
  363. 		 * @param readTimeout    读回应超时时间
  364. 		 * @param header         请求头
  365. 		 * @param cookie         cookie
  366. 		 * @param body           请求体
  367. 		 * @param outCharset     是否启用缓存，建议false
  368. 		 * @param inCharset      发送请求采用的字符编码
  369. 		 * @param useCahces      读回应采用的字符编码
  370. 		 * @return 返回结果
  371. 		 * @throws IOException
  372. 		 * @throws KeyManagementException   秘钥异常
  373. 		 * @throws NoSuchAlgorithmException 找不到加密协议
  374. 		 */
  375. 		public static Result sendRequest(String url, String methodType, String protocol, int connectTimeout,
  376. 				int readTimeout, Map<String, String> header, Map<String, String> cookie, String body,
  377. 				Charset outCharset, Charset inCharset, boolean useCahces)
  378. 				throws IOException, KeyManagementException, NoSuchAlgorithmException {
  379. 			HttpsURLConnection connection = null;
  380. 			if (protocol == null) {
  381. 				protocol = "SSL";// 默认协议
  382. 			}
  383. 			trustAllHttpsCertificates(protocol);// 信任所有证书
  384.  
  385. 			URL realUrl = new URL(url);
  386. 			connection = (HttpsURLConnection) realUrl.openConnection();// 转为HTTPS
  387. 			connection.setHostnameVerifier(getHostnameVerifier());// 主机验证规则
  388. 			connection.setDoOutput(true);// 输出(发送数据)
  389. 			connection.setDoInput(true);// 输入(接收数据)
  390. 			connection.setUseCaches(useCahces); // 设置是否开启缓存，post请求时，缓存必须关掉
  391. 			connection.setRequestMethod(methodType); // 请求方法
  392.  
  393. 			// 超时时间
  394. 			if (connectTimeout >= 0) {
  395. 				connection.setConnectTimeout(connectTimeout);
  396. 			}
  397.  
  398. 			// 读取超时时间
  399. 			if (readTimeout >= 0) {
  400. 				connection.setReadTimeout(readTimeout);
  401. 			}
  402.  
  403. 			// 添加请求头
  404. 			if (header != null) {
  405. 				for (String headerKey : header.keySet()) {
  406. 					connection.setRequestProperty(headerKey, header.get(headerKey));// 设置请求属性
  407. 				}
  408. 			}
  409.  
  410. 			// 添加cookie
  411. 			if (cookie != null) {
  412. 				StringBuilder c = new StringBuilder();
  413. 				for (String name : cookie.keySet()) {
  414. 					String value = cookie.get(name);
  415. 					if (value == null) {
  416. 						continue;
  417. 					}
  418. 					value = URLEncoder.encode(value, outCharset.name());
  419. 					c.append(name + "=" + value + ";");
  420. 				}
  421. 				c.deleteCharAt(c.length() - 2);
  422. 				connection.setRequestProperty("Cookie", c.toString());// 设置请求属性
  423. 			}
  424.  
  425. 			// 写入请求体
  426. 			if (body != null) {
  427. 				BufferedWriter bw = new BufferedWriter(
  428. 						new OutputStreamWriter(connection.getOutputStream(), outCharset));
  429. 				bw.write(body);
  430. 				bw.flush();
  431. 				bw.close();
  432. 			}
  433.  
  434. 			InputStream is = null;
  435. 			BufferedReader in = null;
  436. 			StringBuffer resultStr = new StringBuffer();
  437. 			int responseCode = connection.getResponseCode();// 请求响应码
  438. 			if (responseCode == HttpURLConnection.HTTP_OK) { // 正常返回状态码200
  439. 				is = connection.getInputStream();
  440. 			} else { // 400、401等其他错误类型
  441. 				is = connection.getErrorStream();
  442. 			}
  443.  
  444. 			in = new BufferedReader(new InputStreamReader(is, inCharset));
  445. 			String line = "";
  446. 			while ((line = in.readLine()) != null) {
  447. 				resultStr.append(line);
  448. 			}
  449. 			Result result = new Result();
  450. 			result.setCode(responseCode);
  451. 			result.setContent(resultStr.toString());
  452. 			if (null != is) {
  453. 				is.close();
  454. 			}
  455. 			if (null != in) {
  456. 				in.close();
  457. 			}
  458. 			connection.disconnect();
  459. 			return result;
  460. 		}
  461.  
  462. 		/**
  463. 		 * 信任所有证书
  464. 		 */
  465. 		private static void trustAllHttpsCertificates(String protocol)
  466. 				throws KeyManagementException, NoSuchAlgorithmException {
  467. 			TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {
  468. 				public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
  469. 					return;
  470. 				}
  471.  
  472. 				public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
  473. 					return;
  474. 				}
  475.  
  476. 				public X509Certificate[] getAcceptedIssuers() {
  477. 					return null;
  478. 				}
  479. 			} };
  480. 			SSLContext sc = SSLContext.getInstance(protocol);
  481. 			sc.init(null, trustAllCerts, null);
  482. 			HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
  483. 		}
  484.  
  485. 		/**
  486. 		 * 所有主机验证都通过
  487. 		 * 
  488. 		 * @return 主机验证对象
  489. 		 */
  490. 		private static HostnameVerifier getHostnameVerifier() {
  491. 			return new HostnameVerifier() {
  492. 				@Override
  493. 				public boolean verify(String hostname, SSLSession session) {
  494. 					return true;
  495. 				}
  496. 			};
  497. 		}
  498. 	}
  499. }

使用方式如下：

  1. import java.io.IOException;
  2. import java.nio.charset.Charset;
  3. import java.security.KeyManagementException;
  4. import java.security.NoSuchAlgorithmException;
  5. import java.util.HashMap;
  6. import java.util.Map;
  7.  
  8. import util.HttpUtil;
  9.  
  10. public class Test {
  11.  
  12. 	public static void main(String[] args) {
  13.  
  14. 		HttpUtil.Result getResult = HttpUtil.get("http://127.0.0.1:8080");
  15. 		System.out.println(getResult.getContent());
  16.  
  17. 		HttpUtil.Result psotResult1 = HttpUtil.post("http://127.0.0.1:8080/api/sms/send", "name=shencomd");
  18. 		System.out.println(psotResult1.getContent());
  19.  
  20. 		HttpUtil.Result psotResult2 = HttpUtil.post("http://127.0.0.1:8080/api/sms/send", "{\"name\":\"shencomd\"}",
  21. 				"application/json");
  22. 		System.out.println(psotResult2.getContent());
  23.  
  24. 		String url = "https://127.0.0.1:8082/api/sms/send";// 请求地址
  25. 		String method = "POST";// 请求类型
  26. 		int connectTimeout = 0;// 连接超时时间
  27. 		int readTimeout = 0; // 读回应超时时间
  28. 		String protocol = "SSL";// 加密协议
  29. 		Map<String, String> header = new HashMap<>();// 请求头
  30. 		header.put("Content-Type", "application/json");
  31. 		Map<String, String> cookie = new HashMap<>();
  32. 		cookie.put("sessionid", "asiuqwenqweasga");
  33. 		String body = "{\"name\":\"shencomd\"}";// 请求体
  34. 		Charset outCharset = Charset.forName("utf-8"); // 发送请求采用的字符编码
  35. 		Charset inCharset = Charset.forName("utf-8"); // 读回应采用的字符编码
  36. 		boolean useCahces = false; // 是否启用缓存
  37. 		try {
  38. 			HttpUtil.Result psotResult3 = HttpUtil.sendRequest(url, method, protocol, connectTimeout, readTimeout,
  39. 					header, cookie, body, outCharset, inCharset, useCahces);
  40. 			if (psotResult3.getCode() == 200) {
  41. 				System.out.println(psotResult3.getContent());
  42. 			} else {
  43. 				System.out.println("请求发生错误，结果如下:");
  44. 				System.out.println(psotResult3.getContent());
  45. 			}
  46. 		} catch (KeyManagementException | NoSuchAlgorithmException | IOException e) {
  47. 			e.printStackTrace();
  48. 		}
  49. 	}
  50. }

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号