निकालें वैरिएबल नीति

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

यह क्या है

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

आम तौर पर, इस नीति का इस्तेमाल किसी अनुरोध या रिस्पॉन्स मैसेज से जानकारी निकालने के लिए किया जाता है. हालांकि, इसका इस्तेमाल अन्य सोर्स से जानकारी लेने के लिए भी किया जा सकता है. इसमें AccessEntity नीति से बनाई गई इकाइयां, एक्सएमएल ऑब्जेक्ट या JSON ऑब्जेक्ट शामिल हैं.

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

वीडियो

ExtractVariables की नीति के बारे में ज़्यादा जानने के लिए, नीचे दिए गए वीडियो देखें.

सैंपल

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

<ExtractVariables name="ExtractVariables-1">
   <DisplayName>Extract a portion of the url path</DisplayName>
   <Source>request</Source>
   <URIPath>
      <Pattern ignoreCase="true">/accounts/{id}</Pattern>
   </URIPath>
   <VariablePrefix>urirequest</VariablePrefix>
   <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
</ExtractVariables>

<AssignMessage async="false" continueOnError="false" enabled="true" name="AssignPayload">
 <DisplayName>AssignPayload</DisplayName>
  <Set>
   <Payload contentType="text/xml">
    <IdExtractedFromURI>{urirequest.id}</IdExtractedFromURI>
   </Payload>
  </Set>
  <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
  <AssignTo createNew="true" transport="http" type="request">newRequest</AssignTo>
</AssignMessage>

<ExtractVariables name="ExtractVariables-2">
   <DisplayName>Extract a value from a query parameter</DisplayName>
   <Source>request</Source>
   <QueryParam name="code">
      <Pattern ignoreCase="true">DBN{dbncode}</Pattern>
   </QueryParam>
   <VariablePrefix>queryinfo</VariablePrefix>
   <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
</ExtractVariables>

<AssignMessage async="false" continueOnError="false" enabled="true" name="GetURIPath">
 <DisplayName>GetQP</DisplayName>
  <Set>
   <Payload contentType="text/xml">
    <ExtractQP>{queryinfo.dbncode}</ExtractQP>
   </Payload>
  </Set>
  <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
  <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>

<ExtractVariables name="ExtractVariables-2">
   <DisplayName>Extract a value from a query parameter</DisplayName>
   <Source>request</Source>
   <QueryParam name="w">
      <Pattern ignoreCase="true">{firstWeather}</Pattern>
   </QueryParam>
   <QueryParam name="w.2">
     <Pattern ignoreCase="true">{secondWeather}</Pattern>
   </QueryParam>
   <VariablePrefix>queryinfo</VariablePrefix>
 <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
</ExtractVariables>

<AssignMessage async="false" continueOnError="false" enabled="true" name="GetURIPath">
 <DisplayName>GetQP</DisplayName>
  <Set>
   <Payload contentType="text/xml">
    <ExtractQP1>{queryinfo.firstWeather}</ExtractQP1>
    <ExtractQP2>{queryinfo.secondWeather}</ExtractQP2>
   </Payload>
  </Set>
  <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
  <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>

<ExtractVariables name='ExtractVariable-OauthToken'>
  <Source>request</Source>
  <Header name="Authorization">
    <Pattern ignoreCase="false">Bearer {oauthtoken}</Pattern>
  </Header>
  <VariablePrefix>clientrequest</VariablePrefix>
  <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
</ExtractVariables>

<AssignMessage async="false" continueOnError="false" enabled="true" name="GetURIPath">
 <DisplayName>GetHeader</DisplayName>
  <Set>
   <Payload contentType="text/xml">
    <ExtractHeader>{clientrequest.oauthtoken}</ExtractHeader>
   </Payload>
  </Set>
  <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
  <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>

<ExtractVariables name="ExtractVariables-3">
   <Source>response</Source>
   <JSONPayload>
      <Variable name="latitude" type="float">
         <JSONPath>$.results[0].geometry.location.lat</JSONPath>
      </Variable>
      <Variable name="longitude" type="float">
         <JSONPath>$.results[0].geometry.location.lng</JSONPath>
      </Variable>
   </JSONPayload>
   <VariablePrefix>geocoderesponse</VariablePrefix>
</ExtractVariables>

{
  "results": [{
    "geometry": {
      "location": {
        "lat": 37.42291810,
        "lng": -122.08542120
      },
      "location_type": "ROOFTOP",
      "viewport": {
        "northeast": {
          "lat": 37.42426708029149,
          "lng": -122.0840722197085
        },
        "southwest": {
          "lat": 37.42156911970850,
          "lng": -122.0867701802915
        }
      }
    }
  }]
}

