XMLtoJSON नीति

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

यह क्या है

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

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

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

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

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

सैंपल

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

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

<DisplayName> एलिमेंट

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

<DisplayName>Policy Display Name</DisplayName>

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

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

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

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

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

<Source>response</Source>

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

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

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

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

<OutputVariable>response</OutputVariable>

<विकल्प>

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

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

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

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

<RecognizeNumber>true</RecognizeNumber>

एक्सएमएल के इस उदाहरण पर ध्यान दें:

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

true होने पर, यह इसमें बदल जाता है:

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

false होने पर, यह इसमें बदल जाता है:

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

<विकल्प>/<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"
  }
}

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

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

<NullValue>not-present</NullValue>

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

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

<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>/<OUTPrefix>
<Options>/<OUTSuffix> एलिमेंट

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

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

कभी-कभी एक्सएमएल पेलोड में, ऐसे कई पैरंट लेवल होते हैं जिन्हें आपको बदले गए 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
            }  ...

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

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

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

ध्यान दें कि Scholar1 अब कैटगरी में है. अब, इस बात से कोई फ़र्क़ नहीं पड़ता कि छात्र-छात्राएं एक हैं या एक से ज़्यादा छात्र-छात्राएं, नीचे दिए गए 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.

<फ़ॉर्मैट>

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

स्कीमा

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

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

रनटाइम से जुड़ी गड़बड़ियां

नीति के लागू होने पर ये गड़बड़ियां हो सकती हैं.

डिप्लॉयमेंट से जुड़ी गड़बड़ियां

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

गड़बड़ी वाले वैरिएबल

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

गड़बड़ी के जवाब का उदाहरण

{
  "fault": {
    "faultstring": "XMLToJSON[XMLtoJSON-1]: Source xyz is not available",
    "detail": {
      "errorcode": "steps.xml2json.SourceUnavailable"
    }
  }
}

गड़बड़ी के नियम का उदाहरण

<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 से एक्सएमएल की नीति