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

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

क्या

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

इस नीति का इस्तेमाल अक्सर अनुरोध या जवाब के मैसेज से जानकारी निकालने के लिए किया जाता है. हालांकि, इसका इस्तेमाल अन्य स्रोतों से जानकारी निकालने के लिए भी किया जा सकता है. जैसे, AccessEntity नीति से बनाई गई इकाइयां, XML ऑब्जेक्ट या 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 का इस्तेमाल कैसे किया जा सकता है, यह जानने के लिए कस्टम Analytics का इस्तेमाल करके एपीआई मैसेज के कॉन्टेंट का विश्लेषण करना लेख पढ़ें.

दायरा

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

• PreFlow: ProxyEndpoint और TargetEndpoint (अनुरोध और जवाब)
• PostFlow: ProxyEndpoint और TargetEndpoint (अनुरोध और जवाब)
• PostClientFlow: ProxyEndpoint (सिर्फ़ जवाब, Message Logging policy का इस्तेमाल करके)
• गड़बड़ी वाले फ़्लो

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

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 वैरिएबल को उस वैल्यू पर सेट किया जाता है जो "/a/" के बाद proxy.pathsuffix में दिखती है. उदाहरण के लिए, मान लें कि आपकी एपीआई प्रॉक्सी का बेस पाथ /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/b/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 और XML से डेटा निकालते समय, नीति में एक या उससे ज़्यादा <Variable> टैग तय किए जाते हैं. <Variable> टैग, डेस्टिनेशन वैरिएबल का नाम तय करता है. इसमें निकाली गई जानकारी सेव की जाती है. साथ ही, इसमें निकाली गई जानकारी के लिए JsonPath (JSON) या XPATH (XML) भी तय किया जाता है.

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

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

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

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

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

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

<DisplayName>Policy Display Name</DisplayName>

<Source> एलिमेंट

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

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

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

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

विशेषताएं

<VariablePrefix> एलिमेंट

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

<VariablePrefix>myprefix</VariablePrefix>

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

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

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

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

विशेषताएं

<Header> एलिमेंट

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

<!-- 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> एलिमेंट

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

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

विशेषताएं

<Variable> एलिमेंट

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

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

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

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

विशेषताएं

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

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

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

<XMLPayload> एलिमेंट

(ज़रूरी नहीं, लेकिन ज़्यादा जानकारी के लिए, यहां दी गई टेबल में 'उपलब्धता' पंक्ति देखें.) यह उस XML फ़ॉर्मैट वाले मैसेज के बारे में बताता है जिससे वैरिएबल की वैल्यू निकाली जाएगी. एक्सएमएल पेलोड सिर्फ़ तब निकाले जाते हैं, जब मैसेज का 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> element

(ज़रूरी नहीं) 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> element

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

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

विशेषताएं

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

(XMLPayload:Variable एलिमेंट में यह ज़रूरी है.) वैरिएबल के लिए तय किए गए 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>

स्कीमा

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

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

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