JavaWeb之抓包之旅(三) :HttpClient封裝工具類

阿新 • • 發佈：2019-02-17

談到httpClient相信大家都不陌生，網上也有一大推別人總結的。HttpClient是Apache Jakarta Common下的子專案，用來提供高效的、最新的、功能豐富的支援HTTP協議的客戶端程式設計工具包，並且它支援HTTP協議最新的版本和建議。
詳細請參考文件：HttpClient

我們在對資料進行請求的時候經常使用。

前不久在做一個百度地圖定位的（通過GPS判斷你在某個學校，但是並不是每個學校地圖上都有，而且如何確定範圍呢？）

類似於餓了麼，我一直在想它為什麼能定位到具體的某個宿舍呢？後來發現是利用了百度地圖LBS雲(當然這是我個人實現的方案)：
1. 呼叫手機GPS定位（或者瀏覽器定位，瀏覽器定位不會很精確，一般會定位到區，街道不會很詳細）。獲取經緯度。
2. 上傳經緯度，以及名稱（具體請參考百度api介面文件），比如武漢紡織大學，這樣在你的百度LBS雲，中就有了這個點的資訊。
3. 當你手機要獲取具體定位時，手機GPS獲取經緯度，然後呼叫介面（具體請參考百度api介面文件）,獲取這個點為中心，半徑為50m（自己寫），百度LBS雲是否有這個點，有返回list資訊，這樣你就獲取了你所在位置在哪了。

這樣你在配送地址就可以自己定位了。我大膽猜測，我們用外賣軟體的時候，首先它已經定位到了一個比較精確的位置，比如武漢紡織大學，但是得自己輸入樓號，比如輸入5號教學樓，這樣他就會把，你位置的經緯度，還有武漢紡織大學5號教學樓，傳到伺服器上，（如果有很多人打錯了字，或者其他，估計有個特定的演算法，比如取資料名稱相同最多的3個）。這樣我們下次定位的時候，可能就在這個50m範圍內，就能推薦這個地址了（武漢紡織大學5號教學樓）。

為什麼要講這個呢？我偏題了嗎？

最近在做畢設，瀏覽器定位，我想直接用Ajax請求，url就寫百度LBS雲介面即可。
但是出了一個問題，我請求跨域了(本地伺服器想要訪問百度伺服器)，雖然網上有解決跨域的方法，但是後來我想了一個解決方法，我為什麼一定要用JS來訪問百度LBS雲介面呢？
我JS獲得了經緯度，位置名稱，直接傳到後臺伺服器，然後後臺通過HttpClient來請求百度雲伺服器不就好了嗎？然後將資料返回給前端JS。

接下來我就來通過HttpClient 工具類，來進行請求，來實現百度地圖定位的這個功能。

Request.java

package com.http;

import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * Requst分裝類，封裝一些資訊
 * 作者：Administrator<br>
 * 版本：1.0<br>
 * 建立日期：下午9:24:43<br>
 */
public class Request {


    /**請求屬性*/ 

    private Map<String, String> properties;

    /**請求引數*/
    private Map<String, String> params ;

    /**請求頭部*/
    private Map<String, String> headers;

    private byte[] postData;

    /**是否同步*/
    private boolean sync=false;


    /**
     * 獲得設定的屬性
     * @param property
     * @return
     */
    public String getProperty(String property) {
        if(properties ==null){
            return null;
        }
        return properties.get(property);
    }

    /**
     * 設定屬性
     * @param propery
     * @param value
     */
    public void setProperty(String propery,String value) {
        if(properties==null){
            properties = new LinkedHashMap<String, String>();
        }
        properties.put(propery, value);
    }


    /**
     * 設定引數
     * @param params
     */
    public void setParam(String param,String value) {
        if(params==null){
            params = new LinkedHashMap<String, String>();
        }
        params.put(param, value);
    }

    public Map<String, String> getHeaders() {
        return headers;
    }

