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>
यह कॉन्फ़िगरेशन, एक्सएमएल को JSON में बदलने के लिए ज़रूरी सबसे छोटा कॉन्फ़िगरेशन है. इसके बाद, यह एक्सएमएल फ़ॉर्मैट वाले रिस्पॉन्स मैसेज को सोर्स के तौर पर इस्तेमाल करता है. इसके बाद, JSON फ़ॉर्मैट वाला एक मैसेज बनाता है, जो response
आउटपुट वैरिएबल में अपने-आप भरा जाता है. Edge
इस वैरिएबल के कॉन्टेंट को अपने-आप मैसेज के तौर पर इस्तेमाल करता है, ताकि प्रोसेस करने के अगले चरण में उसे मिले.
एलिमेंट का रेफ़रंस
यहां ऐसे एलिमेंट और एट्रिब्यूट दिए गए हैं जिन्हें इस नीति पर कॉन्फ़िगर किया जा सकता है.
<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">
इस टेबल में उन एट्रिब्यूट के बारे में बताया गया है जो नीति के सभी पैरंट एलिमेंट के लिए एक जैसे होते हैं:
एट्रिब्यूट | ब्यौरा | डिफ़ॉल्ट | मौजूदगी |
---|---|---|---|
name |
नीति का अंदरूनी नाम. इसके अलावा, मैनेजमेंट यूज़र इंटरफ़ेस (यूआई) प्रॉक्सी एडिटर में नीति को आम भाषा में अलग नाम से लेबल करने के लिए, |
लागू नहीं | ज़रूरी है |
continueOnError |
इस नीति को किसी नीति के काम न करने पर भी फ़्लो एक्ज़ीक्यूट करने की प्रोसेस को जारी रखने के लिए, |
false | ज़रूरी नहीं |
enabled |
नीति लागू करने के लिए, नीति को बंद करने के लिए, |
सही | ज़रूरी नहीं |
async |
यह एट्रिब्यूट अब काम नहीं करता. |
false | बहिष्कृत |
<DisplayName> एलिमेंट
मैनेजमेंट यूज़र इंटरफ़ेस (यूआई) प्रॉक्सी एडिटर में, आम भाषा के अलग नाम से नीति को लेबल करने के लिए, name
एट्रिब्यूट का इस्तेमाल करें.
<DisplayName>Policy Display Name</DisplayName>
डिफ़ॉल्ट |
लागू नहीं अगर इस एलिमेंट को छोड़ दिया जाता है, तो नीति के |
---|---|
मौजूदगी | ज़रूरी नहीं |
Type | String |
<सोर्स> एलिमेंट
वह वैरिएबल, अनुरोध या रिस्पॉन्स, जिसमें वह एक्सएमएल मैसेज शामिल होता है जिसे आपको JSON में बदलना है.
सोर्स मैसेज के एचटीटीपी कॉन्टेंट-टाइप हेडर को
application/xml
पर सेट किया जाना चाहिए. ऐसा न होने पर, नीति लागू नहीं होती.
अगर <Source>
की जानकारी नहीं दी गई है, तो इसे मैसेज माना जाता है. इसका मतलब है कि जब नीति के किसी अनुरोध फ़्लो से अटैच हो जाता है, तब अनुरोध किया जाता है या जब नीति के किसी रिस्पॉन्स फ़्लो से अटैच किया जाता है, तब अनुरोध किया जाता है.
अगर सोर्स वैरिएबल को हल नहीं किया जा सकता या यह बिना मैसेज वाले टाइप में बदल जाता है, तो नीति गड़बड़ी दिखाती है.
<Source>response</Source>
डिफ़ॉल्ट | एपीआई प्रॉक्सी फ़्लो में नीति को कहां जोड़ा गया है, इसके आधार पर अनुरोध या रिस्पॉन्स तय किया जाता है |
मौजूदगी | ज़रूरी नहीं |
स्ट्रीम किस तरह की है | ग्राहक का मैसेज |
<आउटपुट वैरिएबल> एलिमेंट
एक्सएमएल के आउटपुट को JSON फ़ॉर्मैट में होने वाले कन्वर्ज़न में स्टोर करता है. यह आम तौर पर, सोर्स की वैल्यू के बराबर होती है. आम तौर पर, एक्सएमएल रिस्पॉन्स को JSON रिस्पॉन्स में बदल दिया जाता है.
एक्सएमएल मैसेज के पेलोड को पार्स करके JSON में बदला जाता है. साथ ही, एक्सएमएल फ़ॉर्मैट वाले मैसेज के एचटीटीपी कॉन्टेंट-टाइप हेडर को application/json
पर सेट किया जाता है.
अगर OutputVariable
के बारे में नहीं बताया गया है, तो source
को
OutputVariable
माना जाता है. उदाहरण के लिए, अगर source
की वैल्यू response
है, तो OutputVariable
की डिफ़ॉल्ट वैल्यू response
होगी.
<OutputVariable>response</OutputVariable>
डिफ़ॉल्ट | एपीआई प्रॉक्सी फ़्लो में नीति को कहां जोड़ा गया है, इसके आधार पर अनुरोध या रिस्पॉन्स तय किया जाता है |
मौजूदगी | यह एलिमेंट तब ज़रूरी है, जब <Source> एलिमेंट में तय किया गया वैरिएबल, टाइप स्ट्रिंग का हो. |
स्ट्रीम किस तरह की है | ग्राहक का मैसेज |
<विकल्प>
विकल्पों से, आपको एक्सएमएल से 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" } }
डिफ़ॉल्ट | false |
मौजूदगी | ज़रूरी नहीं |
स्ट्रीम किस तरह की है | बूलियन |
<विकल्प>/<RecognizeBoolean> एलिमेंट
इसकी मदद से, वैल्यू को स्ट्रिंग में बदलने के बजाय, कन्वर्ज़न की सही/गलत वैल्यू को बनाए रखने में मदद मिलती है.
<RecognizeBoolean>true</RecognizeBoolean>
यहां दिए गए एक्सएमएल के उदाहरण के लिए:
<a> <b>true</b> <c>value</c> </a>
true
होने पर, यह इसमें बदल जाता है:
{ "a": { "b": true, "c": "value" } }
false
होने पर, यह इसमें बदल जाता है:
{ "a": { "b": "true", "c": "value" } }
डिफ़ॉल्ट | false |
मौजूदगी | ज़रूरी नहीं |
स्ट्रीम किस तरह की है | बूलियन |
<Options>/<RecognizeNull> एलिमेंट
खाली वैल्यू को शून्य वैल्यू में बदला जा सकता है.
<RecognizeNull>true</RecognizeNull>
यहां दिए गए एक्सएमएल के लिए:
<a> <b></b> <c>value</c> </a>
true
होने पर, यह इसमें बदल जाता है:
{ "a": { "b": null, "c": "value" } }
false
होने पर, यह इसमें बदल जाता है:
{ "a": { "b": {}, "c": "value" } }
डिफ़ॉल्ट | false |
मौजूदगी | ज़रूरी नहीं |
स्ट्रीम किस तरह की है | बूलियन |
<विकल्प>/<NullValue> एलिमेंट
यह उस वैल्यू के बारे में बताता है जिसमें सोर्स मैसेज की मान्य शून्य वैल्यू
बदली जानी चाहिए. डिफ़ॉल्ट तौर पर, यह वैल्यू null
होती है. यह विकल्प सिर्फ़ तब लागू होता है,
जब RecognizeNull
सही हो.
<NullValue>not-present</NullValue>
डिफ़ॉल्ट | null |
मौजूदगी | ज़रूरी नहीं |
स्ट्रीम किस तरह की है | String |
<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" } }
डिफ़ॉल्ट | ऊपर दिए गए उदाहरण देखें. |
मौजूदगी | ज़रूरी नहीं हालांकि, अगर <NamespaceBlockName> की जानकारी दी जाती है, तो आपको अन्य दो एलिमेंट की भी जानकारी देनी होगी. |
स्ट्रीम किस तरह की है | स्ट्रिंग |
<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", } } }
डिफ़ॉल्ट | <TextAlwaysAsProperty> : गलत<TextNodeName> : लागू नहीं |
मौजूदगी | ज़रूरी नहीं |
स्ट्रीम किस तरह की है | <TextAlwaysAsProperty> : बूलियन<TextNodeName> : स्ट्रिंग |
<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" } }
डिफ़ॉल्ट | ऊपर दिए गए उदाहरण देखें. |
मौजूदगी | ज़रूरी नहीं |
स्ट्रीम किस तरह की है | String |
<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" }
डिफ़ॉल्ट | ऊपर उदाहरण देखें. |
मौजूदगी | ज़रूरी नहीं |
स्ट्रीम किस तरह की है | String |
<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 वगैरह पर सेट किया है, तो आपको ऊपर दिए गए जवाब मिलते रहेंगे.
डिफ़ॉल्ट | 0 (कोई लेवल स्ट्रिपिंग नहीं) |
मौजूदगी | ज़रूरी नहीं |
स्ट्रीम किस तरह की है | Integer |
<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
एट्रिब्यूट भी होता है, जिसके बारे में
अगले सेक्शन में बताया गया है.
डिफ़ॉल्ट | लागू नहीं |
मौजूदगी | ज़रूरी नहीं |
स्ट्रीम किस तरह की है | String |
एट्रिब्यूट
<Options> <TreatAsArray> <Path unwrap="true">teachers/teacher/studentnames/name</Path> </TreatAsArray> </Options>
एट्रिब्यूट | ब्यौरा | मौजूदगी | Type |
---|---|---|---|
अनरैप करें |
डिफ़ॉल्ट: false JSON आउटपुट से एलिमेंट हटाता है. JSON को स्ट्रीमलाइन या फ़्लैट ("अनरैप") करने के लिए इसका इस्तेमाल करें, जो वैल्यू पाने के लिए ज़रूरी JSONPath को भी छोटा कर देता है. उदाहरण के लिए, यहां JSON का एक उदाहरण दिया गया है: { "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>
<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>
डिफ़ॉल्ट | उपलब्ध फ़ॉर्मैट का नाम डालें:xml.com , yahoo , google , badgerFish |
मौजूदगी | अगर <Options> का इस्तेमाल नहीं किया जा रहा है, तो इसे भरना ज़रूरी है. |
स्ट्रीम किस तरह की है | String |
स्कीमा
गड़बड़ी का रेफ़रंस
यह सेक्शन गड़बड़ी के कोड और दिखाए गए गड़बड़ी के मैसेज के बारे में बताता है. साथ ही, इस नीति के ट्रिगर होने पर Edge की मदद से सेट की गई गड़बड़ी के वैरिएबल के बारे में बताता है. यह जानकारी जानना ज़रूरी है कि क्या गड़बड़ियों को ठीक करने के लिए, गड़बड़ी से जुड़े नियम बनाए जा रहे हैं. ज़्यादा जानने के लिए, नीति से जुड़ी गड़बड़ियों के बारे में आपके लिए ज़रूरी जानकारी और गड़बड़ियों को ठीक करने के तरीके देखें.
रनटाइम से जुड़ी गड़बड़ियां
नीति के लागू होने पर ये गड़बड़ियां हो सकती हैं.
गड़बड़ी का कोड | एचटीटीपी कोड स्थिति | वजह | समाधान |
---|---|---|---|
steps.xmltojson.ExecutionFailed |
500 | यह गड़बड़ी तब होती है, जब इनपुट पेलोड (एक्सएमएल) खाली हो या इनपुट एक्सएमएल अमान्य हो या गलत हो. | build |
steps.xmltojson.InCompatibleType |
500 | यह गड़बड़ी तब होती है, जब <Source> एलिमेंट में बताए गए वैरिएबल और <OutputVariable> एलिमेंट में फ़र्क़ होता है. यह ज़रूरी है कि <Source> एलिमेंट और <OutputVariable> एलिमेंट में शामिल वैरिएबल के टाइप आपस में मेल खाते हों.
|
build |
steps.xmltojson.InvalidSourceType |
500 | यह गड़बड़ी तब होती है, जब <Source> एलिमेंट को तय करने के लिए इस्तेमाल किए गए वैरिएबल का टाइप
अमान्य हो.मैसेज और स्ट्रिंग, मान्य वैरिएबल के तौर पर इस्तेमाल किए जाते हैं. |
build |
steps.xmltojson.OutputVariableIsNotAvailable |
500 | यह गड़बड़ी तब होती है, जब एक्सएमएल से JSON नीति के <Source> एलिमेंट में बताया गया वैरिएबल, स्ट्रिंग टाइप का हो और <OutputVariable> एलिमेंट तय न किया गया हो.
<OutputVariable> एलिमेंट तब ज़रूरी होता है, जब <Source> एलिमेंट में तय किया गया वैरिएबल, टाइप स्ट्रिंग का हो. |
build |
steps.xmltojson.SourceUnavailable |
500 |
यह गड़बड़ी तब होती है, जब एक्सएमएल से JSON नीति के <Source> एलिमेंट में बताया गया message वैरिएबल, इनमें से कोई एक हो:
|
build |
डिप्लॉयमेंट से जुड़ी गड़बड़ियां
ये गड़बड़ियां तब हो सकती हैं, जब इस नीति वाले किसी प्रॉक्सी को डिप्लॉय किया जाता है.
गड़बड़ी का नाम | वजह | समाधान |
---|---|---|
EitherOptionOrFormat |
अगर एक्सएमएल में JSON नीति में किसी एलिमेंट <Options> या <Format> के बारे में
जानकारी नहीं दी गई है, तो एपीआई प्रॉक्सी को डिप्लॉय नहीं किया जा सकता.
|
build |
UnknownFormat |
अगर एक्सएमएल से JSON नीति में <Format> एलिमेंट का फ़ॉर्मैट अज्ञात है, तो एपीआई प्रॉक्सी को डिप्लॉय नहीं किया जा सकता. पहले से तय किए गए फ़ॉर्मैट में ये शामिल हैं:
xml.com , yahoo , google , और badgerFish .
|
build |
गड़बड़ी वाले वैरिएबल
रनटाइम में कोई गड़बड़ी होने पर ये वैरिएबल सेट किए जाते हैं. ज़्यादा जानकारी के लिए, नीति से जुड़ी गड़बड़ियों के बारे में आपके लिए ज़रूरी जानकारी देखें.
वैरिएबल | जगह | उदाहरण |
---|---|---|
fault.name="fault_name" |
fault_name, गड़बड़ी का नाम है, जैसा कि ऊपर रनटाइम की गड़बड़ियां टेबल में दिया गया है. गड़बड़ी का नाम, गड़बड़ी के कोड का आखिरी हिस्सा होता है. | fault.name = "SourceUnavailable" |
xmltojson.policy_name.failed |
policy_name, उस नीति का उपयोगकर्ता तय किया गया नाम है जिसकी वजह से गड़बड़ी हुई है. | xmltojson.XMLtoJSON-1.failed = true |
गड़बड़ी के जवाब का उदाहरण
{ "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 से एक्सएमएल की नीति