java-正则替换功能类

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONException;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 参数替换功能类
 */
@Slf4j
public class RegexUtil {

    private static void jsonCycle(JSONArray jsonArrayIn, JSONObject caseParams, List<JSONObject> caseResultList) {
        int size = jsonArrayIn.size();
        for (int i = 0; i < size; i++) {
            Object value = jsonArrayIn.get(i);
            if (value instanceof JSONObject) {
                jsonCycle((JSONObject) value, caseParams, caseResultList);
            } else if (value instanceof JSONArray) {
                jsonCycle((JSONArray) value, caseParams, caseResultList);
            } else {
                JSONObject replaceJson = new JSONObject();
                if (value.toString().contains("$(")) {
                    String valueStr = value.toString();
                    // 是否存在多个替换表达式
                    boolean more = false;
                    // Pattern p = Pattern.compile("(\\$\\()(.*)(\\))");
                    Pattern p = Pattern.compile("\\$\\(([^)^(]*)\\)");
                    Matcher m = p.matcher(value.toString());
                    while (m.find()) {
                        String values = m.group();
                        String valueIn = m.group(1);
                        if (values.length() < valueStr.length()) {
                            Object replaceRet = replaceParams(valueIn, caseParams, caseResultList);
                            if (replaceRet == null) {
                                valueStr = valueStr.replace(values, "");
                            } else {
                                valueStr = valueStr.replace(values, replaceRet.toString());
                            }
                            more = true;
                        } else {
                            Object replaceRet = replaceParams(valueIn, caseParams, caseResultList);
                            valueStr = replaceRet.toString();
                            replaceJson.put(String.valueOf(i), replaceRet);
                        }
                        m = p.matcher(valueStr);
                    }
                    if (more) {
                        replaceJson.put(String.valueOf(i), valueStr);
                    }

                }
                if (!replaceJson.isEmpty()) {
                    // jsonArray替换
                    for (String index : replaceJson.keySet()) {
                        jsonArrayIn.remove(Integer.parseInt(index));
                        jsonArrayIn.add(Integer.parseInt(index), replaceJson.get(index));
                    }
                }
            }
        }
    }

    private static void jsonCycle(Map<String, Object> jsonIn, JSONObject caseParams, List<JSONObject> caseResultList) {
        try {
            for (String key : jsonIn.keySet()) {
                Object value = jsonIn.get(key);
                if (value instanceof JSONObject) {
                    jsonCycle((JSONObject) value, caseParams, caseResultList);
                } else if (value instanceof JSONArray) {
                    jsonCycle((JSONArray) value, caseParams, caseResultList);
                } else {
                    if (value.toString().contains("$(")) {
                        String valueStr = value.toString();
                        // 是否存在多个替换表达式
                        boolean more = false;
                        // 匹配包含数字字母小数点中括号的$()内容。
                        // Pattern p = Pattern.compile("(\\$\\()([\\w\\.\\[\\]-]+)(\\))");
                        // Pattern p = Pattern.compile("(\\$\\()(.*)(\\))");
                        Pattern p = Pattern.compile("\\$\\(([^)^(]*)\\)");
                        Matcher m = p.matcher(value.toString());
                        while (m.find()) {
                            String values = m.group();
                            String valueIn = m.group(1);
                            if (values.length() < valueStr.length()) {
                                Object replaceRet = replaceParams(valueIn, caseParams, caseResultList);
                                if (replaceRet == null) {
                                    valueStr = valueStr.replace(values, "");
                                } else {
                                    valueStr = valueStr.replace(values, replaceRet.toString());
                                }
                                more = true;
                            } else {
                                Object replaceRet = replaceParams(valueIn, caseParams, caseResultList);
                                valueStr = replaceRet.toString();
                                jsonIn.put(key, replaceRet);
                            }
                            m = p.matcher(valueStr);
                        }
                        if (more) {
                            jsonIn.put(key, valueStr);
                        }
                    }
                }
            }
        } catch (Exception e) {
            log.error("参数替换异常：" + e.getMessage());
        }
    }

