HTTPClientUtil工具

package com.finlabtech.pinjamancepatanalyse.util;

import com.google.common.base.Predicates;
import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.io.Charsets;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpRequestRetryHandler;
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.RequestBuilder;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.ConnectionKeepAliveStrategy;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.DefaultConnectionKeepAliveStrategy;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.client.StandardHttpRequestRetryHandler;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * Created by liqing on 2017/12/12 0012.
 */
@Slf4j
public class HttpClientUtil {

    private static final int DEFAULT_TIME_OUT = 60 * 1000; // 超时时间

    public static String get(String uri) {
        return get(uri, null, null);
    }

    public static String get(String uri, Map<String, String> parameters) {
        return get(uri, null, parameters);
    }

    public static String get(String uri, Map<String, String> headers, Map<String, String> parameters) {
        return doHttp(RequestBuilder.get(), uri, headers, parameters, 0);
    }

    public static String get(String uri, Map<String, String> headers, Map<String, String> parameters, int timeOut) {
        return doHttp(RequestBuilder.get(), uri, headers, parameters, timeOut);
    }

    public static String post(String uri) {
        return post(uri, null, null);
    }

    public static String post(String uri, Map<String, String> parameters) {
        return post(uri, null, parameters);
    }

    public static String post(String uri, Map<String, String> headers, Map<String, String> parameters) {
        return post(uri, headers, parameters, 0);
    }

    public static String post(String uri, Map<String, String> headers, Map<String, String> parameters, int timeOut) {
        return doHttp(RequestBuilder.post(), uri, headers, parameters, timeOut);
    }

    public static String postJSON(String uri, String jsonParam) {
        return postJSON(uri, jsonParam, 0);
    }

    public static String postJSON(String uri, String jsonParam, int timeOut) {
        return postJSON(uri, null, jsonParam, timeOut);
    }

    public static String postJSON(String uri, Map<String, String> headers, String jsonParam, int timeOut) {
        return doHttp(RequestBuilder.post(), uri, headers, jsonParam, timeOut);
    }

    /**
     * 发送http请求，参数为json串，Content-Type为application/json
     * @param requestBuilder
     * @param uri
     * @param headers
     * @param jsonParam
     * @param timeOut
     * @return
     */
    private static String doHttp(RequestBuilder requestBuilder, String uri, Map<String, String> headers, String jsonParam, int timeOut) {
        if (StringUtils.isEmpty(uri)) {
            log.info("uri cannot be empty, uri:{}", uri);
            return null;
        }
        if (StringUtils.isBlank(jsonParam)){
            log.info("param cannot be empty, param:{}", jsonParam);
            return null;
        }

        String method = requestBuilder.getMethod();
        log.info("{}, uri:[{}], headers:{}, parameters:{}", method, uri, headers, jsonParam);
        HttpEntity httpEntity = null;
        CloseableHttpResponse httpResponse = null;
        try {
            /************** 设置URI **************/
            requestBuilder.setUri(uri);

            /************** 公共配置 **************/
            setConfig(requestBuilder, timeOut);

            /************** 设置Header **************/
            setHeader(requestBuilder, headers);

            /************** 设置Parameter **************/
            requestBuilder.setEntity(new StringEntity(jsonParam, ContentType.APPLICATION_JSON));

            /************** 发送请求 **************/
            httpResponse = httpClient().execute(requestBuilder.build());
            httpEntity = httpResponse.getEntity();
            String response = EntityUtils.toString(httpEntity, Charsets.UTF_8);

            log.info("{}, uri:[{}], response:{}", method, uri, StringUtils.substring(response, 0, 200));

            return response;
        } catch (Exception e) {
            log.error("{}, uri:[{}], headers:{}, parameters:{}, error={}", method, uri, headers, jsonParam, e);
            return null;
        } finally {
            EntityUtils.consumeQuietly(httpEntity);
            try {
                if(httpResponse != null){
                    httpResponse.close();
                }
            } catch (Exception e) {
                log.error("{}, httpResponse.close error", method, e);
            }
        }
    }

