XMLtoJSON नीति

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

क्या

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

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

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

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

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

सैंपल

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

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

The following table describes attributes that are common to all policy parent elements:

<DisplayName> element

Use in addition to the name attribute to label the policy in the management UI proxy editor with a different, natural-language name.

<DisplayName>Policy Display Name</DisplayName>

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

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

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

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

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

<Source>response</Source>

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

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

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

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

<OutputVariable>response</OutputVariable>

&lt;Options&gt;

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

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

&lt;Options&gt;/&lt;RecognizeNumber&gt; एलिमेंट

अगर सही है, तो एक्सएमएल पेलोड में नंबर फ़ील्ड अपना मूल फ़ॉर्मैट बनाए रखते हैं.

<RecognizeNumber>true</RecognizeNumber>

एक्सएमएल के इस उदाहरण पर गौर करें:

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

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

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

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

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

&lt;Options&gt;/&lt;RecognizeBoolean&gt; एलिमेंट

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

<RecognizeBoolean>true</RecognizeBoolean>

एक्सएमएल के इस उदाहरण के लिए:

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

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

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

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

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

&lt;Options&gt;/&lt;RecognizeNull&gt; एलिमेंट

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

<RecognizeNull>true</RecognizeNull>

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

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

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

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

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

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

&lt;Options&gt;/&lt;NullValue&gt; एलिमेंट

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

<NullValue>not-present</NullValue>

&lt;Options&gt;/&lt;NamespaceBlockName&gt;
&lt;Options&gt;/&lt;DefaultNamespaceNodeName&gt;
&lt;Options&gt;/&lt;NamespaceSeparator&gt; एलिमेंट

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

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

&lt;Options&gt;/&lt;TextAlwaysAsProperty&gt;
&lt;Options&gt;/&lt;TextNodeName&gt; एलिमेंट

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

अगर इसे 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",
      }
    }
}

&lt;Options&gt;/&lt;AttributeBlockName&gt;
&lt;Options&gt;/&lt;AttributePrefix&gt; एलिमेंट

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

इसकी मदद से, वैल्यू को 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"
    }
}

&lt;Options&gt;/&lt;OutputPrefix&gt;
&lt;Options&gt;/&lt;OutputSuffix&gt; एलिमेंट

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

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

एक्सएमएल के इस उदाहरण पर गौर करें:

<a>value</a>

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

PREFIX_{
    "a": "value"
}_SUFFIX

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

PREFIX_{
  "a" : "value"
}

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

{
  "a" : "value"
}_SUFFIX

अगर OutputPrefix या OutputSuffix में से कोई भी नहीं बताया गया है, तो ये JSON का स्ट्रक्चर जनरेट हुआ है:

{
    "a": "value"
}

&lt;Options&gt;/&lt;StripLevels&gt; एलिमेंट

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

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

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

इस उदाहरण में तीसरा लेवल 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 वगैरह पर सेट किया जाता है, तो आपको ऊपर दिया गया जवाब देखें.

&lt;Options&gt;/&lt;TreatAsArray&gt;/&lt;Path&gt; एलिमेंट

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

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

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

जब किसी एक्सएमएल दस्तावेज़ में कई चाइल्ड वैल्यू (आम तौर पर स्कीमा पर आधारित) वाले एलिमेंट होते हैं जहां एलिमेंट का maxOccurs='unbounded'), एक्सएमएल से 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"]
              }
            ]
          }
      }
}

ध्यान दें कि छात्र1 अब एक श्रेणी में है. अब, चाहे एक से ज़्यादा छात्र-छात्राएं, तो आप नीचे दिए गए JSONPath का इस्तेमाल करके अपने कोड में JSON अरे से उन्हें वापस ला सकते हैं: $.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 कम्यूनिटी का यह लेख पढ़ें: https://community.apigee.com/content/kbentry/33374/new-edge-minifeature-the-treatasarray-option-in-th.html.

&lt;Format&gt;

फ़ॉर्मैट की मदद से, एक्सएमएल से 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 से एक्सएमएल: JSON से XML नीति