simulation-cloud/api-common/src/main/java/api/common/util/HttpUtil.java

package api.common.util;

import lombok.extern.slf4j.Slf4j;
import org.apache.http.client.config.RequestConfig;
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.config.Registry;
import org.apache.http.config.RegistryBuilder;
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.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.ssl.SSLContextBuilder;
import org.apache.http.util.EntityUtils;

import java.io.IOException;
import java.io.InputStream;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.util.Map;

/**
 * <dependency>
 * <groupId>org.apache.httpcomponents</groupId>
 * <artifactId>httpclient</artifactId>
 * <version>${http.client.version}</version>
 * </dependency>
 */
@Slf4j
public class HttpUtil {

    public static CloseableHttpClient getHttpClient() throws NoSuchAlgorithmException, KeyStoreException, KeyManagementException {

        PlainConnectionSocketFactory plainConnectionSocketFactory = new PlainConnectionSocketFactory();
        SSLConnectionSocketFactory sslConnectionSocketFactory = new SSLConnectionSocketFactory(
                SSLContextBuilder.create().loadTrustMaterial(null, (x509Certificates, s) -> true).build(), // 全部信任 不做身份鉴定
                new String[]{"SSLv2Hello", "SSLv3", "TLSv1", "TLSv1.2"},
                null,
                NoopHostnameVerifier.INSTANCE);
        Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create()
                .register("http", plainConnectionSocketFactory)
                .register("https", sslConnectionSocketFactory)
                .build();
        PoolingHttpClientConnectionManager pool = new PoolingHttpClientConnectionManager(registry);
        pool.setMaxTotal(300);
        pool.setDefaultMaxPerRoute(300);
        return HttpClients.custom().setConnectionManager(pool).build();
    }

    public static RequestConfig getRequestConfig() {
        return RequestConfig.custom()
                .setSocketTimeout(5000)
                .setConnectTimeout(5000)
                .setConnectionRequestTimeout(5000)
                .setRedirectsEnabled(false)
                .setExpectContinueEnabled(false)
                .build();
    }


    /**
     * 默认请求头的 get 请求
     *
     * @param closeableHttpClient http 客户端
     * @param requestConfig       请求配置
     * @param url                 请求路径带参数
     * @return 请求结果
     */
    public static String get(CloseableHttpClient closeableHttpClient, RequestConfig requestConfig, String url) {
        String result = null;
        try {
            //1 创建 post 请求
            HttpGet get = new HttpGet(url);
            get.setConfig(requestConfig);
            //2 发送请求
            CloseableHttpResponse response = closeableHttpClient.execute(get);
            //3 处理返回结果，如果状态码为200,就是正常返回
            int statusCode = response.getStatusLine().getStatusCode();
            if (statusCode == 200) {
                result = EntityUtils.toString(response.getEntity());
            } else {
                log.error(response.getEntity().toString());
                throw new RuntimeException("get() 请求错误：" + response);
            }
        } catch (org.apache.http.conn.ConnectTimeoutException cte) {
            log.debug(url + " 请求超时。", cte);
            log.info(url + " 请求超时。");
        } catch (Exception e) {
            log.info("请求 " + url + " 失败。", e);
        }
        return result;
    }

    /**
     * 带请求头的 get 请求
     *
     * @param closeableHttpClient http 客户端
     * @param requestConfig       请求配置
     * @param url                 请求路径带参数
     * @param headers             请求头
     * @return 请求结果
     * @throws IOException IO异常
     */
    public static String get(CloseableHttpClient closeableHttpClient, RequestConfig requestConfig, String url,
                             Map<String, String> headers) throws IOException {
        //1 创建 post 请求
        HttpGet get = new HttpGet(url);
        //2 设置请求默认配置
        get.setConfig(requestConfig);
        //3 设置请求头 post.setHeader("Content-type", "application/json; charset=utf-8");
        if (!CollectionUtil.isEmpty(headers)) {
            headers.forEach(get::setHeader);
        }
        //4 发送请求
        CloseableHttpResponse response = closeableHttpClient.execute(get);
        //5 处理返回结果，
        //5-1 如果状态码为200,就是正常返回
        int statusCode = response.getStatusLine().getStatusCode();
        if (statusCode == 200) {
            return EntityUtils.toString(response.getEntity());
        } else {
            throw new RuntimeException("------- 请求错误：" + statusCode);
        }
    }


    /**
     * 默认请求头的 get 请求下载文件
     *
     * @param url 请求地址
     * @return 文件流
     * @throws IOException 异常
     */
    public static InputStream getInputStream(CloseableHttpClient closeableHttpClient, RequestConfig requestConfig, String url) throws IOException {
        return getInputStream(closeableHttpClient, requestConfig, url, null);
    }

