JSON-zu-JSON-Transformator

Lesezeit: 7 Minuten

Benutzer-Avatar
Chaturvedi Dewashish

Ich habe ein Szenario.

Erforderliche Eingabe und Ausgabe sind JSON.

// Input
{
  "OldObject": {
    "Time": 1351160457922,
    "Name": "OName",
    "quantity": 100,
    "price": 10
  }
}


// Output
{
  "NewObject": {
    "Time": 1351160457922,
    "Title": "OName",
    "quantity": 100
  }
}

Ich brauche einen Transformationscode oder vorzugsweise eine xslt-Sprache, um json von einem Format in ein anderes umzuwandeln. Dieser Transformator muss auch schnell sein, da die Transformation im laufenden Betrieb erfolgt.

Bearbeiten

Ich habe die Definition des INPUT-Objekts nicht erhalten und kann sich zur Laufzeit ändern. aber ich kann bei Bedarf die Klasse für das OUTPUT-Objekt verwenden. Ich habe versucht, dies als zu tun json -> xml -> xslt -> xml -> jsonaber an diesem Ende werden etwa 1000 Objekte pro Sekunde empfangen, und dieser Prozess kann Overhead verursachen.
Ich kann auch kein JavaScript verwenden, da myApp einfach ist Windows-basierte Java-Anwendung und die Verwendung von JavaScript kann Overhead verursachen.

  • Ja sicher, ich kann Javascript verwenden. aber bevorzugter xslt-Typ-Sprache und Transformer-Prozessor

    – Chaturvedi Dewashish

    25. Oktober 2012 um 12:13 Uhr

  • Was ist mit dem JSON-Patch? tools.ietf.org/html/draft-pbryan-json-patch-00

    – KARASZI Istvan

    25. Oktober 2012 um 12:15 Uhr

  • Implementierungen dafür finden Sie zum Beispiel: github.com/bruth/jsonpatch-js

    – KARASZI Istvan

    25. Oktober 2012 um 12:15 Uhr

  • Eine kleine Sorge – wird dies leistungsmäßig gut genug sein, da dieses Javascript etwa 1000 JSON-Objekte pro Sekunde patchen muss?

    – Chaturvedi Dewashish

    25. Oktober 2012 um 12:22 Uhr

  • Ich habe genau dafür eine Bibliothek geschrieben (in Groovy, einfach in Java zu integrieren und einfach genug zu portieren): github.com/ripdajacker/json-transformer

    – Jes

    22. September 2016 um 12:12 Uhr

Versuchen RUCK. Es ist eine in Java geschriebene JSON-zu-JSON-Transformationsbibliothek. Es wurde in einem Projekt erstellt, das viele JSON-Dateien von einem ElasticSearch-„Backend“ in eine Frontend-API umwandelte.

Für die JSON-Transformation, die Sie in Ihrem Problem aufgelistet haben, wäre die Jolt-„Shift“-Spezifikation:

// Jolt "shift" spec
{
    "OldObject": {
        "Time": "NewObject.Time",   
        "Name": "NewObject.Title", // if the input has "OldObject.Name", copy it's value
                                   // to "NewObject.Title
        "quantity": "NewObject.quantity"
    }
}

Benutzer-Avatar
KARASZI István

Sie können diese Transformation mit durchführen JSON-Patch.

Beispiel mit jsonpatch-js:

var transformations = [
  { move: '/OldObject', to: '/NewObject' },
  { remove: '/NewObject/price' },
  { move: '/NewObject/Name', to: '/NewObject/Title' }
];

var oldObject = { "OldObject": { "Time": 1351160457922, "Name": "OName", "quantity": 100, "price": 10 } };

jsonpatch.apply(oldObject, transformations);

Ich habe das bereitgestellte nicht getestet, sollte aber so funktionieren.

Es gibt Java-Implementierungen für JSON-Patch:

  • Eine kleine Sorge – wird dies leistungsmäßig gut genug sein, da dieses Javascript etwa 1000 JSON-Objekte pro Sekunde patchen muss?

    – Chaturvedi Dewashish

    25. Oktober 2012 um 12:29 Uhr

  • Es hängt von Ihrer Situation ab. Wenn Sie dies auf der Serverseite tun möchten, können Sie verschiedene Implementierungen in verschiedenen Sprachen haben. Ich habe dies gepostet, weil Ihre Frage ein Javascript-Tag enthielt.

    – KARASZI Istvan

    25. Oktober 2012 um 12:33 Uhr

  • Ich verwende Java und es wird eine Windows-basierte Desktop-Anwendung sein.

    – Chaturvedi Dewashish

    25. Oktober 2012 um 12:36 Uhr

Sie können ZORBA und JsonIQ verwenden http://www.jsoniq.org/
Es handelt sich jedoch um eine native Bibliothek, die mit einem Wrapper geliefert wird, sodass Sie sie in Java verwenden können.

Du kannst es versuchen jmama eine kleine Java-Bibliothek

