जियोकोडिंग एपीआई वेब सेवाओं का इस्तेमाल करने के सबसे सही तरीके

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

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

वेब सेवा क्या है?

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

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

आम तौर पर, Geocoding API का अनुरोध इस तरह का होता है:

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

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

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

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

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

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

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

विशेष वर्ण

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

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

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

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

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

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

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

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

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

गड़बड़ियों को मैनेज करना और फिर से कोशिश करना

Geocoding API से मिले UNKNOWN_ERROR या OVER_QUERY_LIMIT रिस्पॉन्स कोड के बारे में जानकारी पाने के लिए, गड़बड़ियों को मैनेज करने और फिर से कोशिश करने के बारे में पढ़ें.

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

कुछ मामलों में, आपके अनुरोध को पूरा करने में कोई गड़बड़ी हो सकती है. आपको 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 की मदद से एक्सएमएल को प्रोसेस करना

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

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

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

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

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

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

    <location>
     <lat>37.4217550</lat>
     <lng>-122.0846330</lng>
    </location>
    

    <message>The secret message</message>
    

     <type>sample</type>
     <name>Sample XML</name>
     <location>
      <lat>37.4217550</lat>
      <lng>-122.0846330</lng>
     </location>
    

    Sample XML
    

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

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

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

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

    sample
    Sample XML

    37.4217550
    -122.0846330
    The secret message
    

    The secret message
    

    Sample XML
    

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

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

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

Java में, javax.xml.xpath.* पैकेज में एक्सएमएल को पार्स करने और 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");
    }
  }
}