    private static Object resultGetValue(String valueStr, List<JSONObject> caseResultList) {
        Object ret = null;
        try {
            String expression = "return " + valueStr + ";";
            JSONObject resultJson = new JSONObject();
            resultJson.put("result", caseResultList);
            resultJson.put("resultList", caseResultList);
            ret = MvelUtil.eval(expression, resultJson);
        } catch (Exception e) {
            log.error("参数替换异常：" + e.getMessage());
        }
        return ret;
    }

    public static Object replaceParams(String values, JSONObject caseParams, List<JSONObject> caseResultList) {
        if (values.contains("sys.")) {
            return DynamicParamsUtil.defaultParams(values, caseParams, caseResultList);
        } else if (values.contains("result")) {
            // 结果内容参数替换
            // 入参规则处理(目前只支持result规则)
            return resultGetValue(values, caseResultList);
        } else {
            // 文件参数替换
            String fileValue = caseParams.get(values).toString();
            if (fileValue.contains("$(")) {
                // 是否存在多个替换表达式
                boolean more = false;
                // 匹配包含数字字母小数点中括号的$()内容。
                // Pattern p = Pattern.compile("(\\$\\()([\\w\\.\\[\\]-]+)(\\))");
                // Pattern p = Pattern.compile("(\\$\\()(.*)(\\))");
                Pattern p = Pattern.compile("\\$\\(([^$]*)\\)");
                Matcher m = p.matcher(fileValue);
                while (m.find()) {
                    String fileValues = m.group();
                    String fileValueIn = m.group(1);
                    if (fileValues.length() < fileValue.length()) {
                        Object replaceRet = replaceParams(fileValueIn, caseParams, caseResultList);
                        if (replaceRet == null) {
                            fileValue = fileValue.replace(fileValues, "");
                        } else {
                            fileValue = fileValue.replace(fileValues, replaceRet.toString());
                        }
                        more = true;
                    } else {
                        return replaceParams(fileValueIn, caseParams, caseResultList);
                    }
                }
                if (more) {
                    return fileValue;
                }
                String fileValueIn = StringUtils.substringBeforeLast(fileValue.substring(2), ")");
                // 系统动态函数替换
                if (fileValueIn.contains("sys.")) {
                    return DynamicParamsUtil.defaultParams(fileValueIn, caseParams, caseResultList);
                } else if (fileValueIn.contains("result")) {
                    // 结果内容参数替换
                    // 入参规则处理(目前只支持result规则)
                    return resultGetValue(fileValueIn, caseResultList);
                }
            }
            try {
                if ("".equals(caseParams.get(values).toString())) {
                    return caseParams.get(values).toString();
                }
                return JSONObject.parseObject(caseParams.get(values).toString());
            } catch (Exception e) {

            }
            try {
                return JSONArray.parseArray(caseParams.get(values).toString());
            } catch (Exception e) {
                return caseParams.get(values);
            }
        }
    }

    public static Map<String, Object> replaceRun(Map<String, Object> params, JSONObject caseParams, List<JSONObject> caseResultList) {
        jsonCycle(params, caseParams, caseResultList);
        return params;
    }

    public static void main(String[] args) {
        String sb
                = "{"\"TaskId\":\"$(text),$(text)\",\"isOnline\":\"$(sys.randomStr{$(text)})\",\"fle\":[\"$(sys.urlToFile{https://})\", \"$(sys.urlToFile{$(url)})\",\"$(sys.randomStr{$(text)})\"]}";
        JSONObject sbJ = JSONObject.parseObject(sb);
        System.out.println(sbJ.toJSONString());
        Map<String, Object> ret = new HashMap<>(sbJ);
        JSONObject tmp = new JSONObject();
        tmp.put("text", 5);
        tmp.put("url", "https:/");
        Map<String, Object> rett = replaceRun(ret, tmp, new ArrayList<>());
        System.out.println(sbJ.toJSONString());
        System.out.println(rett.toString());

    }
}