<AssignMessage async="false" continueOnError="false" enabled="true" name="GetURIPath">
  <DisplayName>GetJSONVar</DisplayName>
  <Add>
    <Headers>
      <Header name="latitude">{geocoderesponse.latitude}</Header>
    </Headers>
  </Add> 
  <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
  <AssignTo createNew="false" transport="http" type="response"/> 
</AssignMessage>

<ExtractVariables name="ExtractVariables-4">
   <Source>response</Source>
   <XMLPayload>
      <Namespaces>
         <Namespace prefix="dir">urn:43BFF88D-D204-4427-B6BA-140AF393142F</Namespace>
      </Namespaces>
      <Variable name="travelmode" type="string">
         <XPath>/dir:Directions/dir:route/dir:leg/dir:step/@mode</XPath>
      </Variable>
      <Variable name="duration" type="string">
         <XPath>/dir:Directions/dir:route/dir:leg/dir:step/dir:duration/dir:value</XPath>
      </Variable>
      <Variable name="timeunit" type="string">
         <XPath>/dir:Directions/dir:route/dir:leg/dir:step/dir:duration/dir:text</XPath>
      </Variable>
   </XMLPayload>
   <VariablePrefix>directionsresponse</VariablePrefix>
</ExtractVariables>

<Directions xmlns="urn:43BFF88D-D204-4427-B6BA-140AF393142F">
   <status>OK</status>
   <route>
      <summary>I-40 W</summary>
      <leg>
         <step mode="DRIVING">
            <start_location>
               <lat>41.8507300</lat>
               <lng>-87.6512600</lng>
            </start_location>
            <end_location>
               <lat>41.8525800</lat>
               <lng>-87.6514100</lng>
            </end_location>
            <duration>
                <value>19</value>
                <text>minutes</text>
            </duration>
         </step>
      </leg>
   </route>
</Directions>

<AssignMessage async="false" continueOnError="false" enabled="true" name="GetURIPath">
  <DisplayName>GetXMLVar</DisplayName>
  <Add>
    <Headers>
      <Header name="tmode">{directionsresponse.travelmode}</Header>
    </Headers>
  </Add>
  <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
  <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>

ExtractVariables की नीति के बारे में जानकारी

एपीआई डेवलपर, एपीआई प्रॉक्सी बनाते हैं, जो मैसेज के कॉन्टेंट के आधार पर अलग-अलग काम करते हैं. इनमें हेडर, यूआरआई पाथ, पेलोड, और क्वेरी पैरामीटर शामिल हैं. अक्सर, प्रॉक्सी सर्वर इस कॉन्टेंट का कुछ हिस्सा निकाल लेता है, ताकि उसे किसी कंडिशन स्टेटमेंट में इस्तेमाल किया जा सके. ऐसा करने के लिए, ExtractVariables नीति का इस्तेमाल करें.

ExtractVariables नीति को तय करते समय, ये विकल्प चुने जा सकते हैं:

• सेट किए जाने वाले वैरिएबल के नाम
• वैरिएबल का सोर्स
• कितने वैरिएबल एक्सट्रैक्ट करने और सेट करने हैं

लागू किए जाने पर, यह नीति कॉन्टेंट पर एक टेक्स्ट पैटर्न लागू करती है. साथ ही, मिलता-जुलता नतीजा मिलने पर, कॉन्टेंट के साथ तय किए गए वैरिएबल की वैल्यू सेट करती है. इसके बाद, अन्य नीतियां और कोड उन वैरिएबल का इस्तेमाल करके, डाइनैमिक व्यवहार को चालू कर सकते हैं या कारोबार का डेटा Edge API Analytics को भेज सकते हैं.

यह जानने के लिए कि कॉन्टेंट पर आधारित Analytics रिपोर्ट बनाने के लिए, ExtractVariables का इस्तेमाल कैसे किया जा सकता है, कस्टम ऐनलिटिक्स का इस्तेमाल करके एपीआई मैसेज के कॉन्टेंट का विश्लेषण करना लेख पढ़ें.

स्कोप

ExtractVariables नीति के साथ सेट किए गए वैरिएबल का स्कोप ग्लोबल होता है. इसका मतलब है कि जब ExtractVariables नीति किसी नए वैरिएबल के बारे में बताती है, तो उस वैरिएबल को फ़्लो के किसी भी स्टेज में मौजूद किसी भी नीति या कोड से ऐक्सेस किया जा सकता है. यह वैरिएबल, ExtractVariables नीति के बाद लागू होता है. इसमें शामिल है:

