JSONtoXML नीति

आपको Apigee Edge का दस्तावेज़ दिख रहा है.
Apigee X के दस्तावेज़ पर जाएं. जानकारी

क्या

इस नीति के तहत, JavaScript Object Notation (JSON) फ़ॉर्मैट वाले मैसेज को एक्सटेंसिबल मार्कअप लैंग्वेज (एक्सएमएल) में बदला जाता है. इससे आपको यह कंट्रोल करने के कई विकल्प मिलते हैं कि मैसेज को कैसे बदला जाए.

अगर आपको XSL का इस्तेमाल करके मैसेज बदलने हैं, तो यह नीति आपके लिए खास तौर पर फ़ायदेमंद है. JSON पेलोड को एक्सएमएल में बदलने के बाद, XSL ट्रांसफ़ॉर्म नीति का इस्तेमाल करें. इसके लिए, कस्टम स्टाइल शीट का इस्तेमाल करें, ताकि आपको ज़रूरी बदलाव किए जा सकें.

मान लें कि JSON फ़ॉर्मैट वाले अनुरोध को XML फ़ॉर्मैट वाले अनुरोध में बदलना है. ऐसे में, नीति को अनुरोध फ़्लो (उदाहरण के लिए, Request / ProxyEndpoint / PostFlow) से जोड़ा जाएगा.

सैंपल

JSON और XML के बीच डेटा को बदलने के बारे में ज़्यादा जानकारी के लिए, रिस्पॉन्स ऑब्जेक्ट में JSON ऐरे को XML ऐरे में बदलने से जुड़ी समस्या लेख पढ़ें.

<JSONToXML name="jsontoxml">
    <Source>request</Source>
    <OutputVariable>request</OutputVariable>
</JSONToXML>

एलिमेंट का रेफ़रंस

इस नीति के लिए, यहां दिए गए एलिमेंट और एट्रिब्यूट कॉन्फ़िगर किए जा सकते हैं.

<JSONToXML async="false" continueOnError="false" enabled="true" name="JSON-to-XML-1">
    <DisplayName>JSON to XML 1</DisplayName>
    <Source>request</Source>
    <OutputVariable>request</OutputVariable>
    <Options>
        <OmitXmlDeclaration>false</OmitXmlDeclaration>
        <DefaultNamespaceNodeName>$default</DefaultNamespaceNodeName>
        <NamespaceSeparator>:</NamespaceSeparator>
        <AttributeBlockName>#attrs</AttributeBlockName>
        <AttributePrefix>@</AttributePrefix>
        <ObjectRootElementName>Root</ObjectRootElementName>
        <ArrayRootElementName>Array</ArrayRootElementName>
        <ArrayItemElementName>Item</ArrayItemElementName>
        <Indent>false</Indent>
        <TextNodeName>#text</TextNodeName>
        <NullValue>I_AM_NULL</NullValue>
        <InvalidCharsReplacement>_</InvalidCharsReplacement>
    </Options>
</JSONToXML>

<JSONToXML> एट्रिब्यूट

यहां दी गई टेबल में, ऐसे एट्रिब्यूट के बारे में बताया गया है जो नीति के सभी पैरंट एलिमेंट में एक जैसे होते हैं:

&lt;DisplayName&gt; एलिमेंट

इस कॉलम में नीति को लेबल करने के लिए, name एट्रिब्यूट के साथ-साथ इस्तेमाल करें मैनेजमेंट यूज़र इंटरफ़ेस (यूआई) प्रॉक्सी एडिटर, जिसका नाम अलग और सामान्य भाषा में है.

<DisplayName>Policy Display Name</DisplayName>

<Source> एलिमेंट

वह वैरिएबल, अनुरोध या जवाब जिसमें JSON मैसेज मौजूद है. आपको इस मैसेज को एक्सएमएल में बदलना है.

अगर <Source> को तय नहीं किया जाता है, तो इसे मैसेज माना जाता है. जब नीति को अनुरोध फ़्लो से जोड़ा जाता है, तो यह अनुरोध में बदल जाता है. वहीं, जब नीति को जवाब फ़्लो से जोड़ा जाता है, तो यह जवाब में बदल जाता है.

अगर सोर्स वैरिएबल को हल नहीं किया जा सकता या वह मैसेज टाइप का नहीं है, तो नीति से जुड़ी गड़बड़ी का मैसेज दिखता है.

<Source>request</Source>

<OutputVariable> एलिमेंट

