XMLtoJSON नीति

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

क्या

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

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

इसके बारे में जानकारी

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

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

सैंपल

JSON और XML के बीच फ़ॉर्मैट बदलने के बारे में ज़्यादा जानकारी के लिए, Apigee की मदद से XML और JSON के बीच फ़ॉर्मैट बदलना: आपको क्या जानना चाहिए लेख पढ़ें.

<XMLToJSON name="ConvertToJSON">
  <Options>
  </Options>
  <OutputVariable>response</OutputVariable>
  <Source>response</Source>
</XMLToJSON>

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

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

<XMLToJSON async="false" continueOnError="false" enabled="true" name="XML-to-JSON-1">
    <DisplayName>XML to JSON 1</DisplayName>
    <Source>response</Source>
    <OutputVariable>response</OutputVariable>
    <Options>
        <RecognizeNumber>true</RecognizeNumber>
        <RecognizeBoolean>true</RecognizeBoolean>
        <RecognizeNull>true</RecognizeNull>
        <NullValue>NULL</NullValue>
        <NamespaceBlockName>#namespaces</NamespaceBlockName>
        <DefaultNamespaceNodeName>&</DefaultNamespaceNodeName>
        <NamespaceSeparator>***</NamespaceSeparator>
        <TextAlwaysAsProperty>true</TextAlwaysAsProperty>
        <TextNodeName>TEXT</TextNodeName>
        <AttributeBlockName>FOO_BLOCK</AttributeBlockName>
        <AttributePrefix>BAR_</AttributePrefix>
        <OutputPrefix>PREFIX_</OutputPrefix>
        <OutputSuffix>_SUFFIX</OutputSuffix>
        <StripLevels>2</StripLevels>
        <TreatAsArray>
            <Path unwrap="true">teachers/teacher/studentnames/name</Path>
        </TreatAsArray>
    </Options>
    <!-- Use Options or Format, not both -->
    <Format>yahoo</Format>
</XMLToJSON>

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

<XMLtoJSON async="false" continueOnError="false" enabled="true" name="XML-to-JSON-1">

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

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

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

<DisplayName>Policy Display Name</DisplayName>

<Source> एलिमेंट

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

सोर्स मैसेज का एचटीटीपी कॉन्टेंट-टाइप हेडर, application/xml पर सेट होना चाहिए. ऐसा न होने पर, नीति लागू नहीं होगी.

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

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

<Source>response</Source>

<OutputVariable> एलिमेंट

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

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

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

<OutputVariable>response</OutputVariable>

<Options>

इन विकल्पों की मदद से, XML को JSON में बदलने की प्रोसेस को कंट्रोल किया जा सकता है. <Options> ग्रुप का इस्तेमाल करें. इससे आपको कन्वर्ज़न की सेटिंग जोड़ने की सुविधा मिलती है. इसके अलावा, <Format> एलिमेंट का इस्तेमाल करें. इससे आपको पहले से तय किए गए विकल्पों के टेंप्लेट का रेफ़रंस देने की सुविधा मिलती है. <Options> और <Format>, दोनों का इस्तेमाल नहीं किया जा सकता.

अगर <Format> का इस्तेमाल नहीं किया गया है, तो <Options> देना ज़रूरी है.

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

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

<RecognizeNumber>true</RecognizeNumber>

यहां दिया गया एक्सएमएल उदाहरण देखें:

<a>
  <b>100</b>
  <c>value</c>
</a>

अगर true, तो इसमें बदल जाता है:

{
    "a": {
        "b": 100,
        "c": "value"
    }
}

अगर false, तो इसमें बदल जाता है:

{
    "a": {
        "b": "100",
        "c": "value"
    }
}

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

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

<RecognizeBoolean>true</RecognizeBoolean>

नीचे दिए गए एक्सएमएल उदाहरण के लिए:

<a>
  <b>true</b>
  <c>value</c>
</a>

अगर true, तो इसमें बदल जाता है:

{
    "a": {
        "b": true,
        "c": "value"
    }
}

अगर false, तो इसमें बदल जाता है:

{
    "a": {
        "b": "true",
        "c": "value"
    }
}

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

इसकी मदद से, खाली वैल्यू को शून्य वैल्यू में बदला जा सकता है.

<RecognizeNull>true</RecognizeNull>

इस एक्सएमएल के लिए:

<a>
  <b></b>
  <c>value</c>
</a>

