Suchen Json-Pfad/(eine API) zur Aktualisierung der Wert in der gegebenen json-string in Java

Unter der Annahme, dass geparste JSON repräsentiert werden können in der Erinnerung als Anzeigen, können Sie bauen eine API ähnlich JsonPath, dass sieht aus wie:

void update(Map<String, Object> json, String path, Object newValue);

Habe ich schnell eine Zusammenfassung von dirty-Implementierung für einfache bestimmte Pfade (keine Unterstützung für die Bedingungen und Platzhalter), die traverse json-Baum, E. g. $.store.name, $.store.Bücher[0].isbn. Hier ist es: MutableJson.java. Es benötigt auf jeden Fall eine Verbesserung, aber kann einen guten start.

Beispiel:

import java.util.*;

public class MutableJson {

    public static void main(String[] args) {
        MutableJson json = new MutableJson(
                new HashMap<String, Object>() {{
                    put("store", new HashMap<String, Object>() {{
                        put("name", "Some Store");
                        put("books", Arrays.asList(
                                new HashMap<String, Object>() {{
                                    put("isbn", "111");
                                }},
                                new HashMap<String, Object>() {{
                                    put("isbn", "222");
                                }}
                        ));
                    }});
                }}
        );

        System.out.println("Before:\t" + json.map());

        json.update("$.store.name", "Book Store");
        json.update("$.store.books[0].isbn", "444");
        json.update("$.store.books[1].isbn", "555");

        System.out.println("After:\t" + json.map());
    }

    private final Map<String, Object> json;

    public MutableJson(Map<String, Object> json) {
        this.json = json;
    }

    public Map<String, Object> map() {
        return json;
    }

    public void update(String path, Object newValue) {
        updateJson(this.json, Path.parse(path), newValue);
    }

    private void updateJson(Map<String, Object> data, Iterator<Token> path, Object newValue) {
        Token token = path.next();
        for (Map.Entry<String, Object> entry : data.entrySet()) {
            if (!token.accept(entry.getKey(), entry.getValue())) {
                continue;
            }

            if (path.hasNext()) {
                Object value = token.value(entry.getValue());
                if (value instanceof Map) {
                    updateJson((Map<String, Object>) value, path, newValue);
                }
            } else {
                token.update(entry, newValue);
            }
        }
    }
}

class Path {
    public static Iterator<Token> parse(String path) {
        if (path.isEmpty()) {
            return Collections.<Token>emptyList().iterator();
        }
        if (path.startsWith("$.")) {
            path = path.substring(2);
        }

        List<Token> tokens = new ArrayList<>();
        for (String part : path.split("\\.")) {
            if (part.matches("\\w+\\[\\d+\\]")) {
                String fieldName = part.substring(0, part.indexOf('['));
                int index = Integer.parseInt(part.substring(part.indexOf('[')+1, part.indexOf(']')));
                tokens.add(new ArrayToken(fieldName, index));
            } else {
                tokens.add(new FieldToken(part));
            }
        };

        return tokens.iterator();
    }
}

abstract class Token {

    protected final String fieldName;

    Token(String fieldName) {
        this.fieldName = fieldName;
    }

    public abstract Object value(Object value);

    public abstract boolean accept(String key, Object value);

    public abstract void update(Map.Entry<String, Object> entry, Object newValue);
}

class FieldToken extends Token {

    FieldToken(String fieldName) {
        super(fieldName);
    }

    @Override
    public Object value(Object value) {
        return value;
    }

    @Override
    public boolean accept(String key, Object value) {
        return fieldName.equals(key);
    }

    @Override
    public void update(Map.Entry<String, Object> entry, Object newValue) {
        entry.setValue(newValue);
    }
}

class ArrayToken extends Token {

    private final int index;

    ArrayToken(String fieldName, int index) {
        super(fieldName);
        this.index = index;
    }

    @Override
    public Object value(Object value) {
        return ((List) value).get(index);
    }

    @Override
    public boolean accept(String key, Object value) {
        return fieldName.equals(key) && value instanceof List && ((List) value).size() > index;
    }

    @Override
    public void update(Map.Entry<String, Object> entry, Object newValue) {
        List list = (List) entry.getValue();
        list.set(index, newValue);
    }
}

Einen JSON-string kann leicht untersucht und in einer Karte mit Jackson:

Map<String,Object> userData = new ObjectMapper().readValue("{ \"store\": ... }", Map.class);

InformationsquelleAutor Vlad

Nur die Antwort für Leute, die Landung auf dieser Seite in Zukunft als Referenz.

Könnten Sie überlegen, ein Java-Implementierung von jsonpatch. RFC finden Sie hier

JSON-Patch ist ein format für die Beschreibung von änderungen, um ein JSON-Dokument. Es kann verwendet werden, um zu vermeiden, dass ein ganzes Dokument, wenn nur ein Teil geändert hat. Wenn verwendet, in Kombination mit HTTP-PATCH-Methode, die es ermöglicht, partielle updates für HTTP-APIs in einer standardkonformen Weise.

Können Sie die operation, die durchgeführt werden muss (ersetzen, hinzufügen....), json-Pfad, in dem es durchgeführt werden, und der Wert, der verwendet werden soll.

Wieder, wobei Beispiel aus dem RFC :

 [
     { "op": "test", "path": "/a/b/c", "value": "foo" },
     { "op": "remove", "path": "/a/b/c" },
     { "op": "add", "path": "/a/b/c", "value": [ "foo", "bar" ] },
     { "op": "replace", "path": "/a/b/c", "value": 42 },
     { "op": "move", "from": "/a/b/c", "path": "/a/b/d" },
     { "op": "copy", "from": "/a/b/d", "path": "/a/b/e" }
   ]

Zur Implementierung in Java, ich habe es nicht selbst, aber Sie können einen Versuch geben, um https://github.com/fge/json-patch

InformationsquelleAutor kunal