यह कुकी, JSON को XML फ़ॉर्मैट में बदलने के आउटपुट को सेव करती है. आम तौर पर, यह वैल्यू सोर्स के जैसी ही होती है. इसका मतलब है कि आम तौर पर, JSON अनुरोध को XML अनुरोध में बदल दिया जाता है.

JSON मैसेज के पेलोड को पार्स किया जाता है और एक्सएमएल में बदला जाता है. साथ ही, एक्सएमएल फ़ॉर्मैट वाले मैसेज के एचटीटीपी कॉन्टेंट-टाइप हेडर को text/xml;charset=UTF-8 पर सेट किया जाता है.

अगर OutputVariable नहीं दिया गया है, तो source को OutputVariable माना जाता है. उदाहरण के लिए, अगर source की वैल्यू request है, तो OutputVariable की डिफ़ॉल्ट वैल्यू request होगी.

<OutputVariable>request</OutputVariable>

<Options>/<OmitXmlDeclaration>

इससे आउटपुट में XML नेमस्पेस को शामिल न करने के बारे में पता चलता है. डिफ़ॉल्ट वैल्यू false है. इसका मतलब है कि आउटपुट में नेमस्पेस शामिल करें.

उदाहरण के लिए, यहां दी गई सेटिंग, नेमस्पेस को हटाने के लिए नीति को कॉन्फ़िगर करती है:

<OmitXmlDeclaration>true</OmitXmlDeclaration>

<Options>/<NamespaceBlockName>
<Options>/<DefaultNamespaceNodeName>
<Options>/<NamespaceSeparator> एलिमेंट

JSON में नेमस्पेस का इस्तेमाल नहीं किया जा सकता, जबकि एक्सएमएल दस्तावेज़ों में अक्सर इनकी ज़रूरत होती है. NamespaceBlockName की मदद से, ऐसी JSON प्रॉपर्टी तय की जा सकती है जो नीति से जनरेट होने वाले एक्सएमएल में नेमस्पेस की परिभाषा के सोर्स के तौर पर काम करती है. (इसका मतलब है कि सोर्स JSON को ऐसी प्रॉपर्टी देनी होगी जिसे ऐसे नेमस्पेस में मैप किया जा सके जिसकी ज़रूरत उस ऐप्लिकेशन को है जो नतीजे के तौर पर मिले XML का इस्तेमाल करता है.)

उदाहरण के लिए, ये सेटिंग:

<NamespaceBlockName>#namespaces</NamespaceBlockName>
<DefaultNamespaceNodeName>$default</DefaultNamespaceNodeName>
<NamespaceSeparator>:</NamespaceSeparator>

इससे पता चलता है कि सोर्स JSON में #namespaces नाम की एक प्रॉपर्टी मौजूद है. इसमें कम से कम एक नेमस्पेस ऐसा है जिसे डिफ़ॉल्ट के तौर पर सेट किया गया है. उदाहरण के लिए:

{
   "population": {
       "#namespaces": {
           "$default": "http://www.w3.org/1999/people",
           "exp": "http://www.w3.org/1999/explorers"
       },
       "person": "John Smith",
       "exp:person": "Pedro Cabral"
   }
}

बदलकर यह हो जाता है:

<population xmlns="http://www.w3.org/1999/people" xmlns:exp="http://www.w3.org/1999/explorers">
  <person>John Smith</person>
  <exp:person>Pedro Cabral</exp:person>
</population>

<Options>/<ObjectRootElementName>

<ObjectRootElementName> यह JSON से XML में बदलने पर, रूट एलिमेंट का नाम तय करता है. JSON में नाम वाला रूट एलिमेंट नहीं होता है.

उदाहरण के लिए, अगर JSON इस तरह दिखता है:

{
  "abc": "123",
  "efg": "234"
}

आपने <ObjectRootElementName> को इस तरह सेट किया है:

<ObjectRootElementName>Root</ObjectRootElementName>

इसके बाद, एक्सएमएल ऐसा दिखेगा:

<Root>
   <abc>123</abc>
   <efg>234</efg>
</Root>

<Options>/<AttributeBlockName>
<Options>/<AttributePrefix> एलिमेंट

<AttributeBlockName> की मदद से, यह तय किया जा सकता है कि JSON एलिमेंट को XML एट्रिब्यूट में कब बदला जाए (XML एलिमेंट के बजाय).

उदाहरण के लिए, यहां दी गई सेटिंग, #attrs नाम के ऑब्जेक्ट में मौजूद प्रॉपर्टी को एक्सएमएल एट्रिब्यूट में बदल देती है:

<AttributeBlockName>#attrs</AttributeBlockName>

यह JSON ऑब्जेक्ट:

{
    "person" : {
        "#attrs" : {
            "firstName" : "John",
            "lastName" : "Smith"
        },
        "occupation" : "explorer",
    }
}

को इस एक्सएमएल स्ट्रक्चर में बदल दिया जाता है:

<person firstName="John" lastName="Smith">
  <occupation>explorer</occupation>
</person>

<AttributePrefix>, तय किए गए प्रीफ़िक्स से शुरू होने वाली प्रॉपर्टी को एक्सएमएल एट्रिब्यूट में बदलता है. यहां एट्रिब्यूट प्रीफ़िक्स को @ पर सेट किया गया है. उदाहरण के लिए:

<AttributePrefix>@</AttributePrefix>

यह फ़ंक्शन, इस JSON ऑब्जेक्ट को बदलता है:

{
"person" : {
   "@firstName" : "John",
   "@lastName" : "Smith"
   "occupation" : "explorer",

 }
}

को इस एक्सएमएल स्ट्रक्चर में बदलें:

<person firstName="John" lastName="Smith">
  <occupation>explorer</occupation>
</person>

<Options>/<ArrayRootElementName>
<Options>/<ArrayItemElementName> एलिमेंट

यह फ़ंक्शन, JSON ऐरे को एक्सएमएल एलिमेंट की सूची में बदलता है. इसमें पैरंट और चाइल्ड एलिमेंट के नाम तय किए जाते हैं.

उदाहरण के लिए, ये सेटिंग:

<ArrayRootElementName>Array</ArrayRootElementName>
<ArrayItemElementName>Item</ArrayItemElementName>

यह फ़ंक्शन, इस JSON कलेक्शन को बदलता है:

[
"John Cabot",
{
 "explorer": "Pedro Cabral"
},
"John Smith"
]

को इस एक्सएमएल स्ट्रक्चर में बदलें:

<Array>
  <Item>John Cabot</Item>
  <Item>
    <explorer>Pedro Cabral</explorer>
  </Item>
  <Item>John Smith</Item>
</Array>

<Options>/<Indent>

इससे एक्सएमएल आउटपुट को इंडेंट करने के बारे में पता चलता है. डिफ़ॉल्ट वैल्यू false है इसका मतलब है कि इंडेंट न करें.

उदाहरण के लिए, यहां दी गई सेटिंग, आउटपुट को इंडेंट करने के लिए नीति को कॉन्फ़िगर करती है:

<Indent>true</Indent>

अगर JSON इनपुट इस फ़ॉर्म में है:

{"n": [1, 2, 3] }

इसके बाद, बिना इंडेंट किए आउटपुट यह होगा:

<Array><n>1</n><n>2</n><n>3</n></Array>

इंडेंट करने की सुविधा चालू होने पर, आउटपुट इस तरह दिखता है:

  <Array>
    <n>1</n>
    <n>2</n>
    <n>3</n>
  </Array>

<Options>/<TextNodeName> एलिमेंट

यह फ़ंक्शन, JSON प्रॉपर्टी को दिए गए नाम वाले एक्सएमएल टेक्स्ट नोड में बदलता है. उदाहरण के लिए, यह सेटिंग:

<TextNodeName>age</TextNodeName>

इस JSON को बदलता है:

{
    "person": {
        "firstName": "John",
        "lastName": "Smith",
        "age": 25
    }
}

इस एक्सएमएल स्ट्रक्चर में बदलें:

<person>
  <firstName>John</firstName>25<lastName>Smith</lastName>
</person>

अगर TextNodeName तय नहीं किया गया है, तो टेक्स्ट नोड के लिए डिफ़ॉल्ट सेटिंग का इस्तेमाल करके, एक्सएमएल जनरेट किया जाता है:

<person>
  <firstName>John</firstName>
  <age>25</age>
  <lastName>Smith</lastName>
</person>

<Options>/<NullValue> एलिमेंट

यह शून्य वैल्यू दिखाता है. डिफ़ॉल्ट रूप से वैल्यू NULL होती है.

उदाहरण के लिए, यह सेटिंग:

<NullValue>I_AM_NULL</NullValue>

{"person" : "I_AM_NULL"}

एक्सएमएल एलिमेंट में बदल दिया जाता है:

<person></person>