• PreFlow: ProxyEndpoint और TargetEndpoint (अनुरोध और जवाब)
• PostFlow: प्रॉक्सीEndpoint और TargetEndpoint (अनुरोध और जवाब)
• PostClientFlow: प्रॉक्सीEndpoint (मैसेज लॉग करने की नीति का इस्तेमाल करके, सिर्फ़ जवाब दिया जा सकता है)
• गड़बड़ी का फ़्लो

मैचिंग और वैरिएबल बनाने के बारे में जानकारी

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

हालांकि, पैटर्न मैचिंग के काम करने का तरीका, एक्सट्रैक्शन के सोर्स पर निर्भर करता है. इन सेक्शन में, जानकारी की उन दो बुनियादी कैटगरी के बारे में बताया गया है जिन्हें एक्सट्रैक्ट किया जा सकता है.

मैच होने वाले यूआरआई पाथ, क्वेरी पैरामीटर, हेडर, फ़ॉर्म पैरामीटर, और वैरिएबल

यूआरआई पाथ, क्वेरी पैरामीटर, हेडर, फ़ॉर्म पैरामीटर, और वैरिएबल से जानकारी निकालते समय, <Pattern> टैग का इस्तेमाल करके, मैच करने के लिए एक या एक से ज़्यादा पैटर्न तय किए जाते हैं. उदाहरण के लिए, नीति के इस उदाहरण में, यूआरआई पाथ से मैच करने वाला एक ही पैटर्न दिखाया गया है:

<ExtractVariables name="ExtractVariables-1">
   <Source>request</Source>
   <URIPath>
      <Pattern ignoreCase="true">/a/{pathSeg}</Pattern>
   </URIPath>
   <VariablePrefix>urirequest</VariablePrefix>
   <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
</ExtractVariables>

इस उदाहरण में, urirequest.pathSeg वैरिएबल को उस पर सेट किया गया है जो प्रॉक्सी.pathsuffix में "/a/" के बाद दिखता है. उदाहरण के लिए, मान लें कि आपके एपीआई प्रॉक्सी का बेस पाथ /basepath/v1 है . http://myCo.com/basepath/v1/a/b के इनबाउंड अनुरोध में वैरिएबल को "b" पर सेट किया गया है.

कई पैटर्न तय करना

आपके पास <Pattern> टैग के मुताबिक, मैच करने के लिए कई पैटर तय करने का विकल्प होता है. यहां:

• सभी पैटर्न को मैच करने के लिए टेस्ट किया जाता है.
• अगर कोई भी पैटर्न मेल नहीं खाता, तो नीति कुछ नहीं करती और वैरिएबल नहीं बनाए जाते.
• अगर एक से ज़्यादा पैटर्न मैच करते हैं, तो सबसे लंबे पाथ सेगमेंट वाले पैटर्न का इस्तेमाल एक्सट्रैक्शन के लिए किया जाता है.
• अगर मैच होने वाले दो पैटर्न में एक जैसे सबसे लंबे पाथ सेगमेंट हैं, तो नीति में पहले बताए गए पैटर्न का इस्तेमाल एक्सट्रैक्शन के लिए किया जाता है.

अगले उदाहरण में, एक ऐसी नीति बनाई गई है जिसमें यूआरआई पाथ से मेल खाने वाले तीन पैटर्न शामिल हैं:

<ExtractVariables name="ExtractVariables-1">
   <Source>request</Source>
   <URIPath>
      <Pattern ignoreCase="true">/a/{pathSeg}</Pattern>
      <Pattern ignoreCase="true">/a/b/{pathSeg}</Pattern>
      <Pattern ignoreCase="true">/a/b/c/{pathSeg}</Pattern>
   </URIPath>
   <VariablePrefix>urirequest</VariablePrefix>
   <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
</ExtractVariables>

मान लें कि /basepath/v1 के बेसपाथ वाले किसी एपीआई प्रॉक्सी के लिए, एपीआई प्रॉक्सी के लिए इनबाउंड अनुरोध यूआरएल इस तरह का होता है:

http://myCo.com/basepath/v1/a/b

इस उदाहरण में, पहला पैटर्न यूआरआई से मेल खाता है और urirequest.pathSeg वैरिएबल "b" पर सेट है.

अगर अनुरोध का यूआरएल यह है:

http://myCo.com/basepath/v1/a/b/c/d

