HttpClient用法--這一篇全瞭解（內含例子）

阿新 • • 發佈：2019-01-29

HttpClient相比傳統JDK自帶的URLConnection，增加了易用性和靈活性，它不僅使客戶端傳送Http請求變得容易，而且也方便開發人員測試介面（基於Http協議的），提高了開發的效率，也方便提高程式碼的健壯性。因此熟練掌握HttpClient是很重要的必修內容，掌握HttpClient後，相信對於Http協議的瞭解會更加深入。

org.apache.commons.httpclient.HttpClient與org.apache.http.client.HttpClient的區別

Commons的HttpClient專案現在是生命的盡頭，不再被開發, 已被Apache HttpComponents專案HttpClient和HttpCore 模組取代，提供更好的效能和更大的靈活性。

一、簡介

HttpClient是Apache Jakarta Common下的子專案，用來提供高效的、最新的、功能豐富的支援HTTP協議的客戶端程式設計工具包，並且它支援HTTP協議最新的版本和建議。HttpClient已經應用在很多的專案中，比如Apache Jakarta上很著名的另外兩個開源專案Cactus和HTMLUnit都使用了HttpClient。

二、特性

1. 基於標準、純淨的java語言。實現了Http1.0和Http1.1

2. 以可擴充套件的面向物件的結構實現了Http全部的方法（GET, POST, PUT, DELETE, HEAD, OPTIONS, and TRACE）。

3. 支援HTTPS協議。

4. 通過Http代理建立透明的連線。

5. 利用CONNECT方法通過Http代理建立隧道的https連線。

6. Basic, Digest, NTLMv1, NTLMv2, NTLM2 Session, SNPNEGO/Kerberos認證方案。

7. 外掛式的自定義認證方案。

8. 便攜可靠的套接字工廠使它更容易的使用第三方解決方案。

9. 連線管理器支援多執行緒應用。支援設定最大連線數，同時支援設定每個主機的最大連線數，發現並關閉過期的連線。

10. 自動處理Set-Cookie中的Cookie。

11. 外掛式的自定義Cookie策略。

12. Request的輸出流可以避免流中內容直接緩衝到socket伺服器。

13. Response的輸入流可以有效的從socket伺服器直接讀取相應內容。

14. 在http1.0和http1.1中利用KeepAlive保持持久連線。

15. 直接獲取伺服器傳送的response code和 headers。

16. 設定連線超時的能力。

17. 實驗性的支援http1.1 response caching。

18. 原始碼基於Apache License 可免費獲取。

三、使用方法

使用HttpClient傳送請求、接收響應很簡單，一般需要如下幾步即可。

1. 建立HttpClient物件。

2. 建立請求方法的例項，並指定請求URL。如果需要傳送GET請求，建立HttpGet物件；如果需要傳送POST請求，建立HttpPost物件。

3. 如果需要傳送請求引數，可呼叫HttpGet、HttpPost共同的setParams(HttpParams params)方法來新增請求引數；對於HttpPost物件而言，也可呼叫setEntity(HttpEntity entity)方法來設定請求引數。

4. 呼叫HttpClient物件的execute(HttpUriRequest request)傳送請求，該方法返回一個HttpResponse。

5. 呼叫HttpResponse的getAllHeaders()、getHeaders(String name)等方法可獲取伺服器的響應頭；呼叫HttpResponse的getEntity()方法可獲取HttpEntity物件，該物件包裝了伺服器的響應內容。程式可通過該物件獲取伺服器的響應內容。

6. 釋放連線。無論執行方法是否成功，都必須釋放連線

相關jar包

commons-cli-1.2.jar  
commons-codec-1.9.jar  
commons-logging-1.2.jar  
fluent-hc-4.5.1.jar  
httpclient-4.5.1.jar  
httpclient-cache-4.5.1.jar  
httpclient-win-4.5.1.jar  
httpcore-4.4.3.jar  
httpcore-ab-4.4.3.jar  
httpcore-nio-4.4.3.jar  
httpmime-4.5.1.jar  
jna-4.1.0.jar  
jna-platform-4.1.0.jar

package a;  
   
import java.io.FileInputStream;  
import java.io.IOException;  
import java.util.ArrayList;  
import java.util.List;  
import java.util.Properties;  
   
import org.apache.http.HttpEntity;  
import org.apache.http.HttpResponse;  
import org.apache.http.NameValuePair;  
import org.apache.http.client.HttpClient;  
import org.apache.http.client.config.RequestConfig;  
import org.apache.http.client.entity.UrlEncodedFormEntity;  
import org.apache.http.client.methods.HttpPost;  
import org.apache.http.impl.client.DefaultHttpClient;  
import org.apache.http.message.BasicNameValuePair;  
import org.apache.http.util.EntityUtils;  
   
public class First {  
    public static void main(String[] args) throws Exception{  
        List<NameValuePair> formparams = new ArrayList<NameValuePair>();  
        formparams.add(new BasicNameValuePair("account", ""));  
        formparams.add(new BasicNameValuePair("password", ""));  
        HttpEntity reqEntity = new UrlEncodedFormEntity(formparams, "utf-8");  
    
        RequestConfig requestConfig = RequestConfig.custom()  
        .setConnectTimeout(5000)//一、連線超時：connectionTimeout-->指的是連線一個url的連線等待時間  
                .setSocketTimeout(5000)// 二、讀取資料超時：SocketTimeout-->指的是連線上一個url，獲取response的返回等待時間  
                .setConnectionRequestTimeout(5000)  
                .build();  
    
        HttpClient client = new DefaultHttpClient();  
        HttpPost post = new HttpPost("http://cnivi.com.cn/login");  
        post.setEntity(reqEntity);  
        post.setConfig(requestConfig);  
        HttpResponse response = client.execute(post);  
    
        if (response.getStatusLine().getStatusCode() == 200) {  
            HttpEntity resEntity = response.getEntity();  
            String message = EntityUtils.toString(resEntity, "utf-8");  
            System.out.println(message);  
        } else {  
            System.out.println("請求失敗");  
        }  
    }  
   
}

