JAVA常用http请求工具类封装

几乎每个web项目都会用到http请求，空闲时间封装了一个工具类，分享出来，用到的时候可以直接拷贝使用

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
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.HttpPost;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.client.methods.RequestBuilder;
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.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

/**
 * http请求工具类
 *
 * @author wangfenglei
 */
public class HttpUtil {
    private static Logger log = LoggerFactory.getLogger(HttpUtil.class);
    private static PoolingHttpClientConnectionManager connectionManager = null;
    private static HttpClientBuilder httpBuilder = null;
    private static RequestConfig requestConfig = null;

    /**
     * 最大连接连接数量
     */
    private static int MAX_CONNECTION = 100;
    /**
     * 最大并发请求数量
     */
    private static int DEFAULT_MAX_CONNECTION = 50;

    static {
        //设置http的状态参数
        requestConfig = RequestConfig.custom()
                .setSocketTimeout(10000)
                .setConnectTimeout(10000)
                .setConnectionRequestTimeout(10000)
                .build();

        connectionManager = new PoolingHttpClientConnectionManager();
        connectionManager.setMaxTotal(MAX_CONNECTION);
        connectionManager.setDefaultMaxPerRoute(DEFAULT_MAX_CONNECTION);
        httpBuilder = HttpClients.custom();
        httpBuilder.setConnectionManager(connectionManager);
    }

    /**
     * 获取http客户端连接
     *
     * @return http客户端连接
     */
    public static CloseableHttpClient getConnection() {
        return httpBuilder.build();
    }

    /**
     * http post请求，利用http请求池
     *
     * @param url       请求url
     * @param paramsMap 请求参数
     * @return 请求结果
     * @throws Exception 异常
     */
    public static String httpPost(String url, Map<String, String> paramsMap) throws Exception {
        List<NameValuePair> params = new ArrayList<>();

        for (Map.Entry<String, String> e : paramsMap.entrySet()) {
            NameValuePair pair = new BasicNameValuePair(e.getKey(), e.getValue());
            params.add(pair);
        }

        HttpUriRequest postMethod = RequestBuilder.post().setUri(url)
                .addParameters(params.toArray(new BasicNameValuePair[params.size()]))
                .setConfig(requestConfig).build();

        HttpResponse response = getConnection().execute(postMethod);

        return EntityUtils.toString(response.getEntity());
    }

    /**
     * http post请求，利用http请求池
     *
     * @param url     请求url
     * @param jsonStr json字符串
     * @return 请求结果
     * @throws Exception 异常
     */
    public static String httpPostJson(String url, String jsonStr) throws Exception {

        HttpUriRequest postMethod = RequestBuilder.post().setUri(url)
                .setHeader("Content-Type", "application/json;charset=utf-8")
                .setHeader("Accept", "application/json")
                .setEntity(new StringEntity(jsonStr, Charset.forName("UTF-8")))
                .setConfig(requestConfig).build();
        HttpResponse response = getConnection().execute(postMethod);

        return EntityUtils.toString(response.getEntity());
    }

    /**
     * http get请求，利用http请求池
     *
     * @param url 请求url
     * @return 请求结果
     * @throws Exception 异常
     */
    public static String httpGet(String url) throws Exception {
        HttpUriRequest getMethod = RequestBuilder.get().setUri(url)
                .setConfig(requestConfig).build();

        HttpResponse response = getConnection().execute(getMethod);

        return EntityUtils.toString(response.getEntity());
    }

    /**
     * http get请求，利用http请求池
     *
     * @param url       请求url
     * @param paramsMap 请求参数
     * @return 请求结果
     * @throws Exception 异常
     */
    public static String httpGet(String url, Map<String, String> paramsMap) throws Exception {
        List<NameValuePair> params = new ArrayList<>();

        for (Map.Entry<String, String> e : paramsMap.entrySet()) {
            NameValuePair pair = new BasicNameValuePair(e.getKey(), e.getValue());
            params.add(pair);
        }

        HttpUriRequest getMethod = RequestBuilder.get().setUri(url)
                .addParameters(params.toArray(new BasicNameValuePair[params.size()]))
                .setConfig(requestConfig).build();

        HttpResponse response = getConnection().execute(getMethod);

        return EntityUtils.toString(response.getEntity());
    }

    /**
     * http post 请求,每次创建请求客户端
     *
     * @param url    url
     * @param params 请求参数
     * @return 请求返回值
     */
    public static String httpPostNoPool(String url, Map<String, String> params) {
        CloseableHttpClient closeableHttpClient = null;
        try {
            HttpPost httpPost = new HttpPost(url);

            if (params != null) {
                List<NameValuePair> form = new ArrayList<>();

                for (String name : params.keySet()) {
                    form.add(new BasicNameValuePair(name, params.get(name)));
                }

                httpPost.setEntity(new UrlEncodedFormEntity(form, HTTP.UTF_8));
            }

            closeableHttpClient = HttpClients.createDefault();
            CloseableHttpResponse httpResponse = closeableHttpClient.execute(httpPost);
            HttpEntity entry = httpResponse.getEntity();
            return EntityUtils.toString(entry);
        } catch (Exception e) {
            log.error("HttpUtil.httpPost failed!", e);
        } finally {
            if (null != closeableHttpClient) {
                try {
                    closeableHttpClient.close();
                } catch (IOException e) {
                    log.error("closeableHttpClient.close failed!", e);
                }
            }
        }

        return null;
    }