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

Directions API (लेगसी) की वेब सेवाओं का इस्तेमाल करने के सबसे सही तरीके

Google Maps Platform की वेब सेवाएं, Google की सेवाओं के लिए एचटीटीपी इंटरफ़ेस का कलेक्शन हैं. ये सेवाएं, आपके मैप ऐप्लिकेशन के लिए भौगोलिक डेटा उपलब्ध कराती हैं.

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

वेब सेवा क्या होती है?

Google Maps Platform की वेब सेवाएं, Maps API से डेटा का अनुरोध करने के लिए एक इंटरफ़ेस हैं. इनकी मदद से, बाहरी सेवाओं से डेटा का अनुरोध किया जा सकता है और Maps ऐप्लिकेशन में उस डेटा का इस्तेमाल किया जा सकता है. इन सेवाओं को मैप के साथ इस्तेमाल करने के लिए डिज़ाइन किया गया है. ऐसा Google Maps Platform की सेवा की शर्तों में दी गई लाइसेंस से जुड़ी पाबंदियों के मुताबिक किया जाता है.

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

Directions API (लेगसी) का सामान्य अनुरोध, आम तौर पर इस तरह का होता है:

https://maps.googleapis.com/maps/api/directions/output?parameters

यहां output, जवाब के फ़ॉर्मैट को दिखाता है. आम तौर पर, यह json या xml होता है.

ध्यान दें: Directions API (लेगसी) के सभी ऐप्लिकेशन के लिए पुष्टि करना ज़रूरी है. पुष्टि करने के क्रेडेंशियल के बारे में ज़्यादा जानें.

एसएसएल/टीएलएस ऐक्सेस

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

मान्य यूआरएल बनाना

आपको लग सकता है कि "मान्य" यूआरएल के बारे में बताने की ज़रूरत नहीं है, लेकिन ऐसा नहीं है. उदाहरण के लिए, ब्राउज़र के पता बार में डाला गया यूआरएल, खास वर्णों (जैसे, "上海+中國") को शामिल कर सकता है. ब्राउज़र को ट्रांसमिशन से पहले, उन वर्णों को किसी अन्य एन्कोडिंग में बदलना होता है. इसी तरह, UTF-8 इनपुट जनरेट करने या स्वीकार करने वाला कोई भी कोड, UTF-8 वर्णों वाले यूआरएल को "मान्य" के तौर पर देख सकता है. हालांकि, उसे उन वर्णों को वेब सर्वर पर भेजने से पहले उनका अनुवाद भी करना होगा. इस प्रोसेस को यूआरएल-एनकोडिंग या परसेंट-एनकोडिंग कहा जाता है.

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

विशेष वर्ण

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

मान्य यूआरएल वर्णों के बारे में खास जानकारी

सेट करें	वर्ण	यूआरएल का इस्तेमाल
अक्षर और अंक दोनों शामिल हो सकते हैं	a b c d e f g h i j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 0 1 2 3 4 5 6 7 8 9	टेक्स्ट स्ट्रिंग, स्कीम का इस्तेमाल (`http`), पोर्ट (`8080`) वगैरह.
गैर-आरक्षित	- _ . ~	टेक्स्ट स्ट्रिंग
बुकिंग की गई	! * ' ( ) ; : @ & = + $ , / ? % # [ ]	कंट्रोल वर्ण और/या टेक्स्ट स्ट्रिंग

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

आपको जिन वर्णों को हैंडल करना है वे ऊपर दिए गए सेट में शामिल नहीं हैं. उदाहरण के लिए, विदेशी भाषाओं के वर्णों, जैसे कि 上海+中國 को ऊपर दिए गए वर्णों का इस्तेमाल करके कोड में बदलना ज़रूरी है. आम तौर पर, स्पेस (जिन्हें यूआरएल में इस्तेमाल करने की अनुमति नहीं है) को प्लस '+' वर्ण का इस्तेमाल करके भी दिखाया जाता है.
ऊपर दिए गए सेट में मौजूद वर्णों को रिज़र्व किए गए वर्णों के तौर पर इस्तेमाल किया जाता है. हालांकि, इन्हें लिटरल तौर पर इस्तेमाल किया जाना चाहिए. उदाहरण के लिए, यूआरएल में ? का इस्तेमाल क्वेरी स्ट्रिंग की शुरुआत दिखाने के लिए किया जाता है. अगर आपको "? and the Mysterions" स्ट्रिंग का इस्तेमाल करना है, तो आपको '?' वर्ण को कोड में बदलना होगा.