四、例項

主檔案

package com.test;  
      
import java.io.File;  
import java.io.FileInputStream;  
import java.io.IOException;  
import java.io.UnsupportedEncodingException;  
import java.security.KeyManagementException;  
import java.security.KeyStore;  
import java.security.KeyStoreException;  
import java.security.NoSuchAlgorithmException;  
import java.security.cert.CertificateException;  
import java.util.ArrayList;  
import java.util.List;  
import javax.net.ssl.SSLContext;  
import org.apache.http.HttpEntity;  
import org.apache.http.NameValuePair;  
import org.apache.http.ParseException;  
import org.apache.http.client.ClientProtocolException;  
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.conn.ssl.SSLConnectionSocketFactory;  
import org.apache.http.conn.ssl.SSLContexts;  
import org.apache.http.conn.ssl.TrustSelfSignedStrategy;  
import org.apache.http.entity.ContentType;  
import org.apache.http.entity.mime.MultipartEntityBuilder;  
import org.apache.http.entity.mime.content.FileBody;  
import org.apache.http.entity.mime.content.StringBody;  
import org.apache.http.impl.client.CloseableHttpClient;  
import org.apache.http.impl.client.HttpClients;  
import org.apache.http.message.BasicNameValuePair;  
import org.apache.http.util.EntityUtils;  
import org.apache.http.client.config.RequestConfig;  
import org.junit.Test;  
public class HttpClientTest {  
　　//方法見下........  
}

HttpClientUtils工具類

package com.bobo.code.web.controller.technology.httpcomponents;  
   
   
import org.apache.http.HttpEntity;  
import org.apache.http.HttpHost;  
import org.apache.http.HttpResponse;  
import org.apache.http.NameValuePair;  
import org.apache.http.client.HttpClient;  
import org.apache.http.client.config.RequestConfig;  
import org.apache.http.client.methods.HttpUriRequest;  
import org.apache.http.client.methods.RequestBuilder;  
import org.apache.http.conn.routing.HttpRoute;  
import org.apache.http.impl.client.CloseableHttpClient;  
import org.apache.http.impl.client.HttpClientBuilder;  
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.util.*;  
    
public class HttpClientUtils {  
    
    private static PoolingHttpClientConnectionManager connectionManager = null;  
    private static HttpClientBuilder httpBuilder = null;  
    private static RequestConfig requestConfig = null;  
    
    private static int MAXCONNECTION = 10;  
    
    private static int DEFAULTMAXCONNECTION = 5;  
    
    private static String IP = "cnivi.com.cn";  
    private static int PORT = 80;  
    
    static {  
        //設定http的狀態引數  
        requestConfig = RequestConfig.custom()  
                .setSocketTimeout(5000)  
                .setConnectTimeout(5000)  
                .setConnectionRequestTimeout(5000)  
                .build();  
    
        HttpHost target = new HttpHost(IP, PORT);  
        connectionManager = new PoolingHttpClientConnectionManager();  
        connectionManager.setMaxTotal(MAXCONNECTION);//客戶端總並行連結最大數  
        connectionManager.setDefaultMaxPerRoute(DEFAULTMAXCONNECTION);//每個主機的最大並行連結數  
        connectionManager.setMaxPerRoute(new HttpRoute(target), 20);  
        httpBuilder = HttpClients.custom();  
        httpBuilder.setConnectionManager(connectionManager);  
    }  
    
    public static CloseableHttpClient getConnection() {  
        CloseableHttpClient httpClient = httpBuilder.build();  
        return httpClient;  
    }  
    
    
    public static HttpUriRequest getRequestMethod(Map<String, String> map, String url, String method) {  
        List<NameValuePair> params = new ArrayList<NameValuePair>();  
        Set<Map.Entry<String, String>> entrySet = map.entrySet();  
        for (Map.Entry<String, String> e : entrySet) {  
            String name = e.getKey();  
            String value = e.getValue();  
            NameValuePair pair = new BasicNameValuePair(name, value);  
            params.add(pair);  
        }  
        HttpUriRequest reqMethod = null;  
        if ("post".equals(method)) {  
            reqMethod = RequestBuilder.post().setUri(url)  
                    .addParameters(params.toArray(new BasicNameValuePair[params.size()]))  
                    .setConfig(requestConfig).build();  
        } else if ("get".equals(method)) {  
            reqMethod = RequestBuilder.get().setUri(url)  
                    .addParameters(params.toArray(new BasicNameValuePair[params.size()]))  
                    .setConfig(requestConfig).build();  
        }  
        return reqMethod;  
    }  
    
    public static void main(String args[]) throws IOException {  
        Map<String, String> map = new HashMap<String, String>();  
        map.put("account", "");  
        map.put("password", "");  
    
        HttpClient client = getConnection();  
        HttpUriRequest post = getRequestMethod(map, "http://cnivi.com.cn/login", "post");  
        HttpResponse response = client.execute(post);  
    
        if (response.getStatusLine().getStatusCode() == 200) {  
            HttpEntity entity = response.getEntity();  
            String message = EntityUtils.toString(entity, "utf-8");  
            System.out.println(message);  
        } else {  
            System.out.println("請求失敗");  
        }  
    }  
}

get方式

/** 
     * 傳送 get請求 
     */   
    public void get() {   
        CloseableHttpClient httpclient = HttpClients.createDefault();   
        try {   
            // 建立httpget.     
            HttpGet httpget = new HttpGet("http://www.baidu.com/");   
            System.out.println("executing request " + httpget.getURI());   
            // 執行get請求.     
            CloseableHttpResponse response = httpclient.execute(httpget);   
            try {   
                // 獲取響應實體     
                HttpEntity entity = response.getEntity();   
                System.out.println("--------------------------------------");   
                // 列印響應狀態     
                System.out.println(response.getStatusLine());   
                if (entity != null) {   
                    // 列印響應內容長度     
                    System.out.println("Response content length: " + entity.getContentLength());   
                    // 列印響應內容     
                    System.out.println("Response content: " + EntityUtils.toString(entity));   
                }   
                System.out.println("------------------------------------");   
            } finally {   
                response.close();   
            }   
        } catch (ClientProtocolException e) {   
            e.printStackTrace();   
        } catch (ParseException e) {   
            e.printStackTrace();   
        } catch (IOException e) {   
            e.printStackTrace();   
        } finally {   
            // 關閉連線,釋放資源     
            try {   
                httpclient.close();   
            } catch (IOException e) {   
                e.printStackTrace();   
            }   
        }   
    }

