httpclient案例二（调用百度地图的接口）

一，class T

 package com.http.test;

 import org.junit.Test;

 import com.http.BaiduMapProxyService;
 import com.http.BaiduMapService;

 public class T {

     /**
      * 测试插入数据
      */
     @Test
     public void testInsert(){
         BaiduMapService baiduMapService= new BaiduMapService();
         //随便写的经纬度
         baiduMapService.insertLocation("武汉纺织大学5号宿舍楼", "116.428415", "39.927109", "北京");
     }

     /**
      * 测试获得数据
      */
     @Test
     public void testGet(){
         BaiduMapService baiduMapService= new BaiduMapService();
         baiduMapService.findNearBySchool("116.428415", "39.927109");
     }

     /**
      * 代理测试插入数据
      */
     @Test
     public void testProxyInsert(){
         BaiduMapProxyService baiduMapService= new BaiduMapProxyService();

         //随便写的经纬度
         baiduMapService.insertLocation("武汉纺织大学5号宿舍楼", "116.428415", "39.927109", "北京");
     }

     /**
      * 测试获得数据
      */
     @Test
     public void testProxyGet(){
         BaiduMapProxyService baiduMapService= new BaiduMapProxyService();
         baiduMapService.findNearBySchool("116.428415", "39.927109");
     }
 }

二，request

 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

 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;
     }

 }

四，BaiduMapService

 package com.http;

 import java.util.ArrayList;
 import java.util.List;

 import org.apache.http.NameValuePair;
 import org.apache.http.message.BasicNameValuePair;

 /**
  *
  * title:百度地图服务类 <br>
  * 版权: Copyright (c) 2011-2016<br>
  *
  * @author:Administrator<br>
  * @date:Apr 7, 2016<br>
  */
 public class BaiduMapService {

     /**
      * 请求发送类
      */
     private  HttpClientUtil httpClientUtil=new HttpClientUtil();

     public String insertLocation(String title, String longitude,
             String latitude, String address) {
         //插入数据接口
         String url = "http://api.map.baidu.com/geodata/v3/poi/create";
         Request request=new Request();
         //数据
         request.setProperty("url", url);
         request.setProperty("method", "post");
         //我自己的百度云数据库名称
         request.setParam("geotable_id", "137287");
         request.setParam("ak", "GShGXR4uNroTq4mzqsf1v7h3VgsC3aIk");
         request.setParam("latitude", latitude);
         request.setParam("longitude", longitude);
         request.setParam("address", address);
         request.setParam("coord_type", "3");
         request.setParam("title", title);

         Response response;
             try {
                 response = httpClientUtil.sendRequest(request);
                 if(response==null||response.getStatusCode()!=200){
                     return null;
                 }
                 String content =response.getContentString("utf-8");
                 System.out.println("返回的数据是:"+StringUtils.decodeUnicode(content));
                 return content;
             } catch (Exception e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }

         return null;

     }

     /**
      * 根据经纬度查周边学校半径500米
      *
      * @return
      */
     public String findNearBySchool(String longitude, String latitude) {
         String url = "http://api.map.baidu.com/geosearch/v3/nearby?geotable_id=137287&ak=GShGXR4uNroTq4mzqsf1v7h3VgsC3aIk&radius=500&location="
                 + longitude + "," + latitude;

         Request request=new Request();
         request.setProperty("url", url);
         request.setProperty("method", "get");

         Response response=new Response();

         try {
             response = httpClientUtil.sendRequest(request);
             if(response==null||response.getStatusCode()!=200){
                 return null;
             }

             String content =response.getContentString("utf-8");
             System.out.println("返回的数据是:"+StringUtils.decodeUnicode(content));
             return content;
         } catch (Exception e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
         return null;

     }
 }

五，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.lang.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);
         }
     }

 }

