แนวทางปฏิบัติแนะนำในการใช้บริการ Distance Matrix API บนเว็บ

บริการเว็บของ Google Maps Platform เป็นชุดอินเทอร์เฟซ HTTP ที่ส่งไปยัง Google ซึ่งเป็นบริการที่ให้ข้อมูลทางภูมิศาสตร์สำหรับแอปพลิเคชันแผนที่ของคุณ

คู่มือนี้จะอธิบายแนวทางปฏิบัติทั่วไปบางส่วนที่มีประโยชน์สำหรับการตั้งค่า เว็บเซอร์วิส และประมวลผลการตอบกลับของบริการ ดูคู่มือสำหรับนักพัฒนาซอฟต์แวร์ หากต้องการดูเอกสารประกอบฉบับเต็มเกี่ยวกับ Distance Matrix API

บริการทางเว็บคืออะไร

บริการบนเว็บของ Google Maps Platform คืออินเทอร์เฟซสําหรับขอข้อมูล Maps API จาก บริการภายนอกและการใช้ข้อมูลภายในแอปพลิเคชันแผนที่ของคุณ บริการเหล่านี้ เพื่อใช้ร่วมกับแผนที่ ตาม ข้อจำกัดของใบอนุญาต ในข้อกำหนดในการให้บริการของ Google Maps Platform

บริการบนเว็บของ Maps API ใช้คำขอ HTTP(S) ไปยัง URL ที่เฉพาะเจาะจง โดยส่งผ่านพารามิเตอร์ของ URL และ/หรือ ข้อมูล POST ในรูปแบบ JSON เป็นอาร์กิวเมนต์ไปยังบริการ โดยทั่วไป บริการเหล่านี้จะแสดงข้อมูลใน เนื้อหาการตอบกลับเป็น JSON หรือ XML สำหรับการแยกวิเคราะห์ และ/หรือกำลังประมวลผลโดยแอปพลิเคชันของคุณ

คำขอ Distance Matrix API โดยทั่วไปจะเป็น แบบฟอร์มต่อไปนี้:

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

โดยที่ output ระบุรูปแบบการตอบกลับ (โดยปกติแล้ว json หรือ xml)

หมายเหตุ: แอปพลิเคชัน Distance Matrix API ทั้งหมดต้องมีการตรวจสอบสิทธิ์ ดูข้อมูลเพิ่มเติมเกี่ยวกับข้อมูลเข้าสู่ระบบการตรวจสอบสิทธิ์

การเข้าถึง SSL/TLS

ต้องใช้ HTTPS สำหรับคำขอ Google Maps Platform ทั้งหมดที่ใช้คีย์ API หรือมีผู้ใช้ คำขอที่ส่งผ่าน HTTP ซึ่งมีข้อมูลที่ละเอียดอ่อนอาจถูกปฏิเสธ

การสร้าง URL ที่ถูกต้อง

คุณอาจคิดว่า "ถูกต้อง" URL ชัดเจน แต่มีความชัดเจน ยังไม่ใช่แบบนั้น URL ที่ป้อนในแถบที่อยู่เว็บใน อาจมีสัญลักษณ์พิเศษ (เช่น "上海+中國"); เบราว์เซอร์จำเป็นต้องแปลเป็นการภายใน อักขระเหล่านั้นเป็นการเข้ารหัสที่แตกต่างกันก่อนส่ง โทเค็นเดียวกันจะหมายถึงโค้ดที่สร้างหรือยอมรับอินพุต UTF-8 อาจถือว่า URL ที่มีอักขระ UTF-8 นั้น "ถูกต้อง" แต่ก็ต้อง เพื่อแปลอักขระเหล่านั้นก่อนที่จะส่งไปยังเว็บเซิร์ฟเวอร์ กระบวนการนี้เรียกว่า การเข้ารหัส URL หรือการเข้ารหัสเปอร์เซ็นต์

อักขระพิเศษ

เราจำเป็นต้องแปลอักขระพิเศษเนื่องจาก URL ทั้งหมดต้องสอดคล้องกับไวยากรณ์ที่ระบุโดย เครื่องแบบ ข้อกำหนดของตัวระบุทรัพยากร (URI) ในความเป็นจริงหมายความว่า URL จะต้องประกอบด้วยชุดย่อยพิเศษของอักขระ ASCII ได้แก่ สัญลักษณ์ที่เป็นตัวอักษรและตัวเลขคละกัน และอักขระที่สงวนไว้บางตัวเพื่อใช้เป็นตัวควบคุม อักขระภายใน URL ตารางนี้จะสรุปอักขระเหล่านี้