post方式

/** 
     * 傳送 post請求訪問本地應用並根據傳遞引數不同返回不同結果 
     */   
    public void post() {   
        // 建立預設的httpClient例項.     
        CloseableHttpClient httpclient = HttpClients.createDefault();   
        // 建立httppost     
        HttpPost httppost = new HttpPost("http://localhost:8080/myDemo/Ajax/serivceJ.action");   
        // 建立引數佇列     
        List<NameValuePair> formparams = new ArrayList<NameValuePair>();   
        formparams.add(new BasicNameValuePair("type", "house"));   
        UrlEncodedFormEntity uefEntity;   
        try {   
            uefEntity = new UrlEncodedFormEntity(formparams, "UTF-8");   
            httppost.setEntity(uefEntity);   
            System.out.println("executing request " + httppost.getURI());   
            CloseableHttpResponse response = httpclient.execute(httppost);   
            try {   
                HttpEntity entity = response.getEntity();   
                if (entity != null) {   
                    System.out.println("--------------------------------------");   
                    System.out.println("Response content: " + EntityUtils.toString(entity, "UTF-8"));   
                    System.out.println("--------------------------------------");   
                }   
            } finally {   
                response.close();   
            }   
        } catch (ClientProtocolException e) {   
            e.printStackTrace();   
        } catch (UnsupportedEncodingException e1) {   
            e1.printStackTrace();   
        } catch (IOException e) {   
            e.printStackTrace();   
        } finally {   
            // 關閉連線,釋放資源     
            try {   
                httpclient.close();   
            } catch (IOException e) {   
                e.printStackTrace();   
            }   
        }   
    }

post方式亂碼補充　

如果有亂碼,可以償試使用 StringEntity 來替換HttpEntity:

StringEntity content =new StringEntity(soapRequestData.toString(), Charset.forName("UTF-8"));// 第二個引數，設定後才會對，內容進行編碼  
        content.setContentType("application/soap+xml; charset=UTF-8");  
        content.setContentEncoding("UTF-8");  
        httppost.setEntity(content);

