将逻辑文本解析为 Json 结构

Question

我收到一个 java 字符串： "(((x=ss)OR(x=0))AND((y=dd)OR(y=rr))AND(z=1S))" 。 我需要将其解析并格式化为以下结构的 json。

{
  "exp": {
    "typ": "and",
    "sbe": [
      {
        "exp": {
          "typ": "or",
          "vtp": "sta",
          "key": "x",
          "vsa": [
            "ss",
            "0"
          ]
        }
      },
      {
        "exp": {
          "typ": "or",
          "vtp": "sta",
          "key": "y",
          "vsa": [
            "dd",
            "rr"
          ]
        }
      },
      {
        "exp": {
          "typ": "eq",
          "vtp": "str",
          "key": "z",
          "vsa": "1S"
        }
      }
    ]
  }
}

一直在尝试使用以下 java 程序按逻辑运算符拆分。 以下是我一直在尝试的逻辑：

1. 检查平衡支架。
2. 如果是，则提取括号内的内容。
3. 提取逻辑运算符（AND 或 OR）
4. 使用上面提取的运算符，将内容拆分为数组/列表。
5. 对于每个内容，从步骤 1 开始重复

我无法思考继续前进的逻辑应该是什么

public class Tester {
    public static void main(String[] args) throws IOException {
        String input  = "(((x=ss)OR(x=0))AND((y=dd)OR(y=rr))AND(z=1S))";
        if (isExpressionBalanced(input)) {
            System.out.println("input = " + input);
            extractRecursive(input);
        } else {
            System.out.println("The expression is not balanced");
        }
    }

    private static List<String> splitByOperator(String text) {
        Map<String, String > map = new HashMap<>();
        String bracketContents = getWhatsInsideBrackets(text);
        String operator = extractOperator(bracketContents);
        if (operator == null) {
            System.out.println(bracketContents);
            map.put(bracketContents.split("=")[0],  bracketContents.split("=")[1]);
            return Collections.emptyList();
        }
        String[] splitTextArray = bracketContents.split(operator);
        for (String splitText : splitTextArray) {

            System.out.println(operator);

            List<String>  list = splitByOperator(splitText);
            list.size();
        }
        return Arrays.asList(splitTextArray);
    }

    private static void extractRecursive(String text) {
        List<String> splitTextArray = splitByOperator(text);
        for (String splitText : splitTextArray) {
            String bracketContents = getWhatsInsideBrackets(splitText);
            List<String> list = splitByOperator(bracketContents);
            list.size();
        }
    }

    public static String getWhatsInsideBrackets(String stringWithBracket) {
        int firstBracketIndexStart = stringWithBracket.indexOf('(');
        int firstBracketIndexEnd = findClosingParen(stringWithBracket.toCharArray(), firstBracketIndexStart);
        String stringWIthinBrackets = stringWithBracket.substring(firstBracketIndexStart + 1, firstBracketIndexEnd);
        return stringWIthinBrackets;
    }

    private static String extractOperator(String text) {
        String operator = null;
        int innerFirstBracketIndexStart = text.indexOf('(');
        if (innerFirstBracketIndexStart < 0) {
            return operator;
        }
        int innerFirstBracketIndexEnd = findClosingParen(text.toCharArray(), innerFirstBracketIndexStart);
        if (text.startsWith("AND", innerFirstBracketIndexEnd + 1)) {
            operator = "AND";
        } else if (text.startsWith("OR", innerFirstBracketIndexEnd + 1)) {
            operator = "OR";
        }
        return operator;

    }

    public static int findClosingParen(char[] text, int openPos) {
        int closePos = openPos;
        int counter = 1;
        while (counter > 0) {
            char c = text[++closePos];
            if (c == '(') {
                counter++;
            } else if (c == ')') {
                counter--;
            }
        }
        return closePos;
    }

    static boolean isExpressionBalanced(String searchTerm) {
        Stack stack = new Stack();
        for (int i = 0; i < searchTerm.length(); i++) {
            if (searchTerm.charAt(i) == '(') {
                stack.push(searchTerm.charAt(i));
            }
            if (searchTerm.charAt(i) == ')') {
                if (stack.empty()) {
                    return false;
                }
                char top_char = (char) stack.pop();

                if ((top_char == '(' && searchTerm.charAt(i) != ')')) {
                    return false;
                }
            }
        }
        return stack.empty();
    }

}

无法思考拆分逻辑并形成预期的json结构。

Answer 1

如果您可以先解析字符串并将其建模为 Java 对象，则会更容易。 然后，您可以使用 Gson 轻松地将 Java 对象转换为 JSON。

1. 创建一个类似于以下内容的 Java 类：

    class Expression { String typ; String vtp; // Other stuff }

   这应该能够存储您的数据，例如typ 、 vtp 、 key等。

2. 解析你的表达。 可能是Jim Mischel在上面的评论中建议的方式。

3. 解析后，不要将内容存储到数组/列表中（如您在步骤 4 中提到的）：

   使用上面提取的运算符，将内容拆分为数组/列表。

但为每个拆分的内容创建一个new Expression() 。 类似于： new Expression("eq", "str", "z", "15");

4. 现在您将拥有解析表达式的 Java 对象结构。 您必须将该 Java 对象转换为 JSON。 使用Gson并将其转换为 JSON。