HttpClientUtill工具类

import cn.hutool.http.HttpUtil;
import com.zcys.admin.common.utils.core.StringUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
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.methods.HttpUriRequest;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.HttpMultipartMode;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;

/**
 * Http请求工具类
 */
@Slf4j
public class HttpClientUtils extends HttpUtil {

    /**
     * 带参数的get请求
     *
     * @param url   接口路径
     * @param param 请求参数
     * @return String 响应结果
     */
    public static String doGet(String url, Map<String, String> param) {
        // 创建http GET请求
        HttpGet httpGet = new HttpGet();

        try {
            URIBuilder builder = new URIBuilder(url);

            // 拼接参数
            if (Objects.nonNull(param)) {
                for (String key : param.keySet()) {
                    builder.addParameter(key, param.get(key));
                }
            }

            URI uri = builder.build();
            httpGet.setURI(uri);

            // 执行请求
            return execute(httpGet);
        } catch (URISyntaxException e) {
            e.printStackTrace();
        }

        return StringUtils.EMPTY;
    }

    /**
     * 不带参数的get请求
     *
     * @param url 接口路径
     * @return String 响应结果
     */
    public static String doGet(String url) {
        return doGet(url, null);
    }

    /**
     * 带参数的post请求
     *
     * @param url   接口路径
     * @param param 请求参数
     * @return String  响应结果
     */
    public static String doPost(String url, Map<String, String> param) {
        // 创建Http Post请求
        HttpPost httpPost = new HttpPost(url);

        try {
            // 创建参数列表
            if (Objects.nonNull(param)) {
                List<NameValuePair> paramList = new ArrayList<>();

                for (String key : param.keySet()) {
                    paramList.add(new BasicNameValuePair(key, param.get(key)));
                }

                // 模拟表单
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList);
                httpPost.setEntity(entity);
            }

            //执行http请求
            return execute(httpPost);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

        return StringUtils.EMPTY;
    }

    /**
     * 不带参数的post请求
     *
     * @param url 接口路径
     * @return String 响应结果
     */
    public static String doPost(String url) {
        return doPost(url, null);
    }

    /**
     * 传送json类型的post请求
     *
     * @param url  接口路径
     * @param json 请求参数
     * @return String 响应结果
     */
    public static String doPostJson(String url, String json) {
        // 创建Http Post请求
        HttpPost httpPost = new HttpPost(url);

        // 创建请求内容
        StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
        httpPost.setEntity(entity);

        // 执行http请求
        return execute(httpPost);
    }

    /**
     * 发送文件对象到服务端
     *
     * @param url      发送路径
     * @param fileKey  文件key
     * @param json     请求json格式参数
     * @param fileName 文件名称
     * @param param    其他参数
     * @return 发送结果
     */
    public static String doPostFile(String url, String fileKey, String json, String fileName, Map<String, String> param) {
        HttpPost httpPost = new HttpPost(url);

        MultipartEntityBuilder multipartEntityBuilder = MultipartEntityBuilder.create();

        /*
         * 设置模式为BROWSER_COMPATIBLE，并设置字符集为UTF8,HttpClient上传文件时，会调用doWriteTo方法，写一个输出流，
         * 但是在调用formatMultipartHeader方法时，底层主要有3种不同的实现，3种方式的采用的字符集不一样
         */
        multipartEntityBuilder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
        multipartEntityBuilder.setCharset(StandardCharsets.UTF_8);

        // 创建文件参数
        if (StringUtils.isNotBlank(json)) {
            multipartEntityBuilder.addBinaryBody(fileKey, StringUtils.getBytes(json, StandardCharsets.UTF_8),
                    ContentType.create(ContentType.APPLICATION_JSON.getMimeType(), StandardCharsets.UTF_8), fileName);
        }

        // 创建文本参数列表
        if (Objects.nonNull(param)) {
            for (String key : param.keySet()) {
                multipartEntityBuilder.addTextBody(key, param.get(key), ContentType.create(ContentType.TEXT_PLAIN.getMimeType(),
                        StandardCharsets.UTF_8));
            }
        }

        // 设置请求表单
        httpPost.setEntity(multipartEntityBuilder.build());

        // 执行http请求
        return execute(httpPost);
    }