...तो तीसरा पैटर्न मैच करता है और urirequest.pathSeg वैरिएबल "d" पर सेट कर दिया जाता है.

कई वैरिएबल वाले पैटर्न तय करना

आपके पास मैच करने वाले पैटर्न में एक से ज़्यादा वैरिएबल तय करने का विकल्प होता है. उदाहरण के लिए, आपके पास दो वैरिएबल के साथ कोई मैचिंग पैटर्न तय करने का विकल्प होता है:

<ExtractVariables name="ExtractVariables-1">
   <Source>request</Source>
   <URIPath>
      <Pattern ignoreCase="true">/a/{pathSeg}</Pattern>
      <Pattern ignoreCase="true">/a/b/{pathSeg}</Pattern>
      <Pattern ignoreCase="true">/a/{pathSeg1}/c/{pathSeg2}</Pattern>
   </URIPath>
   <VariablePrefix>urirequest</VariablePrefix>
   <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
</ExtractVariables>

इनबाउंड अनुरोध यूआरएल के लिए , /basepath/v1 के बेस पाथ के साथ एपीआई प्रॉक्सी को फिर से लागू करने का तरीका:

http://myCo.com/basepath/v1/a/b/c/d

...urirequest.pathSeg1 वैरिएबल "b" पर और urirequest.pathSeg2 वैरिएबल "d" पर सेट है.

पैटर्न में एक से ज़्यादा इंस्टेंस का मिलान करना

एक ही नाम वाले किसी आइटम के एक से ज़्यादा इंस्टेंस होने पर भी पैटर्न मैच किए जा सकते हैं. उदाहरण के लिए, एक ऐसा अनुरोध किया जा सकता है जिसमें एक से ज़्यादा क्वेरी पैरामीटर या एक ही नाम वाले कई हेडर शामिल हों. नीचे दिए गए अनुरोध में "w" नाम के दो क्वेरी पैरामीटर शामिल हैं:

http://myCo.com/basepath/v1/a/b/c/d?w=1&w=2

ExtractVariables नीति में इन क्वेरी पैरामीटर का रेफ़रंस देने के लिए, आपको इंडेक्स का इस्तेमाल करना होता है. इसमें क्वेरी पैरामीटर के पहले इंस्टेंस में कोई इंडेक्स नहीं है, दूसरा इंडेक्स 2 पर और तीसरा इंडेक्स 3 पर है. उदाहरण के लिए, यह नीति, अनुरोध में "w" नाम के दूसरे क्वेरी पैरामीटर की वैल्यू निकालती है:

<ExtractVariables name="ExtractVariables-1">
   <Source>request</Source>
   <QueryParam name="w.2">
      <Pattern ignoreCase="true">{secondW}</Pattern>
   </QueryParam>
   <VariablePrefix>urirequest</VariablePrefix>
   <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
</ExtractVariables>

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

पैटर्न में खास वर्णों का इस्तेमाल करना

यूआरआई पाथ का मिलान करते समय, पैटर्न में "*" और "**" वाइल्डकार्ड वर्णों का इस्तेमाल किया जा सकता है, जहां:

• "*", पाथ के किसी एक सेगमेंट से मेल खाता है
• "**", पाथ के एक से ज़्यादा सेगमेंट से मेल खाता है

उदाहरण के लिए, <URIPath> एलिमेंट के लिए पैटर्न तय किए जा सकते हैं, जैसा कि नीचे दिखाया गया है:

<URIPath>
  <Pattern ignoreCase="true">/a/*/{id}</Pattern>
  <Pattern ignoreCase="true">/a/**/{id}</Pattern>
</URIPath>

पहला पैटर्न, पाथफ़िक्स (बेसपाथ के बाद आने वाले यूआरआई पाथ का हिस्सा) से मैच करता है, जैसे कि "/a/b/c", "/a/foo/bar" वगैरह. दूसरा पैटर्न "/a/" के बाद, पाथ के किसी भी सेगमेंट से मैच करता है, जैसे कि "/a/foo/bar/baz/c" और "/a/foo/bar".

क्वेरी पैरामीटर, हेडर, और फ़ॉर्म पैरामीटर के पैटर्न तय करते समय, "*" वर्ण यह बताता है कि इससे ज़्यादा वर्णों का मिलान किया जा सकता है. उदाहरण के लिए, हेडर का मिलान करते समय, पैटर्न को इस तरह तय करें:

*;charset={encoding}

यह पैटर्न, "text/xml;charset=UTF-16" और "application/xml;charset=ASCII" वैल्यू से मेल खाता है.