具體SOAP協議程式碼如下:

    package com.isoftstone.core.service.impl;  
      
    import java.io.BufferedReader;  
    import java.io.File;  
    import java.io.FileInputStream;  
    import java.io.FileReader;  
    import java.io.IOException;  
    import java.io.InputStreamReader;  
    import java.nio.charset.Charset;  
    import java.util.Scanner;  
      
    import org.apache.http.HttpEntity;  
    import org.apache.http.HttpResponse;  
    import org.apache.http.client.ClientProtocolException;  
    import org.apache.http.client.HttpClient;  
    import org.apache.http.client.entity.EntityBuilder;  
    import org.apache.http.client.methods.HttpPost;  
    import org.apache.http.entity.ContentType;  
    import org.apache.http.entity.StringEntity;  
    import org.apache.http.impl.client.HttpClients;  
    import org.apache.http.util.EntityUtils;  
    import org.apache.log4j.Logger;  
    import org.jdom.Document;  
    import org.jdom.Element;  
      
    import com.isoftstone.core.common.constant.RequestConstants;  
    import com.isoftstone.core.common.tools.XmlTool;  
    import com.isoftstone.core.service.intf.ServiceOfStringPara;  
    /** 
     * 
     * 
     */  
    public class DeloittePricingSingleCarImpl implements ServiceOfStringPara {  
        private  String serviceUrl = "http://10.30.0.35:7001/ZSInsUW/Auto/PricingService";  
      
        private static Logger log = Logger.getLogger(DeloittePricingSingleCarImpl.class.getName());  
      
        public String invoke(String sRequest) {  
              
            StringBuffer soapRequestData = new StringBuffer();  
            soapRequestData.append("<soapenv:Envelope");  
            soapRequestData.append("  xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" ");  
            soapRequestData.append("  xmlns:prov=\"http://provider.webservice.zsins.dtt.com/\">");  
            soapRequestData.append(" <soapenv:Header/> ");  
            soapRequestData.append("<soapenv:Body>");  
            soapRequestData.append("<prov:executePrvPricing>");  
            soapRequestData.append("<arg0>");  
            soapRequestData.append("<![CDATA[" + sRequest + "]]>");  
            soapRequestData.append("</arg0>");  
            soapRequestData.append("</prov:executePrvPricing>");  
            soapRequestData.append(" </soapenv:Body>");  
            soapRequestData.append("</soapenv:Envelope>");  
      
            HttpClient httpclient = HttpClients.createDefault();  
            HttpPost httppost = new HttpPost(serviceUrl);  
      
            StringEntity content =new StringEntity(soapRequestData.toString(), Charset.forName("UTF-8"));// 第二個引數，設定後才會對，內容進行編碼  
            content.setContentType("application/soap+xml; charset=UTF-8");  
            content.setContentEncoding("UTF-8");  
            httppost.setEntity(content);  
              
            //用下面的伺服器端以UTF-8接收到的報文會亂碼,原因未知  
    //        HttpEntity reqEntity = EntityBuilder.create().setContentType(  
    //                ContentType.TEXT_PLAIN) // .TEXT_PLAIN  
    //                .setText(soapRequestData.toString()).build();  
    //        httppost.setEntity(reqEntity);  
    //        httppost.addHeader("Content-Type",  
    //                "application/soap+xml; charset=utf-8");  
            HttpResponse response = null;  
            Document doc = null;  
            String returnXml = null;  
            String sentity = null;  
            try {  
                response = httpclient.execute(httppost);  
                HttpEntity resEntity = response.getEntity();  
                if (resEntity != null) {  
                    sentity = EntityUtils.toString(resEntity, "UTF-8");  
                    doc = XmlTool.getDocument(sentity, RequestConstants.ENCODE);  
                    System.out.println(doc.toString());  
                    Element eRoot = doc.getRootElement();  
                    Element body = eRoot.getChild("Body", eRoot.getNamespace());  
                    Element resp = (Element) body.getChildren().get(0);  
                    Element returnele = resp.getChild("return");  
                    returnXml = returnele.getText().toString();  
                }  
            } catch (ClientProtocolException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            } catch (Exception e) {  
                e.printStackTrace();  
            } finally {  
                log.info("傳送給系統的請求報文：\n" + soapRequestData.toString());  
                log.info("系統返回的響應報文：\n" + sentity);  
                log.info("返回給核心的的報文:\n" + returnXml);  
            }  
            return returnXml;  
        }  
          
          
        public String getServiceUrl() {  
            return serviceUrl;  
        }  
      
      
        public void setServiceUrl(String serviceUrl) {  
            this.serviceUrl = serviceUrl;  
        }  
      
      
        public static void main(String[] args) throws Exception{  
            File file = new File("D:/test.txt");  
            System.out.println(file.exists());  
              
            String temp2 = null;  
            StringBuilder sb2 = new StringBuilder();  
            InputStreamReader isr = new InputStreamReader(new FileInputStream(file),"GBK");  
            BufferedReader br = new BufferedReader(isr);  
            temp2 = br.readLine();  
              
            while( temp2 != null ){  
                sb2.append(temp2);  
                temp2 = br.readLine();  
            }  
            String sss = sb2.toString();  
    //        System.out.println(sss.toString());  
            new DeloittePricingSingleCarImpl().invoke(sss);  
        }  
    }

post提交表單

/** 
     * post方式提交表單（模擬使用者登入請求） 
     */   
    public void postForm() {   
        // 建立預設的httpClient例項.     
        CloseableHttpClient httpclient = HttpClients.createDefault();   
        // 建立httppost     
        HttpPost httppost = new HttpPost("http://localhost:8080/myDemo/Ajax/serivceJ.action");   
        // 建立引數佇列     
        List<NameValuePair> formparams = new ArrayList<NameValuePair>();   
        formparams.add(new BasicNameValuePair("username", "admin"));   
        formparams.add(new BasicNameValuePair("password", "123456"));   
        UrlEncodedFormEntity uefEntity;   
        try {   
            uefEntity = new UrlEncodedFormEntity(formparams, "UTF-8");   
            httppost.setEntity(uefEntity);   
            System.out.println("executing request " + httppost.getURI());   
            CloseableHttpResponse response = httpclient.execute(httppost);   
            try {   
                HttpEntity entity = response.getEntity();   
                if (entity != null) {   
                    System.out.println("--------------------------------------");   
                    System.out.println("Response content: " + EntityUtils.toString(entity, "UTF-8"));   
                    System.out.println("--------------------------------------");   
                }   
            } finally {   
                response.close();   
            }   
        } catch (ClientProtocolException e) {   
            e.printStackTrace();   
        } catch (UnsupportedEncodingException e1) {   
            e1.printStackTrace();   
        } catch (IOException e) {   
            e.printStackTrace();   
        } finally {   
            // 關閉連線,釋放資源     
            try {   
                httpclient.close();   
            } catch (IOException e) {   
                e.printStackTrace();   
            }   
        }   
    }

檔案上傳

/** 
     * 上傳檔案 
     */   
    public void upload() {   
        CloseableHttpClient httpclient = HttpClients.createDefault();   
        try {   
            HttpPost httppost = new HttpPost("http://localhost:8080/myDemo/Ajax/serivceFile.action");   
     
            FileBody bin = new FileBody(new File("F:\\image\\sendpix0.jpg"));   
            StringBody comment = new StringBody("A binary file of some kind", ContentType.TEXT_PLAIN);   
     
            HttpEntity reqEntity = MultipartEntityBuilder.create().addPart("bin", bin).addPart("comment", comment).build();   
     
            httppost.setEntity(reqEntity);   
     
            System.out.println("executing request " + httppost.getRequestLine());   
            CloseableHttpResponse response = httpclient.execute(httppost);   
            try {   
                System.out.println("----------------------------------------");   
                System.out.println(response.getStatusLine());   
                HttpEntity resEntity = response.getEntity();   
                if (resEntity != null) {   
                    System.out.println("Response content length: " + resEntity.getContentLength());   
                }   
                EntityUtils.consume(resEntity);   
            } finally {   
                response.close();   
            }   
        } catch (ClientProtocolException e) {   
            e.printStackTrace();   
        } catch (IOException e) {   
            e.printStackTrace();   
        } finally {   
            try {   
                httpclient.close();   
            } catch (IOException e) {   
                e.printStackTrace();   
            }   
        }   
    }

ssl連線

/** 
     * HttpClient連線SSL 
     */   
    public void ssl() {   
        CloseableHttpClient httpclient = null;   
        try {   
            KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());   
            FileInputStream instream = new FileInputStream(new File("d:\\tomcat.keystore"));   
            try {   
                // 載入keyStore d:\\tomcat.keystore     
                trustStore.load(instream, "123456".toCharArray());   
            } catch (CertificateException e) {   
                e.printStackTrace();   
            } finally {   
                try {   
                    instream.close();   
                } catch (Exception ignore) {   
                }   
            }   
            // 相信自己的CA和所有自簽名的證書   
            SSLContext sslcontext = SSLContexts.custom().loadTrustMaterial(trustStore, new TrustSelfSignedStrategy()).build();   
            // 只允許使用TLSv1協議   
            SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext, new String[] { "TLSv1" }, null,   
                    SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);   
            httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();   
            // 建立http請求(get方式)   
            HttpGet httpget = new HttpGet("https://localhost:8443/myDemo/Ajax/serivceJ.action");   
            System.out.println("executing request" + httpget.getRequestLine());   
            CloseableHttpResponse response = httpclient.execute(httpget);   
            try {   
                HttpEntity entity = response.getEntity();   
                System.out.println("----------------------------------------");   
                System.out.println(response.getStatusLine());   
                if (entity != null) {   
                    System.out.println("Response content length: " + entity.getContentLength());   
                    System.out.println(EntityUtils.toString(entity));   
                    EntityUtils.consume(entity);   
                }   
            } finally {   
                response.close();   
            }   
        } catch (ParseException e) {   
            e.printStackTrace();   
        } catch (IOException e) {   
            e.printStackTrace();   
        } catch (KeyManagementException e) {   
            e.printStackTrace();   
        } catch (NoSuchAlgorithmException e) {   
            e.printStackTrace();   
        } catch (KeyStoreException e) {   
            e.printStackTrace();   
        } finally {   
            if (httpclient != null) {   
                try {   
                    httpclient.close();   
                } catch (IOException e) {   
                    e.printStackTrace();   
                }   
            }   
        }   
    }

