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