अगर ExtractVariables नीति को पास किए गए वैल्यू में कोई खास वर्ण शामिल है, जैसे कि "{", तो उसे एस्केप करने के लिए "%" वर्ण का इस्तेमाल करें. इस उदाहरण में, पैटर्न में "{" और "}" वर्ण एस्केप कर दिए गए हैं, क्योंकि उनका इस्तेमाल क्वेरी पैरामीटर की वैल्यू में लिटरल वर्णों के तौर पर किया जाता है:

<QueryParam>
  <Pattern ignoreCase="true">%{user%} {name}</Pattern>
</QueryParam>

इस उदाहरण में, पैटर्न "user} Steve" वैल्यू से मैच करता है, न कि "user Steve" वैल्यू से.

मेल खाने वाला JSON और XML

JSON और एक्सएमएल से डेटा एक्सट्रैक्ट करते समय, आपको नीति में एक या एक से ज़्यादा <Variable> टैग तय करने होते हैं. <Variable> टैग उस डेस्टिनेशन वैरिएबल के नाम के बारे में बताता है जहां निकाली गई जानकारी को स्टोर किया जाता है. साथ ही, इससे निकाली गई जानकारी के लिए JsonPath (JSON) या XPATH (XML) का पता चलता है.

नीति के सभी <Variable> टैग का आकलन किया जाता है, ताकि आप एक ही नीति से कई वैरिएबल भर सकें. अगर <Variable> टैग JSON या एक्सएमएल में किसी मान्य फ़ील्ड के तौर पर आकलन नहीं करता, तो उससे जुड़ा वैरिएबल नहीं बनाया जाता.

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

<ExtractVariables name="ExtractVariables-3">
   <Source>response</Source>
   <JSONPayload>
      <Variable name="latitude" type="float">
         <JSONPath>$.results[0].geometry.location.lat</JSONPath>
      </Variable>
      <Variable name="longitude" type="float">
         <JSONPath>$.results[0].geometry.location.lng</JSONPath>
      </Variable>
   </JSONPayload>
   <VariablePrefix>geocoderesponse</VariablePrefix>
</ExtractVariables>

एक ही वैरिएबल को कई जगहों पर लिखना

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

उदाहरण के लिए, आपको ऐसी टोकन वैल्यू को एक्सट्रैक्ट करना है जिसे क्वेरी पैरामीटर या हेडर में पास किया जा सके, जैसा कि यहां दिखाया गया है:

<!-- If token only in query param, the query param determines the value. 
     If token is found in both the query param and header, header sets value. -->
<QueryParam name="token">
  <Pattern ignoreCase="true">{tokenValue}</Pattern>
</QueryParam>
 
<!-- Overwrite tokenValue even if it was found in query parameter. -->
<Header name="Token">
  <Pattern ignoreCase="true">{tokenValue}</Pattern>
</Header>

यह तय करना कि कोई मैच न होने पर क्या हो

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

एक विकल्प यह है कि नीति में <IgnoreUnresolvedVariables> को 'सही' पर सेट किया जाए. यह वैरिएबल के रेफ़रंस के लिए, नीति को कॉन्फ़िगर करें. ऐसा करके, हल न किए जा सकने वाले किसी भी वैरिएबल को खाली स्ट्रिंग (शून्य) के तौर पर माना जाएगा:

<IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>

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

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

<ExtractVariables async="false" continueOnError="false" enabled="true" name="Extract-Variables-1">
   <DisplayName>Extract Variables 1</DisplayName>
   <Source clearPayload="true|false">request</Source>
   <VariablePrefix>myprefix</VariablePrefix>
   <IgnoreUnresolvedVariables>true|false</IgnoreUnresolvedVariables>
   <URIPath>
      <Pattern ignoreCase="false">/accounts/{id}</Pattern>
   </URIPath>
   <QueryParam name="code">
      <Pattern ignoreCase="true">DBN{dbncode}</Pattern>
   </QueryParam>
   <Header name="Authorization">
      <Pattern ignoreCase="false">Bearer {oauthtoken}</Pattern>
   </Header>
   <FormParam name="greeting">
      <Pattern>hello {user}</Pattern>
   </FormParam>
   <Variable name="request.content">
       <Pattern>hello {user}</Pattern>
   </Variable>
   <JSONPayload>
      <Variable name="name">
         <JSONPath>{example}</JSONPath>
      </Variable>
   </JSONPayload>
   <XMLPayload stopPayloadProcessing="false">
      <Namespaces/>
      <Variable name="name" type="boolean">
         <XPath>/test/example</XPath>
      </Variable>
   </XMLPayload>