यूआरएल में कोड में बदले जाने वाले सभी वर्णों को, '%' वर्ण और उनके UTF-8 वर्ण के हिसाब से दो वर्णों वाली हेक्स वैल्यू का इस्तेमाल करके कोड में बदला जाता है. उदाहरण के लिए, 上海+中國 को UTF-8 में, यूआरएल के तौर पर %E4%B8%8A%E6%B5%B7%2B%E4%B8%AD%E5%9C%8B कोड में बदला जाएगा. स्ट्रिंग ? and the Mysterians को यूआरएल में कोड में बदलकर %3F+and+the+Mysterians या %3F%20and%20the%20Mysterians लिखा जाएगा.

ऐसे सामान्य वर्ण जिन्हें एन्कोड करने की ज़रूरत होती है

यहां कुछ सामान्य वर्ण दिए गए हैं जिन्हें कोड में बदलना ज़रूरी है:

असुरक्षित वर्ण	कोड की गई वैल्यू
स्पेस	`%20`
"	`%22`
<	`%3C`
>	`%3E`
#	`%23`
%	`%25`
\|	`%7C`

उपयोगकर्ता के इनपुट से मिले यूआरएल को बदलना कभी-कभी मुश्किल होता है. उदाहरण के लिए, कोई उपयोगकर्ता पते को "5th&Main St." के तौर पर डाल सकता है. आम तौर पर, आपको यूआरएल को उसके हिस्सों से बनाना चाहिए. साथ ही, उपयोगकर्ता के किसी भी इनपुट को लिटरल वर्णों के तौर पर मानना चाहिए.

इसके अलावा, Google Maps Platform की सभी वेब सेवाओं और स्टैटिक वेब एपीआई के लिए, यूआरएल में ज़्यादा से ज़्यादा 16,384 वर्ण इस्तेमाल किए जा सकते हैं. ज़्यादातर सेवाओं के लिए, वर्णों की इस सीमा तक पहुंचने की ज़रूरत नहीं पड़ेगी. हालांकि, ध्यान दें कि कुछ सेवाओं में कई पैरामीटर होते हैं. इस वजह से, यूआरएल लंबे हो सकते हैं.

Google API का सही तरीके से इस्तेमाल करना

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

एक्स्पोनेंशियल बैकऑफ़

कभी-कभी, आपके अनुरोध को पूरा करने में कोई गड़बड़ी हो सकती है. आपको 4XX या 5XX एचटीटीपी रिस्पॉन्स कोड मिल सकता है. इसके अलावा, ऐसा भी हो सकता है कि आपके क्लाइंट और Google के सर्वर के बीच टीसीपी कनेक्शन काम न करे. अक्सर, अनुरोध को फिर से आज़माना फ़ायदेमंद होता है. ऐसा इसलिए, क्योंकि हो सकता है कि मूल अनुरोध पूरा न होने पर, फ़ॉलोअप अनुरोध पूरा हो जाए. हालांकि, यह ज़रूरी है कि Google के सर्वर से बार-बार अनुरोध न किए जाएं. इस तरह के लूपिंग व्यवहार से, आपके क्लाइंट और Google के बीच नेटवर्क पर ज़्यादा लोड पड़ सकता है. इससे कई पक्षों को समस्याएं हो सकती हैं.

बेहतर तरीका यह है कि अनुरोध को फिर से भेजा जाए. हालांकि, हर बार अनुरोध भेजने के बीच का समय बढ़ता जाना चाहिए. आम तौर पर, हर कोशिश के साथ देरी को एक मल्टीप्लिकेटिव फ़ैक्टर से बढ़ाया जाता है. इस तरीके को एक्सपोनेंशियल बैकऑफ़ कहा जाता है.

उदाहरण के लिए, मान लें कि कोई ऐप्लिकेशन Time Zone API से यह अनुरोध करना चाहता है:

https://maps.googleapis.com/maps/api/timezone/json?location=39.6034810,-119.6822510&timestamp=1331161200&key=YOUR_API_KEY

यहां दिए गए Python के उदाहरण में, एक्सपोनेंशियल बैकऑफ़ के साथ अनुरोध करने का तरीका बताया गया है:

import json
import time
import urllib.error
import urllib.parse
import urllib.request

# The maps_key defined below isn't a valid Google Maps API key.
# You need to get your own API key.
# See https://developers.google.com/maps/documentation/timezone/get-api-key
API_KEY = "YOUR_KEY_HERE"
TIMEZONE_BASE_URL = "https://maps.googleapis.com/maps/api/timezone/json"