เมื่อสร้าง URL ที่ถูกต้อง คุณต้องตรวจสอบว่า URL นั้นมีเฉพาะอักขระที่แสดงใน การปฏิบัติตาม URL เพื่อใช้ชุดอักขระนี้โดยทั่วไป จะก่อให้เกิดปัญหา 2 ประการ อันหนึ่งคือ การละเว้นสิ่งใดสิ่งหนึ่ง และการทดแทนอีกอย่างหนึ่งอย่างนั้น

• มีอักขระที่คุณต้องการจัดการอยู่นอก ข้างต้น ตัวอย่างเช่น อักขระในภาษาต่างประเทศ เช่น 上海+中國 จำเป็นต้องเข้ารหัสโดยใช้ ที่อยู่เหนืออักขระ ตามการประชุมยอดนิยม การเว้นวรรค (ซึ่งก็คือ ไม่อนุญาตภายใน URL) มักจะแสดงโดยใช้เครื่องหมายบวก '+' อักขระด้วย
• อักขระอยู่ภายในชุดด้านบนเป็นอักขระสงวน แต่จำเป็นต้องใช้จริงๆ ตัวอย่างเช่น ? จะใช้ภายใน URL เพื่อระบุว่า จุดเริ่มต้นของสตริงการค้นหา หากคุณต้องการใช้ สตริง "? และเรื่องลึกลับ" คุณจะต้องเข้ารหัส '?' อักขระ

อักขระทั้งหมดที่จะเข้ารหัส URL จะเข้ารหัส โดยใช้อักขระ '%' และเลขฐานสิบหก 2 ตัว ที่สอดคล้องกับอักขระ UTF-8 ตัวอย่างเช่น 上海+中國 ใน UTF-8 จะเข้ารหัส URL เป็น %E4%B8%8A%E6%B5%B7%2B%E4%B8%AD%E5%9C%8B สตริง ? and the Mysterians จะมีการเข้ารหัส URL เป็น %3F+and+the+Mysteriansหรือ%3F%20and%20the%20Mysterians

อักขระทั่วไปที่ต้องเข้ารหัส

อักขระทั่วไปที่จะต้องเข้ารหัสมีดังนี้

การแปลง URL ที่คุณได้รับจากข้อมูลจากผู้ใช้เป็นบางครั้ง ซับซ้อน ตัวอย่างเช่น ผู้ใช้สามารถป้อนที่อยู่เป็น "5th&Main St." โดยทั่วไป คุณควรสร้าง URL จากชิ้นส่วน โดยถือ ข้อมูลจากผู้ใช้เป็นอักขระลิเทอรัล

นอกจากนี้ URL จะมีอักขระได้ไม่เกิน 16, 384 ตัวสำหรับบริการบนเว็บของ Google Maps Platform ทั้งหมด และเว็บ API แบบคงที่ สำหรับบริการส่วนใหญ่ จำนวนอักขระสูงสุดนี้แทบจะไม่ได้ใช้เลย อย่างไรก็ตาม โปรดทราบว่าบริการบางอย่างมีพารามิเตอร์หลายรายการที่อาจทำให้เกิด URL แบบยาว

การใช้ Google APIs อย่างสุภาพ

ไคลเอ็นต์ API ซึ่งออกแบบมาไม่ดีอาจมีภาระงานมากเกินความจำเป็นทั้งบนโลกอินเทอร์เน็ตและ เซิร์ฟเวอร์ของ Google ส่วนนี้ประกอบด้วยแนวทางปฏิบัติที่ดีที่สุดบางส่วนสำหรับไคลเอ็นต์ของ API กำลังติดตาม แนวทางปฏิบัติแนะนำเหล่านี้จะช่วยให้คุณสามารถป้องกันไม่ให้แอปพลิเคชันถูกบล็อกเนื่องจากการละเมิด API

Exponential Backoff

