2. public class HttpClientUtil {
    3.     private final static Logger logger = LoggerFactory.getLogger(HttpClientUtil.class);
    5.     public static String doGet(String url, Map<String, String> param) {
    6.         return doGet(url, param, "");
    7.     }
    9.     public static String doGet(String url, String body) {
    10.         return doGet(url, null, body);
    11.     }
    12.     public static String doGet(String url) {
    13.         return doGet(url, null,"");
    14.     }
    16.     @SuppressWarnings("deprecation")
    17.     public static String doGet(String url, Map<String, String> param, String body) {
    18.         CloseableHttpClient httpclient = null;
    19.         String resultString = "";
    20.         CloseableHttpResponse response = null;
    21.         try {
    22.             if(url.startsWith("https")){
    23.                 httpclient = getIgnoeSSLClient();
    24.             } else {
    25.                 httpclient = HttpClients.createDefault();
    26.             }
    28.             // 创建uri
    29.             URIBuilder builder = new URIBuilder(url);
    30.             if (param != null) {
    31.                 for (String key : param.keySet()) {
    32.                     builder.addParameter(key, param.get(key));
    33.                 }
    34.             } else if (StringUtils.isNotEmpty(body)) {
    35.                 builder.setQuery(body);
    36.             }
    37.             URI uri = builder.build();
    39.             // 创建http GET请求
    40.             HttpGet httpGet = new HttpGet(uri);
    41.             RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(2000).setConnectTimeout(2000).build();
    42.             httpGet.setConfig(requestConfig);
    43.             // 执行请求
    44.             response = httpclient.execute(httpGet);
    45.             // 判断返回状态是否为200
    46.             if (response.getStatusLine().getStatusCode() == 200) {
    47.                 resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
    48.             }
    49.             if(url.startsWith("https")){
    50.                 EntityUtils.consume(response.getEntity());
    51.             }
    52.         } catch (Exception e) {
    53.             logger.error("do get error.", e);
    54.             return resultString;
    55.         } finally {
    56.             try {
    57.                 if (response != null) {
    58.                     response.close();
    59.                 }
    60.                 if(httpclient != null) {
    61.                     httpclient.close();
    62.                 }
    63.             } catch (IOException e) {
    64.                 logger.error("do get error.", e);
    65.             }
    66.         }
    67.         return resultString;
    68.     }
    71.     public static String doPost(String url, Map<String, String> param) {
    72.         return doPost(url, param, "");
    73.     }
    75.     public static String doPost(String url, String body) {
    76.         return doPost(url, null, body);
    77.     }
    78.     public static String doPost(String url, Map<String, String> param, String body) {
    79.         CloseableHttpClient httpClient = null;
    80.         CloseableHttpResponse response = null;
    81.         String resultString = "";
    82.         try {
    83.             // 创建Httpclient对象
    84.             if(url.startsWith("https")){
    85.                 httpClient = getIgnoeSSLClient();
    86.             } else {
    87.                 httpClient = HttpClients.createDefault();
    88.             }
    89.             // 创建Http Post请求
    90.             HttpPost httpPost = new HttpPost(url);
    91.             RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(2000).setConnectTimeout(2000).build();
    92.             httpPost.setConfig(requestConfig);
    93.             // 创建参数列表
    94.             if (param != null) {
    95.                 List<NameValuePair> paramList = new ArrayList<>();
    96.                 for (String key : param.keySet()) {
    97.                     paramList.add(new BasicNameValuePair(key, param.get(key)));
    98.                 }
    99.                 // 模拟表单
    100.                 UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList,"utf-8");
    101.                 httpPost.setEntity(entity);
    102.             } else if (StringUtils.isNotEmpty(body)) {
    103.                 StringEntity entity = null;
    104.                 try {
    105.                     entity = new StringEntity(body, "UTF-8");
    106.                 } catch (UnsupportedCharsetException ex) {
    107.                     ex.printStackTrace();
    108.                 }
    109.                 httpPost.setEntity(entity);
    110.                 // post.setRequestBody(body);
    111.             }
    112.             // 执行http请求
    113.             response = httpClient.execute(httpPost);
    114.             resultString = EntityUtils.toString(response.getEntity(), "utf-8");
    115.             if(url.startsWith("https")){
    116.                 EntityUtils.consume(response.getEntity());
    117.             }
    118.         } catch (Exception e) {
    119.             logger.error("do post error.", e);
    120.             return resultString;
    121.         } finally {
    122.             try {
    123.                 if(response != null) {
    124.                     response.close();
    125.                 }
    126.                 if(httpClient != null) {
    127.                     httpClient.close();
    128.                 }
    129.             } catch (IOException e) {
    130.                 e.printStackTrace();
    131.             }
    132.         }
    134.         return resultString;
    135.     }
    137.     public static String doPost(String url) {
    138.         return doPost(url, null,"");
    139.     }
    141.     public static String doPost(String url,Map<String, String> head, Map<String, String> bodyParam) {
    142.         CloseableHttpClient httpClient = null;
    143.         CloseableHttpResponse response = null;
    144.         String resultString = "";
    145.         try {
    146.             // 创建Httpclient对象
    147.             if(url.startsWith("https")){
    148.                 httpClient = getIgnoeSSLClient();
    149.             } else {
    150.                 httpClient = HttpClients.createDefault();
    151.             }
    153.             // 创建Http Post请求
    154.             HttpPost httpPost = new HttpPost(url);
    155.             RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(2000).setConnectTimeout(2000).build();
    156.             httpPost.setConfig(requestConfig);
    157.             // 创建参数列表
    158.             if (head != null) {
    159.                 for (String key : head.keySet()) {
    160.                     httpPost.setHeader(key, head.get(key));
    161.                 }
    162.             }
    164.             if (bodyParam != null) {
    165.                 List<NameValuePair> paramList = new ArrayList<>();
    166.                 for (String key : bodyParam.keySet()) {
    167.                     paramList.add(new BasicNameValuePair(key, bodyParam.get(key)));
    168.                 }
    169.                 // 模拟表单
    170.                 UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList,"utf-8");
    171.                 httpPost.setEntity(entity);
    172.             }
    174.             // 执行http请求
    175.             response = httpClient.execute(httpPost);
    176.             resultString = EntityUtils.toString(response.getEntity(), "utf-8");
    177.             if(url.startsWith("https")){
    178.                 EntityUtils.consume(response.getEntity());
    179.             }
    180.         } catch (Exception e) {
    181.             logger.error("do post error.", e);
    182.             return resultString;
    183.         } finally {
    184.             try {
    185.                 if(response != null) {
    186.                     response.close();
    187.                 }
    188.                 if(httpClient != null) {
    189.                     httpClient.close();
    190.                 }
    191.             } catch (IOException e) {
    192.                 e.printStackTrace();
    193.             }
    194.         }
    196.         return resultString;
    197.     }
    199.     public static String doPostJson(String url, String json) {
    200.         CloseableHttpClient httpClient = null;
    201.         CloseableHttpResponse response = null;
    202.         String resultString = "";
    203.         try {
    204.             // 创建Httpclient对象
    205.             if(url.startsWith("https")){
    206.                 httpClient = getIgnoeSSLClient();
    207.             } else {
    208.                 httpClient = HttpClients.createDefault();
    209.             }
    210.             HttpPost httpPost = new HttpPost(url);
    211.             // 创建请求内容
    212.             StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
    213.             httpPost.setEntity(entity);
    214.             RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(2000).setConnectTimeout(2000).build();
    215.             httpPost.setConfig(requestConfig);
    216.             // 执行http请求
    217.             response = httpClient.execute(httpPost);
    218.             resultString = EntityUtils.toString(response.getEntity(), "utf-8");
    219.             if(url.startsWith("https")){
    220.                 EntityUtils.consume(response.getEntity());
    221.             }
    222.         } catch (Exception e) {
    223.             logger.error("do post error.", e);
    224.             return resultString;
    225.         } finally {
    226.             try {
    227.                 if (response != null) {
    228.                     response.close();
    229.                 }
    230.                 if(httpClient != null) {
    231.                     httpClient.close();
    232.                 }
    233.             } catch (IOException e) {
    234.                 e.printStackTrace();
    235.             }
    236.         }
    238.         return resultString;
    239.     }
    241.     /**
    242.      * http发送文件
    243.      * @param url
    244.      * @param localFilePath
    245.      * @return
    246.      */
    247.     public static String doPostFile(String url, String localFilePath) {
    248.         CloseableHttpClient httpClient = null;
    249.         CloseableHttpResponse response = null;
    250.         String resultString = "";
    251.         try {
    252.             // 创建Httpclient对象
    253.             if(url.startsWith("https")){
    254.                 httpClient = getIgnoeSSLClient();
    255.             } else {
    256.                 httpClient = HttpClients.createDefault();
    257.             }
    258.             // 创建Http Post请求
    259.             HttpPost httpPost = new HttpPost(url);
    260.             // 创建请求内容
    261.             // 把文件转换成流对象FileBody
    262.             File localFile = new File(localFilePath);
    263.             FileBody fileBody = new FileBody(localFile);
    264.             // 以浏览器兼容模式运行，防止文件名乱码。
    265.             HttpEntity entity = MultipartEntityBuilder.create().setMode(HttpMultipartMode.BROWSER_COMPATIBLE).
    266.                     addPart("uploadFile", fileBody).setCharset(CharsetUtils.get("UTF-8")).build();
    267.             httpPost.setEntity(entity);
    268.             // 执行http请求
    269.             response = httpClient.execute(httpPost);
    270.             resultString = EntityUtils.toString(response.getEntity(), "utf-8");
    271.             if(url.startsWith("https")){
    272.                 EntityUtils.consume(response.getEntity());
    273.             }
    274.         } catch (Exception e) {
    275.             logger.error("do post error.", e);
    276.             return resultString;
    277.         } finally {
    278.             try {
    279.                 if (response != null) {
    280.                     response.close();
    281.                 }
    282.                 if(httpClient != null) {
    283.                     httpClient.close();
    284.                 }
    285.             } catch (IOException e) {
    286.                 e.printStackTrace();
    287.             }
    288.         }
    290.         return resultString;
    291.     }
    293.     public static String doPut(String url, String json) {
    294.         CloseableHttpClient httpClient = null;
    295.         CloseableHttpResponse response = null;
    296.         String resultString = "";
    297.         try {
    298.             // 创建Httpclient对象
    299.             if(url.startsWith("https")){
    300.                 httpClient = getIgnoeSSLClient();
    301.             } else {
    302.                 httpClient = HttpClients.createDefault();
    303.             }
    304.             HttpPut httpPut = new HttpPut(url);
    305.             // 创建请求内容
    306.             StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
    307.             httpPut.setEntity(entity);
    308. //            //设置请求超时时间
    309. //            RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(5000).setConnectTimeout(5000).build();
    310. //            httpPut.setConfig(requestConfig);
    311.             // 执行http请求
    312.             response = httpClient.execute(httpPut);
    313.             resultString = EntityUtils.toString(response.getEntity(), "utf-8");
    314.             if(url.startsWith("https")){
    315.                 EntityUtils.consume(response.getEntity());
    316.             }
    317.         } catch (Exception e) {
    318.             logger.error("do put error.", e);
    319.             return resultString;
    320.         } finally {
    321.             try {
    322.                 if (response != null) {
    323.                     response.close();
    324.                 }
    325.                 if(httpClient != null) {
    326.                     httpClient.close();
    327.                 }
    328.             } catch (IOException e) {
    329.                 e.printStackTrace();
    330.             }
    331.         }
    333.         return resultString;
    334.     }
    336.     private static CloseableHttpClient getIgnoeSSLClient() throws Exception {
    337.         SSLContext sslContext = SSLContexts.custom().loadTrustMaterial(null, new TrustStrategy() {
    338.             @Override
    339.             public boolean isTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
    340.                 return true;
    341.             }
    342.         }).build();
    343.         CloseableHttpClient client = HttpClients.custom().setSSLContext(sslContext).
    344.                 setSSLHostnameVerifier(new NoopHostnameVerifier()).build();
    345.         return client;
    346.     }
    348. }