HttpParamsUtils.java

package dev.utils.common;

import java.net.URLEncoder;
import java.util.LinkedHashMap;
import java.util.Map;

import dev.utils.DevFinal;
import dev.utils.JCLogUtils;

/**
 * detail: Http 参数工具类
 * @author Ttt
 */
public final class HttpParamsUtils {

    private HttpParamsUtils() {
    }

    // 日志 TAG
    private static final String TAG = HttpParamsUtils.class.getSimpleName();

    /**
     * 获取 Url 携带参数
     * @param url URL 链接
     * @return Url 携带参数
     */
    public static String getUrlParams(final String url) {
        return getUrlParamsArray(url)[1];
    }

    /**
     * 获取 Url、携带参数 数组
     * @param url URL 链接
     * @return 0 = url, 1 = params
     */
    public static String[] getUrlParamsArray(final String url) {
        String[] result = new String[2];
        if (StringUtils.isNotEmpty(url)) {
            // 清除掉前后空格
            String urlClean = StringUtils.clearSEWiths(url, " ");
            // 清除掉结尾的 ?
            urlClean = StringUtils.clearEndsWith(urlClean, "?");
            // 进行拆分
            int index = urlClean.indexOf("?");
            if (index != -1) {
                result[0] = urlClean.substring(0, index);
                result[1] = urlClean.substring(index + 1);
            } else {
                result[0] = urlClean;
            }
        }
        return result;
    }

    /**
     * 判断是否存在参数
     * @param params 请求参数字符串
     * @return {@code true} yes, {@code false} no
     */
    public static boolean existsParams(final String params) {
        return !splitParams(params).isEmpty();
    }

    /**
     * 通过 Url 判断是否存在参数
     * @param url URL 链接
     * @return {@code true} yes, {@code false} no
     */
    public static boolean existsParamsByURL(final String url) {
        return !splitParams(getUrlParams(url)).isEmpty();
    }

    /**
     * 拼接 Url 及携带参数
     * @param url    URL 链接
     * @param params 请求参数字符串
     * @return {@code true} yes, {@code false} no
     */
    public static String joinUrlParams(
            final String url,
            final String params
    ) {
        if (StringUtils.isEmpty(params)) return url;
        // 获取拼接符号
        String symbol = getUrlParamsJoinSymbol(url, params);
        return url + symbol + params;
    }

    /**
     * 获取 Url 及携带参数 拼接符号
     * @param url    URL 链接
     * @param params 请求参数字符串
     * @return {@code true} yes, {@code false} no
     */
    public static String getUrlParamsJoinSymbol(
            final String url,
            final String params
    ) {
        if (StringUtils.isEmpty(params)) return "";
        // 判断是否存在参数
        if (existsParamsByURL(url)) {
            return "&";
        } else {
            return "?";
        }
    }

    // =

    /**
     * 通过 Url 拆分参数
     * @param url URL 链接
     * @return 拆分后的参数 Map
     */
    public static Map<String, String> splitParamsByUrl(final String url) {
        return splitParamsByUrl(url, false);
    }

    /**
     * 通过 Url 拆分参数
     * @param url       URL 链接
     * @param urlEncode 是否需要 URL 编码
     * @return 拆分后的参数 Map
     */
    public static Map<String, String> splitParamsByUrl(
            final String url,
            final boolean urlEncode
    ) {
        return splitParams(getUrlParams(url), urlEncode);
    }

    /**
     * 拆分参数
     * @param params 请求参数字符串
     * @return 拆分后的参数 Map
     */
    public static Map<String, String> splitParams(final String params) {
        return splitParams(params, false);
    }

    /**
     * 拆分参数
     * @param params    请求参数字符串
     * @param urlEncode 是否需要 URL 编码
     * @return 拆分后的参数 Map
     */
    public static Map<String, String> splitParams(
            final String params,
            final boolean urlEncode
    ) {
        Map<String, String> mapParams = new LinkedHashMap<>();
        if (StringUtils.isNotEmpty(params)) {
            // 拆分数据
            String[] keyValues = params.split("&");
            // 数据长度
            int valLength;
            // 进行循环遍历
            for (String val : keyValues) {
                // 数据不为 null
                if (val != null && (valLength = val.length()) != 0) {
                    // 获取首位 = 索引
                    int indexOf = val.indexOf('=');
                    // 不存在则不处理
                    if (indexOf != -1) {
                        // 获取 key
                        String key = val.substring(0, indexOf);
                        // 获取 value
                        String value;
                        // 防止资源浪费
                        if (indexOf + 1 == valLength) {
                            value = "";
                        } else {
                            value = val.substring(indexOf + 1, valLength);
                        }
                        // 判断是否编码
                        if (urlEncode) {
                            mapParams.put(key, urlEncode(value));
                        } else {
                            mapParams.put(key, value);
                        }
                    }
                }
            }
        }
        return mapParams;
    }