def timezone(lat, lng, timestamp):

    # Join the parts of the URL together into one string.
    params = urllib.parse.urlencode(
        {"location": f"{lat},{lng}", "timestamp": timestamp, "key": API_KEY,}
    )
    url = f"{TIMEZONE_BASE_URL}?{params}"

    current_delay = 0.1  # Set the initial retry delay to 100ms.
    max_delay = 5  # Set the maximum retry delay to 5 seconds.

    while True:
        try:
            # Get the API response.
            response = urllib.request.urlopen(url)
        except urllib.error.URLError:
            pass  # Fall through to the retry loop.
        else:
            # If we didn't get an IOError then parse the result.
            result = json.load(response)

            if result["status"] == "OK":
                return result["timeZoneId"]
            elif result["status"] != "UNKNOWN_ERROR":
                # Many API errors cannot be fixed by a retry, e.g. INVALID_REQUEST or
                # ZERO_RESULTS. There is no point retrying these requests.
                raise Exception(result["error_message"])

        if current_delay > max_delay:
            raise Exception("Too many retry attempts.")

        print("Waiting", current_delay, "seconds before retrying.")

        time.sleep(current_delay)
        current_delay *= 2  # Increase the delay each time we retry.


if __name__ == "__main__":
    tz = timezone(39.6034810, -119.6822510, 1331161200)
    print(f"Timezone: {tz}")

आपको यह भी ध्यान रखना चाहिए कि ऐप्लिकेशन कॉल चेन में, फिर से कोशिश करने वाला कोई ऐसा कोड न हो जिसकी वजह से एक के बाद एक अनुरोध भेजे जा रहे हों.

सिंक किए गए अनुरोध

Google के एपीआई को एक साथ भेजे गए कई अनुरोधों को, Google के इन्फ़्रास्ट्रक्चर पर डिस्ट्रिब्यूटेड डिनायल ऑफ़ सर्विस (डीडीओएस) अटैक माना जा सकता है. इसलिए, इन अनुरोधों को इसी तरह से प्रोसेस किया जाएगा. इससे बचने के लिए, आपको यह पक्का करना चाहिए कि क्लाइंट के बीच एपीआई अनुरोध सिंक न किए जाएं.

उदाहरण के लिए, मान लें कि कोई ऐप्लिकेशन मौजूदा टाइम ज़ोन के हिसाब से समय दिखाता है. यह ऐप्लिकेशन, क्लाइंट ऑपरेटिंग सिस्टम में अलार्म सेट करेगा. इससे हर मिनट की शुरुआत में सिस्टम चालू हो जाएगा, ताकि दिखाया गया समय अपडेट किया जा सके. ऐप्लिकेशन को उस अलार्म से जुड़ी प्रोसेसिंग के दौरान, कोई भी एपीआई कॉल नहीं करना चाहिए.

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

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

मिनट की शुरुआत के अलावा, सिंक करने के अन्य सामान्य समय भी होते हैं. आपको इन समय पर टारगेट नहीं करना चाहिए. जैसे, घंटे की शुरुआत और हर दिन आधी रात को.

जवाब प्रोसेस किए जा रहे हैं

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

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

Google Maps की वेब सेवाएं, ऐसे जवाब देती हैं जिन्हें समझना आसान होता है. हालांकि, ये जवाब उपयोगकर्ता के हिसाब से नहीं होते. क्वेरी करते समय, आपको डेटा का सेट दिखाने के बजाय, कुछ खास वैल्यू एक्सट्रैक्ट करनी होती हैं. आम तौर पर, आपको वेब सेवा से मिले जवाबों को पार्स करना होगा. साथ ही, सिर्फ़ उन वैल्यू को निकालना होगा जिनमें आपकी दिलचस्पी है.

पार्सिंग स्कीम का इस्तेमाल इस बात पर निर्भर करता है कि आपको आउटपुट एक्सएमएल या JSON में चाहिए. JSON रिस्पॉन्स, पहले से ही JavaScript ऑब्जेक्ट के फ़ॉर्म में होते हैं. इसलिए, इन्हें क्लाइंट पर JavaScript में ही प्रोसेस किया जा सकता है. एक्सएमएल फ़ॉर्मैट में मौजूद एलिमेंट को प्रोसेस करने के लिए, एक्सएमएल प्रोसेसर और एक्सएमएल क्वेरी लैंग्वेज का इस्तेमाल करके एक्सएमएल जवाबों को प्रोसेस किया जाना चाहिए. हम यहां दिए गए उदाहरणों में XPath का इस्तेमाल करते हैं, क्योंकि यह आम तौर पर एक्सएमएल प्रोसेसिंग लाइब्रेरी में काम करता है.