ในบางกรณีที่เกิดขึ้นไม่บ่อยนัก อาจเกิดความผิดพลาดในการดำเนินการตามคำขอของคุณ คุณอาจได้รับ HTTP 4XX หรือ 5XX หรือการเชื่อมต่อ TCP อาจล้มเหลวระหว่างไคลเอ็นต์ของคุณและ เซิร์ฟเวอร์ บ่อยครั้งที่คุ้มค่าที่จะลองส่งคำขอใหม่ คำขอติดตามผลอาจสำเร็จเมื่อการดำเนินการครั้งแรกล้มเหลว อย่างไรก็ตาม คุณไม่ควรเพียงแค่ ส่งคำขอไปยังเซิร์ฟเวอร์ของ Google ซ้ำๆ การทำงานแบบวนซ้ำนี้อาจทำให้ เครือข่ายระหว่างไคลเอ็นต์ของคุณและ Google ซึ่งทำให้เกิดปัญหากับหลายฝ่าย

วิธีที่ดีกว่าคือลองอีกครั้งโดยให้ความล่าช้าเพิ่มขึ้นระหว่างการดำเนินการแต่ละครั้ง โดยปกติ ความล่าช้าจะเพิ่มขึ้นตามตัวคูณของความพยายามแต่ละครั้ง ซึ่งเราเรียกกันว่า Exponential Backoff

ตัวอย่างเช่น ลองพิจารณาแอปพลิเคชันที่ต้องการส่งคำขอนี้ไปยัง Time Zone API

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

ตัวอย่าง Python ต่อไปนี้แสดงวิธีส่งคำขอด้วย Exponential Backoff

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

คุณควรระมัดระวังไม่ให้ลองเขียนโค้ดอีกครั้งในการเรียกใช้แอปพลิเคชัน เชนที่นําไปสู่คําขอซ้ำๆ ติดต่อกันอย่างรวดเร็ว

คำขอที่ซิงค์

คำขอที่ซิงค์จำนวนมากไปยัง API ของ Google อาจดูเหมือนคำขอที่ กระจาย การโจมตีการปฏิเสธการให้บริการ (DDoS) บนโครงสร้างพื้นฐานของ Google และควรปฏิบัติอย่างเหมาะสม ถึง เพื่อหลีกเลี่ยงปัญหานี้ คุณควรตรวจสอบว่าคำขอ API ไม่มีการซิงค์ ระหว่างไคลเอ็นต์

ตัวอย่างเช่น ลองพิจารณาแอปพลิเคชันที่แสดงเวลาในเขตเวลาปัจจุบัน แอปพลิเคชันนี้น่าจะตั้งปลุกในระบบปฏิบัติการของไคลเอ็นต์เพื่อให้เริ่มทำงานในเวลา จุดเริ่มต้นของนาทีเพื่อให้อัปเดตเวลาที่แสดงได้ แอปพลิเคชันควร ไม่เรียก API ใดๆ เป็นส่วนหนึ่งของการประมวลผลที่เชื่อมโยงกับการปลุกนั้น

การเรียก API ตามการปลุกแบบคงที่นั้นไม่ดี เนื่องจากจะทำให้การเรียก API ซิงค์ตั้งแต่นาทีแรก แม้กระทั่งระหว่างอุปกรณ์ต่างๆ จะกระจายอย่างเท่าๆ กันเมื่อเวลาผ่านไป แอปพลิเคชันที่ออกแบบไว้ไม่ดี ซึ่งมีส่วนทำให้ การเข้าชมที่ระดับปกติหกสิบเท่า ณ จุดเริ่มต้นของแต่ละนาที

แต่วิธีออกแบบที่ดีที่เป็นไปได้อย่างหนึ่งคือ ตั้งปลุกครั้งที่ 2 ตามเวลาที่เลือกแบบสุ่ม เมื่อการปลุกครั้งที่ 2 เริ่มทํางาน แอปพลิเคชันจะเรียก API ที่จำเป็นต้องใช้และจัดเก็บ ผลลัพธ์ เมื่อแอปพลิเคชันต้องการอัปเดตการแสดงผลตั้งแต่เริ่มต้นนาที แอปพลิเคชันจะใช้ ผลลัพธ์ที่จัดเก็บไว้ก่อนหน้านี้ แทนการเรียกใช้ API อีกครั้ง วิธีนี้ทำให้การเรียก API จะกระจายอย่างเท่าๆ กันเมื่อเวลาผ่านไป นอกจากนี้ การเรียก API จะไม่ทำให้การแสดงผลล่าช้าเมื่อ กำลังอัปเดต

