E1ED922C1E9526DD63272D7EC5C6CB77
2021-02-07 46911b2d954fb8952cc178aa388d977d52d69927
提交 | 用户 | age
5c5945 1 package com.hx.util;
E 2
3 import net.sf.json.JSONException;
4 import net.sf.json.JSONObject;
5 import org.apache.commons.io.IOUtils;
a1dba4 6 import org.bouncycastle.util.encoders.UTF8;
5c5945 7 import org.springframework.web.multipart.MultipartFile;
E 8
9 import javax.activation.MimetypesFileTypeMap;
8bc3c9 10 import javax.servlet.ServletInputStream;
C 11 import javax.servlet.http.HttpServletRequest;
5c5945 12 import java.io.*;
E 13 import java.net.HttpURLConnection;
14 import java.net.URL;
a1dba4 15 import java.nio.charset.Charset;
E 16 import java.nio.charset.CharsetEncoder;
5c5945 17 import java.util.Iterator;
E 18 import java.util.List;
19 import java.util.Map;
20
21 /**
22  * http 工具类
23  */
24 public class HttpUtil {
25
26     /**multipart/form-data 格式发送数据时各个部分分隔符的前缀,必须为 --*/
27     private static final String BOUNDARY_PREFIX = "--";
28     /**回车换行,用于一行的结尾*/
29     private static final String LINE_END = "\r\n";
30
8bc3c9 31     public static String getInputStream(HttpServletRequest request) throws Exception {
C 32         ServletInputStream stream = null;
33         BufferedReader reader = null;
34         StringBuffer sb = new StringBuffer();
35         try {
36             stream = request.getInputStream();
37             // 获取响应
38             reader = new BufferedReader(new InputStreamReader(stream));
39             String line;
40             while ((line = reader.readLine()) != null) {
41                 sb.append(line);
42             }
43         } catch (IOException e) {
44             //logger.error(e);
45             throw new RuntimeException("读取返回支付接口数据流出现异常!");
46         } finally {
47             reader.close();
48         }
49         //logger.info("输入流返回的内容:" + sb.toString());
50         return sb.toString();
51     }
5c5945 52
E 53     public static String post(String requestUrl, String accessToken, String params)
54             throws Exception {
55         String contentType = "application/x-www-form-urlencoded";
56         return HttpUtil.post(requestUrl, accessToken, contentType, params);
57     }
58
59     public static String post(String requestUrl, String accessToken, String contentType, String params)
60             throws Exception {
61         String encoding = "UTF-8";
62         if (requestUrl.contains("nlp")) {
63             encoding = "GBK";
64         }
65         return HttpUtil.post(requestUrl, accessToken, contentType, params, encoding);
66     }
67
68     public static String post(String requestUrl, String accessToken, String contentType, String params, String encoding)
69             throws Exception {
70         String url = requestUrl + "?access_token=" + accessToken;
71         return HttpUtil.postGeneralUrl(url, contentType, params, encoding);
72     }
73
74     public static String postGeneralUrl(String generalUrl, String contentType, String params, String encoding)
75             throws Exception {
76         URL url = new URL(generalUrl);
77         // 打开和URL之间的连接
78         HttpURLConnection connection = (HttpURLConnection) url.openConnection();
79         connection.setRequestMethod("POST");
80         // 设置通用的请求属性
81         connection.setRequestProperty("Content-Type", contentType);
82         connection.setRequestProperty("Connection", "Keep-Alive");
83         connection.setUseCaches(false);
84         connection.setDoOutput(true);
85         connection.setDoInput(true);
86
87         // 得到请求的输出流对象
88         DataOutputStream out = new DataOutputStream(connection.getOutputStream());
89         out.write(params.getBytes(encoding));
90         out.flush();
91         out.close();
92
93         // 建立实际的连接
94         connection.connect();
95         // 获取所有响应头字段
96         Map<String, List<String>> headers = connection.getHeaderFields();
97         // 遍历所有的响应头字段
98         for (String key : headers.keySet()) {
99             System.err.println(key + "--->" + headers.get(key));
100         }
101         // 定义 BufferedReader输入流来读取URL的响应
102         BufferedReader in = null;
103         in = new BufferedReader(
104                 new InputStreamReader(connection.getInputStream(), encoding));
105         String result = "";
106         String getLine;
107         while ((getLine = in.readLine()) != null) {
108             result += getLine;
109         }
110         in.close();
111         System.err.println("result:" + result);
112         return result;
113     }
114
a1dba4 115     /**
E 116      * 带header的post请求
117      * @param generalUrl
118      * @param header
119      * @param params
120      * @return
121      * @throws Exception
122      */
123     public static String post(String generalUrl, Map<String, String> header, String params)
124             throws Exception {
125         URL url = new URL(generalUrl);
126         // 打开和URL之间的连接
127         HttpURLConnection connection = (HttpURLConnection) url.openConnection();
128         connection.setRequestMethod("POST");
129         // 设置通用的请求属性
130         connection.setRequestProperty("Connection", "Keep-Alive");
131         if(header != null)
132         {
133             for(String key : header.keySet())
134             {
135                 connection.setRequestProperty(key, header.get(key));
136             }
137         }
138
139         connection.setUseCaches(false);
140         connection.setDoOutput(true);
141         connection.setDoInput(true);
142
143         // 得到请求的输出流对象
144         DataOutputStream out = new DataOutputStream(connection.getOutputStream());
145         out.write(params.getBytes("UTF-8"));
146         out.flush();
147         out.close();
148
149         // 建立实际的连接
150         connection.connect();
151         // 定义 BufferedReader输入流来读取URL的响应
152         BufferedReader in = null;
153         in = new BufferedReader(
154                 new InputStreamReader(connection.getInputStream(), "UTF-8"));
155         String result = "";
156         String getLine;
157         while ((getLine = in.readLine()) != null) {
158             result += getLine;
159         }
160         in.close();
161
162         return result;
163     }
164
46911b 165     /**
E 166      * 带header的get请求
167      * @param generalUrl
168      * @param header
169      * @return
170      * @throws Exception
171      */
172     public static String get(String generalUrl, Map<String, String> header)
173             throws Exception {
174         URL url = new URL(generalUrl);
175         // 打开和URL之间的连接
176         HttpURLConnection connection = (HttpURLConnection) url.openConnection();
177         connection.setRequestMethod("GET");
178         // 设置通用的请求属性
179         connection.setRequestProperty("Connection", "Keep-Alive");
180         if(header != null)
181         {
182             for(String key : header.keySet())
183             {
184                 connection.setRequestProperty(key, header.get(key));
185             }
186         }
187
188         connection.setUseCaches(false);
189         connection.setDoOutput(true);
190         connection.setDoInput(true);
191
192         // 建立实际的连接
193         connection.connect();
194         // 定义 BufferedReader输入流来读取URL的响应
195         BufferedReader in = null;
196         in = new BufferedReader(new InputStreamReader(connection.getInputStream(), "UTF-8"));
197         String result = "";
198         String getLine;
199         while ((getLine = in.readLine()) != null) {
200             result += getLine;
201         }
202         in.close();
203
204         return result;
205     }
206
5c5945 207     /** 请求http协议 获取信息工具 **/
E 208     public static JSONObject HttpURLUtil(String url, String data) {
209         HttpURLConnection con = null;
210         URL u = null;
211         String wxMsgXml = null;
212         JSONObject obj = null;
213         try {
214             u = new URL(url);
215             con = (HttpURLConnection) u.openConnection();
216             con.setRequestMethod("POST");
217             con.setDoOutput(true);
218             con.setDoInput(true);
219             con.setUseCaches(false);
220             con.setReadTimeout(5000);
221             con.setRequestProperty("Charset", "UTF-8");
222             con.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
223
224             if (data != null) {
225                 OutputStream os = con.getOutputStream();
226                 os.write(data.getBytes("utf-8"));
227             }
228
229             if (con.getResponseCode() != 200)
230                 throw new RuntimeException("请求url失败");
231             // 读取返回内容
232             wxMsgXml = IOUtils.toString(con.getInputStream(), "utf-8");
233             obj = JSONObject.fromObject(wxMsgXml);
234             // //System.out.println("HttpURLUtil:"+wxMsgXml);
235         } catch (Exception e) {
236             e.printStackTrace();
237             obj = new JSONObject();
238             try {
239                 obj.put("status", 1);
240                 obj.put("errMsg", e.getMessage());
241             } catch (JSONException e1) {
242                 e1.printStackTrace();
243             }
244         } finally {
245             if (con != null) {
246                 con.disconnect();
247             }
248         }
249         return obj;
250     }
251
252
253     /** 请求http协议 获取信息工具 **/
254     public static JSONObject HttpURLUtilJson(String url, String data) {
255         HttpURLConnection con = null;
256         URL u = null;
257         String wxMsgXml = null;
258         JSONObject obj = null;
259         try {
260             u = new URL(url);
261             con = (HttpURLConnection) u.openConnection();
262             con.setRequestMethod("POST");
263             con.setDoOutput(true);
264             con.setDoInput(true);
265             con.setUseCaches(false);
266             con.setReadTimeout(5000);
267             con.setRequestProperty("Charset", "UTF-8");
268             con.setRequestProperty("Content-Type", "application/json");
269
270             if (data != null) {
271                 OutputStream os = con.getOutputStream();
272                 os.write(data.getBytes("utf-8"));
273             }
274
275             if (con.getResponseCode() != 200)
276                 throw new RuntimeException("请求url失败");
277             // 读取返回内容
278             wxMsgXml = IOUtils.toString(con.getInputStream(), "utf-8");
279             obj = JSONObject.fromObject(wxMsgXml);
280             // //System.out.println("HttpURLUtil:"+wxMsgXml);
281         } catch (Exception e) {
282             e.printStackTrace();
283         } finally {
284             if (con != null) {
285                 con.disconnect();
286             }
287         }
288         return obj;
289     }
290
291     /**
292      * post 请求:以表单方式提交数据
293      * <p>
294      * 由于 multipart/form-data 不是 http 标准内容,而是属于扩展类型,
295      * 因此需要自己构造数据结构,具体如下:
296      * <p>
297      * 1、首先,设置 Content-Type
298      * <p>
299      * Content-Type: multipart/form-data; boundary=${bound}
300      * <p>
301      * 其中${bound} 是一个占位符,代表我们规定的分割符,可以自己任意规定,
302      * 但为了避免和正常文本重复了,尽量要使用复杂一点的内容
303      * <p>
304      * 2、设置主体内容
305      * <p>
306      * --${bound}
307      * Content-Disposition: form-data; name="userName"
308      * <p>
309      * Andy
310      * --${bound}
311      * Content-Disposition: form-data; name="file"; filename="测试.excel"
312      * Content-Type: application/octet-stream
313      * <p>
314      * 文件内容
315      * --${bound}--
316      * <p>
317      * 其中${bound}是之前头信息中的分隔符,如果头信息中规定是123,那这里也要是123;
318      * 可以很容易看到,这个请求提是多个相同部分组成的:
319      * 每一部分都是以--加分隔符开始的,然后是该部分内容的描述信息,然后一个回车换行,然后是描述信息的具体内容;
320      * 如果传送的内容是一个文件的话,那么还会包含文件名信息以及文件内容类型。
321      * 上面第二部分是一个文件体的结构,最后以--分隔符--结尾,表示请求体结束
322      *
323      * @param urlStr      请求的url
324      * @param filePathMap key 参数名,value 文件的路径
325      * @param keyValues   普通参数的键值对
326      * @param headers
327      * @return
328      * @throws IOException
329      */
330     public static HttpResponse postFormData(String urlStr, Map<String, String> filePathMap, Map<String, Object> keyValues, Map<String, Object> headers) throws IOException {
331         HttpResponse response;
332         HttpURLConnection conn = getHttpURLConnection(urlStr, headers);
333         //分隔符,可以任意设置,这里设置为 MyBoundary+ 时间戳(尽量复杂点,避免和正文重复)
334         String boundary = "MyBoundary" + System.currentTimeMillis();
335         //设置 Content-Type 为 multipart/form-data; boundary=${boundary}
336         conn.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + boundary);
337
338         //发送参数数据
339         try (DataOutputStream out = new DataOutputStream(conn.getOutputStream())) {
340             //发送普通参数
341             if (keyValues != null && !keyValues.isEmpty()) {
342                 for (Map.Entry<String, Object> entry : keyValues.entrySet()) {
343                     writeSimpleFormField(boundary, out, entry);
344                 }
345             }
346             //发送文件类型参数
347             if (filePathMap != null && !filePathMap.isEmpty()) {
348                 for (Map.Entry<String, String> filePath : filePathMap.entrySet()) {
349                     writeFile(filePath.getKey(), filePath.getValue(), boundary, out);
350                 }
351             }
352
353             //写结尾的分隔符--${boundary}--,然后回车换行
354             String endStr = BOUNDARY_PREFIX + boundary + BOUNDARY_PREFIX + LINE_END;
355             out.write(endStr.getBytes());
356         } catch (Exception e) {
357             e.printStackTrace();
358             response = new HttpResponse(500, e.getMessage());
359             return response;
360         }
361
362         return getHttpResponse(conn);
363     }
364
365     public static HttpResponse postFormData(String urlStr, Map<String, MultipartFile> filePathMap, Map<String, Object> keyValues) throws IOException {
366         HttpResponse response;
367         HttpURLConnection conn = getHttpURLConnection(urlStr, null);
368         //分隔符,可以任意设置,这里设置为 MyBoundary+ 时间戳(尽量复杂点,避免和正文重复)
369         String boundary = "MyBoundary" + System.currentTimeMillis();
370         //设置 Content-Type 为 multipart/form-data; boundary=${boundary}
371         conn.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + boundary);
372
373         //发送参数数据
374         try (DataOutputStream out = new DataOutputStream(conn.getOutputStream())) {
375             //发送普通参数
376             if (keyValues != null && !keyValues.isEmpty()) {
377                 for (Map.Entry<String, Object> entry : keyValues.entrySet()) {
378                     writeSimpleFormField(boundary, out, entry);
379                 }
380             }
381             //发送文件类型参数
382             if (filePathMap != null && !filePathMap.isEmpty()) {
383                 for (Map.Entry<String, MultipartFile> filePath : filePathMap.entrySet()) {
384                     writeFile(filePath.getKey(), filePath.getValue(), boundary, out);
385                 }
386             }
387
388             //写结尾的分隔符--${boundary}--,然后回车换行
389             String endStr = BOUNDARY_PREFIX + boundary + BOUNDARY_PREFIX + LINE_END;
390             out.write(endStr.getBytes());
391         } catch (Exception e) {
392             response = new HttpResponse(500, e.getMessage());
393             return response;
394         }
395
396         return getHttpResponse(conn);
397     }
398
399     /**
400      * 获得连接对象
401      *
402      * @param urlStr
403      * @param headers
404      * @return
405      * @throws IOException
406      */
407     private static HttpURLConnection getHttpURLConnection(String urlStr, Map<String, Object> headers) throws IOException {
408         URL url = new URL(urlStr);
409         HttpURLConnection conn = (HttpURLConnection) url.openConnection();
410         //设置超时时间
411         conn.setConnectTimeout(50000);
412         conn.setReadTimeout(50000);
413         //允许输入流
414         conn.setDoInput(true);
415         //允许输出流
416         conn.setDoOutput(true);
417         //不允许使用缓存
418         conn.setUseCaches(false);
419         //请求方式
420         conn.setRequestMethod("POST");
421         //设置编码 utf-8
422         conn.setRequestProperty("Charset", "UTF-8");
423         //设置为长连接
424         conn.setRequestProperty("connection", "keep-alive");
425
426         //设置其他自定义 headers
427         if (headers != null && !headers.isEmpty()) {
428             for (Map.Entry<String, Object> header : headers.entrySet()) {
429                 conn.setRequestProperty(header.getKey(), header.getValue().toString());
430             }
431         }
432
433         return conn;
434     }
435
436     private static HttpResponse getHttpResponse(HttpURLConnection conn) {
437         HttpResponse response;
438         try (BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()))) {
439             int responseCode = conn.getResponseCode();
440             StringBuilder responseContent = new StringBuilder();
441             String line;
442             while ((line = reader.readLine()) != null) {
443                 responseContent.append(line);
444             }
445             response = new HttpResponse(responseCode, responseContent.toString());
446         } catch (Exception e) {
447             e.printStackTrace();
448             response = new HttpResponse(500, e.getMessage());
449         }
450         return response;
451     }
452
453     /**
454      * 写文件类型的表单参数
455      *
456      * @param paramName 参数名
457      * @param filePath  文件路径
458      * @param boundary  分隔符
459      * @param out
460      * @throws IOException
461      */
462     private static void writeFile(String paramName, String filePath, String boundary,
463                                   DataOutputStream out) {
464         try (BufferedReader fileReader = new BufferedReader(new InputStreamReader(new FileInputStream(filePath)))) {
465             /**
466              * 写分隔符--${boundary},并回车换行
467              */
468             String boundaryStr = BOUNDARY_PREFIX + boundary + LINE_END;
469             out.write(boundaryStr.getBytes());
470             /**
471              * 写描述信息(文件名设置为上传文件的文件名):
472              * 写 Content-Disposition: form-data; name="参数名"; filename="文件名",并回车换行
473              * 写 Content-Type: application/octet-stream,并两个回车换行
474              */
475             String fileName = new File(filePath).getName();
476             String contentDispositionStr = String.format("Content-Disposition: form-data; name=\"%s\"; filename=\"%s\"", paramName, fileName) + LINE_END;
477             out.write(contentDispositionStr.getBytes());
478             String contentType = "Content-Type: application/octet-stream" + LINE_END + LINE_END;
479             out.write(contentType.getBytes());
480
481             String line;
482             while ((line = fileReader.readLine()) != null) {
483                 out.write(line.getBytes());
484             }
485             //回车换行
486             out.write(LINE_END.getBytes());
487         } catch (Exception e) {
488             e.printStackTrace();
489         }
490     }
491
492     /**
493      * 写文件类型的表单参数
494      *
495      * @param paramName 参数名
496      * @param multipartFile  文件
497      * @param boundary  分隔符
498      * @param out
499      * @throws IOException
500      */
501     private static void writeFile(String paramName, MultipartFile multipartFile, String boundary,
502                                   DataOutputStream out) {
503
504         try (BufferedReader fileReader = new BufferedReader(new InputStreamReader(multipartFile.getInputStream()))) {
505             /**
506              * 写分隔符--${boundary},并回车换行
507              */
508             String boundaryStr = BOUNDARY_PREFIX + boundary + LINE_END;
509             out.write(boundaryStr.getBytes());
510             /**
511              * 写描述信息(文件名设置为上传文件的文件名):
512              * 写 Content-Disposition: form-data; name="参数名"; filename="文件名",并回车换行
513              * 写 Content-Type: application/octet-stream,并两个回车换行
514              */
515             String fileName = multipartFile.getName();
516             String contentDispositionStr = String.format("Content-Disposition: form-data; name=\"%s\"; filename=\"%s\"", paramName, fileName) + LINE_END;
517             out.write(contentDispositionStr.getBytes());
518             String contentType = "Content-Type: application/octet-stream" + LINE_END + LINE_END;
519             out.write(contentType.getBytes());
520
521             String line;
522             while ((line = fileReader.readLine()) != null) {
523                 out.write(line.getBytes());
524             }
525             //回车换行
526             out.write(LINE_END.getBytes());
527         } catch (Exception e) {
528             e.printStackTrace();
529         }
530     }
531
532     /**
533      * 写普通的表单参数
534      *
535      * @param boundary 分隔符
536      * @param out
537      * @param entry    参数的键值对
538      * @throws IOException
539      */
540     private static void writeSimpleFormField(String boundary, DataOutputStream out, Map.Entry<String, Object> entry) throws IOException {
541         //写分隔符--${boundary},并回车换行
542         String boundaryStr = BOUNDARY_PREFIX + boundary + LINE_END;
543         out.write(boundaryStr.getBytes());
544         //写描述信息:Content-Disposition: form-data; name="参数名",并两个回车换行
545         String contentDispositionStr = String.format("Content-Disposition: form-data; name=\"%s\"", entry.getKey()) + LINE_END + LINE_END;
546         out.write(contentDispositionStr.getBytes());
547         //写具体内容:参数值,并回车换行
548         String valueStr = entry.getValue().toString() + LINE_END;
549         out.write(valueStr.getBytes());
550     }
551
552     public static String formUpload(String urlStr, Map<String, String> textMap,
553                                     Map<String, String> fileMap,String contentType) {
554         String res = "";
555         HttpURLConnection conn = null;
556         // boundary就是request头和上传文件内容的分隔符
557         String BOUNDARY = "---------------------------123821742118716";
558         try {
559             URL url = new URL(urlStr);
560             conn = (HttpURLConnection) url.openConnection();
561             conn.setConnectTimeout(5000);
562             conn.setReadTimeout(30000);
563             conn.setDoOutput(true);
564             conn.setDoInput(true);
565             conn.setUseCaches(false);
566             conn.setRequestMethod("POST");
567             conn.setRequestProperty("Connection", "Keep-Alive");
568             // conn.setRequestProperty("User-Agent","Mozilla/5.0 (Windows; U; Windows NT 6.1; zh-CN; rv:1.9.2.6)");
569             conn.setRequestProperty("Content-Type","multipart/form-data; boundary=" + BOUNDARY);
570             OutputStream out = new DataOutputStream(conn.getOutputStream());
571             // text
572             if (textMap != null) {
573                 StringBuffer strBuf = new StringBuffer();
574                 Iterator iter = textMap.entrySet().iterator();
575                 while (iter.hasNext()) {
576                     Map.Entry entry = (Map.Entry) iter.next();
577                     String inputName = (String) entry.getKey();
578                     String inputValue = (String) entry.getValue();
579                     if (inputValue == null) {
580                         continue;
581                     }
582                     strBuf.append("\r\n").append("--").append(BOUNDARY).append("\r\n");
583                     strBuf.append("Content-Disposition: form-data; name=\"" + inputName + "\"\r\n\r\n");
584                     strBuf.append(inputValue);
585                 }
586                 out.write(strBuf.toString().getBytes());
587             }
588             // file
589             if (fileMap != null) {
590                 Iterator iter = fileMap.entrySet().iterator();
591                 while (iter.hasNext()) {
592                     Map.Entry entry = (Map.Entry) iter.next();
593                     String inputName = (String) entry.getKey();
594                     String inputValue = (String) entry.getValue();
595                     if (inputValue == null) {
596                         continue;
597                     }
598                     File file = new File(inputValue);
599                     String filename = file.getName();
600
601                     //没有传入文件类型,同时根据文件获取不到类型,默认采用application/octet-stream
602                     contentType = new MimetypesFileTypeMap().getContentType(file);
603                     //contentType非空采用filename匹配默认的图片类型
604                     if(!"".equals(contentType)){
605                         if (filename.endsWith(".png")) {
606                             contentType = "image/png";
607                         }else if (filename.endsWith(".jpg") || filename.endsWith(".jpeg") || filename.endsWith(".jpe")) {
608                             contentType = "image/jpeg";
609                         }else if (filename.endsWith(".gif")) {
610                             contentType = "image/gif";
611                         }else if (filename.endsWith(".ico")) {
612                             contentType = "image/image/x-icon";
613                         }
614                     }
615                     if (contentType == null || "".equals(contentType)) {
616                         contentType = "application/octet-stream";
617                     }
618                     StringBuffer strBuf = new StringBuffer();
619                     strBuf.append("\r\n").append("--").append(BOUNDARY).append("\r\n");
620                     strBuf.append("Content-Disposition: form-data; name=\"" + inputName + "\"; filename=\"" + filename + "\"\r\n");
621                     strBuf.append("Content-Type:" + contentType + "\r\n\r\n");
622                     out.write(strBuf.toString().getBytes());
623                     DataInputStream in = new DataInputStream(new FileInputStream(file));
624                     int bytes = 0;
625                     byte[] bufferOut = new byte[1024];
626                     while ((bytes = in.read(bufferOut)) != -1) {
627                         out.write(bufferOut, 0, bytes);
628                     }
629                     in.close();
630                 }
631             }
632             byte[] endData = ("\r\n--" + BOUNDARY + "--\r\n").getBytes();
633             out.write(endData);
634             out.flush();
635             out.close();
636             // 读取返回数据
637             StringBuffer strBuf = new StringBuffer();
638             BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
639             String line = null;
640             while ((line = reader.readLine()) != null) {
641                 strBuf.append(line).append("\n");
642             }
643             res = strBuf.toString();
644             reader.close();
645             reader = null;
646         } catch (Exception e) {
647             System.out.println("发送POST请求出错。" + urlStr);
648             e.printStackTrace();
649         } finally {
650             if (conn != null) {
651                 conn.disconnect();
652                 conn = null;
653             }
654         }
655         return res;
656     }
657 }