1 package com.juchn.gateway.common.utils;
2
3 import java.io.BufferedReader;
4 import java.io.IOException;
5 import java.io.InputStream;
6 import java.io.InputStreamReader;
7 import java.security.KeyManagementException;
8 import java.security.KeyStoreException;
9 import java.security.NoSuchAlgorithmException;
10 import java.security.cert.CertificateException;
11 import java.security.cert.X509Certificate;
12 import java.util.ArrayList;
13 import java.util.Iterator;
14 import java.util.List;
15 import java.util.Map;
16 import java.util.Map.Entry;
17
18 import javax.net.ssl.SSLContext;
19
20 import org.apache.commons.lang3.StringUtils;
21 import org.apache.http.HttpEntity;
22 import org.apache.http.HttpHost;
23 import org.apache.http.NameValuePair;
24 import org.apache.http.ParseException;
25 import org.apache.http.client.config.RequestConfig;
26 import org.apache.http.client.entity.UrlEncodedFormEntity;
27 import org.apache.http.client.methods.CloseableHttpResponse;
28 import org.apache.http.client.methods.HttpGet;
29 import org.apache.http.client.methods.HttpPost;
30 import org.apache.http.client.methods.HttpPut;
31 import org.apache.http.client.utils.URLEncodedUtils;
32 import org.apache.http.conn.ssl.NoopHostnameVerifier;
33 import org.apache.http.entity.StringEntity;
34 import org.apache.http.impl.client.CloseableHttpClient;
35 import org.apache.http.impl.client.HttpClients;
36 import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
37 import org.apache.http.message.BasicNameValuePair;
38 import org.apache.http.ssl.SSLContextBuilder;
39 import org.apache.http.ssl.TrustStrategy;
40 import org.apache.http.util.EntityUtils;
41 import org.slf4j.Logger;
42 import org.slf4j.LoggerFactory;
43
44 /**
45 * 新版httpClient的工具方法
46 *
47 * @author tangzl
48 * @since 2019年04月11日
49 */
50 public class HttpClientUtil {
51
52 static Logger log = LoggerFactory.getLogger(HttpClientUtil.class);
53 protected static final String CHARSET = "UTF-8";
54 protected static final String CHARSET_GBK = "UTF-8";
55 /** 默认超时时间 */
56 private final static int default_timeout = 10000;
57
58 private static PoolingHttpClientConnectionManager cm = null;
59
60 private static CloseableHttpClient httpclient = null;
61 static {
62
63 // 多连接的线程安全的管理器
64 cm = new PoolingHttpClientConnectionManager();
65 cm.setDefaultMaxPerRoute(100); // 每个主机的最大并行链接数
66 cm.setMaxTotal(200); // 客户端总并行链接最大数
67
68 httpclient = HttpClients.custom().setConnectionManager(cm).build();
69 }
70
71 /**
72 * 发送 get请求
73 *
74 * @param url
75 * @param timeout 超时时间
76 * @param ignoreHttps 是否忽略https证书检查
77 * @return
78 */
79 public static String get(String url, Map<String, String> params, Integer timeout, boolean ignoreHttps,
80 HttpHost proxy) {
81 CloseableHttpClient client = null;
82 if (ignoreHttps) {
83 client = getIgnoreHttpsClient();
84 } else {
85 client = httpclient;
86 }
87 try {
88 HttpGet httpGet = null;
89 if (params == null)
90 httpGet = new HttpGet(url);
91 else {
92 List<NameValuePair> qparams = new ArrayList<NameValuePair>();
93 for (Entry<String, String> entry : params.entrySet()) {
94 qparams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
95 }
96 String queryParams = URLEncodedUtils.format(qparams, "UTF-8");
97 if (url.indexOf("?") != -1) {
98 url += "&" + queryParams;
99 } else {
100 url += "?" + queryParams;
101 }
102 httpGet = new HttpGet(url);
103 }
104 timeout = timeout != null ? timeout : default_timeout;
105 RequestConfig.Builder builder = RequestConfig.custom();// 设置请求和传输超时时间
106 if (null != proxy) {
107 builder.setProxy(proxy);
108 }
109 RequestConfig requestConfig = builder.setSocketTimeout(timeout).setConnectTimeout(timeout).build();// 设置请求和传输超时时间
110 httpGet.setConfig(requestConfig);
111
112 CloseableHttpResponse response = client.execute(httpGet);
113 HttpEntity entity = response.getEntity();
114 try {
115 if (entity != null)
116 return EntityUtils.toString(entity);
117 } finally {
118 if (entity != null)
119 EntityUtils.consume(entity);
120 response.close();
121 }
122 } catch (ParseException e) {
123 log.error("发送HTTP请求时出现异常：" + e);
124 e.printStackTrace(System.out);
125 } catch (IOException e) {
126 log.error("发送HTTP请求时出现异常：" + e);
127 e.printStackTrace(System.out);
128 } catch (Exception e) {
129 log.error("发送HTTP请求时出现异常：" + e);
130 e.printStackTrace(System.out);
131 } finally {
132 /*
133 * try { httpclient.close(); } catch (IOException e) {
134 * log.error("关闭HTTP连接时出现异常：" + e); }
135 */
136 }
137 return null;
138 }
139
140 /**
141 * 发送 get请求
142 *
143 * @param url
144 * @param timeout 超时时间
145 * @param ignoreHttps 是否忽略https证书检查
146 * @return
147 */
148 public static String get(String url, Map<String, String> params, Map<String, Object> headers, Integer timeout,
149 boolean ignoreHttps) {
150 CloseableHttpClient client = null;
151 if (ignoreHttps) {
152 client = getIgnoreHttpsClient();
153 } else {
154 client = httpclient;
155 }
156 try {
157 HttpGet httpGet = null;
158 if (params != null && params.size() > 0) {
159 List<NameValuePair> qparams = new ArrayList<NameValuePair>();
160 for (Entry<String, String> entry : params.entrySet()) {
161 qparams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
162 }
163 String queryParams = URLEncodedUtils.format(qparams, "UTF-8");
164 if (url.indexOf("?") != -1) {
165 url += "&" + queryParams;
166 } else {
167 url += "?" + queryParams;
168 }
169
170 }
171 httpGet = new HttpGet(url);
172 httpGet.setHeader("Content-type", "application/json;charset=UTF-8");
173 if (headers != null && headers.size() > 0) {
174 for (Iterator<String> iter = headers.keySet().iterator(); iter.hasNext();) {
175 String key = iter.next();
176 httpGet.setHeader(key, headers.get(key).toString());
177 }
178 }
179
180 timeout = timeout != null ? timeout : default_timeout;
181 RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(timeout).setConnectTimeout(timeout)
182 .build();// 设置请求和传输超时时间
183 httpGet.setConfig(requestConfig);
184
185 CloseableHttpResponse response = client.execute(httpGet);
186 HttpEntity entity = response.getEntity();
187 try {
188 if (entity != null)
189 return EntityUtils.toString(entity);
190 } finally {
191 if (entity != null)
192 EntityUtils.consume(entity);
193 response.close();
194 }
195 } catch (ParseException e) {
196 log.error("发送HTTP请求时出现异常：" + e);
197 e.printStackTrace(System.out);
198 } catch (IOException e) {
199 log.error("发送HTTP请求时出现异常：" + e);
200 e.printStackTrace(System.out);
201 } catch (Exception e) {
202 log.error("发送HTTP请求时出现异常：" + e);
203 e.printStackTrace(System.out);
204 } finally {
205 /*
206 * try { httpclient.close(); } catch (IOException e) {
207 * log.error("关闭HTTP连接时出现异常：" + e); }
208 */
209 }
210 return null;
211 }
212
213 /**
214 * 发送 get请求
215 *
216 * @param url
217 * @param timeout 超时时间
218 * @param ignoreHttps 是否忽略https证书检查
219 * @return
220 */
221 public static String get(String url, Map<String, String> params, Integer timeout, boolean ignoreHttps) {
222 CloseableHttpClient client = null;
223 if (ignoreHttps) {
224 client = getIgnoreHttpsClient();
225 } else {
226 client = httpclient;
227 }
228 try {
229 HttpGet httpGet = null;
230 if (params == null)
231 httpGet = new HttpGet(url);
232 else {
233 List<NameValuePair> qparams = new ArrayList<NameValuePair>();
234 for (Entry<String, String> entry : params.entrySet()) {
235 qparams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
236 }
237 String queryParams = URLEncodedUtils.format(qparams, "UTF-8");
238 if (url.indexOf("?") != -1) {
239 url += "&" + queryParams;
240 } else {
241 url += "?" + queryParams;
242 }
243 httpGet = new HttpGet(url);
244 }
245 timeout = timeout != null ? timeout : default_timeout;
246 RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(timeout).setConnectTimeout(timeout)
247 .build();// 设置请求和传输超时时间
248 httpGet.setConfig(requestConfig);
249
250 CloseableHttpResponse response = client.execute(httpGet);
251 HttpEntity entity = response.getEntity();
252 try {
253 if (entity != null)
254 return EntityUtils.toString(entity);
255 } finally {
256 if (entity != null)
257 EntityUtils.consume(entity);
258 response.close();
259 }
260 } catch (ParseException e) {
261 log.error("发送HTTP请求时出现异常：" + e);
262 e.printStackTrace(System.out);
263 } catch (IOException e) {
264 log.error("发送HTTP请求时出现异常：" + e);
265 e.printStackTrace(System.out);
266 } catch (Exception e) {
267 log.error("发送HTTP请求时出现异常：" + e);
268 e.printStackTrace(System.out);
269 } finally {
270 /*
271 * try { httpclient.close(); } catch (IOException e) {
272 * log.error("关闭HTTP连接时出现异常：" + e); }
273 */
274 }
275 return null;
276 }
277
278 /**
279 * 发送get请求
280 *
281 * @param url
282 * @param timeout 超时时间(毫秒)
283 * @return
284 */
285 public static String get(String url, Map<String, String> params, Integer timeout) {
286 return get(url, params, timeout, false);
287 }
288
289 /**
290 * 发送get请求
291 *
292 * @param url
293 * @param timeout 超时时间(毫秒)
294 * @return
295 */
296 public static String get(String url, Map<String, String> params, Map<String, Object> headers) {
297 return get(url, params, headers, null, false);
298 }
299
300 /**
301 * 发送 get请求
302 *
303 * @param url
304 * @param timeout 超时时间
305 * @param ignoreHttps 是否忽略https证书检查
306 * @return
307 */
308 public static String get(String url, Integer timeout, boolean ignoreHttps) {
309 return get(url, null, timeout, ignoreHttps);
310 }
311
312 /**
313 * 获取忽略https证书的client
314 *
315 * @return
316 */
317 public static CloseableHttpClient getIgnoreHttpsClient() {
318 SSLContext sslContext = null;
319 try {
320 sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
321 public boolean isTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {
322 return true;
323 }
324 }).build();
325 } catch (KeyManagementException e) {
326 e.printStackTrace();
327 } catch (NoSuchAlgorithmException e) {
328 e.printStackTrace();
329 } catch (KeyStoreException e) {
330 e.printStackTrace();
331 }
332
333 return HttpClients.custom().setSslcontext(sslContext).setSSLHostnameVerifier(new NoopHostnameVerifier())
334 .build();
335 }
336
337 /**
338 * 发送 post请求
339 *
340 * @param url
341 * @param timeout 超时时间(毫秒)
342 * @param params 请求参数
343 * @return
344 */
345 public static String post(String url, Map<String, String> params, Integer timeout) {
346
347 CloseableHttpClient httpclient = HttpClients.custom().setConnectionManager(cm).build();
348 try {
349
350 HttpPost httpPost = new HttpPost(url);
351 if (params != null) {
352 List<NameValuePair> qparams = new ArrayList<NameValuePair>();
353 for (Entry<String, String> entry : params.entrySet()) {
354 qparams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
355 }
356 httpPost.setEntity(new UrlEncodedFormEntity(qparams, "UTF-8"));
357 }
358 timeout = timeout != null ? timeout : default_timeout;
359 RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(timeout).setConnectTimeout(timeout)
360 .build();// 设置请求和传输超时时间
361 httpPost.setConfig(requestConfig);
362
363 CloseableHttpResponse response = httpclient.execute(httpPost);
364 HttpEntity entity = response.getEntity();
365 try {
366 if (entity != null) {
367 StringBuilder sb = new StringBuilder();
368 String line = null;
369 InputStream inputStream = entity.getContent();
370 try {
371 BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
372 while ((line = bufferedReader.readLine()) != null) {
373 sb.append(line);
374 }
375 } finally {
376 inputStream.close();
377 }
378 return sb.toString();
379 }
380 } finally {
381 response.close();
382 }
383
384 /*
385 * try { if (entity != null) return EntityUtils.toString(entity); } finally { if
386 * (entity != null) EntityUtils.consume(entity); response.close(); }
387 */
388 } catch (ParseException e) {
389 log.error("发送HTTP请求时出现异常：" + e);
390 e.printStackTrace(System.out);
391 } catch (IOException e) {
392 log.error("发送HTTP请求时出现异常：" + e);
393 e.printStackTrace(System.out);
394 } catch (Exception e) {
395 log.error("发送HTTP请求时出现异常：" + e);
396 e.printStackTrace(System.out);
397 } finally {
398 /*
399 * try { httpclient.close(); } catch (IOException e) {
400 * log.error("关闭HTTP连接时出现异常：" + e); }
401 */
402 }
403 return null;
404 }
405
406 /**
407 * 发送 post请求 带请求头
408 *
409 * @param url
410 * @param params
411 * @param headers
412 * @param timeout
413 * @return
414 */
415 public static String post(String url, Map<String, String> params, Map<String, String> headers, Integer timeout) {
416
417 CloseableHttpClient httpclient = HttpClients.custom().setConnectionManager(cm).build();
418 try {
419 HttpPost httpPost = new HttpPost(url);
420
421 if (params != null) {
422 List<NameValuePair> qparams = new ArrayList<NameValuePair>();
423 for (Entry<String, String> entry : params.entrySet()) {
424 qparams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
425 }
426 httpPost.setEntity(new UrlEncodedFormEntity(qparams, CHARSET));
427 }
428 if (headers != null && headers.size() > 0) {
429 for (Iterator<String> iter = headers.keySet().iterator(); iter.hasNext();) {
430 String key = iter.next();
431 httpPost.setHeader(key, headers.get(key));
432 }
433 }
434 timeout = timeout != null ? timeout : default_timeout;
435 RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(timeout).setConnectTimeout(timeout)
436 .build();// 设置请求和传输超时时间
437 httpPost.setConfig(requestConfig);
438
439 CloseableHttpResponse response = httpclient.execute(httpPost);
440 HttpEntity entity = response.getEntity();
441
442 // 方法一：
443 try {
444 if (entity != null) {
445 StringBuilder sb = new StringBuilder();
446 String line = null;
447 InputStream inputStream = entity.getContent();
448 try {
449 BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
450 while ((line = bufferedReader.readLine()) != null) {
451 sb.append(line);
452 }
453 } finally {
454 inputStream.close();
455 }
456 return sb.toString();
457 }
458 } finally {
459 response.close();
460 }
461
462 // 方法二：
463 /*
464 * try { if (entity != null) return EntityUtils.toString(entity); } finally { if
465 * (entity != null) EntityUtils.consume(entity); response.close(); }
466 */
467 } catch (ParseException e) {
468 log.error("发送HTTP请求时出现异常：" + e);
469 e.printStackTrace(System.out);
470 } catch (IOException e) {
471 log.error("发送HTTP请求时出现异常：" + e);
472 e.printStackTrace(System.out);
473 } catch (Exception e) {
474 log.error("发送HTTP请求时出现异常：" + e);
475 e.printStackTrace(System.out);
476 } finally {
477 /*
478 * try { httpclient.close(); } catch (IOException e) {
479 * log.error("关闭HTTP连接时出现异常：" + e); }
480 */
481 }
482 return null;
483 }
484
485 /**
486 * post body
487 *
488 * @param url
489 * @param params 请求body内容
490 * @return
491 */
492 public static String postBody(String url, String params, Map<String, String> headers, Integer timeout) {
493
494 CloseableHttpClient httpclient = HttpClients.custom().setConnectionManager(cm).build();
495 try {
496
497 HttpPost httpPost = new HttpPost(url);
498 if (!StringUtils.isEmpty(params)) {
499 httpPost.setEntity(new StringEntity(params, "UTF-8"));
500 }
501 if (headers != null && headers.size() > 0) {
502 for (Iterator<String> iter = headers.keySet().iterator(); iter.hasNext();) {
503 String key = iter.next();
504 httpPost.setHeader(key, headers.get(key));
505 }
506 }
507 timeout = timeout != null ? timeout : default_timeout;
508 RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(timeout).setConnectTimeout(timeout)
509 .build();// 设置请求和传输超时时间
510 httpPost.setConfig(requestConfig);
511
512 CloseableHttpResponse response = httpclient.execute(httpPost);
513 HttpEntity entity = response.getEntity();
514 // 方法一：
515 try {
516 if (entity != null) {
517 StringBuilder sb = new StringBuilder();
518 String line = null;
519 InputStream inputStream = entity.getContent();
520 try {
521 BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
522 while ((line = bufferedReader.readLine()) != null) {
523 sb.append(line);
524 }
525 } finally {
526 inputStream.close();
527 }
528 return sb.toString();
529 }
530 } finally {
531 response.close();
532 }
533 // 方法二：
534 /*
535 * try { if (entity != null) return EntityUtils.toString(entity); } finally { if
536 * (entity != null) EntityUtils.consume(entity); response.close(); }
537 */
538 } catch (ParseException e) {
539 log.error("发送HTTP请求时出现异常：" + e);
540 e.printStackTrace(System.out);
541 } catch (IOException e) {
542 log.error("发送HTTP请求时出现异常：" + e);
543 e.printStackTrace(System.out);
544 } catch (Exception e) {
545 log.error("发送HTTP请求时出现异常：" + e);
546 e.printStackTrace(System.out);
547 } finally {
548 }
549 return null;
550 }
551
552 public static String postBodyJson(String url, String params, Map<String, String> headers, Integer timeout) {
553
554 CloseableHttpClient httpclient = HttpClients.custom().setConnectionManager(cm).build();
555 try {
556
557 HttpPost httpPost = new HttpPost(url);
558 httpPost.setHeader("Content-type", "application/json;charset=UTF-8");
559 if (!StringUtils.isEmpty(params)) {
560 httpPost.setEntity(new StringEntity(params, "UTF-8"));
561 }
562 if (headers != null && headers.size() > 0) {
563 for (Iterator<String> iter = headers.keySet().iterator(); iter.hasNext();) {
564 String key = iter.next();
565 httpPost.setHeader(key, headers.get(key));
566 }
567 }
568 timeout = timeout != null ? timeout : default_timeout;
569 RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(timeout).setConnectTimeout(timeout)
570 .build();// 设置请求和传输超时时间
571 httpPost.setConfig(requestConfig);
572
573 CloseableHttpResponse response = httpclient.execute(httpPost);
574 HttpEntity entity = response.getEntity();
575 // 方法一：
576 try {
577 if (entity != null) {
578 StringBuilder sb = new StringBuilder();
579 String line = null;
580 InputStream inputStream = entity.getContent();
581 try {
582 BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
583 while ((line = bufferedReader.readLine()) != null) {
584 sb.append(line);
585 }
586 } finally {
587 inputStream.close();
588 }
589 return sb.toString();
590 }
591 } finally {
592 response.close();
593 }
594 // 方法二：
595 /*
596 * try { if (entity != null) return EntityUtils.toString(entity); } finally { if
597 * (entity != null) EntityUtils.consume(entity); response.close(); }
598 */
599 } catch (ParseException e) {
600 log.error("发送HTTP请求时出现异常：" + e);
601 e.printStackTrace(System.out);
602 } catch (IOException e) {
603 log.error("发送HTTP请求时出现异常：" + e);
604 e.printStackTrace(System.out);
605 } catch (Exception e) {
606 log.error("发送HTTP请求时出现异常：" + e);
607 e.printStackTrace(System.out);
608 } finally {
609 }
610 return null;
611 }
612
613 public static String putBodyJson(String url, String params, Map<String, String> headers, Integer timeout) {
614
615 CloseableHttpClient httpclient = HttpClients.custom().setConnectionManager(cm).build();
616 try {
617
618 HttpPut httpPost = new HttpPut(url);
619 httpPost.setHeader("Content-type", "application/json;charset=UTF-8");
620 if (!StringUtils.isEmpty(params)) {
621 httpPost.setEntity(new StringEntity(params, "UTF-8"));
622 }
623 if (headers != null && headers.size() > 0) {
624 for (Iterator<String> iter = headers.keySet().iterator(); iter.hasNext();) {
625 String key = iter.next();
626 httpPost.setHeader(key, headers.get(key));
627 }
628 }
629 timeout = timeout != null ? timeout : default_timeout;
630 RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(timeout).setConnectTimeout(timeout)
631 .build();// 设置请求和传输超时时间
632 httpPost.setConfig(requestConfig);
633
634 CloseableHttpResponse response = httpclient.execute(httpPost);
635 HttpEntity entity = response.getEntity();
636 // 方法一：
637 try {
638 if (entity != null) {
639 StringBuilder sb = new StringBuilder();
640 String line = null;
641 InputStream inputStream = entity.getContent();
642 try {
643 BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
644 while ((line = bufferedReader.readLine()) != null) {
645 sb.append(line);
646 }
647 } finally {
648 inputStream.close();
649 }
650 return sb.toString();
651 }
652 } finally {
653 response.close();
654 }
655 // 方法二：
656 /*
657 * try { if (entity != null) return EntityUtils.toString(entity); } finally { if
658 * (entity != null) EntityUtils.consume(entity); response.close(); }
659 */
660 } catch (ParseException e) {
661 log.error("发送HTTP请求时出现异常：" + e);
662 e.printStackTrace(System.out);
663 } catch (IOException e) {
664 log.error("发送HTTP请求时出现异常：" + e);
665 e.printStackTrace(System.out);
666 } catch (Exception e) {
667 log.error("发送HTTP请求时出现异常：" + e);
668 e.printStackTrace(System.out);
669 } finally {
670 }
671 return null;
672 }
673 }