นอกจากเวลาเริ่มนาทีแล้ว เวลาซิงค์ทั่วไปอื่นๆ ที่ควรระมัดระวัง ไม่ ในการกําหนดเป้าหมายคือจุดเริ่มต้นของชั่วโมงและเริ่มต้นของแต่ละวันตอนเที่ยงคืน

กำลังประมวลผลคำตอบ

ส่วนนี้จะกล่าวถึงวิธีดึงค่าเหล่านี้แบบไดนามิกจากการตอบกลับของบริการเว็บ

บริการบนเว็บของ Google Maps ให้คำตอบที่ เข้าใจ แต่ไม่ค่อยใช้งานง่ายนัก เมื่อดำเนินการค้นหา คุณอาจต้องการแยกชุดข้อมูล โดยทั่วไป คุณจะต้องแยกวิเคราะห์คำตอบจากเว็บ บริการและแยกเฉพาะค่าที่คุณสนใจ

รูปแบบการแยกวิเคราะห์ที่คุณใช้จะขึ้นอยู่กับว่าคุณกำลังส่งคืน เป็น XML หรือ JSON การตอบกลับ JSON อยู่ในรูปแบบของ ออบเจ็กต์ JavaScript อาจประมวลผลภายใน JavaScript เอง ไคลเอ็นต์ การตอบกลับ XML ควรประมวลผลโดยใช้ตัวประมวลผล XML และภาษาการค้นหา XML เพื่อจัดการกับองค์ประกอบภายในรูปแบบ XML เราใช้ XPath ในพารามิเตอร์ ดังตัวอย่างต่อไปนี้ เนื่องจากโดยทั่วไปจะรองรับในการประมวลผล XML ห้องสมุด

การประมวลผล XML ด้วย XPath

XML เป็นรูปแบบข้อมูลที่มีโครงสร้างที่สมบูรณ์สำหรับผู้ใช้ การแลกเปลี่ยนข้อมูลกัน แม้จะไม่ได้เรียบง่ายเท่า JSON, XML ให้การสนับสนุนด้านภาษาเพิ่มเติมและเครื่องมือที่มีประสิทธิภาพยิ่งขึ้น รหัสสำหรับ เช่น การประมวลผล XML ใน Java จะฝังอยู่ใน javax.xml แพ็กเกจ

ในการประมวลผลการตอบกลับ XML คุณควรใช้ ภาษาในการค้นหาสำหรับการเลือกโหนดภายในเอกสาร XML จะถือว่าองค์ประกอบอยู่ที่ตำแหน่งสัมบูรณ์ภายในองค์ประกอบ มาร์กอัป XML XPath คือไวยากรณ์ในภาษาที่ใช้ในการอธิบายโหนดและองค์ประกอบต่างๆ อย่างไม่ซ้ำกัน ภายในเอกสาร XML นิพจน์ XPath ช่วยให้คุณระบุ เนื้อหาเฉพาะภายในเอกสารการตอบกลับ XML

นิพจน์ XPath

ความคุ้นเคยกับ XPath ทำให้พัฒนาได้ วิธีการแยกวิเคราะห์ที่มีประสิทธิภาพ เนื้อหาส่วนนี้จะเน้นวิธีที่องค์ประกอบ ภายในเอกสาร XML จะกล่าวถึงด้วย XPath ซึ่งช่วยให้คุณ จัดการองค์ประกอบที่หลากหลายและสร้างการค้นหาที่ซับซ้อน

XPath ใช้นิพจน์เพื่อเลือกองค์ประกอบภายใน XML โดยใช้ไวยากรณ์ที่คล้ายกับที่ใช้ในเส้นทางไดเรกทอรี นิพจน์เหล่านี้จะระบุองค์ประกอบภายในเอกสาร XML ซึ่งเป็นต้นไม้ที่มีลำดับชั้นคล้ายกับ DOM โดยทั่วไป นิพจน์ XPath จะใช้ได้อย่างกว้างขวาง โดยระบุว่า จะตรงกับโหนดทั้งหมดที่ตรงกับเกณฑ์ที่ให้ไว้

เราจะใช้ XML สมมติต่อไปนี้เพื่อแสดงให้เห็น ตัวอย่าง:

<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 จะเลือกโหนด โหนดราก ครอบคลุมทั้งเอกสาร คุณเลือกโหนดนี้โดยใช้ นิพจน์พิเศษ "/" โปรดทราบว่ารูท โหนดไม่ใช่โหนดระดับบนสุดของเอกสาร XML ของคุณ จริงๆ แล้ว อยู่เหนือองค์ประกอบระดับบนสุดนี้ 1 ระดับ และรวมถึง ได้

