【问题标题】:Check if JSONObject matches JSON boolean expression检查 JSONObject 是否匹配 JSON 布尔表达式
【发布时间】:2021-03-24 12:32:16
【问题描述】:

为了正确解释问题,我必须从一个示例开始,假设我有一个这样的用户列表

[
    { "name": "John",  "surname": "Doe",   "age": 22 },
    { "name": "Syrus", "surname": "Black", "age": 20 }
]

我还有一个JSONObject 代表一个必须像这样匹配的条件:

{
    "OR":[
        { "name": { "eq": "John"} },
        { "AND":[
            { "name": { "eq": "Syrus"} },
            { "age": { "gt": 18 } }
        ] }
    ]
}

应该翻译成:

name = "John" OR (name = "Syrus" AND age > 18)

现在我必须编写给出JSONObject 条件的代码,如果条件匹配,用户列表会检查每个用户。 目前这是我所做的:

import java.util.Set;
import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;
import java.util.function.BiConsumer;
import com.query.Queryable;
import org.json.JSONArray;
import org.json.JSONObject;

public class QueryableTreeMap<K,V extends JSONObject> extends TreeMap<K,V> implements Queryable<JSONObject,JSONObject> {

    private static final long serialVersionUID = 2586026774025401270L;

    private static boolean test(Set<Map.Entry<String, Object>> condition, JSONObject value){
        boolean isValid = true;
        Iterator<Map.Entry<String, Object>> iter = condition.iterator();
        while(iter.hasNext()){
            Map.Entry<String, Object> subcond = iter.next();
            if(subcond.getKey().equals("OR")){
                //isValid = isValid || test((Set<Map.Entry<String, Object>>) subcond.getValue(), value);
            } else if(subcond.getKey().equals("AND")){
                //isValid = isValid && test((Set<Map.Entry<String, Object>>) subcond.getValue(), value);
            } else if(subcond.getKey().equals("NOT")){
            
            } else {
                
            }
        }
        return isValid;
    }

    @Override
    public JSONObject query(JSONObject query) {
        // the set containing the conditions
        Set<Map.Entry<String, Object>> entries = query.toMap().entrySet();
        // the JSONArray with containing the records that match the condition
        JSONArray array = new JSONArray();
        // for each JSONObject inside this structure
        this.forEach(new BiConsumer<K,JSONObject>(){

            @Override
            public void accept(K key, JSONObject value) {
                // testing if the current record matches the condition
                if(test(entries, value)) array.put(value);
            }
            
        });
        // returns a JSONObject containing a JSONArray that contains the records that match the condition
        return new JSONObject(array);
    }
}

我目前卡在测试方法中,该方法实际上应该测试给定对象是否与给定条件匹配。

我不介意更改 JSON 条件的格式,只要它是 JSONObject。

目前我想出了一个部分解决方案,它构建一个名为 Condition 的对象,它表示 JSONObject 中的布尔表达式(不是很有效,但仍然是一个可能的解决方案)这显然目前不起作用,我需要帮助关于我现在应该做什么

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Condition {

    private Condition left, right;
    private String boolExpr, key, value;
    private boolean not;
    private int operationType; // greater then, less then, equal to, greater or equal of, less or equal of

    public Condition(Map<String, Object> map) {
        Set<Map.Entry<String, Object>> set = map.entrySet();
        Iterator<Map.Entry<String, Object>> iterator = set.iterator();
        while(iterator.hasNext()){
            Object entry = iterator.next();
            System.out.println(entry);
            System.out.println(entry.getClass());
            if(entry instanceof Map.Entry) {
                String key = (String) ((Map.Entry) entry).getKey();
                switch(key){
                    case "AND":
                    case "OR":
                        this.boolExpr = key;
                        break;
                    case "eq":
                    case "gt":
                    case "lt":
                    case "gte":
                    case "lte":
                        this.operationType = getOperationTypeFromString(key);
                        break;
                    case "NOT":
                        this.not = true;
                        break;
                    default:
                        this.key = key;
                        break;
                }
            }
        }
    }

    public int getOperationTypeFromString(String operation) {
        switch(operation){
            case "eq":
                return 0;
            case "gt":
                return 1;
            case "lt":
                return 2;
            case "gte":
                return 3;
            case "lte":
                return 4;
            default:
                return 0;
        }
    }

}

我宁愿不使用 Condition 类,而只使用 JSONObject。 我正在使用 org.json JSON-Java 解析器。

