JAVA API about HTTP 3

 package com.han.http;

 import java.io.IOException;
 import java.io.UnsupportedEncodingException;
 import java.nio.charset.Charset;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 import org.apache.http.HttpEntity;
 import org.apache.http.HttpResponse;
 import org.apache.http.NameValuePair;
 import org.apache.http.client.ClientProtocolException;
 import org.apache.http.client.ResponseHandler;
 import org.apache.http.client.config.CookieSpecs;
 import org.apache.http.client.config.RequestConfig;
 import org.apache.http.client.entity.UrlEncodedFormEntity;
 import org.apache.http.client.methods.CloseableHttpResponse;
 import org.apache.http.client.methods.HttpGet;
 import org.apache.http.client.methods.HttpPost;
 import org.apache.http.client.protocol.HttpClientContext;
 import org.apache.http.entity.StringEntity;
 import org.apache.http.impl.client.CloseableHttpClient;
 import org.apache.http.impl.client.HttpClientBuilder;
 import org.apache.http.impl.client.HttpClients;
 import org.apache.http.message.BasicHeader;
 import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
 import org.apache.http.message.BasicNameValuePair;
 import org.apache.http.util.EntityUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 public class HttpClientHelp {

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

     private final static String ENCODE = "utf-8";

     private final static Charset CHARSET = Charset.forName("utf-8");
     public static final int TIMEOUT = 20000;

     private static PoolingHttpClientConnectionManager cm = null;
     private static RequestConfig defaultRequestConfig = null;

     static {
         /**
          * 连接池管理
          * **/
         cm = new PoolingHttpClientConnectionManager(); // 将最大连接数
         cm.setMaxTotal(50);
         // 将每个路由基础的连接增加到20
         cm.setDefaultMaxPerRoute(20);

         /** request设置 **/
         // 连接超时 20s
         defaultRequestConfig = RequestConfig.custom().setCookieSpec(CookieSpecs.IGNORE_COOKIES).setRedirectsEnabled(false).setSocketTimeout(TIMEOUT)
                 .setConnectTimeout(TIMEOUT).setConnectionRequestTimeout(TIMEOUT).build();
     }

     public static CloseableHttpClient getClient() {
         return HttpClientBuilder.create().setDefaultRequestConfig(defaultRequestConfig).setConnectionManager(cm).build();
     }

     public static String httpGetByUrl(String url) throws ClientProtocolException, IOException {
         String responseBody = "";
         CloseableHttpClient httpclient = HttpClients.createDefault();
         try {
             HttpGet httpget = new HttpGet(url);
             ResponseHandler<String> responseHandler = new ResponseHandler<String>() {
                 @Override
                 public String handleResponse(final HttpResponse response) throws ClientProtocolException, IOException {
                     int status = response.getStatusLine().getStatusCode();
                     if (status >= 200 && status < 300) {
                         HttpEntity entity = response.getEntity();
                         return entity != null ? EntityUtils.toString(entity) : null;
                     } else {
                         throw new ClientProtocolException("Unexpected response status: " + status);
                     }
                 }
             };
             responseBody = httpclient.execute(httpget, responseHandler);
         } finally {
             httpclient.close();
         }
         return responseBody;
     }

     public static String postBodyContent(String url, String bodyContent) throws ClientProtocolException, IOException {
         String result = "";
         CloseableHttpClient httpclient = HttpClients.createDefault();
         CloseableHttpResponse response = null;
         try {
             HttpPost httppost = new HttpPost(url);
             StringEntity reqEntity = new StringEntity(bodyContent, "UTF-8");
             httppost.setEntity(reqEntity);
             // 设置连接超时5秒，请求超时1秒，返回数据超时8秒
             RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(5000).setConnectionRequestTimeout(1000).setSocketTimeout(8000)
                     .build();
             httppost.setConfig(requestConfig);
             response = httpclient.execute(httppost);
             HttpEntity responseEntity = response.getEntity();
             byte[] bytes = EntityUtils.toByteArray(responseEntity);
             result = new String(bytes, "UTF-8");
         } finally {
             if (null != response) {
                 response.close();
             }
             httpclient.close();
         }
         return result;
     }

     /**
      * post paramMap
      *
      * @param path
      * @param params
      * @param headers
      * @return
      */
     public static String post(String path, Map<String, String> params, Map<String, String> headers) {
         List<NameValuePair> values = new ArrayList<NameValuePair>();
         for (String s : params.keySet()) {
             values.add(new BasicNameValuePair(s, params.get(s)));
         }
         UrlEncodedFormEntity entity = null;
         try {
             entity = new UrlEncodedFormEntity(values, ENCODE);
         } catch (UnsupportedEncodingException e) {
             // TODO Auto-generated catch block
             logger.error(e.getMessage());
         }
         return post(path, entity, headers);
     }

     /**
      * post body
      *
      * @param path
      * @param body
      * @param headers
      * @return
      */
     public static String post(String path, String body, Map<String, String> headers) {
         return post(path, new StringEntity(body, CHARSET), headers);
     }

     public static String post(String path, HttpEntity postEntity, Map<String, String> headers) {
         String responseContent = null;
         CloseableHttpClient client = getClient();
         HttpPost httpPost = null;
         try {
             httpPost = new HttpPost(path);
             if (headers != null && !headers.isEmpty()) {
                 for (String s : headers.keySet()) {
                     httpPost.addHeader(s, headers.get(s));
                 }
             }
             httpPost.addHeader("Content-Type", "application/json");
             httpPost.setEntity(postEntity);
             CloseableHttpResponse response = client.execute(httpPost, HttpClientContext.create());
             HttpEntity entity = response.getEntity();
             responseContent = EntityUtils.toString(entity, ENCODE);
         } catch (Exception e) {
             logger.error(e.getMessage());
             e.printStackTrace();
         } finally {
             if (httpPost != null) {
                 httpPost.releaseConnection();
             }
         }
         return responseContent;
     }

     public static String get(String path, Map<String, String> headers) {
         String responseContent = null;
         CloseableHttpClient client = getClient();
         HttpGet httpGet = new HttpGet(path);
         try {

             if (headers != null && !headers.isEmpty()) {
                 for (String s : headers.keySet()) {
                     httpGet.addHeader(s, headers.get(s));
                 }
             }
             CloseableHttpResponse response = client.execute(httpGet, HttpClientContext.create());
             HttpEntity entity = response.getEntity();
             responseContent = EntityUtils.toString(entity, ENCODE);
         } catch (Exception e) {
             logger.error(e.getMessage());
             e.printStackTrace();
         } finally {
             httpGet.releaseConnection();
         }
         return responseContent;
     }

     @SuppressWarnings("deprecation")//设置了请求头
     public static String postByBodyStringWithHeader(String url, String bodyString) throws ClientProtocolException, IOException {
         String result = "";
         CloseableHttpClient httpclient = HttpClients.createDefault();
         CloseableHttpResponse response = null;
         try {
             HttpPost httppost = new HttpPost(url);
             StringEntity reqEntity = new StringEntity(bodyString, "UTF-8");
             httppost.setEntity(reqEntity);

             Map<String, String> headers = new HashMap<String, String>();
             headers.put("Content-Type", "application/json;charset=UTF-8");
             if (headers != null && !headers.isEmpty()) {
                 for (String s : headers.keySet()) {
                     httppost.addHeader(s, headers.get(s));
                 }
             }
             //设置连接超时5秒，请求超时1秒，返回数据超时8秒
 //            RequestConfig requestConfig = RequestConfig.custom()
 //                    .setConnectTimeout(5000).setConnectionRequestTimeout(5000)
 //                    .setSocketTimeout(8000).build();
 //            httppost.setConfig(requestConfig);
             response = httpclient.execute(httppost);
             HttpEntity responseEntity = response.getEntity();
             byte[] bytes = EntityUtils.toByteArray(responseEntity);
             result = new String(bytes,"UTF-8");
         } finally {
             if (null != response) {
                 response.close();
             }
             httpclient.close();
         }
         return result;
     }

     @SuppressWarnings("deprecation")//没有设置请求头
     public static String postByBodyString(String url, String bodyString) throws ClientProtocolException, IOException {
         String result = "";
         CloseableHttpClient httpclient = HttpClients.createDefault();
         CloseableHttpResponse response = null;
         try {
             HttpPost httppost = new HttpPost(url);
             StringEntity reqEntity = new StringEntity(bodyString, "UTF-8");
             httppost.setEntity(reqEntity);

             //设置连接超时5秒，请求超时1秒，返回数据超时8秒
 //            RequestConfig requestConfig = RequestConfig.custom()
 //                    .setConnectTimeout(5000).setConnectionRequestTimeout(5000)
 //                    .setSocketTimeout(8000).build();
 //            httppost.setConfig(requestConfig);
             response = httpclient.execute(httppost);
             HttpEntity responseEntity = response.getEntity();
             byte[] bytes = EntityUtils.toByteArray(responseEntity);
             result = new String(bytes,"UTF-8");
         } finally {
             if (null != response) {
                 response.close();
             }
             httpclient.close();
         }
         return result;
     }

 }