    /**
     * 执行请求，返回结果
     *
     * @param request 请求
     * @return 响应结果
     */
    private static String execute(HttpUriRequest request) {
        try (CloseableHttpClient httpClient = HttpClients.createDefault();
             CloseableHttpResponse response = httpClient.execute(request)) {
            // 判断返回状态是否为200
            if (Objects.equals(response.getStatusLine().getStatusCode(), HttpStatus.SC_OK)) {
                return EntityUtils.toString(response.getEntity(), StandardCharsets.UTF_8);
            }
        } catch (IOException e) {
            log.error("执行http请求异常：", e);
        }

        return StringUtils.EMPTY;
    }

}

import org.springframework.http.HttpHeaders;

public class HttpHeadersUtils extends HttpHeaders {

    /**
     * unknown
     */
    public final static String UNKNOWN = "unknown";

    /**
     * x-forwarded-for
     */
    public final static String LOWER_X_FORWARDED_FOR = "x-forwarded-for";

    /**
     * X-Forwarded-For
     */
    public final static String UPPER_X_FORWARDED_FOR = "X-Forwarded-For";

    /**
     * Proxy-Client-IP
     */
    public final static String PROXY_CLIENT_IP = "Proxy-Client-IP";

    /**
     * WL-Proxy-Client-IP
     */
    public final static String WL_PROXY_CLIENT_IP = "WL-Proxy-Client-IP";

    /**
     * X-Real-IP
     */
    public final static String X_REAL_IP = "X-Real-IP";

}

import com.zcys.admin.common.utils.core.StringUtils;
import lombok.extern.slf4j.Slf4j;

import javax.servlet.ServletRequest;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;

/**
 * 通用http工具封装
 */
@Slf4j
public class HttpHelperUtils {

    /**
     * 获取请求Body
     *
     * @param request 请求
     * @return 目标字符串
     */
    public static String getBodyString(ServletRequest request) {
        try (InputStream inputStream = request.getInputStream();
             BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8))) {
            String line;
            StringBuilder sb = new StringBuilder();

            while (StringUtils.isNotEmpty(line = reader.readLine())) {
                sb.append(line);
            }

            return sb.toString();
        } catch (IOException e) {
            log.warn("getBodyString出现异常：！", e);
        }

        return StringUtils.EMPTY;
    }

}

import com.fasterxml.jackson.core.type.TypeReference;
import com.zcys.admin.common.utils.core.JSONUtils;
import com.zcys.admin.common.utils.core.StringUtils;
import lombok.extern.slf4j.Slf4j;

import javax.servlet.http.HttpServletRequest;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;

@Slf4j
public class HttpParamUtils {

    /**
     * 将URL的参数和body参数合并
     *
     * @param request 请求
     */
    public static SortedMap<String, String> getAllParams(HttpServletRequest request) {
        SortedMap<String, String> result = new TreeMap<>();
        // 获取URL上的参数
        getUrlParams(request, result);
        // 获取body参数
        getAllRequestParam(request, result);
        return result;
    }

    /**
     * 获取 Body 参数
     *
     * @param request 请求
     */
    public static void getAllRequestParam(final HttpServletRequest request, SortedMap<String, String> result) {
        try (Reader in = new InputStreamReader(request.getInputStream());
             BufferedReader reader = new BufferedReader(in)){
            String str;
            StringBuilder wholeStr = new StringBuilder();

            // 一行一行的读取body体里面的内容；
            while ((str = reader.readLine()) != null) {
                wholeStr.append(str);
            }

            wholeStr.trimToSize();
            String s = wholeStr.toString();

            if (StringUtils.isNotEmpty(s)) {
                // 转化成json对象
                Map<String, String> allRequestParam = JSONUtils.getTypeReference(s, new TypeReference<Map<String, String>>() {});
                // 将URL的参数和body参数进行合并
                result.putAll(allRequestParam);
            }
        } catch (Exception e) {
            log.error("getAllRequestParam fail :", e);
        }
    }

    /**
     * 获取url参数
     *
     * @param request 请求
     * @author show
     */
    public static void getUrlParams(HttpServletRequest request, SortedMap<String, String> result) {
        String param = StringUtils.EMPTY;

        try {
            String urlParam = request.getQueryString();

            if (StringUtils.isNotEmpty(urlParam)) {
                param = URLDecoder.decode(urlParam, StandardCharsets.UTF_8.name());
            }
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

        String[] params = param.split(StringUtils.AMPERSAND);

        for (String s : params) {
            int index = s.indexOf(StringUtils.EQUAL);

            if (index != -1) {
                result.put(s.substring(0, index), s.substring(index + 1));
            }
        }
    }

}