โหนดองค์ประกอบแสดงองค์ประกอบต่างๆ ภายใน XML แผนผังเอกสาร องค์ประกอบ <WebServiceResponse> เช่น แสดงองค์ประกอบระดับบนสุดที่ปรากฏใน บริการตัวอย่างด้านบน คุณเลือกแต่ละโหนดผ่าน เส้นทางสัมบูรณ์หรือเส้นทางสัมพัทธ์ ซึ่งระบุด้วยการปรากฏหรือ ไม่มี "/" นำหน้า อักขระ

• เส้นทางสัมบูรณ์: "/WebServiceResponse/result" นิพจน์เลือกทั้ง <result> โหนดที่ เป็นลูกของ<WebServiceResponse> (โปรดทราบว่าองค์ประกอบทั้งสองนี้มาจากราก โหนด "/")
• เส้นทางสัมพัทธ์จากบริบทปัจจุบัน: นิพจน์ "result" จะตรงกับ <result> ใดก็ได้ ในบริบทปัจจุบัน โดยทั่วไปแล้วคุณไม่ควร ก็ไม่ต้องกังวลเรื่องบริบท เพราะคุณมักจะประมวลผลเว็บ ผลลัพธ์บริการผ่านทางนิพจน์เดียว

นิพจน์ใดนิพจน์หนึ่งเหล่านี้อาจทำการเสริมผ่านการบวก ของเส้นทางไวลด์การ์ด ซึ่งระบุด้วยเครื่องหมายทับคู่ ("//") ไวลด์การ์ดนี้ระบุว่าองค์ประกอบ 0 รายการขึ้นไปอาจตรงกันใน เข้าไปด้วย นิพจน์ XPath "//formatted_address" ตัวอย่างเช่น จะจับคู่โหนดทั้งหมดของชื่อนั้นในเอกสารปัจจุบัน นิพจน์ //viewport//lat จะจับคู่ <lat> องค์ประกอบที่ติดตาม <viewport> ได้ ในฐานะผู้ปกครอง

โดยค่าเริ่มต้น นิพจน์ XPath จะจับคู่องค์ประกอบทั้งหมด คุณสามารถจำกัด นิพจน์ที่จะจับคู่กับองค์ประกอบบางอย่างโดยการระบุ predicate ซึ่งจะอยู่ในวงเล็บเหลี่ยม ([]) 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 จะแสดงองค์ประกอบที่ไม่มีแอตทริบิวต์ ไม่จำเป็นต้องจับคู่แอตทริบิวต์

การเลือกข้อความในนิพจน์

มีการระบุข้อความภายในเอกสาร XML ในนิพจน์ 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

การประเมิน XPath ใน Java

Java รองรับการแยกวิเคราะห์ XML และการใช้นิพจน์ XPath ในวงกว้าง ในแพ็กเกจ javax.xml.xpath.* ด้วยเหตุนี้ โค้ดตัวอย่างในส่วนนี้จึงใช้ Java เพื่อ แสดงวิธีจัดการ XML และแยกวิเคราะห์ข้อมูลจากการตอบกลับบริการ XML

หากต้องการใช้ XPath ในโค้ด Java ก่อนอื่นคุณจะต้องสร้างอินสแตนซ์ อินสแตนซ์ของ XPathFactory และการเรียกใช้ newXPath() ในโรงงานเพื่อสร้างออบเจ็กต์ XPath จากนั้นออบเจ็กต์นี้จะประมวลผล XML ที่ส่งผ่านได้ และนิพจน์ XPath โดยใช้เมธอด evaluate()

เมื่อประเมินนิพจน์ XPath ควรตรวจสอบว่าคุณได้ทำซ้ำ จาก "ชุดโหนด" ทั้งหมดที่เป็นไปได้ ซึ่งระบบอาจส่งคืนได้ เนื่องจาก ผลลัพธ์แสดงเป็นโหนด DOM ในโค้ด Java คุณควรจับภาพ ค่าหลายค่าภายในออบเจ็กต์ NodeList และ ทำซ้ำในออบเจ็กต์นั้นเพื่อดึงข้อความหรือค่าจาก

โค้ดต่อไปนี้แสดงวิธีสร้าง XPath กำหนด XML และนิพจน์ 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");
    }
  }
}