使用HttpClient發送請求接收響應

1.一般需要如下幾步:
(1) 創建HttpClient對象。
(2)創建請求方法的實例，並指定請求URL。如果需要發送GET請求，創建HttpGet對象；如果需要發送POST請求，創建HttpPost對象。
(3) 如果需要發送請求參數，可調用HttpGet、HttpPost共同的setParams(HetpParams params)方法來添加請求參數；對於HttpPost對象而言，也可調用setEntity(HttpEntity entity)方法來設置請求參數。
(4) 調用HttpClient對象的execute(HttpUriRequest request)發送請求，該方法返回一個HttpResponse。
(5) 調用HttpResponse的getAllHeaders()、getHeaders(String name)等方法可獲取服務器的響應頭；調用HttpResponse的getEntity()方法可獲取HttpEntity對象，該對象包裝了服務器 的響應內容。程序可通過該對象獲取服務器的響應內容。
(6) 釋放連接。無論執行方法是否成功，都必須釋放連接

依賴：

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.3.5</version>
</dependency>

import org.apache.commons.codec.binary.Base64;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.NameValuePair;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContextBuilder;
import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.DefaultHttpRequestRetryHandler;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URLEncoder;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;


public class HttpClientUtils {

    // HTTP內容類型。相當於form表單的形式，提交數據
    public static final String CONTENT_TYPE_JSON_URL = "application/json;charset=utf-8";

    // utf-8字符編碼
    public static final String CHARSET_UTF_8 = "utf-8";

    // 連接管理器
    private static PoolingHttpClientConnectionManager pool;

    // 請求配置
    private static RequestConfig requestConfig;

    static {

        try {
            SSLContextBuilder builder = new SSLContextBuilder();
            builder.loadTrustMaterial(null, new TrustSelfSignedStrategy());
            SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
                    builder.build());
            // 配置同時支持 HTTP 和 HTPPS
            Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create
                    ().register(
                    "http", PlainConnectionSocketFactory.getSocketFactory()).register(
                    "https", sslsf).build();
            // 初始化連接管理器
            pool = new PoolingHttpClientConnectionManager(
                    socketFactoryRegistry);
            // 將最大連接數增加到200，實際項目最好從配置文件中讀取這個值
            pool.setMaxTotal(200);
            // 設置最大路由
            pool.setDefaultMaxPerRoute(2);

            requestConfig = requestConfig();

        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (KeyStoreException e) {
            e.printStackTrace();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        }
    }

    public static CloseableHttpClient getHttpClient() {

        CloseableHttpClient httpClient = HttpClients.custom()
                // 設置連接池管理
                .setConnectionManager(pool)
                // 設置請求配置
                .setDefaultRequestConfig(requestConfig)
                // 設置重試次數
                .setRetryHandler(new DefaultHttpRequestRetryHandler(0, false))
                .build();

        return httpClient;
    }

    /**
     * 構建請求配置信息
     * 超時時間什么的
     */
    private static RequestConfig requestConfig() {
        // 根據默認超時限制初始化requestConfig
        int socketTimeout = 10000;
        int connectTimeout = 10000;
        int connectionRequestTimeout = 10000;
        RequestConfig config = RequestConfig.custom()
                .setConnectTimeout(connectTimeout) // 創建連接的最長時間
                .setConnectionRequestTimeout(connectionRequestTimeout) // 從連接池中獲取到連接的最長時間
                .setSocketTimeout(socketTimeout) // 數據傳輸的最長時間
                .setStaleConnectionCheckEnabled(true) // 提交請求前測試連接是否可用
                .build();
        return config;
    }