    /**
     * 設定頭部資訊
     * @param header
     * @param value
     */
    public void setHeader(String header, String value) {
        if (headers == null) {
            headers = new LinkedHashMap<String, String>();
        }
        headers.put(header, value);
    }

    public Map<String, String> getParams() {
        return params;
    }

    public String getHeader(String header) {
        if (headers == null) {
            return null;
        }
        return headers.get(header);
    }
    public Map<String, String> getProperties() {
        return properties;
    }

    public void setProperties(Map<String, String> properties) {
        this.properties = properties;
    }

    public void setParams(Map<String, String> params) {
        this.params = params;
    }

    public void setHeaders(Map<String, String> headers) {
        this.headers = headers;
    }



    public byte[] getPostData() {
        return postData;
    }

    public void setPostData(byte[] postData) {
        this.postData = postData;
    }

    public boolean isSync() {
        return sync;
    }

    public void setSync(boolean sync) {
        this.sync = sync;
    }





}

Response.java

package com.http;

import java.util.LinkedHashMap;
import java.util.Map;

/**
 * 響應類
 * 作者：Administrator<br>
 * 版本：1.0<br>
 * 建立日期：下午9:36:03<br>
 */
public class Response {

    /**響應碼*/
    private int statusCode ;

    /**響應內容*/
    private byte[] content ;

    /**響應頭部*/
    private Map<String, String> headers;

    /**
     * 設定響應頭
     * 
     * @param name
     * @param value
     */
    public void setHeader(String name, String value) {
        if (headers == null) {
            headers = new LinkedHashMap<String, String>();
        }
        headers.put(name, value);
    }

    /**
     * 按指定編碼獲得響應內容，有些響應亂碼了 需要解決亂碼問題
     * @param encoding
     * @return
     */
    public String getContentString(String encoding) {
        try {
            String contentString = new String(getContent(), encoding);
            return contentString;
        } catch (Exception e) {
            System.out.println("不支援編碼");
        }
        return null;
    }

    public int getStatusCode() {
        return statusCode;
    }

    public void setStatusCode(int statusCode) {
        this.statusCode = statusCode;
    }

    public byte[] getContent() {
        return content;
    }

    public void setContent(byte[] content) {
        this.content = content;
    }

    public Map<String, String> getHeaders() {
        return headers;
    }

    public void setHeaders(Map<String, String> headers) {
        this.headers = headers;
    }


}

HttpClientUtil

package com.http;

import java.io.ByteArrayOutputStream;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InterruptedIOException;
import java.io.UnsupportedEncodingException;
import java.net.SocketException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.UnknownHostException;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.zip.GZIPInputStream;

import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLHandshakeException;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpEntityEnclosingRequest;
import org.apache.http.HttpHost;
import org.apache.http.HttpRequest;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.NoHttpResponseException;
import org.apache.http.ParseException;
import org.apache.http.ProtocolException;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.CookieStore;
import org.apache.http.client.HttpRequestRetryHandler;
import org.apache.http.client.config.CookieSpecs;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.config.RequestConfig.Builder;
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.protocol.HttpClientContext;
import org.apache.http.conn.ConnectTimeoutException;
import org.apache.http.conn.HttpHostConnectException;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.cookie.Cookie;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.impl.client.BasicCookieStore;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.DefaultRedirectStrategy;
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.protocol.HttpContext;
import org.apache.http.util.ByteArrayBuffer;
import org.apache.http.util.EntityUtils;

/**
 * HttpClient工具封裝類，Post，Get請求，代理請求
 * 作者：<br>
 * 版本：1.0<br>
 * 建立日期：下午9:21:00<br>
 */
public class HttpClientUtil {

    /***連線超時時間*/
    private Integer connectTimeout =60*1000;

    private Integer socketTimeout =180*1000;
    private CloseableHttpClient httpClient = null;

    private CookieStore cookieStore = new  BasicCookieStore();


    /** 代理請求 */
    public HttpClientUtil(String proxyHost, int proxyPort) {
        this(proxyHost, proxyPort, -1, -1, 0, 0, true);
    }