【问题讨论】:

  • 您的意思是name == "John",而不是name = "John"?此外,您的数据中有“john”而不是“John”。不确定这是不是故意的。
  • 是的,对不起,我的意思是 name == "John",不,第二个错误不是故意的,我的错!
  • 好的,你可以修复数据,以免其他人混淆。
  • 我会使用递归方法来评估表达式。
  • @Henry 我正在这样做,但我在使用 Map、Set 和 Map.Entry 来处理许多数据结构时遇到了麻烦,我将发布我所取得的成就。这个问题确实应该像树中的 DFS 一样简单,但是由于需要处理大量不同的数据结构和案例,它变得过于复杂。

标签: java json validation optimization


【解决方案1】:

编辑:代码更新为使用 org.json。

以下是处理您的示例的有效实现。

真正完成这项工作的函数是match,它递归地遍历过滤器并将每个节点应用于提供的对象。如果给定对象满足给定过滤器,则该函数返回 true。

从概念上讲,match 函数将过滤器语言(AND、OR、EQ、LT 等)中的每个构造映射到其 Java 等效项。例如。 AND 映射到 Stream.allMatch,NOT 映射到 Java ! 运算符,EQ 映射到 Object.equals,等等。 match 正在为您的过滤器语言定义语义。

我希望代码是不言自明的 - 如果有任何不清楚的地方,请告诉我。

import org.json.*;

import java.io.*;
import java.nio.file.*;
import java.util.List;
import java.util.stream.*;

import static java.util.stream.Collectors.toList;

public class Test {

    public static void main(String[] args) throws IOException {
        final List<JSONObject> jsObjs =
                stream(readJsonArray("users.json"))
                        .map(JSONObject.class::cast)
                        .collect(toList());

        final JSONObject jsFilter = readJsonObject("filter.json");

        final List<JSONObject> matches = applyFilter(jsObjs, jsFilter);

        System.out.println(matches);
    }

    private static List<JSONObject> applyFilter(List<JSONObject> jsObjs, JSONObject jsFilter) {
        return jsObjs.stream()
                .filter(jsObj -> match(jsObj, jsFilter))
                .collect(toList());
    }

    private static boolean match(JSONObject jsObj, JSONObject jsFilter) {

        final String name = getSingleKey(jsFilter);
        final Object value = jsFilter.get(name);

        switch (name) {
            case "AND":
                return stream((JSONArray)value)
                        .map(JSONObject.class::cast)
                        .allMatch(jse -> match(jsObj, jse));
            case "OR":
                return stream((JSONArray)value)
                        .map(JSONObject.class::cast)
                        .anyMatch(jse -> match(jsObj, jse));
            case "NOT":
                return !match(jsObj, (JSONObject)((JSONArray)value).get(0));
            default:
                final JSONObject jsOp = (JSONObject)value;
                final String operator = getSingleKey(jsOp);
                final Object operand = jsOp.get(operator);
                switch (operator) {
                    case "eq": return jsObj.get(name).equals(operand);
                    case "lt": return (Integer)jsObj.get(name) < (Integer)operand;
                    case "gt": return (Integer)jsObj.get(name) > (Integer)operand;
                    default: throw new IllegalArgumentException("Unexpected operator: " + operator);
                }
        }
    }

    private static JSONObject readJsonObject(String fileName) throws IOException {
        try (Reader reader = Files.newBufferedReader(Paths.get(fileName))) {
            return new JSONObject(new JSONTokener(reader));
        }
    }

    private static JSONArray readJsonArray(String fileName) throws IOException {
        try (Reader reader = Files.newBufferedReader(Paths.get(fileName))) {
            return new JSONArray(new JSONTokener(reader));
        }
    }

    private static Stream<Object> stream(JSONArray jsa) {
        return StreamSupport.stream(jsa.spliterator(), false);
    }

    private static String getSingleKey(JSONObject jso) {
        if (jso.length() != 1) {
            throw new IllegalArgumentException("Expected single entry");
        } else {
            return jso.keySet().iterator().next();
        }
    }
}

【讨论】:

  • 我完全理解代码,让我恭维你这是一个可靠的解决方案,问题是它需要我完全改变我正在使用的库,这是不可能的,但我仍然会投赞成票,以防将来有人遇到同样的问题。
  • 如果您能更清楚地说明问题,它可能会帮助我们为您找到解决方案。您使用的是什么库,为什么它会阻止您使用上述方法?
  • 在问题的最后,我添加了我正在使用的库 (org.json),不幸的是,我无法使用该库实现相同的算法。
  • 我已更改代码以使用您正在使用的 org.json 库。同样的算法仍然有效。
猜你喜欢
  • 2023-03-08
  • 2022-01-15
  • 2014-02-20
  • 2012-12-16
  • 1970-01-01
  • 2019-04-20
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
相关资源
最近更新 更多