</ExtractVariables>

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

<ExtractVariables async="false" continueOnError="false" enabled="true" name="Extract-Variables-1">

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

<DisplayName> एलिमेंट

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

<DisplayName>Policy Display Name</DisplayName>

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

(ज़रूरी नहीं) पार्स किया जाने वाला वैरिएबल तय करता है. <Source> की वैल्यू डिफ़ॉल्ट रूप से message होती है. message वैल्यू कॉन्टेक्स्ट के हिसाब से होती है. अनुरोध के फ़्लो में, message का मतलब उस मैसेज से होता है जिसे अनुरोध भेजा गया है. जवाब के फ़्लो में, message रिज़ॉल्व करता है कि जवाब दिया गया है या नहीं.

आम तौर पर, इस नीति का इस्तेमाल किसी अनुरोध या रिस्पॉन्स मैसेज से जानकारी निकालने के लिए किया जाता है. हालांकि, इसका इस्तेमाल किसी भी वैरिएबल से जानकारी निकालने के लिए किया जा सकता है. उदाहरण के लिए, इसका इस्तेमाल AccessEntity नीति से बनाई गई इकाई से जानकारी हासिल करने के लिए या किसी एक्सएमएल या JSON ऑब्जेक्ट से जानकारी निकालने के लिए किया जा सकता है. इसके लिए, सेवा की कॉलआउट नीति से मिले डेटा का भी इस्तेमाल किया जा सकता है.

अगर <Source> का समाधान नहीं किया जा सकता या यह बिना मैसेज वाले किसी टाइप के हो जाता है, तो नीति का जवाब नहीं मिलेगा.

<Source clearPayload="true|false">request</Source>

एट्रिब्यूट

<VariablePrefix> एलिमेंट

(ज़रूरी नहीं) वैरिएबल का पूरा नाम, <VariablePrefix>, एक बिंदु, और {curly braces} में तय किए गए नाम को <Pattern> एलिमेंट या <Variable> एलिमेंट में जोड़कर बनाया जाता है. उदाहरण के लिए: myprefix.id, myprefix.dbncode या myprefix.oauthtoken.

<VariablePrefix>myprefix</VariablePrefix>

उदाहरण के लिए, मान लें कि नाम की वैल्यू "user" है.

• अगर <VariablePrefix> के बारे में नहीं बताया गया है, तो एक्सट्रैक्ट की गई वैल्यू, user नाम वाले वैरिएबल को असाइन की जाती हैं.
• अगर <VariablePrefix> को मेरे प्रीफ़िक्स के तौर पर बताया गया है, तो निकाली गई वैल्यू, myprefix.user नाम वाले वैरिएबल को असाइन की जाती हैं.

<ignoreUnresolvedVariables> एलिमेंट

(ज़रूरी नहीं) किसी भी रिज़ॉल्व न किए जा सकने वाले वैरिएबल को खाली स्ट्रिंग (शून्य) के तौर पर मेज़र करने के लिए, true पर सेट करें. अगर आप चाहते हैं कि रेफ़र किए गए किसी भी वैरिएबल को ठीक नहीं किया जा सकता, तो नीति से गड़बड़ी होने की सूचना मिले, तो इसे false पर सेट करें.

<IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>

अगर <XMLPayload> में किसी XPath रेफ़रंस को हल नहीं किया गया है, तो नीति यह गड़बड़ी दिखाती है:

{
   "fault":{
      "faultstring":"Unresolved xpath path in policy policy_name.",
      "detail":{
         "errorcode":"steps.extractvariables.InvalidXPath"
      }
   }
}

<uriPath> एलिमेंट

(ज़रूरी नहीं है, लेकिन ज़्यादा जानकारी के लिए नीचे दी गई टेबल में, मौजूदगी वाली पंक्ति देखें.) किसी अनुरोध सोर्स मैसेज के प्रॉक्सी.pathsuffix से वैल्यू एक्सट्रैक्ट करता है. पैटर्न पर लागू किया गया पाथ प्रॉक्सी.pathsuffix है, जिसमें एपीआई प्रॉक्सी के लिए बेसपाथ शामिल नहीं है. अगर सोर्स मैसेज से रिस्पॉन्स वाले मैसेज का इस्तेमाल किया जाता है, तो यह एलिमेंट कुछ नहीं करता.

<URIPath>
   <Pattern ignoreCase="false">/accounts/{id}</Pattern>
</URIPath>