關於RequestConfig的配置:

源自:

public void requestConfig(){  
//      新建一個RequestConfig：  
        RequestConfig defaultRequestConfig = RequestConfig.custom()  
            //一、連線目標伺服器超時時間：ConnectionTimeout-->指的是連線一個url的連線等待時間  
            .setConnectTimeout(5000)  
            //二、讀取目標伺服器資料超時時間：SocketTimeout-->指的是連線上一個url，獲取response的返回等待時間  
            .setSocketTimeout(5000)  
            //三、從連線池獲取連線的超時時間:ConnectionRequestTimeout  
            .setConnectionRequestTimeout(5000)  
            .build();  
           
//      這個超時可以設定為客戶端級別,作為所有請求的預設值：  
        CloseableHttpClient httpclient = HttpClients.custom()  
            .setDefaultRequestConfig(defaultRequestConfig)  
            .build();  
//       httpclient.execute(httppost);的時候可以讓httppost直接享受到httpclient中的預設配置.  
           
//      Request不會繼承客戶端級別的請求配置，所以在自定義Request的時候，需要將客戶端的預設配置拷貝過去：  
        HttpGet httpget = new HttpGet("http://www.apache.org/");  
        RequestConfig requestConfig = RequestConfig.copy(defaultRequestConfig)  
            .setProxy(new HttpHost("myotherproxy", 8080))  
            .build();  
        httpget.setConfig(requestConfig);  
//      httpget可以單獨地使用新copy的requestConfig請求配置,不會對別的request請求產生影響  
    }

httpGet或httpPost 的abort()和releaseConnection()差異

//httpPost.abort();//中斷請求,接下來可以開始另一段請求,所以個人理應,用這個應該可以在session中虛擬登入  
 //httpPost.releaseConnection();//釋放請求.如果釋放了相當於要清空session

package com.bms.core;  
     
import java.io.IOException;  
import java.util.ArrayList;  
import java.util.List;  
     
import org.apache.http.Consts;  
import org.apache.http.HttpEntity;  
import org.apache.http.HttpResponse;  
import org.apache.http.NameValuePair;  
import org.apache.http.client.ClientProtocolException;  
import org.apache.http.client.entity.UrlEncodedFormEntity;  
import org.apache.http.client.methods.HttpGet;  
import org.apache.http.client.methods.HttpPost;  
import org.apache.http.impl.client.DefaultHttpClient;  
import org.apache.http.message.BasicNameValuePair;  
import org.apache.http.util.EntityUtils;  
     
import com.bms.util.CommonUtil;  
     
public class Test2 {  
     
    /** 
     * @param args 
     * @throws IOException 
     * @throws ClientProtocolException 
     */  
    public static void main(String[] args) throws ClientProtocolException, IOException {  
        DefaultHttpClient httpclient = new DefaultHttpClient();  
     
         HttpGet httpGet = new HttpGet("http://www.baidu.com");  
         String body = "";  
         HttpResponse response;  
         HttpEntity entity;  
         response = httpclient.execute(httpGet);  
         entity = response.getEntity();  
         body = EntityUtils.toString(entity);//這個就是頁面原始碼了  
         httpGet.abort();//中斷請求,接下來可以開始另一段請求  
         System.out.println(body);  
         //httpGet.releaseConnection();//釋放請求.如果釋放了相當於要清空session  
         //以下是post方法  
         HttpPost httpPost = new HttpPost("http://www.baidu.com");//一定要改成可以提交的地址,這裡用百度代替  
         List <NameValuePair> nvps = new ArrayList <NameValuePair>();  
         nvps.add(new BasicNameValuePair("name", "1"));//名值對  
         nvps.add(new BasicNameValuePair("account", "xxxx"));  
         httpPost.setEntity(new UrlEncodedFormEntity(nvps, Consts.UTF_8));  
         response = httpclient.execute(httpPost);  
         entity = response.getEntity();  
         body = EntityUtils.toString(entity);  
         System.out.println("Login form get: " + response.getStatusLine());//這個可以列印狀態  
         httpPost.abort();  
         System.out.println(body);  
         httpPost.releaseConnection();  
    }  
     
}

我專案中用到的HttpClientUtil (2016/12/17)

package com.isoftstone.pcis.isc.util;  
  
import java.io.IOException;  
import java.io.InterruptedIOException;  
import java.net.UnknownHostException;  
  
import javax.net.ssl.SSLException;  
import javax.net.ssl.SSLHandshakeException;  
  
