ทดลองใช้ฟีเจอร์ใหม่ของ ระยะทางเมทริกซ์ กับ Routes API ได้แล้วในหน้าตัวอย่าง

แนวทางปฏิบัติแนะนําโดยใช้ Web Matrix API Web Services

จัดทุกอย่างให้เป็นระเบียบอยู่เสมอด้วยคอลเล็กชัน บันทึกและจัดหมวดหมู่เนื้อหาตามค่ากำหนดของคุณ

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

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

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

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

บริการเว็บ Maps API จะใช้คําขอ HTTP(S) ไปยัง URL ที่เฉพาะเจาะจง โดยส่งพารามิเตอร์ของ URL และ/หรือข้อมูล POST ในรูปแบบ JSON เป็นอาร์กิวเมนต์ให้กับบริการ โดยทั่วไปบริการเหล่านี้จะแสดงผลคําขอ HTTP(S) ในรูปแบบ 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 ที่ถูกต้อง

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

สัญลักษณ์พิเศษ

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

สรุปอักขระ URL ที่ถูกต้อง
ตั้งค่าตัวอักขระการใช้ URL
ตัวอักษรและตัวเลขคละกัน ก พ รั ด แ ล้ ว สตริงข้อความ การใช้งานสคีม (http) พอร์ต (8080) และอื่นๆ
ไม่ได้จอง - _ ~ สตริงข้อความ
จองแล้ว ! * ' ( ) ; : @ & = + $ , / ? % # [ ] ควบคุมอักขระและ/หรือสตริงข้อความ

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

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

อักขระทั้งหมดที่จะเข้ารหัส URL จะได้รับการเข้ารหัสโดยใช้อักขระ '%' และค่าเลขฐานสิบหกอักขระสองตัวที่สัมพันธ์กับอักขระ 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

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

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

อักขระที่ไม่ปลอดภัย ค่าที่เข้ารหัส
เว้นวรรค %20
" %22
< %3C
> %3E
# %23
% %25
| %7C

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

นอกจากนี้ URL ต้องไม่เกิน 8192 อักขระสําหรับบริการเว็บ Google Maps Platform ทั้งหมดและ API เว็บแบบคงที่ สําหรับบริการส่วนใหญ่ ใกล้จะถึงจํานวนอักขระที่จํากัดแล้ว อย่างไรก็ตาม โปรดทราบว่าบริการบางประเภทมีพารามิเตอร์หลายรายการที่อาจส่งผลให้ URL ยาว

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

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

Exponential Backoff

ในบางกรณีที่เกิดขึ้นไม่บ่อยนักคืออาจมีข้อผิดพลาดเกิดขึ้นตามคําขอ คุณอาจได้รับรหัสการตอบกลับ HTTP 4XX หรือ 5XX หรือการเชื่อมต่อ TCP อาจล้มเหลวระหว่างไคลเอ็นต์กับเซิร์ฟเวอร์ของ Google บ่อยครั้งที่ควรลองใช้คําขออีกครั้งเพราะคําขอติดตามผลอาจสําเร็จเมื่อคําขอเดิมไม่สําเร็จ อย่างไรก็ตาม การไม่ส่งคําขอซ้ําไปยังเซิร์ฟเวอร์ของ Google&#39 ซ้ําๆ พฤติกรรมการวนซ้ํานี้อาจทําให้เครือข่าย ระหว่างไคลเอ็นต์และ 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 ซิงโครไนซ์ตั้งแต่ต้นนาที แม้จะเผยแพร่ระหว่างอุปกรณ์ต่างๆ แทนที่จะกระจายเท่าๆ กันในช่วงเวลาหนึ่งๆ การออกแบบแอปพลิเคชันที่ไม่ดีเช่นนี้จะทําให้เกิดการเข้าชมที่เพิ่มขึ้นอย่างรวดเร็วที่ระดับปกติ 60 เท่าในตอนต้นของแต่ละนาที