XPath की मदद से XML को प्रोसेस करना

एक्सएमएल, स्ट्रक्चर्ड जानकारी का एक फ़ॉर्मैट है. इसका इस्तेमाल डेटा इंटरचेंज के लिए किया जाता है. हालांकि, यह JSON जितना हल्का नहीं है, लेकिन XML ज़्यादा भाषाओं में काम करता है और इसमें ज़्यादा बेहतर टूल उपलब्ध हैं. उदाहरण के लिए, Java में XML को प्रोसेस करने का कोड, javax.xml पैकेज में बनाया गया है.

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

XPath एक्सप्रेशन

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

XPath, एक्सएमएल दस्तावेज़ में मौजूद एलिमेंट चुनने के लिए एक्सप्रेशन का इस्तेमाल करता है. इसके लिए, डायरेक्ट्री पाथ के लिए इस्तेमाल किए जाने वाले सिंटैक्स जैसा ही सिंटैक्स इस्तेमाल किया जाता है. ये एक्सप्रेशन, एक्सएमएल दस्तावेज़ ट्री में मौजूद एलिमेंट की पहचान करते हैं. यह एक क्रमबद्ध ट्री होता है, जो डीओएम ट्री की तरह होता है. आम तौर पर, XPath एक्सप्रेशन में मैच करने की ज़्यादा क्षमता होती है. इसका मतलब है कि वे दिए गए मानदंड से मेल खाने वाले सभी नोड से मैच करेंगे.

हम अपने उदाहरणों को दिखाने के लिए, इस ऐब्स्ट्रैक्ट एक्सएमएल का इस्तेमाल करेंगे:

<WebServiceResponse>
 <status>OK</status>
 <result>
  <type>sample</type>
  <name>Sample XML</name>
  <location>
   <lat>37.4217550</lat>
   <lng>-122.0846330</lng>
  </location>
 </result>
 <result>
  <message>The secret message</message>
 </result>
</WebServiceResponse>

एक्सप्रेशन में नोड चुनना

XPath सिलेक्टर, नोड चुनते हैं. रूट नोड में पूरा दस्तावेज़ शामिल होता है. इस नोड को चुनने के लिए, "/" खास एक्सप्रेशन का इस्तेमाल करें. ध्यान दें कि रूट नोड, आपके एक्सएमएल दस्तावेज़ का टॉप-लेवल नोड नहीं होता. दरअसल, यह टॉप-लेवल के इस एलिमेंट से एक लेवल ऊपर होता है और इसमें यह शामिल होता है.

एलिमेंट नोड, एक्सएमएल दस्तावेज़ ट्री में मौजूद अलग-अलग एलिमेंट को दिखाते हैं. <WebServiceResponse> एलिमेंट, उदाहरण के लिए, ऊपर दी गई हमारी सैंपल सेवा में दिखाए गए टॉप-लेवल एलिमेंट को दिखाता है. आपके पास अलग-अलग नोड चुनने का विकल्प होता है. इसके लिए, ऐब्सलूट या रिलेटिव पाथ का इस्तेमाल किया जा सकता है. ऐब्सलूट पाथ में "/" वर्ण मौजूद होता है, जबकि रिलेटिव पाथ में यह वर्ण मौजूद नहीं होता.

ऐब्सलूट पाथ: "/WebServiceResponse/result" एक्सप्रेशन, <WebServiceResponse> नोड के सभी <result> चाइल्ड नोड को चुनता है. (ध्यान दें कि ये दोनों एलिमेंट, रूट नोड "/" से मिलते-जुलते हैं.)
मौजूदा कॉन्टेक्स्ट से जुड़ा रिलेटिव पाथ: "result" एक्सप्रेशन, मौजूदा कॉन्टेक्स्ट में मौजूद किसी भी <result> एलिमेंट से मेल खाएगा. आम तौर पर, आपको कॉन्टेक्स्ट के बारे में चिंता करने की ज़रूरत नहीं होती, क्योंकि आम तौर पर वेब सेवा के नतीजों को एक ही एक्सप्रेशन के ज़रिए प्रोसेस किया जाता है.

