JSON-JSON 변압기

JSON-JSON 변압기

시나리오가 있어요

필수 입력 및 출력은 JSON입니다.

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


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

json을 하나의 형식에서 다른 형식으로 변환하기 위해 변환 코드 또는 가급적 xslt 타입의 언어가 필요합니다.이 변압기는 변형이 즉석에서 이루어지기 때문에 속도도 빨라야 합니다.

편집
수신된 INPUT 객체에 대한 정의가 없으므로 런타임에 변경될 수 있습니다.하지만 필요하다면 OUTPUT 오브젝트에 클래스를 사용할 수 있습니다.이것을 json -> xml -> xlt -> xml -> xml -> json으로 실행하려고 했는데, 이 엔드에서 초당 약 1000개의 오브젝트가 수신되어 이 프로세스에 오버헤드가 발생할 수 있습니다.
또한 myApp은 단순한 윈도 기반의 자바 어플리케이션이기 때문에 JavaScript를 사용할 수 없으며 JavaScript를 사용하면 오버헤드가 발생할 수 있습니다.

JOLT 해봐.Java로 작성된 JSON-to-JSON 변환 라이브러리입니다.JSON의 로트를 Elastic Search "백엔드"에서 프런트엔드 API로 변환하는 프로젝트에서 작성되었습니다.

문제에 열거된 JSON 변환의 경우 Jolt "shift" 사양은 다음과 같습니다.

// 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"
    }
}

이 변환은 JSON 패치를 사용하여 수행할 수 있습니다.

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);

저는 제공된 것을 테스트하지 않았지만, 그렇게 작업해야 합니다.

JSON 패치의 Java 실장은 다음과 같습니다.

ZORBA와 Json을 사용할 수 있습니다.IQ http://www.jsoniq.org/ 단, 네이티브 라이브러리이므로 패키지와 함께 제공되므로 자바에서 사용할 수 있습니다.

jmom에게 작은 자바 라이브러리를 시도해 볼 수 있다.

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();

Java 라이브러리 Silencio를 사용하여 JSON 파일의 각 노드를 새로운 값으로 변환할 수 있습니다.변환 대상 노드 및 변환 방법을 결정할 수 있습니다.

또 다른 옵션은 Logz.io Sawmill 라이브러리를 사용하는 것입니다.파이프라인을 정의하고 실행합니다.예를 들어 다음과 같습니다.

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

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

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

Javascript JSON 트랜스포머 : https://raw.githubusercontent.com/udhayasoftware/codebase/master/standalone/javascript/TransformJSON.js

JSON 어레이를 JSON 개체로 변환할 수 있습니다.xPaths를 정의할 때 주의할 필요가 있습니다.

//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: udhayaraagam@gmail.com"

 */

//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));

주의: JSON은 다른 차원의 어레이 간에 변환할 수 없습니다.sourceXpath의 '[]' 카운트는 targetXpath의 '[]' 카운트와 같아야 하며 그 반대도 마찬가지입니다.

또 다른 옵션은 Josson입니다.트랜스포메이션 스테이트먼트는 다음과 같습니다.

map(NewObject: OldObject.map(Time,Title:Name,quantity))

언급URL : https://stackoverflow.com/questions/13068267/json-to-json-transformer