六，补充类StringUtils

 package com.http;

 public class StringUtils {

     /**
      * Unicode 转化成中文
      *
      * @param utfString
      * @return
      */
     public static String decodeUnicode(String theString) {
         char aChar;
         int len = theString.length();
         StringBuffer outBuffer = new StringBuffer(len);
         for (int x = 0; x < len;) {
             aChar = theString.charAt(x++);
             if (aChar == '\\') {
                 aChar = theString.charAt(x++);
                 if (aChar == 'u') {
                     // Read the xxxx
                     int value = 0;
                     for (int i = 0; i < 4; i++) {
                         aChar = theString.charAt(x++);
                         switch (aChar) {
                         case '0':
                         case '1':
                         case '2':
                         case '3':
                         case '4':
                         case '5':
                         case '6':
                         case '7':
                         case '8':
                         case '9':
                             value = (value << 4) + aChar - '0';
                             break;
                         case 'a':
                         case 'b':
                         case 'c':
                         case 'd':
                         case 'e':
                         case 'f':
                             value = (value << 4) + 10 + aChar - 'a';
                             break;
                         case 'A':
                         case 'B':
                         case 'C':
                         case 'D':
                         case 'E':
                         case 'F':
                             value = (value << 4) + 10 + aChar - 'A';
                             break;
                         default:
                             throw new IllegalArgumentException(
                                     "Malformed   \\uxxxx   encoding.");
                         }

                     }
                     outBuffer.append((char) value);
                 } else {
                     if (aChar == 't')
                         aChar = '\t';
                     else if (aChar == 'r')
                         aChar = '\r';
                     else if (aChar == 'n')
                         aChar = '\n';
                     else if (aChar == 'f')
                         aChar = '\f';
                     outBuffer.append(aChar);
                 }
             } else
                 outBuffer.append(aChar);
         }
         return outBuffer.toString();
     }
 }

七，补充类BaiduMapProxyService

 package com.http;

 /**
  * 使用代理 请求会经过代理
  * title:百度地图服务类 <br>
  * 版权: Copyright (c) 2011-2016<br>
  *
  * @author:Administrator<br>
  * @date:Apr 7, 2016<br>
  */
 public class BaiduMapProxyService {

     /**
      * 代理发送请求
      */
     private  HttpClientUtil httpClientUtil=new HttpClientUtil("127.0.0.1",8888);

     public String insertLocation(String title, String longitude,
             String latitude, String address) {

         //插入数据接口
         String url = "http://api.map.baidu.com/geodata/v3/poi/create";

         Request request=new Request();
         //数据
         request.setProperty("url", url);
         request.setProperty("method", "post");

         //我自己的百度云数据库名称
         request.setParam("geotable_id", "137287");
         request.setParam("ak", "GShGXR4uNroTq4mzqsf1v7h3VgsC3aIk");
         request.setParam("latitude", latitude);
         request.setParam("longitude", longitude);
         request.setParam("address", address);
         request.setParam("coord_type", "3");

         request.setParam("title", title);

         Response response;
             try {
                 response = httpClientUtil.sendRequest(request);
                 if(response==null||response.getStatusCode()!=200){
                     return null;
                 }
                 String content =response.getContentString("utf-8");
                 System.out.println("返回的数据是:"+content);
                 return content;
             } catch (Exception e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }

         return null;

     }

     /**
      * 根据经纬度查周边学校半径500米
      *
      * @return
      */
     public String findNearBySchool(String longitude, String latitude) {
         String url = "http://api.map.baidu.com/geosearch/v3/nearby?geotable_id=137287&ak=GShGXR4uNroTq4mzqsf1v7h3VgsC3aIk&radius=500&location="
                 + longitude + "," + latitude;

         Request request=new Request();
         request.setProperty("url", url);
         request.setProperty("method", "get");

         Response response=new Response();

         try {
             response = httpClientUtil.sendRequest(request);
             if(response==null||response.getStatusCode()!=200){
                 return null;
             }

             String content =response.getContentString("utf-8");
             System.out.println("返回数据:"+content);
             return content;
         } catch (Exception e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
         return null;

     }
 }