इनमें से किसी भी एक्सप्रेशन में, वाइल्डकार्ड पाथ जोड़कर उसे बढ़ाया जा सकता है. इसे डबल-स्लैश ("//") से दिखाया जाता है. इस वाइल्डकार्ड से पता चलता है कि इंटरवीनिंग पाथ में शून्य या उससे ज़्यादा एलिमेंट मैच हो सकते हैं. उदाहरण के लिए, XPath एक्सप्रेशन "//formatted_address," मौजूदा दस्तावेज़ में उस नाम के सभी नोड से मेल खाएगा. एक्सप्रेशन //viewport//lat, उन सभी <lat> एलिमेंट से मेल खाएगा जिनके पैरंट के तौर पर <viewport> को ट्रेस किया जा सकता है.

डिफ़ॉल्ट रूप से, XPath एक्सप्रेशन सभी एलिमेंट से मेल खाते हैं. किसी एक्सप्रेशन को किसी खास एलिमेंट से मैच करने के लिए, उस पर पाबंदी लगाई जा सकती है. इसके लिए, प्रीडिकेट का इस्तेमाल करें. इसे स्क्वेयर ब्रैकेट ([]) में रखा जाता है. उदाहरण के लिए, XPath एक्सप्रेशन "/GeocodeResponse/result[2] हमेशा दूसरा नतीजा दिखाता है.

एक्सप्रेशन का टाइप
रूट नोड	XPath एक्सप्रेशन: "`/`" चुना गया: <WebServiceResponse> <status>OK</status> <result> <type>sample</type> <name>Sample XML</name> <location> <lat>37.4217550</lat> <lng>-122.0846330</lng> </location> </result> <result> <message>The secret message</message> </result> </WebServiceResponse>
ऐब्सलूट पाथ	XPath एक्सप्रेशन: "`/WebServiceResponse/result`" चुना गया: <result> <type>sample</type> <name>Sample XML</name> <location> <lat>37.4217550</lat> <lng>-122.0846330</lng> </location> </result> <result> <message>The secret message</message> </result>
वाइल्डकार्ड वाला पाथ	XPath एक्सप्रेशन: "`/WebServiceResponse//location`" चुना गया: <location> <lat>37.4217550</lat> <lng>-122.0846330</lng> </location>
Path with Predicate	XPath एक्सप्रेशन: "`/WebServiceResponse/result[2]/message`" चुना गया: <message>The secret message</message>
पहले `result` के सभी डायरेक्ट चाइल्ड	XPath एक्सप्रेशन: "`/WebServiceResponse/result[1]/`" चुना गया:* <type>sample</type> <name>Sample XML</name> <location> <lat>37.4217550</lat> <lng>-122.0846330</lng> </location>
`name`, `result` का है. `result` का `type` टेक्स्ट "sample." है.	XPath एक्सप्रेशन: "`/WebServiceResponse/result[type/text()='sample']/name`" चुना गया: Sample XML

यह ध्यान रखना ज़रूरी है कि एलिमेंट चुनते समय, आपको नोड चुनने होते हैं. सिर्फ़ उन ऑब्जेक्ट में मौजूद टेक्स्ट नहीं चुनना होता. आम तौर पर, आपको मैच किए गए सभी नोड पर दोहराव करना होगा और टेक्स्ट को एक्सट्रैक्ट करना होगा. टेक्स्ट नोड को सीधे तौर पर भी मैच किया जा सकता है. इसके बारे में जानने के लिए, नीचे दिया गया टेक्स्ट नोड सेक्शन देखें.

ध्यान दें कि XPath, एट्रिब्यूट नोड के साथ भी काम करता है. हालांकि, Google Maps की सभी वेब सेवाएं, एट्रिब्यूट के बिना एलिमेंट दिखाती हैं. इसलिए, एट्रिब्यूट का मेल खाना ज़रूरी नहीं है.

एक्सप्रेशन में टेक्स्ट चुनने की सुविधा

एक्सएमएल दस्तावेज़ में मौजूद टेक्स्ट को XPath एक्सप्रेशन में, टेक्स्ट नोड ऑपरेटर के ज़रिए तय किया जाता है. यह ऑपरेटर "text()" दिखाता है कि चुने गए नोड से टेक्स्ट निकाला गया है. उदाहरण के लिए, XPath एक्सप्रेशन "//formatted_address/text()" से, <formatted_address> एलिमेंट में मौजूद सभी टेक्स्ट दिखेंगे.