    /** 預設*/
    public HttpClientUtil() {
        this(null, 0, -1, -1, 0, 0, true);
    }

    /** 進行請求無代理設定連線時間  */
    public HttpClientUtil(int socketTimeout, int connectTimeout) {
        this(null, 0, socketTimeout, connectTimeout, 0, 0, true);
    }


    /**
     * 
     * @param proxyHost  代理主機地址
     * @param proxyPort  代理埠
     * @param socketTimeout
     * @param connectTimeout
     * @param route  
     * @param maxTotal
     * @param followRedirect
     */
    public HttpClientUtil(String proxyHost, int proxyPort, int socketTimeout, int connectTimeout, int route, int maxTotal, boolean followRedirect){
        Builder builder = RequestConfig.custom();
        builder.setCookieSpec(CookieSpecs.BROWSER_COMPATIBILITY);
        if (followRedirect) {
            builder.setCircularRedirectsAllowed(true);
            builder.setMaxRedirects(100);
        }
        if (StringUtils.isNotBlank(proxyHost) && proxyPort > 0) {
            builder.setProxy(new HttpHost(proxyHost, proxyPort));
        }

        //設定連線時間
        if (socketTimeout != -1) {
            this.socketTimeout = socketTimeout;
        }
        builder.setSocketTimeout(this.socketTimeout);

        if (connectTimeout != -1) {
            this.connectTimeout = connectTimeout;
        }
        builder.setConnectTimeout(this.connectTimeout);
        builder.setConnectionRequestTimeout(this.connectTimeout);

        RequestConfig requestConfig = builder.build();
        init(requestConfig, route, maxTotal);
    }

    private void init(RequestConfig requestConfig, int route, int maxTotal) {
        X509TrustManager x509mgr = new X509TrustManager() {
            @Override
            public void checkClientTrusted(X509Certificate[] xcs, String string) {
            }

            @Override
            public void checkServerTrusted(X509Certificate[] xcs, String string) {
            }

            @Override
            public X509Certificate[] getAcceptedIssuers() {
                return null;
            }
        };

        SSLContext sslContext = null;
        try {
            sslContext = SSLContext.getInstance("TLS");
        } catch (NoSuchAlgorithmException e1) {
            e1.printStackTrace();
        }

        try {
            sslContext.init(null, new TrustManager[] { x509mgr }, null);
        } catch (KeyManagementException e) {
            e.printStackTrace();
        }

        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext, SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

        HttpRequestRetryHandler httpRequestRetryHandler = new HttpRequestRetryHandler() {
            @Override
            public boolean retryRequest(IOException exception, int executionCount, HttpContext context) {
                if (executionCount >= 5) {// 如果已經重試了5次，就放棄
                    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;
                }
                // 2016-03-09針對broken pipe的問題做處理
                if (exception instanceof SocketException) {
                    return true;
                }

                HttpClientContext clientContext = HttpClientContext.adapt(context);
                HttpRequest request = clientContext.getRequest();
                // 如果請求是冪等的，就再次嘗試
                if (!(request instanceof HttpEntityEnclosingRequest)) {
                    return true;
                }
                return false;
            }
        };
        DefaultRedirectStrategy redirectStrategy = new DefaultRedirectStrategy() {
            public boolean isRedirected(HttpRequest request, HttpResponse response, HttpContext context) {
                boolean isRedirect = false;
                try {
                    isRedirect = super.isRedirected(request, response, context);
                } catch (ProtocolException e) {
                    e.printStackTrace();
                }
                if (!isRedirect) {
                    int responseCode = response.getStatusLine().getStatusCode();
                    if (responseCode == 301 || responseCode == 302) {
                        return true;
                    }
                }
                return isRedirect;
            }

            @Override
            protected URI createLocationURI(String location) throws ProtocolException {
                location = location.replace("|", "%7C");
                return super.createLocationURI(location);
            }
        };

        HttpClientBuilder httpClientBuilder = HttpClients.custom();
        httpClientBuilder.setDefaultRequestConfig(requestConfig);
        if (route > 0 && maxTotal > 0) {
            PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager();
            connManager.setDefaultMaxPerRoute(route);
            connManager.setMaxTotal(maxTotal);
            httpClientBuilder.setConnectionManager(connManager);
        }

        httpClientBuilder.setSSLSocketFactory(sslsf);
        httpClientBuilder.setDefaultCookieStore(cookieStore);
        httpClientBuilder.setRedirectStrategy(redirectStrategy);
        httpClientBuilder.setRetryHandler(httpRequestRetryHandler);
        httpClient = httpClientBuilder.build();
    }
    public Response sendRequest(Request request) throws Exception {
        // request.setHeader("Accept",
        // "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");
        // request.setHeader("Accept-Encoding", "gzip, deflate");
        if (request.getHeader("User-Agent") == null) {
            request.setHeader("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:24.0) Gecko/20100101 Firefox/24.0");
        }
        request.setHeader("Accept-Language", "zh-cn,zh;q=0.8,en-us;q=0.5,en;q=0.3");
        request.setHeader("Connection", "keep-alive");

        // logger.debug("傳送請求:" + request);

        String method = request.getProperty("method").toLowerCase();
        String url = request.getProperty("url");
        Map<String, String> headers = request.getHeaders();
        Map<String, String> params = request.getParams();

        List<NameValuePair> formParams = new ArrayList<NameValuePair>();
        if (params != null && params.size() != 0) {
            formParams = new ArrayList<NameValuePair>();
            for (Entry<String, String> entry : params.entrySet()) {
                formParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
            }
        }

        Response response = null;
        if ("post".equals(method)) {
            byte[] postData = request.getPostData();
            if (postData != null) {
                response = post(url, postData, headers);
            } else {
                response = post(url, formParams, headers);
            }
        } else if ("get".equals(method)) {
            response = get(url, formParams, headers);
        }
        return response;
    }