import org.apache.http.HttpEntityEnclosingRequest;  
import org.apache.http.HttpRequest;  
import org.apache.http.NoHttpResponseException;  
import org.apache.http.client.HttpRequestRetryHandler;  
import org.apache.http.client.protocol.HttpClientContext;  
import org.apache.http.config.Registry;  
import org.apache.http.config.RegistryBuilder;  
import org.apache.http.conn.ConnectTimeoutException;  
import org.apache.http.conn.socket.ConnectionSocketFactory;  
import org.apache.http.conn.socket.LayeredConnectionSocketFactory;  
import org.apache.http.conn.socket.PlainConnectionSocketFactory;  
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;  
import org.apache.http.impl.client.CloseableHttpClient;  
import org.apache.http.impl.client.HttpClients;  
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;  
import org.apache.http.protocol.HttpContext;  
import com.isoftstone.pcis.isc.util.ProperUtil;  
  
public class HttpClientUtil {  
      
    private static CloseableHttpClient httpclient = null;   
      
    static final int maxTotal=Integer.valueOf(ProperUtil.get("maxTotal")).intValue();//總最大連線數  
    static final int defaultMaxPerRoute=Integer.valueOf(ProperUtil.get("corePoolSize")).intValue();//每條線路最大連線數 = 本系統核心執行緒數 , 這樣永遠不會超過最大連線  
      
     public static CloseableHttpClient getHttpClient() {  
              
            if (null == httpclient) {  
                synchronized (HttpClientUtil.class) {  
                    if (null == httpclient) {  
                        httpclient = getNewHttpClient();  
                    }  
                }  
            }  
              
            return httpclient;  
        }  
       
       private static CloseableHttpClient getNewHttpClient() {  
  
            
            // 設定連線池  
            ConnectionSocketFactory plainsf = PlainConnectionSocketFactory.getSocketFactory();  
            LayeredConnectionSocketFactory sslsf = SSLConnectionSocketFactory.getSocketFactory();  
            Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory> create().register("http", plainsf).register("https", sslsf).build();  
            PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(registry);  
            // 配置最大連線數  
            cm.setMaxTotal(maxTotal);  
            // 配置每條線路的最大連線數  
            cm.setDefaultMaxPerRoute(defaultMaxPerRoute);  
              
            // 請求重試處理  
            HttpRequestRetryHandler httpRequestRetryHandler = new HttpRequestRetryHandler() {  
                @Override  
                public boolean retryRequest(IOException exception,  
                        int executionCount, HttpContext context) {  
                    if (executionCount >= 2) {// 如果已經重試了2次，就放棄  
                        return false;  
                    }  
                    if (exception instanceof NoHttpResponseException) {// 如果伺服器丟掉了連線，那麼就重試  
                        return true;  
                    }  
                    if (exception instanceof SSLHandshakeException) {// 不要重試SSL握手異常  
                        return false;  
                    }  
                    if (exception instanceof InterruptedIOException) {// 超時  
                        return false;  
                    }  
                    if (exception instanceof UnknownHostException) {// 目標伺服器不可達  
                        return false;  
                    }  
                    if (exception instanceof ConnectTimeoutException) {// 連線被拒絕  
                        return false;  
                    }  
                    if (exception instanceof SSLException) {// SSL握手異常  
                        return false;  
                    }  
  
                    HttpClientContext clientContext = HttpClientContext.adapt(context);  
                    HttpRequest request = clientContext.getRequest();  
                      
                    if (!(request instanceof HttpEntityEnclosingRequest)) {  
                        return true;  
                    }  
                    return false;  
                }  
  
            };  
              
            CloseableHttpClient newHttpclient=null;  
          
                newHttpclient = HttpClients.custom()  
                                           .setConnectionManager(cm)  
//                                           .setDefaultRequestConfig(requestConfig)  
                                           .setRetryHandler(httpRequestRetryHandler)  
                                           .build();  
                  
             return newHttpclient;  
       }  
}

我自己整理的HttpClientTool

package com.isoftstone.core.util;  
  
import java.io.IOException;  
import java.io.InterruptedIOException;  
import java.net.UnknownHostException;  
  
import javax.net.ssl.SSLException;  
import javax.net.ssl.SSLHandshakeException;  
  
import org.apache.http.HttpEntityEnclosingRequest;  
import org.apache.http.HttpHost;  
import org.apache.http.HttpRequest;  
import org.apache.http.NoHttpResponseException;  
import org.apache.http.client.HttpRequestRetryHandler;  
import org.apache.http.client.config.RequestConfig;  
import org.apache.http.client.protocol.HttpClientContext;  
import org.apache.http.config.Registry;  
import org.apache.http.config.RegistryBuilder;  
import org.apache.http.conn.ConnectTimeoutException;  
import org.apache.http.conn.routing.HttpRoute;  
import org.apache.http.conn.socket.ConnectionSocketFactory;  
import org.apache.http.conn.socket.LayeredConnectionSocketFactory;  
import org.apache.http.conn.socket.PlainConnectionSocketFactory;  
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;  
import org.apache.http.impl.client.CloseableHttpClient;  
import org.apache.http.impl.client.HttpClients;  
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;  
import org.apache.http.protocol.HttpContext;  
  
/** 
 * org.apache.http.impl.client.CloseableHttpClient連結池生成工具 
 * @reference http://www.cnblogs.com/whatlonelytear/articles/4835538.html 
 * @author King 
 * @date 20170601 
 */  
public class HttpClientTool {  
  
    // org.apache.http.impl.client.CloseableHttpClient  
    private static CloseableHttpClient httpclient = null;  
  
    // 這裡就直接預設固定了,因為以下三個引數在新建的method中仍然可以重新配置並被覆蓋.  
    static final int connectionRequestTimeout = 5000;// ms毫秒,從池中獲取連結超時時間  
    static final int connectTimeout = 5000;// ms毫秒,建立連結超時時間  
    static final int socketTimeout = 30000;// ms毫秒,讀取超時時間  
  
    // 總配置,主要涉及是以下兩個引數,如果要作調整沒有用到properties會比較後麻煩,但鑑於一經貼上,隨處可用的特點,就不再做依賴性配置化處理了.  
    // 而且這個引數同一家公司基本不會變動.  
    static final int maxTotal = 500;// 最大總併發,很重要的引數  
    static final int maxPerRoute = 100;// 每路併發,很重要的引數  
  