अगर शून्य वैल्यू के लिए कोई वैल्यू नहीं दी गई है या I_AM_NULL के अलावा कोई अन्य वैल्यू दी गई है, तो वही पेलोड इस तरह बदल जाता है:

<person>I_AM_NULL</person>

<Options>/<InvalidCharsReplacement> एलिमेंट

यह सेटिंग, अमान्य एक्सएमएल को हैंडल करने में मदद करती है. इससे पार्सर में समस्याएं आ सकती हैं. यह सेटिंग, अमान्य एक्सएमएल बनाने वाले किसी भी JSON एलिमेंट को स्ट्रिंग से बदल देती है. उदाहरण के लिए, यह सेटिंग:

<InvalidCharsReplacement>_</InvalidCharsReplacement>

यह JSON ऑब्जेक्ट को बदलता है

{
    "First%%%Name": "John"
}

इस एक्सएमएल स्ट्रक्चर में बदलें:

<First_Name>John<First_Name>

इस्तेमाल की जानकारी

आम तौर पर, मीडिएशन के मामले में, इनबाउंड अनुरोध फ़्लो पर JSON से XML में बदलने की नीति को अक्सर आउटबाउंड रिस्पॉन्स फ़्लो पर XML से JSON में बदलने की नीति के साथ जोड़ा जाता है. नीतियों को इस तरह से मिलाकर, JSON API को उन सेवाओं के लिए उपलब्ध कराया जा सकता है जो सिर्फ़ XML के साथ काम करती हैं.

अक्सर, JSON से XML में बदलने की डिफ़ॉल्ट (खाली) नीति लागू करना और ज़रूरत के मुताबिक कॉन्फ़िगरेशन एलिमेंट जोड़ना फ़ायदेमंद होता है.

ऐसे मामलों में जहां अलग-अलग क्लाइंट ऐप्लिकेशन, एपीआई का इस्तेमाल करते हैं और उन्हें JSON और XML, दोनों की ज़रूरत हो सकती है, वहां जवाब के फ़ॉर्मैट को डाइनैमिक तरीके से सेट किया जा सकता है. इसके लिए, JSON से XML और XML से JSON में बदलने की नीतियों को कॉन्फ़िगर किया जा सकता है, ताकि उन्हें शर्तों के हिसाब से लागू किया जा सके. इस स्थिति को लागू करने के लिए, फ़्लो वैरिएबल और शर्तें देखें.

स्कीमा

गड़बड़ी की जानकारी

इस सेक्शन में, गड़बड़ी के कोड और गड़बड़ी के मैसेज के बारे में बताया गया है. साथ ही, इन गड़बड़ियों के वैरिएबल के बारे में भी बताया गया है, जो Edge की मदद से सेट किए जाते हैं. यह जानकारी जानना ज़रूरी है कि क्या आप गड़बड़ियों को ठीक करता है. ज़्यादा जानने के लिए, आपके लिए ज़रूरी जानकारी देखें नीति से जुड़ी गड़बड़ियों और हैंडलिंग के बारे में जानकारी गलतियां.

रनटाइम की गड़बड़ियां

नीति के लागू होने पर ये गड़बड़ियां हो सकती हैं.

डिप्लॉयमेंट से जुड़ी गड़बड़ियां

कोई नहीं.

गड़बड़ी के वैरिएबल

रनटाइम की गड़बड़ी होने पर ये वैरिएबल सेट किए जाते हैं. ज़्यादा जानकारी के लिए, आपके लिए ज़रूरी जानकारी देखें नीति से जुड़ी गड़बड़ियों के बारे में जानकारी.

गड़बड़ी के रिस्पॉन्स का उदाहरण

{
  "fault": {
    "faultstring": "JSONToXML[JSON-to-XML-1]: Source xyz is not available",
    "detail": {
      "errorcode": "steps.json2xml.SourceUnavailable"
    }
  }
}

गड़बड़ी के नियम का उदाहरण

<FaultRule name="JSON To XML Faults">
    <Step>
        <Name>AM-SourceUnavailableMessage</Name>
        <Condition>(fault.name Matches "SourceUnavailable") </Condition>
    </Step>
    <Step>
        <Name>AM-BadJSON</Name>
        <Condition>(fault.name = "ExecutionFailed")</Condition>
    </Step>
    <Condition>(jsontoxml.JSON-to-XML-1.failed = true) </Condition>
</FaultRule>

मिलते-जुलते विषय

• XML से JSON: XML से JSON नीति
• XSL ट्रांसफ़ॉर्मेशन: XSL ट्रांसफ़ॉर्म नीति