एक से ज़्यादा <Pattern> एलिमेंट इस्तेमाल किए जा सकते हैं:

<URIPath>
   <Pattern ignoreCase="false">/accounts/{id}</Pattern>
   <Pattern ignoreCase="false">/accounts/{id}/transactions/{index}</Pattern>
</URIPath>

एट्रिब्यूट

<QueryParam> एलिमेंट

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

<QueryParam name="code">
   <Pattern ignoreCase="true">DBN{dbncode}</Pattern>
</QueryParam>

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

<QueryParam name="w.2">
   <Pattern ignoreCase="true">{secondW}</Pattern>
</QueryParam>

एट्रिब्यूट

<हेडर> एलिमेंट

(ज़रूरी नहीं है, लेकिन ज़्यादा जानकारी के लिए नीचे दी गई टेबल में, मौजूदगी वाली पंक्ति देखें.) दिए गए request या response मैसेज के दिए गए एचटीटीपी हेडर से वैल्यू एक्सट्रैक्ट करता है. अगर एक से ज़्यादा हेडर का नाम एक जैसा है, तो उनकी वैल्यू एक कैटगरी में सेव की जाती हैं.

<!-- The name is the actual header name. -->
<Header name="Authorization">
<!-- Provide a name for your new custom variable here. -->
   <Pattern ignoreCase="false">Bearer {oauthtoken}</Pattern>
</Header>

अगर एक से ज़्यादा हेडर के नाम एक ही हैं, तो अरे में अलग-अलग हेडर का रेफ़रंस देने के लिए, इंडेक्स का इस्तेमाल करें:

<Header name="myHeader.2">
   <Pattern ignoreCase="true">{secondHeader}</Pattern>
</Header>

या अरे में सभी हेडर को शामिल करने के लिए नीचे दिया गया तरीका अपनाएं:

<Header name="myHeader.values">
   <Pattern ignoreCase="true">{myHeaders}</Pattern>
</Header>

एट्रिब्यूट

<FormParam> एलिमेंट

(ज़रूरी नहीं है, लेकिन ज़्यादा जानकारी के लिए नीचे दी गई टेबल में, मौजूदगी वाली पंक्ति देखें.) दिए गए request या response मैसेज के लिए, दिए गए फ़ॉर्म पैरामीटर से वैल्यू एक्सट्रैक्ट करता है. फ़ॉर्म के पैरामीटर सिर्फ़ तब निकाले जा सकते हैं, जब तय किए गए मैसेज का Content-Type हेडर application/x-www-form-urlencoded हो.

<FormParam name="greeting">
    <Pattern>hello {user}</Pattern>
</FormParam>

एट्रिब्यूट

<वैरिएबल> एलिमेंट

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

<Variable name="myVar">
    <Pattern>hello {user}</Pattern>
</Variable>

वैरिएबल से दो वैल्यू एक्सट्रैक्ट करने के लिए:

<Variable name="myVar">
   <Pattern>hello {firstName} {lastName}</Pattern>
</Variable>

एट्रिब्यूट

<JSONPayload> एलिमेंट

(ज़रूरी नहीं है, लेकिन ज़्यादा जानकारी के लिए नीचे दी गई टेबल में, मौजूदगी वाली पंक्ति देखें.) JSON के फ़ॉर्मैट वाला वह मैसेज तय करता है जिससे वैरिएबल की वैल्यू निकाली जाएगी. JSON एक्सट्रैक्शन सिर्फ़ तब किया जाता है, जब मैसेज का Content-Type हेडर application/json हो.

<JSONPayload>
   <Variable name="name" type="string">
      <JSONPath>{example}</JSONPath>
   </Variable>
</JSONPayload>

<JSONPayload>/<Variable> एलिमेंट

(JSONPayload एलिमेंट में ज़रूरी है.) उस वैरिएबल के बारे में बताता है जहां निकाली गई वैल्यू असाइन की जाती है. एक से ज़्यादा वैरिएबल को पॉप्युलेट करने के लिए, <JSONPayload> एलिमेंट में एक से ज़्यादा <Variable> टैग शामिल करें.

<Variable name="name" type="string">
   <JSONPath>{example}</JSONPath>
</Variable>

एट्रिब्यूट

<JSONPayload>/<Variable>/<JSONPath> एलिमेंट

(JSONPayload:वैरिएबल एलिमेंट में ज़रूरी है.) JSON के फ़ॉर्मैट वाले मैसेज से वैल्यू एक्सट्रैक्ट करने के लिए इस्तेमाल किए जाने वाले JSON पाथ के बारे में बताता है.