    // 正常情況這裡應該配成MAP或LIST  
    // 細化配置引數,用來對每路引數做精細化處理,可以管控各ip的流量,比如預設配置請求baidu:80埠最大100個併發連結,  
    static final String detailHostName = "http://www.baidu.com";// 每個細化配置之ip(不重要,在特殊場景很有用)  
    static final int detailPort = 80;// 每個細化配置之port(不重要,在特殊場景很有用)  
    static final int detailMaxPerRoute = 100;// 每個細化配置之最大併發數(不重要,在特殊場景很有用)  
  
    public static CloseableHttpClient getHttpClient() {  
        if (null == httpclient) {  
            synchronized (HttpClientTool.class) {  
                if (null == httpclient) {  
                    httpclient = init();  
                }  
            }  
        }  
        return httpclient;  
    }  
  
    /** 
     * 連結池初始化 這裡最重要的一點理解就是. 讓CloseableHttpClient 一直活在池的世界裡, 但是HttpPost卻一直用完就消掉. 
     * 這樣可以讓連結一直保持著. 
     *  
     * @return 
     */  
    private static CloseableHttpClient init() {  
        CloseableHttpClient newHttpclient = null;  
  
        // 設定連線池  
        ConnectionSocketFactory plainsf = PlainConnectionSocketFactory.getSocketFactory();  
        LayeredConnectionSocketFactory sslsf = SSLConnectionSocketFactory.getSocketFactory();  
        Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory> create().register("http", plainsf).register("https", sslsf).build();  
        PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(registry);  
        // 將最大連線數增加  
        cm.setMaxTotal(maxTotal);  
        // 將每個路由基礎的連線增加  
        cm.setDefaultMaxPerRoute(maxPerRoute);  
  
        // 細化配置開始,其實這裡用Map或List的for迴圈來配置每個連結,在特殊場景很有用.  
        // 將每個路由基礎的連線做特殊化配置,一般用不著  
        HttpHost httpHost = new HttpHost(detailHostName, detailPort);  
        // 將目標主機的最大連線數增加  
        cm.setMaxPerRoute(new HttpRoute(httpHost), detailMaxPerRoute);  
        // cm.setMaxPerRoute(new HttpRoute(httpHost2),  
        // detailMaxPerRoute2);//可以有細化配置2  
        // cm.setMaxPerRoute(new HttpRoute(httpHost3),  
        // detailMaxPerRoute3);//可以有細化配置3  
        // 細化配置結束  
  
        // 請求重試處理  
        HttpRequestRetryHandler httpRequestRetryHandler = new HttpRequestRetryHandler() {  
            @Override  
            public boolean retryRequest(IOException exception, int executionCount, HttpContext context) {  
                if (executionCount >= 2) {// 如果已經重試了2次，就放棄  
                    return false;  
                }  
                if (exception instanceof NoHttpResponseException) {// 如果伺服器丟掉了連線，那麼就重試  
                    return true;  
                }  
                if (exception instanceof SSLHandshakeException) {// 不要重試SSL握手異常  
                    return false;  
                }  
                if (exception instanceof InterruptedIOException) {// 超時  
                    return false;  
                }  
                if (exception instanceof UnknownHostException) {// 目標伺服器不可達  
                    return false;  
                }  
                if (exception instanceof ConnectTimeoutException) {// 連線被拒絕  
                    return false;  
                }  
                if (exception instanceof SSLException) {// SSL握手異常  
                    return false;  
                }  
  
                HttpClientContext clientContext = HttpClientContext.adapt(context);  
                HttpRequest request = clientContext.getRequest();  
                // 如果請求是冪等的，就再次嘗試  
                if (!(request instanceof HttpEntityEnclosingRequest)) {  
                    return true;  
                }  
                return false;  
            }  
        };  
  
        // 配置請求的超時設定  
        RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(connectionRequestTimeout).setConnectTimeout(connectTimeout).setSocketTimeout(socketTimeout).build();  
        newHttpclient = HttpClients.custom().setConnectionManager(cm).setDefaultRequestConfig(requestConfig).setRetryHandler(httpRequestRetryHandler).build();  
        return newHttpclient;  
    }  
}

package com.alqsoft.utils;


import java.io.BufferedReader;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.List;


import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.ParseException;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.config.CookieSpecs;
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.cookie.Cookie;
import org.apache.http.cookie.CookieOrigin;
import org.apache.http.cookie.CookieSpec;
import org.apache.http.cookie.CookieSpecProvider;
import org.apache.http.cookie.MalformedCookieException;
import org.apache.http.impl.client.BasicCookieStore;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.cookie.BestMatchSpecFactory;
import org.apache.http.impl.cookie.BrowserCompatSpec;
import org.apache.http.impl.cookie.BrowserCompatSpecFactory;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HttpContext;
import org.apache.http.util.EntityUtils;


public class HttpClientObject {
    private static Log logger = LogFactory.getLog(HttpClientObject.class);
    private CloseableHttpClient httpClient = null;
    private HttpResponse response;

    private HttpPost httpPost = null;

    private HttpGet httpGet = null;

    private String paramKey = "";

    private String paramValue = "";

    private String responseString;

    public void setParamKey(String paramKey) {
        this.paramKey = paramKey;
    }

    public void setParamValue(String paramValue) {
        this.paramValue = paramValue;
    }

    public String getResponseString() {
        return responseString;
    }

    public HttpClientObject() {
        this.getHttpClient();
    }

    private List<NameValuePair> getRequestBody() {
        NameValuePair pair1 = new BasicNameValuePair(paramKey, paramValue);
        List<NameValuePair> pairList = new ArrayList<NameValuePair>();
        pairList.add(pair1);
        return pairList;
    }


