JSONtoXML नीति

यह Apigee Edge के दस्तावेज़ हैं.
पर जाएं Apigee X दस्तावेज़. info

क्या

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

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

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

सैंपल

JSON और एक्सएमएल के बीच कन्वर्ज़न के बारे में ज़्यादा जानकारी के लिए, रिस्पॉन्स ऑब्जेक्ट में JSON कलेक्शन से एक्सएमएल कलेक्शन में कन्वर्ज़न की समस्या देखें.

<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 से एक्सएमएल फ़ॉर्मैट में कन्वर्ज़न का आउटपुट सेव होता है. आम तौर पर, इसकी वैल्यू सोर्स के जैसी ही होती है. इसका मतलब है कि आम तौर पर, JSON अनुरोध को एक्सएमएल अनुरोध में बदला जाता है.

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

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

<OutputVariable>request</OutputVariable>

<Options>/<OmitXmlDeclaration>

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

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

<OmitXmlDeclaration>true</OmitXmlDeclaration>

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

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

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

<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 से एक्सएमएल में कन्वर्ज़न किया जाता है, तब रूट एलिमेंट के नाम के बारे में पता चलता है. JSON में, नाम वाला रूट एलिमेंट नहीं होता.

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

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

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

<ObjectRootElementName>Root</ObjectRootElementName>

तो नतीजे के तौर पर मिलने वाला एक्सएमएल इस तरह दिखेगा:

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

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

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

उदाहरण के लिए, यहां दी गई सेटिंग से, #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 से एक्सएमएल में बदलने की नीति के साथ, आउटबाउंड रिस्पॉन्स फ़्लो पर एक्सएमएल से JSON में बदलने की नीति का इस्तेमाल किया जाता है. नीतियों को इस तरह से मिलाकर, a JSON API को उन सेवाओं के लिए उपलब्ध कराया जा सकता है जो सिर्फ़ एक्सएमएल को सपोर्ट करती हैं.

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

ऐसे परिदृश्यों में जहां एपीआई का इस्तेमाल अलग-अलग क्लाइंट ऐप्लिकेशन करते हैं और उन्हें JSON और एक्सएमएल, दोनों की ज़रूरत हो सकती है, वहां रिस्पॉन्स का फ़ॉर्मैट डाइनैमिक तरीके से सेट किया जा सकता है. इसके लिए, JSON से एक्सएमएल में बदलने और एक्सएमएल से 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>

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

• एक्सएमएल से JSON में बदलना: एक्सएमएल से JSON नीति
• XSL ट्रांसफ़ॉर्मेशन: XSL ट्रांसफ़ॉर्म नीति