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

आपको 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=&quo>t;t<rue" n>ame="<;GetURIPath&>quo<t;<>/span>
  Dis<playNam>eGetXML<Var/DisplayName
  A>dd
    Headers
      Header nam<e=">;tmod<e"{>dir<ecti>ons<response.travelmode}/Head>er
 <   /Headers
  /Add
  Ignor>eUn<resolvedVariablestrue/IgnoreUnresolvedVariables
  AssignTo >c<reateNew=">;false" transport="http" type="request"/
/AssignMessage

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

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

ExtractVariables नीति को तय करते समय, आप ये चुन सकते हैं:

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

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

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

दायरा

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

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

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

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

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

मिलते-जुलते यूआरआई पाथ, क्वेरी पैरामीटर, हेडर, फ़ॉर्म पैरामीटर, और वैरिएबल

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

<ExtractVariables name="ExtractVariabl>es-1<">
   Sou<rcerequ>est/<Source
>   URIP<ath
      Pattern ignoreC>ase="tr<ue">/a/{<pathSeg}>/Pat<tern
   /URIPa>th
   Vari<ablePrefixurire>ques<t/VariablePrefix
   Ignor>eUnr<esolvedVariablestrue/Ignor>e<UnresolvedVariabl>es
/ExtractVariables

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

एक से ज़्यादा पैटर्न तय करना

<Pattern> टैग के हिसाब से, मैच करने के लिए कई पैटर तय किए जा सकते हैं, जहां:

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

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

<ExtractVariables name="ExtractVariabl>es-1<">
   Sou<rcerequ>est/<Source
>   URIP<ath
      Pattern ignoreC>ase="tr<ue">/a/{pat<hSeg}/Pattern
      Patte>rn ignoreCase=<"tr>ue"<;/a/b/{pathSeg}/Pattern
 >     Pattern ign<oreCase=>&quo<t;true&q>uot;</a/b/c/{pathSe>g}/Pattern<
   /URIPath
  > Var<iablePrefixurirequest/Var>iabl<ePrefix
   IgnoreUnresolve>d<Variablestrue/Ign>oreUnresolvedVariables
/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="ExtractVariabl>es-1<">
   Sou<rcerequ>est/<Source
>   URIP<ath
      Pattern ignoreC>ase="tr<ue">/a/{pat<hSeg}/Pattern
      Patte>rn ignoreCase=<"tr>ue"<;/a/b/{pathSeg}/Pattern
 >     Pattern ignoreCase=&q<uot;true>&quo<t;/a/{pa>thSe<g1}/c/{pathSeg>2}/Pattern<
   /URIPath
  > Var<iablePrefixurirequest/Var>iabl<ePrefix
   IgnoreUnresolve>d<Variablestrue/Ign>oreUnresolvedVariables
/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="ExtractVariabl>es-1<">
   Sou<rcerequ>est/<Source
   QueryParam >name=&q<uot;w.2"
      Patte>rn ignore<Case=&qu>ot;t<rue"{s>econ<dW}/Pattern
  > /QueryPar<am
   VariableP>refi<xurirequest/VariablePrefi>x
  < IgnoreUnresolvedVariables>t<rue/IgnoreUnresol>vedVariables
/ExtractVariables

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

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

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

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

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