<Variable name="name">
   <JSONPath>$.rss.channel.title</JSONPath>
</Variable>

<XMLPayload> एलिमेंट

(ज़रूरी नहीं है, लेकिन ज़्यादा जानकारी के लिए नीचे दी गई टेबल में, मौजूदगी वाली पंक्ति देखें.) उस एक्सएमएल फ़ॉर्मैट का मैसेज बताता है जिससे वैरिएबल की वैल्यू निकाली जाएगी. एक्सएमएल पेलोड सिर्फ़ तब निकाले जाते हैं, जब मैसेज का Content-Type हेडर text/xml, application/xml या application/*+xml हो.

<XMLPayload stopPayloadProcessing="false">
  <Namespaces>
     <Namespace prefix="apigee">http://www.apigee.com</Namespace>
     <Namespace prefix="gmail">http://mail.google.com</Namespace>
  </Namespaces>
  <Variable name="name" type="boolean">
     <XPath>/apigee:test/apigee:example</XPath>
  </Variable>
</XMLPayload>

एट्रिब्यूट

<XMLPayload>/<Namespaces> एलिमेंट

(ज़रूरी नहीं) XPath इवैलुएशन में इस्तेमाल किए जाने वाले नेमस्पेस के बारे में बताता है. अगर आप अपने XPath एक्सप्रेशन में नेमस्पेस का इस्तेमाल कर रहे हैं, तो आपको यहां नेमस्पेस के बारे में बताना होगा, जैसा कि इस उदाहरण में दिखाया गया है.

<XMLPayload stopPayloadProcessing="false">
  <Namespaces>
     <Namespace prefix="apigee">http://www.apigee.com</Namespace>
     <Namespace prefix="gmail">http://mail.google.com</Namespace>
  </Namespaces>
  <Variable name="legName" type="string">
    <XPath>/apigee:Directions/apigee:route/apigee:leg/apigee:name</XPath>
  </Variable>
</XMLPayload>

अगर आप अपने XPath एक्सप्रेशन में नेमस्पेस का इस्तेमाल नहीं कर रहे हैं, तो आप <Namespaces> एलिमेंट को छोड़ सकते हैं या उस पर टिप्पणी कर सकते हैं, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है:

<XMLPayload stopPayloadProcessing="false">
  <!-- <Namespaces/> -->
  <Variable name="legName" type="string">
    <XPath>/Directions/route/leg/name</XPath>
  </Variable>
</XMLPayload>

एट्रिब्यूट

<XMLPayload>/<Variable> एलिमेंट

(ज़रूरी नहीं) यह वैरिएबल बताता है कि एक्सट्रैक्ट की गई वैल्यू किस वैरिएबल को असाइन की जाएगी.

<Variable name="name" type="boolean">
   <XPath>/test/example</XPath>
</Variable>

एट्रिब्यूट

<XMLPayload>/<Variable>/<XPath> एलिमेंट

(XMLPayload:वैरिएबल एलिमेंट में ज़रूरी है.) वैरिएबल के लिए तय किया गया XPath के बारे में बताता है. सिर्फ़ XPath 1.0 एक्सप्रेशन इस्तेमाल किए जा सकते हैं.

<Variable name="name" type="boolean">
   <XPath>/test/example</XPath>
</Variable>

नेमस्पेस के साथ उदाहरण. अगर आपने अपने XPath एक्सप्रेशन में नेमस्पेस का इस्तेमाल किया है, तो आपको नीति के <XMLPayload><Namespaces> सेक्शन में नेमस्पेस के बारे में एलान करना होगा.

<Variable name="name" type="boolean">
   <XPath>/foo:test/foo:example</XPath>
</Variable>

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

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

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

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

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

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

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

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

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

{
   "fault":{
      "detail":{
         "errorcode":"steps.extractvariables.SourceMessageNotAvailable"
      },
      "faultstring":"request message is not available for ExtractVariable: EV-ParseJsonResponse"
   }
}

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

<FaultRule name="Extract Variable Faults">
    <Step>
        <Name>AM-CustomErrorMessage</Name>
        <Condition>(fault.name = "SourceMessageNotAvailable") </Condition>
    </Step>
    <Condition>(extractvariables.EM-ParseJsonResponse.failed = true) </Condition>
</FaultRule>

स्कीमा

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

कस्टम आंकड़ों का इस्तेमाल करके, एपीआई मैसेज के कॉन्टेंट का विश्लेषण करना

वैरिएबल के रेफ़रंस