    /**
     * 自定义请求头的 get 请求下载文件
     *
     * @param url     请求地址
     * @param headers 请求头，可为 null
     * @return 文件流
     * @throws IOException 异常
     */
    public static InputStream getInputStream(CloseableHttpClient closeableHttpClient, RequestConfig requestConfig, String url, Map<String, String> headers) throws IOException {
        InputStream result = null;
        try {
            //1 创建 post 请求
            HttpGet get = new HttpGet(url);
            //2 设置请求默认配置
            get.setConfig(requestConfig);
            //3 设置请求头 post.setHeader("Content-type", "application/json; charset=utf-8");
            if (!CollectionUtil.isEmpty(headers)) {
                headers.forEach(get::setHeader);
            }
            //4 发送请求
            CloseableHttpResponse response = closeableHttpClient.execute(get);
            //5 处理返回结果，
            //5-1 如果状态码为200,就是正常返回
            int statusCode = response.getStatusLine().getStatusCode();
            log.info("请求 " + url + " 状态码为：" + statusCode);
            if (statusCode == 200) {
                result = response.getEntity().getContent();
            }
        } catch (Exception e) {
            log.info("请求 " + url + " 失败。", e);
        }
        return result;
    }

    /**
     * 自定义请求头的 post 请求
     */
    public static String post(CloseableHttpClient closeableHttpClient, RequestConfig requestConfig, String url, Map<String, String> headers, Map<String, String> params) throws IOException {
        //1 创建 post 请求
        HttpPost post = new HttpPost(url);
        //2 设置请求默认配置
        post.setConfig(requestConfig);
        //3 设置请求头 post.setHeader("Content-type", "application/json; charset=utf-8");
        if (!CollectionUtil.isEmpty(headers)) {
            headers.forEach(post::setHeader);
        }
        //4 设置请求体
        post.addHeader("Content-Type", "application/json");
        if (!CollectionUtil.isEmpty(params)) {
            post.setEntity(new StringEntity(JsonUtil.beanToJson(params), "utf-8"));
        }
        //5 发送请求
        CloseableHttpResponse response = closeableHttpClient.execute(post);
        //6 处理返回结果，
        //6-1 如果状态码为200,就是正常返回
        int statusCode = response.getStatusLine().getStatusCode();
        if (statusCode == 200) {
            return EntityUtils.toString(response.getEntity());
        } else {
            throw new RuntimeException("请求错误：" + statusCode);
        }
    }

//
//    /**
//     * 通过 get 请求下载文件
//     * 发送 get 请求，get 请求的参数在 url 里
//     *
//     * @param url     请求地址
//     * @param headers 请求头，可为 null
//     * @return 文件流
//     * @throws IOException 异常
//     */
//    public static InputStream getDownload(String url, Map<String, String> headers) throws IOException {
//        //1 创建 post 请求
//        HttpGet get = new HttpGet(url);
//        //2 设置请求默认配置
//        get.setConfig(requestConfig);
//        //3 设置请求头 post.setHeader("Content-type", "application/json; charset=utf-8");
//        if (!CollectionUtil.isEmpty(headers)) {
//            headers.forEach(get::setHeader);
//        }
//        //4 发送请求
//        CloseableHttpResponse response = httpClient.execute(get);
//        //5 处理返回结果，
//        //5-1 如果状态码为200,就是正常返回
//        int statusCode = response.getStatusLine().getStatusCode();
//        if (statusCode == 200) {
//            return response.getEntity().getContent();
//        } else {
//            throw new RuntimeException("------- 请求错误：" + statusCode);
//        }
//    }
//
//
//    /**
//     * 发送 post 请求
//     */
//    public static InputStream postUpload(String url) throws IOException {
//        //1 创建 post 请求
//        HttpPost post = new HttpPost(url);
//        //2 设置请求默认配置
//        post.setConfig(requestConfig);
//        //3 设置请求头 post.setHeader("Content-type", "application/json; charset=utf-8");
//        post.setHeader("Content-type", "multipart/form-data");
//        //5 发送请求
//        CloseableHttpResponse response = httpClient.execute(post);
//        //6 处理返回结果，
//        //6-1 如果状态码为 200,就是正常返回
//        int statusCode = response.getStatusLine().getStatusCode();
//        if (statusCode == 200) {
//            return response.getEntity().getContent();
//        } else {
//            throw new RuntimeException("------- 请求错误：" + statusCode);
//        }
//    }
//
//    /**
//     * 发送 post 请求
//     */
//    public static InputStream postDownload(String url, Map<String, String> headers, Map<String, String> params) throws IOException {
//        //1 创建 post 请求
//        HttpPost post = new HttpPost(url);
//        //2 设置请求默认配置
//        post.setConfig(requestConfig);
//        //3 设置请求头 post.setHeader("Content-type", "application/json; charset=utf-8");
//        if (!CollectionUtil.isEmpty(headers)) {
//            headers.forEach(post::setHeader);
//        }
//        //4 设置请求体
//        if (!CollectionUtil.isEmpty(params)) {
//            params.forEach(post::setHeader);
//        }
//        //5 发送请求
//        CloseableHttpResponse response = httpClient.execute(post);
//        //6 处理返回结果，
//        //6-1 如果状态码为 200,就是正常返回
//        int statusCode = response.getStatusLine().getStatusCode();
//        if (statusCode == 200) {
//            return response.getEntity().getContent();
//        } else {
//            throw new RuntimeException("------- 请求错误：" + statusCode);
//        }
//    }

}