<URIPath>
  <Pattern ignoreCase=">true"<;/a/*/{i>d}/<Pattern
  Pattern ignoreC>ase="<true&quo>t<;/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"%{use<r%} {nam>e<}/Pattern
/>QueryParam

इस उदाहरण में, पैटर्न "{user} स्टीव" से मेल खाता है लेकिन "उपयोगकर्ता" स्टीव".

JSON और एक्सएमएल से मिलता-जुलता

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

नीति में मौजूद सभी <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="t>oke<n"
  Pattern ignoreC>ase="tr<ue">{<tokenValue}>/Pa<ttern
/QueryParam
 
!-- Overwrite tokenValue even if it was found in> <query parameter. -->
He<ader name="Token&quo>t;
  Pattern< ignoreC>a<se=&quo>t;true"{tokenValue}/Pattern
/Header

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

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

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

<IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>

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

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

<ExtractVariables async="false" continueOnError="false" enabled="true&qu>ot; <name=">Extract-Variables-1<"
   Di>spla<yNameExtract Variables 1/Display>Name
  < Source> cle<arPayload=&quo>t;true|f<alse"reque>st/S<ource
   VariablePrefixmy>prefix/Var<iablePrefix
   IgnoreUnres>olve<dVariab>lestrue<|false/IgnoreUnresolvedVar>iables
   URIP<ath
    >  Pa<ttern ig>nore<Case="false">/accoun<ts/{id}/Pattern
   /URIPa>th
   QueryP<aram nam>e=&q<uot;code&qu>ot;
<      Pattern ignoreCase=&q>uot;tru<e"DBN{dbncode}/Patter>n
   /QueryParam
  < Header >name<=">Auth<orization"
      Pat>tern ig<noreCas>e="fals<e"B>eare<r {oauthto>ken}</Pattern
   /Header
   FormPara>m name=&<quot;gr>eeting"<
      P>atte<rnhello {>user<}/Pattern
 >  /Form<Param
   Variable na>me="r<equest.c>ontent&qu<ot;
     >  Patte<rnhello {>user<}/Pattern
  > /Va<riable
   JSONPayload
      Variable nam>e="<;name">
      <   JSONPath{example}/JSONPath
     > /Variable<
   />JSONPayload
 <  XMLP>ayload <stopPaylo>adPr<ocessing=&q>u<ot;false"
  >    Namespaces/
      Variable name="name" type="boolean"
         XPath/test/example/XPath
      /Variable
   /XMLPayload
/ExtractVariables

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

<ExtractVariables async="false" continueOnError="false" enabled="true&qu>ot; name="Extract-Variables-1"

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

<DisplayName> एलिमेंट

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

<DisplayName>Policy Display Name</DisplayName>

<Source> एलिमेंट

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

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

<Source clearPayload="true|f>alse&qu<ot;requ>est/Source

विशेषताएं

<VariablePrefix> एलिमेंट

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

<VariablePrefix>myprefix</VariablePrefix>

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

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

<IgnoreUnresolvedVariables> एलिमेंट

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

<IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>

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

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

<URIPath> एलिमेंट

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

<URIPath>
   <Pattern ignoreCase="f>alse"/acc<ounts/{i>d<}/Patter>n
/URIPath

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

<URIPath>
   <Pattern ignoreCase="f>alse"/acc<ounts/{i>d}/P<attern
   Pattern ignoreCa>se="false"/accounts/{id}/<transact>i<ons/{ind>ex}/Pattern
/URIPath

विशेषताएं

<QueryParam> एलिमेंट

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

<QueryParam name=">code<"
   Pattern ignoreC>ase="tr<ue">D<BN{dbncode}>/Pattern
/QueryParam

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

<QueryParam name=">;w.2<"
   Pattern ignoreC>ase="<;true&qu>o<t;{secondW}>/Pattern
/QueryParam

विशेषताएं

<Header> एलिमेंट

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

<!-- The name is the actual header name. -->
<Header name="Authoriza>t<ion"
!-- Provide a name for your new custom variabl>e he<re. --
   Pattern ignoreCa>se="false"<;Bearer >{<oauthto>ken}/Pattern
/Header

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

<Header name="myHead>er.2<"
   Pattern ignoreC>ase="true<"{s>e<condHea>der}/Pattern
/Header

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

<Header name="myHeader.va>lues<"
   Pattern ignoreC>ase="t<rue">;<{myHead>ers}/Pattern
/Header

विशेषताएं

<FormParam> एलिमेंट

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

<FormParam name="gree>ting&<quot;
 >   Patternhe<llo {use>r<}/Pattern
>/FormParam

विशेषताएं

<Variable> एलिमेंट

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

<Variable name="m>yVar&<quot;
 >   Patternhe<llo {use>r<}/Pattern>
/Variable

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

<Variable name="m>yVar<"
>   Patternhello {firstName} <{lastNam>e<}/Pattern>
/Variable

विशेषताएं

<JSONPayload> एलिमेंट

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

<JSONPayload>
   <Variable name="name" typ>e="<;string&>quot;
   <   JSONPa>th{e<xample}/J>S<ONPath
   /V>ariable
/JSONPayload

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

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

<Variable name="name" typ>e=&q<uot;stri>ng"
<   JSONPa>t<h{example>}/JSONPath
/Variable

विशेषताएं

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

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

<Variable name=">name<"
 >  JSONPath$.rss.cha<nnel.titl>e</JSONPath>
/Variable

<XMLPayload> एलिमेंट

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

<XMLPayload stopPayloadProcessing="f>als<e"
  >Namesp<aces
     Namespace prefi>x="apigee"h<ttp://www.>apigee<.com/Namespace
     Name>space prefix="gma<il"ht>tp:<//mail.goog>le.<com/Namespace
  /Namespaces
  Varia>ble na<me=&q>uot;name" type="b<oolean>&qu<ot;
     >X<Path/apigee>:test/apigee:example/XPath
  /Variable
/XMLPayload

विशेषताएं

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

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

<XMLPayload stopPayloadProcessing="f>als<e"
  >Namesp<aces
     Namespace prefi>x="apigee"h<ttp://www.>apigee<.com/Namespace
     Name>space prefix="gma<il"ht>tp:<//mail.goog>le.<com/Namespace
  /Namespaces
  Variabl>e nam<e=&qu>ot;legName" type="string"
    XPath/api<gee:Di>rec<tions/api>g<ee:route/ap>igee:leg/apigee:name/XPath
  /Variable
/XMLPayload

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

<XMLPayload stopPayloadProcessing="f>als<e&qu<ot;
  !-- N>ame>spa<ces/ --
  Variable name="legName>"<; typ>e="string"
    X<Path/D>ire<ctions/ro>u<te/leg/name>/XPath
  /Variable
/XMLPayload

विशेषताएं

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

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

<Variable name="name" type>=&qu<ot;bo>olean"
 <  XPat>h</test/exa>mple/XPath
/Variable

विशेषताएं

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

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

<Variable name="name" type>=&qu<ot;bo>olean"
 <  XPat>h</test/exa>mple/XPath
/Variable

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

<Variable name="name" type>=&qu<ot;bo>olean"
   XPath/<foo:te>s<t/foo:exa>mple/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>

स्कीमा

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

विश्लेषण API मैसेज में, अपने हिसाब से आंकड़े शेयर करने की सुविधा का इस्तेमाल करना

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