String jsonstring = "...";
JsonValue json = JsonParser.parse(jsonstring);
Jmom jmom = Jmom.instance()
            .copy("/OldObject", "/NewObject", true)
            .remove("/NewObject/price")
            .copy("/NewObject/Name", "/NewObject/Title", true);
jmom.apply(json);
jsonstring = json.toCompactString();

Sie können die Java-Bibliothek ausprobieren Schweigen Damit können Sie jeden Knoten der JSON-Datei in neue Werte konvertieren. Sie können entscheiden, welche und wie Knoten transformiert werden sollen.

Benutzer-Avatar
Asaf Mesika

Eine weitere Option ist die Verwendung von Logz.io Sägewerk Bücherei. Sie definieren eine Pipeline und führen sie aus. Für dein Beispiel:

{
  steps: [
    {
      rename {
         config {
            from: "OldObject"
            to: "NewObject"
         }
      }
    }

    {
      removeField {
        config {
          path: "NewObject.price"
        }
      }
    }

    {
      rename {
        config {
          from: "NewObject.Name"
          to: "NewObject.Title"
        }
      }
    }
  ]
}

Javascript-JSON-Transformer:
https://raw.githubusercontent.com/udhayasoftware/codebase/master/standalone/javascript/TransformJSON.js

Wir können ein JSON-Array in ein JSON-Objekt konvertieren und umgekehrt. Die einzige Sache ist, dass wir bei der Definition der xPaths vorsichtig sein müssen.

//Transforming JSON array to JSON object:
 var inputObj = [{Name:"Senyora"},{Name:"Clinton"}]
 sourceXpath = "[].Name";
 targetXpath = "Marriage.Couples[].NewName";
 // Output = {Marriage:{Couples:[{NewName:"Senyora"},{NewName:"Clinton"}]}}


 //Transforming JSON object to JSON array:
 var inputObj = {Marriage:{Couples:[{NewName:"Senyora"},{NewName:"Clinton"}]}}
 sourceXpath = "Marriage.Couples[].NewName";
 targetXpath = "[].Name";
 // Output = [{Name:"Senyora"},{Name:"Clinton"}]

/*

 Author: Udhayamoorthy
 Email: [email protected]"

 */

//Code start