    // =

    /**
     * 拼接请求参数
     * @param mapParams Map 请求参数
     * @return 拼接后的参数
     */
    public static String joinParams(final Map<String, String> mapParams) {
        return joinParams(mapParams, false);
    }

    /**
     * 拼接请求参数
     * @param mapParams Map 请求参数
     * @param urlEncode 是否需要 URL 编码
     * @return 拼接后的参数
     */
    public static String joinParams(
            final Map<String, String> mapParams,
            final boolean urlEncode
    ) {
        if (mapParams != null) {
            int           index   = 0;
            StringBuilder builder = new StringBuilder();
            for (Map.Entry<String, String> entry : mapParams.entrySet()) {
                if (index > 0) builder.append('&');
                builder.append(entry.getKey());
                builder.append('=');
                builder.append(urlEncode ? urlEncode(entry.getValue()) : entry.getValue());
                index++;
            }
            return builder.toString();
        }
        return null;
    }

    // =

    /**
     * 拼接请求参数
     * @param mapParams Map 请求参数
     * @return 拼接后的参数
     */
    public static String joinParamsObj(final Map<String, Object> mapParams) {
        return joinParamsObj(mapParams, false);
    }

    /**
     * 拼接请求参数
     * @param mapParams Map 请求参数
     * @param urlEncode 是否需要 URL 编码
     * @return 拼接后的参数
     */
    public static String joinParamsObj(
            final Map<String, Object> mapParams,
            final boolean urlEncode
    ) {
        if (mapParams != null) {
            int           index   = 0;
            StringBuilder builder = new StringBuilder();
            for (Map.Entry<String, Object> entry : mapParams.entrySet()) {
                if (index > 0) builder.append('&');
                builder.append(entry.getKey());
                builder.append('=');
                if (urlEncode) {
                    String strValue = ConvertUtils.newStringNotArrayDecode(
                            entry.getValue()
                    );
                    if (strValue != null) {
                        builder.append(urlEncode(strValue));
                    }
                } else {
                    builder.append(entry.getValue());
                }
                index++;
            }
            return builder.toString();
        }
        return null;
    }

    // ======================================
    // = 拼接成, 模拟 JavaScript 传递对象数组格式 =
    // ======================================

    /**
     * 进行转换对象处理 ( 请求发送对象 )
     * @param mapParams Map 请求参数
     * @param objStr    数组名
     * @param key       数组 key
     * @param value     数组 [key] 保存值
     * @return {@code true} success, {@code false} fail
     */
    public static boolean convertObjToMS(
            final Map<String, String> mapParams,
            final String objStr,
            final String key,
            final String value
    ) {
        if (mapParams != null) {
            String data = null;
            try {
                data = URLEncoder.encode(value, DevFinal.ENCODE.UTF_8);
            } catch (Exception e) {
                JCLogUtils.eTag(TAG, e, "convertObjToMS");
            }
            mapParams.put(objStr + "[" + key + "]", data);
            return true;
        }
        return false;
    }

    /**
     * 进行转换对象处理 ( 请求发送对象 )
     * @param mapParams Map 请求参数
     * @param objStr    数组名
     * @param key       数组 key
     * @param value     数组 [key] 保存值
     * @return {@code true} success, {@code false} fail
     */
    public static boolean convertObjToMO(
            final Map<String, Object> mapParams,
            final String objStr,
            final String key,
            final Object value
    ) {
        if (mapParams != null) {
            Object data = null;
            try {
                data = URLEncoder.encode(value.toString(), DevFinal.ENCODE.UTF_8);
            } catch (Exception e) {
                JCLogUtils.eTag(TAG, e, "convertObjToMO");
            }
            mapParams.put(objStr + "[" + key + "]", data);
            return true;
        }
        return false;
    }

    // ===============
    // = StringUtils =
    // ===============

    /**
     * 进行 URL 编码, 默认 UTF-8
     * @param str 待处理字符串
     * @return UTF-8 编码格式 URL 编码后的字符串
     */
    public static String urlEncode(final String str) {
        return StringUtils.urlEncode(str);
    }

    /**
     * 进行 URL 编码
     * @param str 待处理字符串
     * @param enc 编码格式
     * @return 指定编码格式 URL 编码后的字符串
     */
    public static String urlEncode(
            final String str,
            final String enc
    ) {
        return StringUtils.urlEncode(str, enc);
    }
}