JSONtoXML नीति

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

यह क्या है

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

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

यह मानते हुए कि इंटेंट, JSON फ़ॉर्मैट वाले अनुरोध को एक्सएमएल फ़ॉर्मैट वाले अनुरोध में बदलना है, नीति को अनुरोध फ़्लो के साथ अटैच किया जाएगा (उदाहरण के लिए, अनुरोध / प्रॉक्सीEndpoint / PostFlow).

सैंपल

JSON और एक्सएमएल के बीच फ़ॉर्मैट बदलने के बारे में ज़्यादा जानकारी के लिए, http://community.apigee.com/articles/1839/converting-between-xml-and-json-what-you-need-to-k.html पर जाएं.

<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> एट्रिब्यूट

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

<DisplayName> एलिमेंट

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

<DisplayName>Policy Display Name</DisplayName>

<सोर्स> एलिमेंट

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

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

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

<Source>request</Source>

<आउटपुट वैरिएबल> एलिमेंट

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

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

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

<OutputVariable>request</OutputVariable>

<विकल्प>/<OmitXmlDeclaration>

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

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

<OmitXmlDeclaration>true</OmitXmlDeclaration>

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

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

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

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

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

{
   "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>

<विकल्प>/<ObjectRootElementName>

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

उदाहरण के लिए, अगर 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>

<विकल्प>/<इंडेंट>

एक्सएमएल आउटपुट को इंडेंट करना तय करता है. डिफ़ॉल्ट वैल्यू 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>

<विकल्प>/<NullValue> एलिमेंट

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

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

<NullValue>I_AM_NULL</NullValue>

{"person" : "I_AM_NULL"}

करें:

<person></person>

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

<person>I_AM_NULL</person>

<Options>/<अमान्यCharsReplacement> एलिमेंट

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

<InvalidCharsReplacement>_</InvalidCharsReplacement>

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

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

इस एक्सएमएल स्ट्रक्चर को:

<First_Name>John<First_Name>

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

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

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

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

स्कीमा

गड़बड़ी का रेफ़रंस

This section describes the fault codes and error messages that are returned and fault variables that are set by Edge when this policy triggers an error. This information is important to know if you are developing fault rules to handle faults. To learn more, see What you need to know about policy errors and Handling faults.

Runtime errors

These errors can occur when the policy executes.

Deployment errors

None.

Fault variables

These variables are set when a runtime error occurs. For more information, see What you need to know about policy errors.

Example error response

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

Example fault rule

<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 Transform नीति