    public static String doGetJson(String url, String param, Map<String, String> requestHead) {
        String result = "";
        CloseableHttpResponse response = null;
        CloseableHttpClient httpclient = null;
        try {
            httpclient = getHttpClient();
            URI uri = null;
            if (param == null || param.equals("")) {
                uri = new URIBuilder(url).build();
            } else {
                uri = new URIBuilder(url + "?" + param).build();
            }
            // 創建http GET請求
            HttpGet httpGet = new HttpGet(uri);
            httpGet.setConfig(requestConfig());
            if (null != requestHead) {
                for (Map.Entry<String, String> entry : requestHead.entrySet()) {
                    String key = entry.getKey();
                    String value = entry.getValue();
                    httpGet.addHeader(key, value);
                }
            }
            response = httpclient.execute(httpGet);
            // 判斷返回狀態是否為200
            if (response.getStatusLine().getStatusCode() == 200) {
                result = EntityUtils.toString(response.getEntity(), CHARSET_UTF_8);
            }
            result = decodeData(result);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
                //不可以關閉，不然連接池就會被關閉
                //httpclient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return result;
    }


    public static String doPostJson(String url, String param, Map<String, String> requestHead) {
        // 創建Httpclient對象
        CloseableHttpClient httpClient = getHttpClient();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 創建Http Post請求
            HttpPost httpPost = new HttpPost(url);
            // 創建請求內容
            StringEntity entity = new StringEntity(param, ContentType.APPLICATION_JSON);
            entity.setContentType(CONTENT_TYPE_JSON_URL);
            httpPost.setEntity(entity);
            httpPost.setConfig(requestConfig());
            if (null != requestHead) {
                for (Map.Entry<String, String> entry : requestHead.entrySet()) {
                    String key = entry.getKey();
                    String value = entry.getValue();
                    httpPost.addHeader(key, value);
                }
            }
            // 執行http請求
            response = httpClient.execute(httpPost);
            // 判斷返回狀態是否為200
            if (response.getStatusLine().getStatusCode() == 200) {
                resultString = EntityUtils.toString(response.getEntity(), CHARSET_UTF_8);
            }
            resultString = decodeData(resultString);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
                httpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return resultString;
    }



    public static String doGet(String url, Map<String, String> param, Map<String, String> requestHead) {
        String result = "";
        CloseableHttpResponse response = null;
        CloseableHttpClient httpclient = null;
        try {
            String params = toHttpGetParams(param);
            httpclient = getHttpClient();
            URI uri = new URIBuilder(url + "?" + params).build();
            // 創建http GET請求
            HttpGet httpGet = new HttpGet(uri);
            httpGet.setConfig(requestConfig());
            if (null != requestHead) {
                for (Map.Entry<String, String> entry : requestHead.entrySet()) {
                    String key = entry.getKey();
                    String value = entry.getValue();
                    httpGet.addHeader(key, value);
                }
            }
            response = httpclient.execute(httpGet);
            // 判斷返回狀態是否為200
            if (response.getStatusLine().getStatusCode() == 200) {
                result = EntityUtils.toString(response.getEntity(), CHARSET_UTF_8);
            }
            result = decodeData(result);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return result;
    }

    public static String doGet(String url, Map<String, String> param) {
        return doGet(url, param, null);
    }


    /**
     * 根據實際需要決定是否需要解碼
     */
    static String decodeData(String base64Data) {
        String str = "";
        if (base64Data == null || base64Data.equals("")) {
            str = "";
        }
        try {
            String e = new String(Base64.decodeBase64(base64Data.getBytes(CHARSET_UTF_8)), CHARSET_UTF_8);
            return e;
        } catch (UnsupportedEncodingException var5) {
        }
        return str;
    }

    /**
     * 這里只是其中的一種場景,也就是把參數用&符號進行連接且進行URL編碼
     * 根據實際情況拼接參數
     */
    private static String toHttpGetParams(Map<String, String> param) throws Exception {
        String res = "";
        if (param == null) {
            return res;
        }
        for (Map.Entry<String, String> entry : param.entrySet()) {
            res += entry.getKey() + "=" + URLEncoder.encode(entry.getValue(), CHARSET_UTF_8) + "&";
        }
        return "".equals(res) ? "" : StringUtils.chop(res);
    }


    public static String doPost(String url, Map<String, String> param, Map<String, String> requestHead) {
        // 創建Httpclient對象
        CloseableHttpClient httpClient = getHttpClient();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 創建Http Post請求
            HttpPost httpPost = new HttpPost(url);
            httpPost.setConfig(requestConfig());
            if (null != requestHead) {
                for (Map.Entry<String, String> entry : requestHead.entrySet()) {
                    String key = entry.getKey();
                    String value = entry.getValue();
                    httpPost.addHeader(key, value);
                }
            }
            // 創建參數列表
            if (param != null) {
                List<NameValuePair> paramList = new ArrayList<NameValuePair>();
                for (String key : param.keySet()) {
                    paramList.add(new BasicNameValuePair(key, param.get(key)));
                }
                // 模擬表單
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList);
                httpPost.setEntity(entity);
            }
            // 執行http請求
            response = httpClient.execute(httpPost);
            if (response.getStatusLine().getStatusCode() == 200) {
                resultString = EntityUtils.toString(response.getEntity(), CHARSET_UTF_8);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return resultString;
    }

    public static String doPost(String url, Map<String, String> param) {

        return doPost(url, param, null);
    }

    public static String doPost(String url) {
        return doPost(url, null);
    }

}

package com.winner;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.HashMap;
import java.util.Map;

public class RestClient {

    public static final String GET = "GET";
    public static final String POST = "POST";

    private static Logger logger = LoggerFactory.getLogger(RestClient.class);

    private static Map<String, String> requestHeaders = new HashMap<String, String>() {{
        put("Content-Type", "application/json");
        put("charset", "UTF-8");
    }};

    public static String sendData(String url, String method, String param, Map<String, String> headers) {
        logger.info("調用接口:{},方法:{}", url, method);
        logger.info("參數:{}", param);
        String returnStr = "";

        if (headers != null) {
            for (Map.Entry<String, String> entry : requestHeaders.entrySet()) {
                headers.put(entry.getKey(), entry.getValue());
            }
        } else {
            headers = requestHeaders;
        }
        try {
            if (method.equals(GET)) {
                returnStr = HttpClientUtils.doGetJson(url, param, headers);

            }
            if (method.equals(POST)) {
                returnStr = HttpClientUtils.doPostJson(url, param, headers);
            }
        } catch (Exception exception) {
            logger.error("系統調用異常：", exception);
            //注意，在Controller中進行捕捉
            throw new BusinessException(00000, exception.getMessage());
        }
        logger.info("調用完成,返回值:{}", returnStr);
        return returnStr;
    }
}