अगर true, तो इसमें बदल जाता है:

{
  "a": {
    "b": null,
    "c": "value"
  }
}

अगर false, तो इसमें बदल जाता है:

{
  "a": {
    "b": {},
    "c": "value"
  }
}

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

इससे पता चलता है कि सोर्स मैसेज में पहचानी गई शून्य वैल्यू को किस वैल्यू में बदला जाना चाहिए. डिफ़ॉल्ट रूप से वैल्यू null होती है. यह विकल्प सिर्फ़ तब लागू होता है, जब RecognizeNull को 'सही है' पर सेट किया गया हो.

<NullValue>not-present</NullValue>

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

इन एलिमेंट का एक साथ इस्तेमाल करें.

<NamespaceBlockName>#namespaces</NamespaceBlockName>
<DefaultNamespaceNodeName>&</DefaultNamespaceNodeName>
<NamespaceSeparator>***</NamespaceSeparator>

यहां दिया गया एक्सएमएल उदाहरण देखें:

<a xmlns="http://ns.com" xmlns:ns1="http://ns1.com">
  <ns1:b>value</ns1:b>
</a>

अगर NamespaceSeparator तय नहीं किया गया है, तो यह JSON स्ट्रक्चर जनरेट होता है:

{
    "a": {
        "b": "value"
    }
}

अगर NamespaceBlockName, DefaultNamespaceNodeName, और NamespaceSeparator एलिमेंट को क्रमशः #namespaces, &, और *** के तौर पर तय किया जाता है, तो यह JSON स्ट्रक्चर जनरेट होता है:

{
    "a": {
        "#namespaces": {
            "&": "http://ns.com",
            "ns1": "http://ns1.com"
        },
        "ns1***b": "value"
    }
}

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

इन एलिमेंट का एक साथ इस्तेमाल करें.

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

<TextAlwaysAsProperty>true</TextAlwaysAsProperty>
<TextNodeName>TEXT</TextNodeName>

इस एक्सएमएल के लिए:

<a>
  <b>value1</b>
  <c>value2<d>value3</d>value4</c>
</a>

अगर TextAlwaysAsProperty को true पर सेट किया जाता है और TextNodeName को TEXT के तौर पर तय किया जाता है, तो यह JSON स्ट्रक्चर जनरेट होता है:

{
  "a": {
    "b": {
      "TEXT": "value1"
    },
    "c": {
      "TEXT": [
        "value2",
        "value4"
        ],
        "d": {
          "TEXT": "value3"
        }
      }
    }
}

अगर TextAlwaysAsProperty को false पर सेट किया जाता है और TextNodeName को TEXT के तौर पर तय किया जाता है, तो यह JSON स्ट्रक्चर जनरेट होता है:

{
  "a": {
    "b": "value1",
    "c": {
      "TEXT": [
        "value2",
        "value4"
      ],
      {
        "d": "value3",
      }
    }
}

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

इन एलिमेंट का एक साथ इस्तेमाल करें.

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

<AttributeBlockName>FOO_BLOCK</AttributeBlockName>
<AttributePrefix>BAR_</AttributePrefix>

यहां दिया गया एक्सएमएल उदाहरण देखें:

<a attrib1="value1" attrib2="value2"/>

अगर दोनों एट्रिब्यूट (AttributeBlockName और AttributePrefix) को एक्सएमएल से JSON के उदाहरण में बताए गए तरीके से सेट किया जाता है, तो JSON का यह स्ट्रक्चर जनरेट होता है:

{
  "a": {
    "FOO_BLOCK": {
      "BAR_attrib1": "value1",
      "BAR_attrib2": "value2"
    }
  }
}

अगर सिर्फ़ AttributeBlockName दिया गया है, तो यह JSON स्ट्रक्चर जनरेट होता है:

{
    "a": {
        "FOO_BLOCK": {
            "attrib1": "value1",
            "attrib2": "value2"
        }
    }
}

अगर सिर्फ़ AttributePrefix दिया गया है, तो यह JSON स्ट्रक्चर जनरेट होता है:

{
    "a": {
        "BAR_attrib1": "value1",
        "BAR_attrib2": "value2"
    }
}

अगर दोनों में से कोई भी फ़ील्ड नहीं दिया गया है, तो यह JSON स्ट्रक्चर जनरेट होता है:

{
    "a": {
        "attrib1": "value1",
        "attrib2": "value2"
    }
}

<Options>/<OutputPrefix>
<Options>/<OutputSuffix> एलिमेंट

इन एलिमेंट का एक साथ इस्तेमाल करें.

<OutputPrefix>PREFIX_</OutputPrefix>
<OutputSuffix>_SUFFIX</OutputSuffix>

यहां दिया गया एक्सएमएल उदाहरण देखें:

<a>value</a>

अगर एक्सएमएल से JSON के उदाहरण में बताए गए तरीके से दोनों एट्रिब्यूट (OutputPrefix और OutputSuffix) की वैल्यू दी जाती है, तो JSON का यह स्ट्रक्चर जनरेट होता है:

PREFIX_{
    "a": "value"
}_SUFFIX

अगर सिर्फ़ OutputPrefix दिया गया है, तो यह JSON स्ट्रक्चर जनरेट होता है:

PREFIX_{
  "a" : "value"
}

अगर सिर्फ़ OutputSuffix दिया गया है, तो यह JSON स्ट्रक्चर जनरेट होता है:

{
  "a" : "value"
}_SUFFIX

अगर न तो OutputPrefix और न ही OutputSuffix बताया गया है, तो यह JSON स्ट्रक्चर जनरेट होता है:

{
    "a": "value"
}

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

<Options>
    <StripLevels>4</StripLevels>
</Options>

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

<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/Schemata-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <soap:Body>
      <GetCityWeatherByZIPResponse xmlns="http://ws.cdyne.com/WeatherWS/">
          <GetCityWeatherByZIPResult>
              <State>CO</State>
              <City>Denver</City>
              <Description>Sunny</Description>
              <Temperature>62</Temperature>
          </GetCityWeatherByZIPResult>
      </GetCityWeatherByZIPResponse>
  </soap:Body>
</soap:Envelope>

राज्य, शहर, जानकारी, और तापमान के लेवल पर पहुंचने से पहले, चार लेवल होते हैं. <StripLevels> का इस्तेमाल किए बिना, बदला गया JSON जवाब ऐसा दिखेगा:

{
   "Envelope" : {
      "Body" : {
         "GetCityWeatherByZIPResponse" : {
            "GetCityWeatherByZIPResult" : {
               "State" : "CO",
               "City" : "Denver",
               "Description" : "Sunny",
               "Temperature" : "62"
            }
         }
      }
   }
}

अगर आपको JSON रिस्पॉन्स में मौजूद पहले चार लेवल हटाने हैं, तो <StripLevels>4</StripLevels> सेट करें. इससे आपको यह JSON मिलेगा:

{
  "State" : "CO",
  "City" : "Denver",
  "Description" : "Sunny",
  "Temperature" : "62"
}

आपके पास उन सभी लेवल को हटाने का विकल्प होता है जिनमें एक से ज़्यादा चाइल्ड एलिमेंट मौजूद हैं. इसका क्या मतलब है? आइए, JSON का एक ज़्यादा मुश्किल उदाहरण देखते हैं:

{
   "Envelope" : {
      "Body" : {
         "GetCityForecastByZIPResponse" : {
            "GetCityForecastByZIPResult" : {
               "ResponseText" : "City Found",
               "ForecastResult" : {
                  "Forecast" : [
                     {
                        "ProbabilityOfPrecipiation" : {
                           "Nighttime" : "00",
                           "Daytime" : 10
                        }  ...

इस उदाहरण में लेवल 3, GetCityForecastByZIPResponse है. इसमें सिर्फ़ एक चाइल्ड है. इसलिए, अगर आपको <StripLevels>3</StripLevels> (पहले तीन लेवल हटाना) का इस्तेमाल करना है, तो JSON इस तरह दिखेगा:

{
   "GetCityForecastByZIPResult" : {
      "ResponseText" : "City Found",
      "ForecastResult" : {
         "Forecast" : [
            {
               "ProbabilityOfPrecipiation" : {
                  "Nighttime" : "00",
                  "Daytime" : 10
               }  ...

ध्यान दें कि GetCityForecastByZIPResult के एक से ज़्यादा चाइल्ड खाते हैं. यह कई चाइल्ड एलीमेंट वाला पहला एलीमेंट है. इसलिए, <StripLevels>4</StripLevels> का इस्तेमाल करके इस आखिरी लेवल को हटाया जा सकता है. इससे आपको यह JSON मिलेगा:

{
   "ResponseText" : "City Found",
   "ForecastResult" : {
      "Forecast" : [
         {
            "ProbabilityOfPrecipiation" : {
               "Nighttime" : "00",
               "Daytime" : 10
            }  ...

लेवल 4 पहला ऐसा लेवल है जिसमें एक से ज़्यादा चाइल्ड शामिल हैं. इसलिए, इससे नीचे के किसी भी लेवल को हटाया नहीं जा सकता. स्ट्रिप लेवल को 5, 6, 7 वगैरह पर सेट करने पर, आपको ऊपर दिया गया जवाब मिलता रहेगा.

<Options>/<TreatAsArray>/<Path> एलिमेंट

<Options>
    <TreatAsArray>
        <Path unwrap="true">teachers/teacher/studentnames/name</Path>
    </TreatAsArray>
</Options>

इस एलिमेंट कॉम्बिनेशन की मदद से, यह पक्का किया जा सकता है कि एक्सएमएल दस्तावेज़ की वैल्यू को JSON ऐरे में रखा गया हो. यह तब काम आता है, जब चाइल्ड एलिमेंट की संख्या एक से ज़्यादा हो सकती है. साथ ही, आपको यह पक्का करना हो कि वैल्यू हमेशा ऐरे में हों. ऐसा करने से, आपका कोड स्थिर रहता है. इसकी वजह यह है कि आपको हर बार ऐरे से एक ही तरीके से डेटा मिल सकता है. उदाहरण के लिए: $.teachers.teacher.studentnames[0], कलेक्शन में मौजूद वैल्यू की संख्या से कोई फ़र्क़ नहीं पड़ता. यह कलेक्शन में मौजूद छात्र का पहला नाम दिखाता है.

आइए, एक बार फिर से XML से JSON में बदलने की डिफ़ॉल्ट सेटिंग पर नज़र डालते हैं. इसके बाद, यह जानते हैं कि <TreatAsArray>/<Path> का इस्तेमाल करके आउटपुट को कैसे कंट्रोल किया जा सकता है.

जब किसी एक्सएमएल दस्तावेज़ में, एक ऐसा एलिमेंट होता है जिसकी कई चाइल्ड वैल्यू होती हैं (आम तौर पर, यह किसी ऐसे स्कीमा पर आधारित होता है जहां एलिमेंट का maxOccurs='unbounded'), तो XML to JSON नीति उन वैल्यू को अपने-आप एक ऐरे में डाल देती है. उदाहरण के लिए, यह एक्सएमएल ब्लॉक

<teacher>
    <name>teacherA</name>
    <studentnames>
        <name>student1</name>
        <name>student2</name>
    </studentnames>
</teacher>

...को बिना किसी खास नीति कॉन्फ़िगरेशन के, अपने-आप इस JSON में बदल दिया जाता है:

{
  "teachers" : {
      "teacher" : {
          "name" : "teacherA",
          "studentnames" : {
              "name" : [
                 "student1",
                 "student2"
              ]}
           }
      }
}

ध्यान दें कि छात्र-छात्राओं के दोनों नाम एक ऐरे में रखे गए हैं.

हालांकि, अगर एक्सएमएल दस्तावेज़ में सिर्फ़ एक छात्र या छात्रा दिखता है, तो एक्सएमएल से JSON में बदलने की नीति, वैल्यू को अपने-आप एक स्ट्रिंग के तौर पर मानती है, न कि स्ट्रिंग के ऐरे के तौर पर. इसे यहां दिए गए उदाहरण में दिखाया गया है:

{
  "teachers" : {
      "teacher" : {
          "name" : "teacherA",
          "studentnames" : {
              "name" : "student1"
              }
          }
      }
}

पिछले उदाहरणों में, एक जैसे डेटा को अलग-अलग तरीके से बदला गया था. एक बार इसे ऐरे के तौर पर और दूसरी बार इसे एक स्ट्रिंग के तौर पर बदला गया था. यहाँ <TreatAsArray>/<Path> एलिमेंट की मदद से, आउटपुट को कंट्रोल किया जा सकता है. उदाहरण के लिए, यह पक्का किया जा सकता है कि छात्र-छात्राओं के नाम हमेशा एक ऐरे में रखे जाएं. भले ही, सिर्फ़ एक वैल्यू हो. इसे कॉन्फ़िगर करने के लिए, उस एलिमेंट का पाथ तय करें जिसकी वैल्यू को आपको इस तरह ऐरे में डालना है:

<Options>
    <TreatAsArray>
        <Path>teachers/teacher/studentnames/name</Path>
    </TreatAsArray>
</Options>

ऊपर दिया गया कॉन्फ़िगरेशन, JSON को इस तरह लिखेगा:

{
  "teachers" : {
      "teacher" : {
          "name" : "teacherA",
          "studentnames" : {
              "name" : ["student1"]
              }
            ]
          }
      }
}

ध्यान दें कि student1 अब एक ऐरे में है. अब, छात्र-छात्राओं की संख्या एक हो या एक से ज़्यादा, उन्हें अपने कोड में JSON कलेक्शन से वापस पाया जा सकता है. इसके लिए, यहां दिया गया JSONPath इस्तेमाल करें: $.teachers.teacher.studentnames.name[0]

<Path> एलिमेंट में unwrap एट्रिब्यूट भी होता है. इसके बारे में अगले सेक्शन में बताया गया है.

विशेषताएं

 <Options>
    <TreatAsArray>
        <Path unwrap="true">teachers/teacher/studentnames/name</Path>
    </TreatAsArray>
</Options>

{
  "teachers" : {
      "teacher" : {
          "name" : "teacherA",
          "studentnames" : {
              "name" : [
                 "student1",
                 "student2"
              ]}...

<TreatAsArray>
    <Path unwrap="true">teachers/teacher</Path>
    <Path unwrap="true">teachers/teacher/studentnames/name</Path>
</TreatAsArray>

{
  "teachers" : [{
      "name" : "teacherA",
      "studentnames" : ["student1","student2"]
      }]...

ज़्यादा उदाहरणों और सुविधा के बारे में पूरी जानकारी के लिए, Apigee कम्यूनिटी का यह लेख पढ़ें: Community tutorial: The TreatAsArray option in the XML to JSON policy.

<Format>

फ़ॉर्मैट की मदद से, XML को JSON में बदलने की प्रोसेस को कंट्रोल किया जा सकता है. पहले से तय किए गए किसी ऐसे टेंप्लेट का नाम डालें जिसमें इस विषय में बताए गए विकल्पों के एलिमेंट का कोई खास कॉम्बिनेशन शामिल हो. पहले से तय किए गए फ़ॉर्मैट में ये शामिल हैं: xml.com, yahoo, google, badgerFish.

<Format> एलिमेंट या <Options> ग्रुप का इस्तेमाल करें. <Format> और <Options>, दोनों का इस्तेमाल नहीं किया जा सकता.

यहां पहले से तय किए गए हर टेंप्लेट के फ़ॉर्मैट की परिभाषाएं दी गई हैं.

xml.com

<RecognizeNull>true</RecognizeNull>
<TextNodeName>#text</TextNodeName>
<AttributePrefix>@</AttributePrefix>

yahoo

<RecognizeNumber>true</RecognizeNumber>
<TextNodeName>content</TextNodeName>

google

<TextNodeName>$t</TextNodeName>
<NamespaceSeparator>$</NamespaceSeparator>
<TextAlwaysAsProperty>true</TextAlwaysAsProperty>

badgerFish

<TextNodeName>$</TextNodeName>
<TextAlwaysAsProperty>true</TextAlwaysAsProperty>
<AttributePrefix>@</AttributePrefix>
<NamespaceSeparator>:</NamespaceSeparator>
<NamespaceBlockName>@xmlns</NamespaceBlockName>
<DefaultNamespaceNodeName>$</DefaultNamespaceNodeName>

तत्व का सिंटैक्स:

<Format>yahoo</Format>

स्कीमा

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

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

These errors can occur when you deploy a proxy containing this policy.

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": "XMLToJSON[XMLtoJSON-1]: Source xyz is not available",
    "detail": {
      "errorcode": "steps.xml2json.SourceUnavailable"
    }
  }
}

Example fault rule

<faultrule name="VariableOfNonMsgType"></faultrule><FaultRule name="XML to JSON Faults">
    <Step>
        <Name>AM-SourceUnavailableMessage</Name>
        <Condition>(fault.name Matches "SourceUnavailable") </Condition>
    </Step>
    <Step>
        <Name>AM-BadXML</Name>
        <Condition>(fault.name = "ExecutionFailed")</Condition>
    </Step>
    <Condition>(xmltojson.XMLtoJSON-1.failed = true) </Condition>
</FaultRule>

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

JSON से XML: JSON से XML नीति