    /**
     * Get請求
     * 
     * @param url
     * @param params
     * @return
     */
    public Response get(String url, List<NameValuePair> params, Map<String, String> headers) {
        Response response = new Response();
        try {
            // Get請求
            HttpGet httpGet = new HttpGet(url);

            String encoding = "utf-8";

            // 設定頭
            if (headers != null && headers.size() != 0) {
                for (Entry<String, String> entry : headers.entrySet()) {
                    httpGet.setHeader(entry.getKey(), entry.getValue());
                }

                String contentType = headers.get("Content-Type");
                if (StringUtils.isNotBlank(contentType)) {
                    if (matcher(contentType, "(charset)\\s?=\\s?(gbk)")) {
                        encoding = "gbk";
                    } else if (matcher(contentType, "(charset)\\s?=\\s?(gb2312)")) {
                        encoding = "gb2312";
                    }
                }
            }

            // 設定引數,如果url上已經有了問號，就不附加引數
            if (params != null && params.size() > 0) {
                if (httpGet.getURI().toString().indexOf("?") == -1) {
                    String str = EntityUtils.toString(new UrlEncodedFormEntity(params, encoding));
                    httpGet.setURI(new URI(httpGet.getURI().toString() + "?" + str));
                } else {
                    String str = EntityUtils.toString(new UrlEncodedFormEntity(params, encoding));
                    httpGet.setURI(new URI(httpGet.getURI().toString() + "&" + str));
                }
            }

            // 傳送請求
            CloseableHttpResponse httpResponse = httpClient.execute(httpGet);

            try {
                int statusCode = httpResponse.getStatusLine().getStatusCode();
                response.setStatusCode(statusCode);
                ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
                // 獲取返回資料
                HttpEntity entity = httpResponse.getEntity();

                Header[] responseHeaders = httpResponse.getAllHeaders();
                for (Header header : responseHeaders) {
                    response.setHeader(header.getName(), header.getValue());
                }

                Header header = entity.getContentEncoding();
                if (header != null && header.getValue().toLowerCase().equals("gzip")) {
                    byte[] bytes = IOUtils.toByteArray(new GZIPInputStream(entity.getContent()));
                    response.setContent(bytes);
                } else {
                    byte[] bytes = getData(entity);
                    response.setContent(bytes);
                }
                return response;
            } finally {
                httpResponse.close();
            }
        } catch (ConnectTimeoutException e) {
        } catch (HttpHostConnectException e) {
        } catch (ParseException e) {
        } catch (UnsupportedEncodingException e) {
        } catch (IOException e) {
        } catch (URISyntaxException e) {
        } catch (Exception e) {
        }
        return null;
    }