एक्सप्रेशन का टाइप
सभी टेक्स्ट नोड (इसमें व्हाइटस्पेस भी शामिल है)	XPath एक्सप्रेशन: "`//text()`" चुना गया: sample Sample XML 37.4217550 -122.0846330 The secret message
टेक्स्ट चुनने की सुविधा	XPath एक्सप्रेशन: "`/WebServiceRequest/result[2]/message/text()`" चुना गया: The secret message
कॉन्टेक्स्ट के हिसाब से चुनने की सुविधा	XPath एक्सप्रेशन: "`/WebServiceRequest/result[type/text() = 'sample']/name/text()`" चुना गया: Sample XML

इसके अलावा, किसी एक्सप्रेशन का आकलन किया जा सकता है और नोड का एक सेट वापस किया जा सकता है. इसके बाद, उस "नोड सेट" पर दोहराया जा सकता है. इससे हर नोड से टेक्स्ट निकाला जा सकता है. हमने इस तरीके का इस्तेमाल, यहां दिए गए उदाहरण में किया है.

XPath के बारे में ज़्यादा जानकारी के लिए, XPath W3C की खास जानकारी देखें.

Java में XPath का आकलन करना

Java में, javax.xml.xpath.* पैकेज के अंदर XML को पार्स करने और XPath एक्सप्रेशन का इस्तेमाल करने की सुविधा उपलब्ध है. इसलिए, इस सेक्शन में दिए गए सैंपल कोड में Java का इस्तेमाल किया गया है. इससे यह पता चलता है कि एक्सएमएल को कैसे मैनेज किया जाता है और एक्सएमएल सेवा से मिले जवाबों से डेटा को कैसे पार्स किया जाता है.

अपने Java कोड में XPath का इस्तेमाल करने के लिए, आपको सबसे पहले XPathFactory के इंस्टेंस को इंस्टैंशिएट करना होगा. इसके बाद, XPath ऑब्जेक्ट बनाने के लिए, उस फ़ैक्ट्री पर newXPath() को कॉल करना होगा. इसके बाद, यह ऑब्जेक्ट evaluate() तरीके का इस्तेमाल करके, पास किए गए एक्सएमएल और XPath एक्सप्रेशन को प्रोसेस कर सकता है.

XPath एक्सप्रेशन का आकलन करते समय, पक्का करें कि आपने उन सभी संभावित "नोड सेट" पर बारीकी से नज़र डाली हो जो वापस किए जा सकते हैं. ये नतीजे, Java कोड में DOM नोड के तौर पर दिखाए जाते हैं. इसलिए, आपको NodeList ऑब्जेक्ट में ऐसी कई वैल्यू कैप्चर करनी चाहिए. साथ ही, उस ऑब्जेक्ट पर बार-बार काम करके उन नोड से कोई भी टेक्स्ट या वैल्यू निकालनी चाहिए.

यहां दिए गए कोड में, XPath ऑब्जेक्ट बनाने, उसे एक्सएमएल और XPath एक्सप्रेशन असाइन करने, और एक्सप्रेशन का आकलन करके काम का कॉन्टेंट प्रिंट करने का तरीका बताया गया है.

import org.xml.sax.InputSource;
import org.w3c.dom.*;
import javax.xml.xpath.*;
import java.io.*;

public class SimpleParser {

  public static void main(String[] args) throws IOException {

	XPathFactory factory = XPathFactory.newInstance();

    XPath xpath = factory.newXPath();

    try {
      System.out.print("Web Service Parser 1.0\n");

      // In practice, you'd retrieve your XML via an HTTP request.
      // Here we simply access an existing file.
      File xmlFile = new File("XML_FILE");

      // The xpath evaluator requires the XML be in the format of an InputSource
	  InputSource inputXml = new InputSource(new FileInputStream(xmlFile));

      // Because the evaluator may return multiple entries, we specify that the expression
      // return a NODESET and place the result in a NodeList.
      NodeList nodes = (NodeList) xpath.evaluate("XPATH_EXPRESSION", inputXml, XPathConstants.NODESET);

      // We can then iterate over the NodeList and extract the content via getTextContent().
      // NOTE: this will only return text for element nodes at the returned context.
      for (int i = 0, n = nodes.getLength(); i < n; i++) {
        String nodeString = nodes.item(i).getTextContent();
        System.out.print(nodeString);
        System.out.print("\n");
      }
    } catch (XPathExpressionException ex) {
	  System.out.print("XPath Error");
    } catch (FileNotFoundException ex) {
      System.out.print("File Error");
    }
  }
}