    public void submit() {
        try {
            if (httpPost != null) {
                response = httpClient.execute(httpPost);
                httpPost = null;
            }
            if (httpGet != null) {
                response = httpClient.execute(httpGet);
                httpGet = null;
            }
            this.response();
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    private void response() {
        String result = "";
        BufferedReader in = null;
        try {
            HttpEntity httpEntity = response.getEntity();
            responseString = EntityUtils.toString(httpEntity);
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (in != null) {
                    in.close();
                }
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }


    }


    public void setPost(String httpUrl) {
        try {
            HttpEntity requestHttpEntity = new UrlEncodedFormEntity(this.getRequestBody());
            httpPost = new HttpPost(httpUrl);
            httpPost.addHeader("Content-Type", "”application/json;charset=UTF-8");
            httpPost.setEntity(requestHttpEntity);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }


    public void setGet(String httpUrl) {
        httpGet = new HttpGet(httpUrl);
        httpGet.addHeader("Content-Type", "text/html;charset=UTF-8");
    }


    private void getHttpClient() {
        BasicCookieStore cookieStore = new BasicCookieStore();
        CookieSpecProvider easySpecProvider = new CookieSpecProvider() {
            public CookieSpec create(HttpContext context) {


                return new BrowserCompatSpec() {
                    @Override
                    public void validate(Cookie cookie, CookieOrigin origin)
                            throws MalformedCookieException {
// Oh, I am easy
                    }
                };
            }


        };
        Registry<CookieSpecProvider> r = RegistryBuilder.<CookieSpecProvider>create()
                .register(CookieSpecs.BEST_MATCH, new BestMatchSpecFactory())
                .register(CookieSpecs.BROWSER_COMPATIBILITY, new BrowserCompatSpecFactory())
                .register("easy", easySpecProvider).build();


        RequestConfig requestConfig = RequestConfig.custom().setCookieSpec("easy")
                .setSocketTimeout(20000).setConnectTimeout(20000).build();


        httpClient = HttpClients.custom().setDefaultCookieSpecRegistry(r)
                .setDefaultRequestConfig(requestConfig).setDefaultCookieStore(cookieStore).build();
    }


    /**
     * httpclient傳送http get請求；
     *
     * @return
     * @throws URISyntaxException
     * @throws IOException
     * @throws ClientProtocolException
     */
    public static String sendGet(String uriPath, List<NameValuePair> ns)
            throws URISyntaxException, ClientProtocolException, IOException {
        CloseableHttpClient httpclient = HttpClients.createDefault();
        URIBuilder uri = new URIBuilder();
        uri.setPath(uriPath);
        uri.addParameters(ns);
        URI u = uri.build();
        HttpGet httpget = new HttpGet(u);
        CloseableHttpResponse response = httpclient.execute(httpget);
        return EntityUtils.toString(response.getEntity());
    }


    /**
     * httpclient傳送http post請求；
     *
     * @return
     * @throws URISyntaxException
     * @throws IOException
     * @throws ClientProtocolException
     */
    public static String sendPost(String uriPath, List<NameValuePair> ns)
            throws URISyntaxException, ClientProtocolException, IOException {
        CloseableHttpClient httpclient = HttpClients.createDefault();
        URIBuilder uri = new URIBuilder();
        uri.setPath(uriPath);
        uri.addParameters(ns);
        URI u = uri.build();
        HttpPost httpPost = new HttpPost(u);
        CloseableHttpResponse response = httpclient.execute(httpPost);
        return EntityUtils.toString(response.getEntity());
    }

}


使用方法如下：

        String signUrl= ”路徑“；

        try{
        List<NameValuePair> nameValuePairs=new ArrayList<NameValuePair>();
        nameValuePairs.add(new BasicNameValuePair("phone",phone));
        nameValuePairs.add(new BasicNameValuePair("xytId",String.valueOf(xytId)));
        nameValuePairs.add(new BasicNameValuePair("balance",balance));

        String result=HttpClientObject.sendPost(signUrl,nameValuePairs);
        logger.info("result: = "+result);
        JSONObject jsonObject=JSON.parseObject(result);

        Integer code=Integer.valueOf(jsonObject.getString("code"));
        if(code.equals(0)){
        code1=0L;
        }else if(code.equals(1)){
        code1=1L;
        }else if(code.equals(3)){
        code1=3L;
        }
        }catch(Exception e){
        e.printStackTrace();
        }

HttpClient用法--這一篇全瞭解（內含例子）

一、簡介

二、特性

三、使用方法

四、例項

主檔案

HttpClientUtils工具類

get方式

post方式

post提交表單

檔案上傳

ssl連線

關於RequestConfig的配置:

我專案中用到的HttpClientUtil (2016/12/17)

我自己整理的HttpClientTool

HttpClient用法--這一篇全瞭解（內含例子）

【面試】序列化相關-這一篇全瞭解

【面試】異常相關-這一篇全瞭解

JVM引用模型-這一篇全瞭解

【面試】IO相關-這一篇全瞭解

【面試】列舉相關-這一篇全瞭解

Map相關--這一篇全瞭解

【面試】面向物件相關-這一篇全瞭解

【面試】基本資料型別+String相關-這一篇全瞭解

類載入機制-雙親委派，破壞雙親委派--這一篇全瞭解

List基礎--這一篇全瞭解

List相關原始碼解析--這一篇全瞭解

這可能不只是一篇面經（BAT面試）

JVM-HotSpot虛擬機器-編譯原理、JIT、編譯優化--一篇全瞭解

Java I/O體系從原理到應用，這一篇全說清楚了

Netty堆外記憶體洩漏排查，這一篇全講清楚了

zookeeper實現分散式鎖總結，看這一篇足矣（設計模式應用實戰）

一篇面經（BAT面試）

瞭解golang的不定引數（... parameters），這一篇就夠了

【轉】【修真院“善良”系列之十八】WEB程序員從零開始到就業的全資料V1.0——只看這一篇就夠了！

HttpClient用法--這一篇全瞭解（內含例子）

一、簡介

二、特性

三、使用方法

四、例項

主檔案

HttpClientUtils工具類

get方式

post方式

post提交表單

檔案上傳

ssl連線

關於RequestConfig的配置:

我專案中用到的HttpClientUtil (2016/12/17)

我自己整理的HttpClientTool

相關推薦