    /**
     * 发送普通http/https请求，参数为map
     * @param requestBuilder
     * @param uri
     * @param headers
     * @param parameters
     * @param timeOut
     * @return
     */
    private static String doHttp(RequestBuilder requestBuilder, String uri, Map<String, String> headers, Map<String, String> parameters, int timeOut) {
        if (StringUtils.isEmpty(uri)) {
            log.info("uri cannot be empty, uri:{}", uri);
            return null;
        }

        String method = requestBuilder.getMethod();
        log.info("{}, uri:[{}], headers:{}, parameters:{}", method, uri, headers, parameters);
        HttpEntity httpEntity = null;
        CloseableHttpResponse httpResponse = null;
        try {
            /************** 设置URI **************/
            requestBuilder.setUri(uri);

            /************** 公共配置 **************/
            setConfig(requestBuilder, timeOut);

            /************** 设置Header **************/
            setHeader(requestBuilder, headers);

            /************** 设置Parameter **************/
            setParameter(requestBuilder, parameters, method);

            /************** 发送请求 **************/
            httpResponse = httpClient().execute(requestBuilder.build());
            httpEntity = httpResponse.getEntity();
            String response = EntityUtils.toString(httpEntity, Charsets.UTF_8);

            log.info("{}, uri:[{}], response:{}", method, uri, StringUtils.substring(response, 0, 200));

            return response;
        } catch (Exception e) {
            log.error("{}, uri:[{}], headers:{}, parameters:{}, error={}", method, uri, headers, parameters, e);
            return null;
        } finally {
            EntityUtils.consumeQuietly(httpEntity);
            try {
                if(httpResponse == null){
                    return null;
                }
                httpResponse.close();
            } catch (Exception e) {
                log.error("{}, httpResponse.close error", method, e);
            }
        }
    }

    // 信任管理器
    private static X509TrustManager tm = new X509TrustManager() {
        @Override
        public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        }

        @Override
        public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        }

        @Override
        public X509Certificate[] getAcceptedIssuers() {
            return null;
        }
    };

    /**
     * Create HttpClient
     *
     * @return
     * @throws KeyStoreException
     * @throws NoSuchAlgorithmException
     * @throws KeyManagementException
     */
    private static CloseableHttpClient httpClient() throws KeyStoreException, NoSuchAlgorithmException, KeyManagementException {
        //  socket factory
        ConnectionSocketFactory plainSocketFactory = new PlainConnectionSocketFactory();
        SSLContext sslContext = SSLContext.getInstance("TLS");
        // 初始化SSL上下文
        sslContext.init(null, new TrustManager[] { tm }, null);
        // SSL套接字连接工厂,NoopHostnameVerifier为信任所有服务器
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext, NoopHostnameVerifier.INSTANCE);

        Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
                .register("http", plainSocketFactory)
                .register("https", sslsf).build();

        // connection manager
        PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);

        connectionManager.setMaxTotal(10000);
        connectionManager.setDefaultMaxPerRoute(1000);

        // retry handler
        HttpRequestRetryHandler retryHandler = new StandardHttpRequestRetryHandler(3, false);

        // keep alive strategy
        ConnectionKeepAliveStrategy keepAliveStrategy = new DefaultConnectionKeepAliveStrategy();

        // httpclient
        return HttpClients.custom()
                .setConnectionManager(connectionManager)
                .setRetryHandler(retryHandler)
                .setKeepAliveStrategy(keepAliveStrategy)
                .build();
    }

    /**
     * Set Parameter
     *
     * @param requestBuilder
     * @param parameters
     * @param method
     */
    private static void setParameter(RequestBuilder requestBuilder, Map<String, String> parameters, String method) {
        if (MapUtils.isNotEmpty(parameters)) {
            parameters = Maps.filterValues(parameters, Predicates.notNull());

            Set<Map.Entry<String, String>> entrys = parameters.entrySet();
            /************** Get 请求 **************/
            if (method.equalsIgnoreCase(HttpGet.METHOD_NAME)) {
                for (Map.Entry<String, String> entry : entrys) {
                    requestBuilder.addParameter(entry.getKey(), entry.getValue());
                }
            }
            /************** Post 请求 **************/
            else {
                List<NameValuePair> valuePairs = new ArrayList<>();
                for (Map.Entry<String, String> entry : entrys) {
                    valuePairs.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
                }
                requestBuilder.setEntity(new UrlEncodedFormEntity(valuePairs, Charsets.UTF_8));
            }
        }
    }

    /**
     * Set Header
     *
     * @param requestBuilder
     * @param headers
     */
    private static void setHeader(RequestBuilder requestBuilder, Map<String, String> headers) {
        requestBuilder.setHeader("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.135 Safari/537.36")
                .setHeader("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8")
                .setHeader("Accept-Language", "zh-CN,zh;q=0.8,en;q=0.6")
                .setHeader("Connection", "keep-alive");

        if (MapUtils.isNotEmpty(headers)) {
            headers = Maps.filterValues(headers, Predicates.notNull());

            Set<Map.Entry<String, String>> entrys = headers.entrySet();
            for (Map.Entry<String, String> entry : entrys) {
                requestBuilder.addHeader(entry.getKey(), entry.getValue());
            }
        }
    }

    /**
     * Request config
     * @return
     */
    private static void setConfig(RequestBuilder requestBuilder, int timeOut) {
        int realTimeOut = (timeOut < 3000 || timeOut > 60000)?DEFAULT_TIME_OUT : timeOut; // 设置超时时间至少3s，最多60s
        RequestConfig requestConfig = RequestConfig.custom()
                .setConnectTimeout(realTimeOut)
                .setSocketTimeout(realTimeOut)
                .setConnectionRequestTimeout(realTimeOut)
                .build();
        requestBuilder.setConfig(requestConfig);
    }

}