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 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 jsonIn, JSonObject caseParams, List 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 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 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 replaceRun(Map params, JSonObject caseParams, List 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 ret = new HashMap<>(sbJ);
        JSonObject tmp = new JSonObject();
        tmp.put("text", 5);
        tmp.put("url", "https:/");
        Map rett = replaceRun(ret, tmp, new ArrayList<>());
        System.out.println(sbJ.toJSonString());
        System.out.println(rett.toString());

    }
}