การออกแบบที่ดีอย่างหนึ่งคือ ให้ตั้งปลุกครั้งที่ 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> (โปรดทราบว่าองค์ประกอบทั้ง 2 อย่างนี้จะรับค่ามาจากโหนดราก "/".)
  • เส้นทางที่เกี่ยวข้องจากบริบทปัจจุบัน: นิพจน์"result" จะตรงกับองค์ประกอบ <result> ใดๆ ภายในบริบทปัจจุบัน โดยปกติ คุณไม่ควรกังวลเกี่ยวกับบริบทเนื่องจากโดยปกติแล้ว คุณจะประมวลผลผลการค้นหาบริการทางเว็บผ่านนิพจน์เดียว

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

โดยค่าเริ่มต้น นิพจน์ XPath จะตรงกับองค์ประกอบทั้งหมด คุณจํากัดนิพจน์ให้ตรงกับองค์ประกอบบางอย่างได้โดยระบุคํากริยา ซึ่งอยู่ในวงเล็บเหลี่ยม ([]) นิพจน์ XPath "/GeocodeResponse/result[2] แสดงผลลัพธ์ที่ 2 เสมอ เช่น

ประเภทนิพจน์
โหนดราก
XPath Expression: "/"
การเลือก:
    <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 Expression:  "/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 Expression: "/WebServiceResponse//location"
การเลือก:
    <location>
     <lat>37.4217550</lat>
     <lng>-122.0846330</lng>
    </location>
    
เส้นทางที่มีคํากริยา
XPath Expression: "/WebServiceResponse/result[2]/message"
การเลือก:
    <message>The secret message</message>
    
รายการย่อยทั้งหมดของ result รายการแรก
XPath Expression:  "/WebServiceResponse/result[1]/*"
การเลือก:
     <type>sample</type>
     <name>Sample XML</name>
     <location>
      <lat>37.4217550</lat>
      <lng>-122.0846330</lng>
     </location>
    
name ของ result ที่มีข้อความ type คือ "sample."
XPath Expression:  "/WebServiceResponse/result[type/text()='sample']/name"
การเลือก:
    Sample XML
    

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

โปรดทราบว่า XPath รองรับโหนดแอตทริบิวต์ด้วยเช่นกัน แต่บริการเว็บ Google Maps ทั้งหมดแสดงองค์ประกอบที่ไม่มีแอตทริบิวต์ การจับคู่แอตทริบิวต์จึงไม่จําเป็น

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

ข้อความภายในเอกสาร XML จะระบุในนิพจน์ XPath ผ่านโอเปอเรเตอร์ โหนดข้อความ โอเปอเรเตอร์นี้ "text()" ระบุการแยกข้อความจากโหนดที่ระบุ เช่น นิพจน์ XPath "//formatted_address/text()" จะแสดงผลข้อความทั้งหมดภายในองค์ประกอบ <formatted_address>

ประเภทนิพจน์
โหนดข้อความทั้งหมด (รวมถึงช่องว่าง)
XPath Expression:  "//text()"
การเลือก:
    sample
    Sample XML

    37.4217550
    -122.0846330
    The secret message
    
การเลือกข้อความ
XPath Expression: "/WebServiceRequest/result[2]/message/text()"
การเลือก:
    The secret message
    
การเลือกเนื้อหาตามบริบท
XPath Expression:  "/WebServiceRequest/result[type/text() = 'sample']/name/text()"
การเลือก:
    Sample XML
    

หรือคุณอาจประเมินนิพจน์แล้วแสดงผลชุดโหนด จากนั้นทําซ้ําคําสั่ง "node set," ดึงข้อมูลข้อความจากแต่ละโหนด เราใช้วิธีการดังต่อไปนี้ในตัวอย่างด้านล่าง

ดูข้อมูลเพิ่มเติมเกี่ยวกับ XPath ในข้อมูลจําเพาะของ XPath W3C

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

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

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

เมื่อประเมินนิพจน์ XPath โปรดตรวจสอบว่าคุณทําซ้ํา "node set" ที่อาจแสดงผลกลับมา เนื่องจากผลลัพธ์เหล่านี้แสดงเป็นโหนด 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");
    }
  }
}