JSONtoXML नीति

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

क्या

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

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

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

सैंपल

JSON और XML के बीच फ़ॉर्मैट बदलने के बारे में ज़्यादा जानने के लिए, 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>

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

इससे पता चलता है कि #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>

<Options>/<ObjectRootElementName>

<ObjectRootElementName> 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 से एक्सएमएल नीति को अक्सर को आउटबाउंड रिस्पॉन्स फ़्लो पर 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 ट्रांसफ़ॉर्म नीति