    /**
     * // Post請求
     * 
     * @param url
     * @param params
     * @return
     */
    public Response post(String url, byte[] data, Map<String, String> headers) {
        Response response = new Response();
        try {
            // Post請求
            HttpPost httpPost = new HttpPost(url);
            // 設定頭
            if (headers != null && headers.size() != 0) {
                for (Entry<String, String> entry : headers.entrySet()) {
                    httpPost.setHeader(entry.getKey(), entry.getValue());
                }
            }

            // 設定引數
            httpPost.setEntity(new ByteArrayEntity(data));

            // 傳送請求
            CloseableHttpResponse httpResponse = httpClient.execute(httpPost);

            try {
                int statusCode = httpResponse.getStatusLine().getStatusCode();
                response.setStatusCode(statusCode);

                // 獲取返回資料
                HttpEntity entity = httpResponse.getEntity();

                Header header = entity.getContentEncoding();
                if (header != null && header.getValue().toLowerCase().equals("gzip")) {
                    byte[] bytes = IOUtils.toByteArray(new GZIPInputStream(entity.getContent()));
                    response.setContent(bytes);
                } else {
                    byte[] bytes = EntityUtils.toByteArray(entity);
                    response.setContent(bytes);
                }

                return response;
            } finally {
                httpResponse.close();
            }
        } catch (ConnectTimeoutException e) {
        } catch (HttpHostConnectException e) {
        } catch (UnsupportedEncodingException e) {
        } catch (ClientProtocolException e) {
        } catch (ParseException e) {
        } catch (IOException e) {
        } catch (Exception e) {
        }
        return null;
    }
    private byte[] getData(HttpEntity entity) throws IOException {
        if (entity == null) {
            throw new IllegalArgumentException("HTTP entity may not be null");
        }
        InputStream inputStream = entity.getContent();
        if (inputStream == null) {
            return null;
        }
        try {
            if (entity.getContentLength() > Integer.MAX_VALUE) {
                throw new IllegalArgumentException("HTTP entity too large to be buffered in memory");
            }
            int i = (int) entity.getContentLength();
            if (i < 0) {
                i = 4096;
            }

            ByteArrayBuffer buffer = new ByteArrayBuffer(i);
            byte[] tmp = new byte[1024];
            int l = -1;
            try {
                while ((l = inputStream.read(tmp)) != -1) {
                    buffer.append(tmp, 0, l);
                }
            } catch (EOFException e) {
                buffer.clear();
                // 針對於以沒有結束符的做fix處理,減小快取,並進行異常處理,忽略最後不能獲取的資料
                tmp = new byte[32];
                try {
                    while ((l = inputStream.read(tmp)) != 1) {
                        buffer.append(tmp, 0, l);
                    }
                } catch (EOFException e2) {
                }

            }
            // TODO 查明具體沒有返回的原因
            byte[] byteArray = buffer.toByteArray();
            if (byteArray == null || byteArray.length == 0) {
                return buffer.buffer();
            }
            return byteArray;
        } finally {
            inputStream.close();
        }
    }
    /**
     * // Post請求
     * 
     * @param url
     * @param params
     * @return
     */
    public Response post(String url, List<NameValuePair> params, Map<String, String> headers) {
        Response response = new Response();
        try {
            // Post請求
            HttpPost httpPost = new HttpPost(url);

            String encoding = "utf-8";

            // 設定頭
            if (headers != null && headers.size() != 0) {
                for (Entry<String, String> entry : headers.entrySet()) {
                    httpPost.setHeader(entry.getKey(), entry.getValue());
                }

                String contentType = headers.get("Content-Type");
                if (StringUtils.isNotBlank(contentType)) {
                    if (matcher(contentType, "(charset)\\s?=\\s?(gbk)")) {
                        encoding = "gbk";
                    } else if (matcher(contentType, "(charset)\\s?=\\s?(gb2312)")) {
                        encoding = "gb2312";
                    }
                }
            }

            // 設定引數
            if (params != null && params.size() > 0) {
                httpPost.setEntity(new UrlEncodedFormEntity(params, encoding));
            }

            // 傳送請求
            CloseableHttpResponse httpResponse = httpClient.execute(httpPost);

            try {
                int statusCode = httpResponse.getStatusLine().getStatusCode();
                response.setStatusCode(statusCode);

                // 獲取返回資料
                HttpEntity entity = httpResponse.getEntity();

                Header header = entity.getContentEncoding();
                if (header != null && header.getValue().toLowerCase().equals("gzip")) {
                    byte[] data = IOUtils.toByteArray(new GZIPInputStream(entity.getContent()));
                    response.setContent(data);
                } else {
                    byte[] data = getData(entity);
                    response.setContent(data);
                }

                return response;
            } finally {
                httpResponse.close();
            }
        } catch (ConnectTimeoutException e) {
        } catch (HttpHostConnectException e) {
        } catch (UnsupportedEncodingException e) {
        } catch (ClientProtocolException e) {
        } catch (ParseException e) {
        } catch (IOException e) {
        } catch (Exception e) {
        }
        return null;
    }

    /**
     * 獲取Response內容字符集
     * 
     * @param response
     * @return
     */
    public String getContentCharset(HttpResponse response) {
        String charset = "ISO_8859-1";
        Header header = response.getEntity().getContentType();
        if (header != null) {
            String s = header.getValue();
            if (matcher(s, "(charset)\\s?=\\s?(utf-?8)")) {
                charset = "utf-8";
            } else if (matcher(s, "(charset)\\s?=\\s?(gbk)")) {
                charset = "gbk";
            } else if (matcher(s, "(charset)\\s?=\\s?(gb2312)")) {
                charset = "gb2312";
            }
        }

        Header encoding = response.getEntity().getContentEncoding();

        return charset;
    }

    /**
     * 正則匹配
     * 
     * @param s
     * @param pattern
     * @return
     */
    private boolean matcher(String s, String pattern) {
        Pattern p = Pattern.compile(pattern, Pattern.CASE_INSENSITIVE + Pattern.UNICODE_CASE);
        Matcher matcher = p.matcher(s);
        if (matcher.find()) {
            return true;
        } else {
            return false;
        }
    }

    public Integer getConnectTimeout() {
        return connectTimeout;
    }

    public void setConnectTimeout(Integer connectTimeout) {
        this.connectTimeout = connectTimeout;
    }

    public Integer getSocketTimeout() {
        return socketTimeout;
    }

    public void setSocketTimeout(Integer socketTimeout) {
        this.socketTimeout = socketTimeout;
    }

    public CloseableHttpClient getHttpClient() {
        return httpClient;
    }

    public void setHttpClient(CloseableHttpClient httpClient) {
        this.httpClient = httpClient;
    }

    public CookieStore getCookieStore() {
        return cookieStore;
    }

    public void setCookieStore(CookieStore cookieStore) {
        for(Cookie cookie:cookieStore.getCookies()){
            this.cookieStore.addCookie(cookie);
        }
    }

}

我們來看看測試結果
1. 不用代理使用預設的構造方法，結果如下
將經緯度傳到百度LBS雲：
這裡寫圖片描述
從百度地圖雲獲得資料:

