JAVA http请求 GET/POST 工具

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.codec.Charsets;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpEntity;
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.client.methods.HttpRequestBase;
import org.apache.http.client.protocol.HttpClientContext;
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.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.DefaultHttpRequestRetryHandler;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicHeader;
import org.apache.http.protocol.HTTP;
import org.apache.http.ssl.SSLContextBuilder;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Value;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.util.Map;
import java.util.UUID;


/**
 * @ClassName : HttpClientPool
 * @Description : http请求工具
 * @Author : liming mu
 * @Data : 2022/11/8 12:05
 * @Version : 1.0.0
 **/
public class HttpClientPool implements InitializingBean {
    Logger logger = LoggerFactory.getLogger(HttpClientPool.class);
    private PoolingHttpClientConnectionManager poolConnManager;
    private RequestConfig requestConfig;
    private CloseableHttpClient httpClient;
    @Value("${HTTP_SECRET_KEY:}")
    public String HTTP_SECRET_KEY;
    @Value("${HTTP_APP_KEY:}")
    public String HTTP_APP_KEY;

    private void config(HttpRequestBase httpRequestBase, String requestData) {
        RequestConfig requestConfig = RequestConfig.custom()
                .setConnectionRequestTimeout(100000)
                .setConnectTimeout(100000)
                .setSocketTimeout(100000).build();
        httpRequestBase.addHeader("Content-Type", "application/json;charset=UTF-8");
        if (!StringUtils.isAnyBlank(HTTP_SECRET_KEY, HTTP_APP_KEY)) {
            String timestamp = System.currentTimeMillis() + "";
            String nonce = UUID.randomUUID().toString();
            String ENCODING = "ascii";
            String ALGORITHM = "HmacSHA1";
            String signature = null;
            try {
                Mac mac = Mac.getInstance(ALGORITHM);
                mac.init(new SecretKeySpec(HTTP_SECRET_KEY.getBytes(ENCODING), ALGORITHM));
                String[] array = new String[]{
                        new String(timestamp.getBytes(ENCODING)),
                        new String(nonce.getBytes(ENCODING)),
                        new String(HTTP_APP_KEY.getBytes(ENCODING)),
                        new String(httpRequestBase.getURI().getPath().getBytes(ENCODING)),
                        new String(requestData.getBytes(ENCODING)),
                        "",
                };
                String text = String.join("\n", array);
                byte[] signData = mac.doFinal(text.getBytes());
                byte[] bytes = Base64.encodeBase64(signData);
                signature = new String(Base64.encodeBase64(signData), ENCODING);
            } catch (NoSuchAlgorithmException | InvalidKeyException | UnsupportedEncodingException e) {
                e.printStackTrace();
            }
            httpRequestBase.setHeader("TIMESTAMP", timestamp);
            httpRequestBase.setHeader("NONCE", nonce);
            httpRequestBase.setHeader("APP_KEY", HTTP_APP_KEY);
            httpRequestBase.setHeader("SIGNATURE", signature);
        }
        httpRequestBase.setConfig(requestConfig);
    }

    private void initPool() {
        try {
            SSLContextBuilder builder = new SSLContextBuilder();
            builder.loadTrustMaterial(null, new TrustSelfSignedStrategy());
            SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(builder.build());
            Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create().register(
                    "http", PlainConnectionSocketFactory.getSocketFactory()).register(
                    "https", sslsf).build();
            poolConnManager = new PoolingHttpClientConnectionManager(
                    socketFactoryRegistry);
            poolConnManager.setMaxTotal(1000);
            poolConnManager.setDefaultMaxPerRoute(1000);

            int socketTimeout = 100000;
            int connectTimeout = 100000;
            int connectionRequestTimeout = 100000;
            requestConfig = RequestConfig.custom().setConnectionRequestTimeout(
                    connectionRequestTimeout).setSocketTimeout(socketTimeout).setConnectTimeout(
                    connectTimeout).build();
            httpClient = getConnection();
        } catch (NoSuchAlgorithmException | KeyStoreException | KeyManagementException e) {
            e.printStackTrace();
        }
    }

    private CloseableHttpClient getConnection() {
        CloseableHttpClient httpClient = HttpClients.custom()
                .setConnectionManager(poolConnManager)
                .setDefaultRequestConfig(requestConfig)
                .setRetryHandler(new DefaultHttpRequestRetryHandler(0, false))
                .build();
        return httpClient;
    }

    public String post(String url, Map<String, Object> requestData) {
        HttpPost httpPost = new HttpPost(url);
        config(httpPost, requestData.toString());
        StringEntity stringEntity = new StringEntity(JSON.toJSONString(requestData), "UTF-8");
        stringEntity.setContentEncoding(Charsets.UTF_8.toString());
        httpPost.setEntity(stringEntity);
        return getResponse(httpPost);
    }

    public String post(String url, String requestData) {
        HttpPost httpPost = new HttpPost(url);
        config(httpPost, requestData);
        /*if(url.contains("/api/host") || url.contains("/api/guest")){
            httpPost.addHeader("request_token", request_token);
        }*/
        StringEntity stringEntity = new StringEntity(requestData, Charsets.UTF_8.toString());
        stringEntity.setContentEncoding("UTF-8");
        httpPost.setEntity(stringEntity);
        String result = getResponse(httpPost);
        logger.info("httpclient sent url {} request {} result: {}", url, requestData, result);
        return result;
    }


    /**
     *@Author: liming Mu
     *@Date: Created in 18:41 2022/3/10
     *@Description: 发送json请求给远端
     *@Params:
     @param url:
     @param paras:
     *@Returns: java.lang.String
     *@Modified By: None
     *@Version: 1.0.0
     */
    public String post(String url, JSONObject paras){
        HttpPost httpPost = new HttpPost(url);
        httpPost.setHeader("Content-Type", "application/json");
        httpPost.addHeader("Authorization", "Basic YWRtaW46");
     /*   if(url.contains("/api/host") || url.contains("/api/guest")){
            httpPost.addHeader("request_token", request_token);
        }*/
        StringEntity s = new StringEntity(paras.toString(), "utf-8");
        s.setContentEncoding(new BasicHeader(HTTP.CONTENT_TYPE,
                "application/json"));
        httpPost.setEntity(s);
        logger.info("httpclient sent url {}", url);
        return getResponse(httpPost);
    }

    public String get(String url) {
        HttpGet httpGet = new HttpGet(url);
        config(httpGet, null);
        httpGet.addHeader("Authorization", "xxx"); //如果有认证需求
        return getResponse(httpGet);
    }


    private String getResponse(HttpRequestBase request) {
        CloseableHttpResponse response = null;
        try {
            response = httpClient.execute(request,
                    HttpClientContext.create());
            HttpEntity entity = response.getEntity();
            String result = EntityUtils.toString(entity, Charsets.UTF_8);
            EntityUtils.consume(entity);
            return result;
        } catch (IOException e) {
            logger.error("send http error", e);
            return "request_fail";
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        initPool();
    }

    public static void main(String[] args) {
        HttpClientPool httpClientPool = new HttpClientPool();
        httpClientPool.initPool();
        String s = httpClientPool.get("http://xxx");
        System.out.println(s);
    }