JAVA的HttpClient 对百度进行 POST方法

Posted 2023-05-10

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JAVA的HttpClient 对百度进行 POST方法相关的知识，希望对你有一定的参考价值。

初学，求个完整的简洁代码

参考技术A CloseableHttpClient client = HttpClients.createDefault();
HttpPost httpPost = new HttpPost("你要post的地址");
httpPost.setHeader("Content-type", "application/json"); //header设置
Entity entity = new StringEntity(json, "utf-8");
httpPost.setEntity(entity);
HttpResponse response = httpClient.execute(httpPost);本回答被提问者和网友采纳参考技术B 将你的问题直接在百度搜索会有很多的结果，祝你成功追问

我需求的对百度主页进行POST的方法，应该很简单的代码。我想理解一下NameValuePair[]

JavaWeb之抓包之旅 :HttpClient封装工具类

谈到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": 以上是关于JAVA的HttpClient 对百度进行 POST方法的主要内容，如果未能解决你的问题，请参考以下文章 
 JAVA--利用HttpClient模拟浏览器登陆请求获取响应的Cookie
 JavaWeb之抓包之旅 :HttpClient封装工具类
 最全面Java接口自动化测试实战 HttpClient+TestNG+Mock+MyBatis
 HTTP连接客户端，选 HttpClient 还是 OkHttp ？
 接口自动化：HttpClient + TestNG + Java - 第一个接口测试：get请求
 httpclient检测连接