{
    "status": 0,
    "total": 6,
    "size": 6,
    "contents": [
        {
            "uid": 1694507525,
            "province": "北京市",
            "geotable_id": 137287,
            "district": "東城區",
            "create_time": 1463322154,
            "city": "北京市",
            "location": [
                116.428415,
                39.927109
            ],
            "address": "北京",
            "title": "武漢紡織大學5號宿舍樓",
            "coord_type": 3,
            "direction": "附近",
            "type": 0,
            "distance": 0,
            "weight": 0
        },
        {
            "uid": 1694513755,
            "province": "北京市",
            "geotable_id": 137287,
            "district": "東城區",
            "create_time": 1463322333,
            "city": "北京市",
            "location": [
                116.428415,
                39.927109
            ],
            "address": "北京",
            "title": "武漢紡織大學5號宿舍樓",
            "coord_type": 3,
            "direction": "附近",
            "type": 0,
            "distance": 0,
            "weight": 0
        },
        {
            "uid": 1694514187,
            "province": "北京市",
            "geotable_id": 137287,
            "district": "東城區",
            "create_time": 1463322402,
            "city": "北京市",
            "location": [
                116.428415,
                39.927109
            ],
            "address": "北京",
            "title": "武漢紡織大學5號宿舍樓",
            "coord_type": 3,
            "direction": "附近",
            "type": 0,
            "distance": 0,
            "weight": 0
        },
        {
            "uid": 1694526535,
            "province": "北京市",
            "geotable_id": 137287,
            "district": "東城區",
            "create_time": 1463322534,
            "city": "北京市",
            "location": [
                116.428415,
                39.927109
            ],
            "address": "北京",
            "title": "武漢紡織大學5號宿舍樓",
            "coord_type": 3,
            "direction": "附近",
            "type": 0,
            "distance": 0,
            "weight": 0
        },

    ]
}

用代理，使用含有代理的構造方法，結果如下
使用代理，記得Charles開啟，本地代理主機127.0.0.1或者localhost,埠8888(Charles預設)，這裡只擷取charles 的介面，控制檯顯示是一樣的。
將經緯度傳到百度LBS雲：

從百度地圖雲獲得資料:
1. Request ：
2. Response：

到此，我們就知道如何用HttpClient工具類來請求資料了，後臺要負責很多事情，比如網路請求的資料進行解析，這時HttpClient顯得就重要了。

這一講就講到這裡，有不對的地方，菜鳥希望大家指出。
下一講，我就專門找個網站，模擬請求（登入，並抓取返回的資料）。

最後附上工程原始碼（Maven 專案）: HttpClient

JavaWeb之抓包之旅(三) :HttpClient封裝工具類

JavaWeb之抓包之旅(三) :HttpClient封裝工具類

JavaWeb之抓包之旅(一)

httpclient封裝工具類

Android開源：資料庫ORM框架GreenDao學習（三）封裝工具類使用

Wireshark抓包之詳細分析

Charles抓包之HTTPS抓包配置

介面測試工具之抓包工具介紹

Wireshark實戰之抓包MySQL Java客戶端

Jmeter設定代理，抓包之app請求

Mac 移動端http、https抓包之Charles

jmeter編寫指令碼之抓包實戰

springAOP之framework包的解讀(三)

PHP抓包之curl、file_get_contents 操作例項

測試必備工具之抓包神器 Charles 如何抓取 https 資料包？

java基礎之JDBC三：簡單工具類的提取及應用

用wireshark抓包分析TCP三次握手、四次揮手以及TCP實現可靠傳輸的機制（轉）

Java 日看一類（39）之IO包中的ObjectStreamException和OptionalDataException異常類

tcpdump抓包分析TCP三次握手過程

wireshark抓包圖解 TCP三次握手/四次揮手詳解

三個繪圖工具類詳解

JavaWeb之抓包之旅(三) :HttpClient封裝工具類

相關推薦