function prepareGroup(inputObj, flatted, sourceXpath) {
    sourceXpath = sourceXpath.replace(/\[]/g, ".[0-9]*");
    var reg = new RegExp(sourceXpath, "g")
    var strVal = JSON.stringify(flatted).match(reg);
    var groupVal = {};
    if (strVal != null)
        strVal.forEach(function (data) {
            if (flatted[data] != undefined) {
                groupVal[data] = flatted[data];
            } else {
                data = data.replace(/"/g, "");
                groupVal[data] = getValue(inputObj, data);
            }
        })
    return groupVal;
}

function processGrouped(obj, targetXpath) {
    var flatOutput = {};
    var keys = Object.keys(obj);
    targetXpath = targetXpath.replace(/\[]./g, "[0-9]");
    for (var i = 0; i < keys.length; i++) {
        var key = keys[i];
        var changed = key.match(/(^[0-9]*\.|\W[0-9]*\.)/g);
        if (changed) {
            changed = JSON.stringify(changed).replace(/\"\./g, "\"");
        }
        var arrapos="";
        try {
            arrapos = JSON.parse(changed);
        }
        catch (e) {
            arrapos = changed;
        }
        var temp = targetXpath;
        if (arrapos != null) {
            arrapos.forEach(function (pos) {
                pos = "." + pos;
                temp = temp.replace("[0-9]", pos)
            })
        }
        //tinkering - started
        if (temp.charAt(0) == ".") {
            temp = temp.substring(1, temp.length);
        }
        //tinkering - end
        flatOutput[temp] = obj[key];
    }
    return unflatten(flatOutput);
}

function merge(a, b) {
    for (var key in b)
        if (b.hasOwnProperty(key)) {
            var src = a[key];
            var dest = b[key];
            if (typeof src === 'object' && typeof dest === 'object') {
                merge(src, dest);
            } else {
                a[key] = b[key];
            }
        }
    return a;
};

function getValue(localObj, xpath) {
    //var localObj = JSON.parse(JSON.stringify(obj));
    var xpathArr = xpath.split('.');
    xpathArr.forEach(function (path) {
        localObj = localObj[path];
    })
    return localObj;
}

function unflatten(target, opts) {
    var opts = opts || {}
        , delimiter = opts.delimiter || '.'
        , result = {}

    if (Object.prototype.toString.call(target) !== '[object Object]') {
        return target
    }

    function getkey(key) {
        var parsedKey = parseInt(key)
        return (isNaN(parsedKey) ? key : parsedKey)
    };

    Object.keys(target).forEach(function (key) {
        var split = key.split(delimiter)
            , firstNibble
            , secondNibble
            , recipient = result

        firstNibble = getkey(split.shift())
        secondNibble = getkey(split[0])

        while (secondNibble !== undefined) {
            if (recipient[firstNibble] === undefined) {
                recipient[firstNibble] = ((typeof secondNibble === 'number') ? [] : {})
            }

            recipient = recipient[firstNibble]
            if (split.length > 0) {
                firstNibble = getkey(split.shift())
                secondNibble = getkey(split[0])
            }
        }

        // unflatten again for 'messy objects'
        recipient[firstNibble] = unflatten(target[key])
    });

    //Array Check
    var keys = Object.keys(result);
    if (keys.length > 0 && keys[0] === "0") {
        var output = [];
        keys.forEach(function (key) {
            output.push(result[key])
        });
        return output;
    }
    return result
};

function flatten(target, opts) {
    var output = {}
        , opts = opts || {}
        , delimiter = opts.delimiter || '.'

    function getkey(key, prev) {
        return prev ? prev + delimiter + key : key
    };

    function step(object, prev) {
        Object.keys(object).forEach(function (key) {
            var isarray = opts.safe && Array.isArray(object[key])
                , type = Object.prototype.toString.call(object[key])
                , isobject = (type === "[object Object]" || type === "[object Array]")

            if (!isarray && isobject) {
                return step(object[key]
                    , getkey(key, prev)
                )
            }

            output[getkey(key, prev)] = object[key]
        });
        if (Object.keys(object) == "") {
            if (object instanceof Array) {
                output[prev] = [];
            } else {
                output[prev] = {};
            }
        }
    };
    step(target)
    return output
};

function isChildAttribute(map, flatted, mapArray) {
    var parent = map.sourceXpath;
    for (var j = 0; j < mapArray.length; j++) {
        var child = mapArray[j].sourceXpath;
        if (child.indexOf(parent) != -1 && parent.length < child.length) {
            if (child.indexOf(parent + ".") != -1 || child.indexOf(parent + "[]") != -1) {
                var temp = child;
                temp = temp.replace(/\[]/g, ".0");
                if (flatted[temp] != undefined) {
                    return false;
                }
            }
        }
    }
    return true;
}

function transformJSON(inputObj, mapArray) {
    var flatted = flatten(inputObj);
    var finalout = {};
    if (mapArray.length > 0 && (mapArray[0].targetXpath).charAt(0) == "[")
        finalout = [];
    mapArray.forEach(function (map) {
        if (isChildAttribute(map, flatted, mapArray)) {
            var grouped = prepareGroup(inputObj, flatted, map.sourceXpath);
            var output = processGrouped(grouped, map.targetXpath);
            finalout = merge(finalout, output);  // merge two json objects
        }
    });
    return finalout;
}

//Code end

//How to use (See below) ??

var inputObj = {
    a: {
        b: [
            {
                Name: "Tommy",
                Location: [
                    {Place: "Sydney"},
                    {Place: "Washington"}
                ],
                Info: {age: 23}
            },
            {
                Name: "Sara",
                Location: [
                    {Place: "New York"},
                    {Place: "New Jercy"}
                ],
                Info: {age: 34}
            },
            {
                Name: "John",
                Location: [
                    {Place: "Chicago"},
                    {Place: "Detroit"}
                ],
                Info: {age: 78}
            }
        ],
        d: {
            e: {
                f: {
                    g: {
                        h: "I Love India"
                    }
                }
            }
        }
    }
};

var mapArray = [];     // collect source and target xpath s
var obj = {};
obj.sourceXpath = "a.b[].Name"; // Name is string
obj.targetXpath = "x[].NewName"; // expecting NewName as string
mapArray.push(obj);

//obj = {};
//obj.sourceXpath = "a.b[].Location"; // Location is an array
//obj.targetXpath = "x[].NewName"; // INVALID MAPPING - NewName already mapped
//mapArray.push(obj);

obj = {};
obj.sourceXpath = "a.b[].Location"; // Location is an array
obj.targetXpath = "x[].NewLocation"; // Location data copied to NewLocation array(Place will be present in array elements)
mapArray.push(obj);

obj = {};
obj.sourceXpath = "a.b[].Location[].Place"; // Location is an array
obj.targetXpath = "x[].NewLocation[].NewPlace"; // NewPlace will be created parallel to existing Place.
mapArray.push(obj);

obj = {};
obj.sourceXpath = "a.d.e.f.g.h"; // Transforming attributes at different level
obj.targetXpath = "T.H";
mapArray.push(obj);

var finalout = transformJSON(inputObj, mapArray);
console.log("See line#204 for more about how to use?");
console.log("Transformed JSON = " + JSON.stringify(finalout));

Achtung: JSON kann nicht zwischen verschiedenen Array-Dimensionen transformiert werden. Graf von ‘[]’ in sourceXpath sollte gleich der Anzahl von ‘ sein[]’ in targetXpath und umgekehrt.

1014850cookie-checkJSON-zu-JSON-Transformator

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy