Định vị các phần dữ liệu cụ thể của tài liệu XML với XPath, Phần 1 Sử dụng XPath để định vị và xác định từng phần của tài liệu XML ppt

Định vị các phần dữ liệu cụ thể của tài liệu XML với XPath, Phần 1
Sử dụng XPath để định vị và xác định từng phần của tài liệu XML
Brett McLaughlin , Tác giả, biên tập, O'Reilly Media
Tóm tắt: XML là một kiểu định dạng dữ liệu hiệu quả và linh hoạt. Nhưng mục
đích chính của XML là khả năng không giới hạn cho việc tìm kiếm một cách
nhanh và hiệu quả yêu cầu trong toàn bộ một tài liệu. XPath cung cấp khả năng để
dễ dàng tham chiếu đến một văn bản, đến các thành phần và các thuộc tính của tài
liệu — và không yêu cầu nhiều thời gian để nghiên cứu. Thêm vào đó, XPath là
giải pháp để xây dựng từ vựng và công nghệ của XML ví dụ như XSL và XQuery.
Bài hướng dẫn này sẽ dạy bạn các nguyên tắc cơ bản của XPath bao gồm tất cả
các khái niệm và các đối tượng lựa chọn khác nhau dưới dạng các ví dụ và các bài
tập thực hành.
Trước khi bạn bắt đầu
Tìm hiểu về nội dung của bài hướng dẫn này.
Giới thiệu về bài hướng dẫn
Các bài hướng dẫn khác liên quan
 Cải tiến các kết quả của XPath sử dụng tính chất phù hợp, Phần 2
Trong phần 1 của bài học này giới thiệu chi tiết về XPath, mô tả làm thế nào để
bạn có thể xác định các vùng riêng biệt của tài liệu XML sử dụng cú pháp dưới
dạng thư mục. Bạn sẽ được học về cú pháp của XPath và sẽ làm việc với các công
cụ để bạn hiểu rõ hơn về XPath. Sau khi bạn kết thúc bài hướng dẫn này, bạn sẽ có
những kiến thức cơ bản về XPath. Từ đó bạn sẽ hiểu được những khái niệm cơ
bản về các nút và biết cách dùng XPaths một cách hiệu quả và bạn có thể kết hợp
các kết quả khác nhau của XPaths vào làm một.


Mục tiêu bài hướng dẫn
Các thuật ngữ viết tắt
 API: giao diện lập trình ứng dụng
 HTML: Ngôn ngữ đánh dấu siêu văn bản
 URI: Uniform Resource Identifier

 W3C: World Wide Web Consortium
 XML: Ngô ngữ đánh dấu mở rộng
 XSL: Extensible Stylesheet Language
 XSLT: Các phép biến đổi XSL
Bài hướng dẫn này giúp bạn một cách có hệ thống về các khía cạnh của XPath
API bắt đầu từ cú pháp cơ bản đến các xử lý thông dụng nhất. Bao gồm sử dụng
đường dẫn định vị khác nhau và diễn tả làm cách nào định vị xử lý biểu thức
XPath liên quan.
Bạn cũng sẽ bắt đầu tìm hiểu sự liên quan của XPath tới các khái niệm và công
nghệ khác của XML như XSL, XSLT và XQuery. Có thể bạn chưa thành thạo
XPath trong công việc hiện tại của bạn nhưng bạn cũng sẽ có thể áp dụng nó để
giải quyết các vấn đề của công việc thực tế.


Điều kiện tiên quyết
Bài hướng dẫn được viết cho các tác giả và các lập trình viên làm việc về XML.
Bạn có thể trở thành thành viên của bài hướng dẫn để bạn có thể đọc, viết và thực
thi được XML. Bạn nên tìm hiểu các khái niệm liên quan, bao gồm:
 Các thành phần
 Các thuộc tính
 Văn bản
 Thành phần gốc
Tham khảo phần Mô hình đối tượng tài liệu (DOM) để hiểu rõ hơn Các nút, điều
này là không bắt buộc. Nếu bạn muốn đọc tìm hiểu về DOM, ghé thăm Tài nguyên
tìm kiếm một vài đường liên kết liên quan.
Bài hướng dẫn này đề cập đến một số API khác như XSL, XSLT và XPath. Nếu
có sự hiểu biết trước về những vấn đề này thì có ích hơn mặc dù điều này là không
bắt buộc. Để có nhiều thông tin hơn về những vấn đề này, tham khảo Tài nguyên
của bài học.
Cài đặt môi trường làm việc của bạn để áp dụng cho các ví dụ

Bạn sẽ làm việc với tài liệu XML trong suốt bài hướng dẫn này. Bạn sẽ cần phải
sử dụng tài liệu này trên máy của bạn và cần phải biết rõ cấu trúc cơ bản của tài
liệu. Thêm vào đó, bạn sẽ cần phải có công cụ để thực thi XPath và trả lại kết quả
tương ứng với công việc bạn lựa chọn thực hiện. Trong phần này trình bày làm thế
nào để có thể làm việc được trên môi trường làm việc cá nhân của bạn vì thế có
thể thực hiện theo các ví dụ hướng dẫn của bài hướng dẫn.
Các công cụ để đánh giá XPath được phân loại tương ứng cho từng hệ thống xử lý
khác nhau. Một vài công cụ làm việc tốt hơn khi bài tải tệp dưới dạng EXE và
chạy trên nền của Microsoft® Windows® không làm việc trên hệ điều hành Mac
OS X. Tương tự, các công cụ để làm việc với XPath trên hệ điều hành Mac OS X
không thể chạy được trên hệ điều hành Windows. Trong khi bạn sử dụng Java™
các chương trình và các lớp được tạo ra độc lập về mặt hệ thống để có thể làm việc
được với XPath, bài hướng dẫn này tập trung nhiều vào XPath chứ không quan
tâm nhiều về ngôn ngữ lập trình.
Các phần tiếp theo sẽ mô tả cách để làm việc với công cụ mà cho phép làm việc
với XPath trên cả hai hệ điều hành Windows và Mac OS X. Bạn hãy lựa chọn
phần mà bạn muốn tìm hiểu. Với mỗi phần bạn đều có công cụ, tất cả các cú pháp
và các ví dụ xuyên suốt của toàn khóa học để có thể làm việc. Bạn sẽ sử dụng
công cụ của bạn để đánh giá các XPath.
Đánh giá XPaths trên Windows
Một trong các công cụ tốt nhất để làm việc với XPath trên Windows là Stylus
Studio (tham khảo tại tài nguyên tới trang web của Stylus Studio và tải công cụ
về). Tải bất kỳ phiên bản nào của Stylus Studio, gồm: Trial, — Enterprise Suite,
Professional Suite, hoặc Home Edition — và sau đó cài đặt chúng ra trên máy của
bạn tương ứng.
Mỗi lần bạn cài đặt Stylus Studio, phải chắc chắn rằng bạn có thể mở chương trình
và tải được tài liệu XML vào để bạn có thể làm việc được với XPaths. Màn hình
làm việc của bạn trông tương tự như Hình 1.

Hình 1. Stylus Studio cho phép bạn có thể đánh giá làm việc với XPath

Đánh giá XPaths trên Mac OS X
Các công cụ để làm việc với XPath trên Mac OS X — không cần sử dụng các lớp
của Java — là ít được quan tâm và sử dụng hơn so với các phiên bản của
Windows. Công cụ sử dụng hiệu quả nhất để học XPath là AquaPath, là thuộc loại
mã nguồn mở và có thể được tải miễn phí (ghé thăm trang tải về tại Tài nguyên).
Tải AquaPath như là ảnh của đĩa và đơn giản thực hiện di chuyển ứng dụng
AquaPath từ chỗ cài đặt tới thư mục các ứng.
Nháy đúp chuột vào ứng dụng AquaPath được cài đặt mới, và bạn nên tiếp cận
màn hình của ứng dựng, có dạng như sau Hình 2.

Hình 2. AquaPAth cùng cấp cách đánh giá XPath trên hệ điều hành Mac OS
X

Có thể trông không giống như trên nhưng khi đó bạn có thể bắt đầu tải các tài liệu
XML và làm việc trong XPaths, công cụ này — giống như Stylus Studio — nên
đáng để bạn bỏ thời gian để nghiên cứu.
Tài liệu kiểm tra XML
XPath là tốt hơn khi làm việc về XML so với bất kỳ ngôn ngữ lập trình nào. Vì thế
mà trong khi hầu hết các ngôn ngữ lập trình cơ bản sử dụng XPath dưới dạng API
kể từ Java đến ngôn ngữ C# thì bài hướng dẫn này tập trung vào việc đánh giá
XPaths (thông qua công cụ AqualPath hoặc Stylus Studio) tương ứng với các tài
liệu XML
Ví dụ 1 hiển thị một phần của tài liệu XML, là tệp Ant được xây dựng từ bộ phân
tích Java Apache Xerces2. Toàn bộ tài liệu này rất nhiều nhưng phần này chỉ hiển
thị một vài trang ví dụ. Tuy nhiên bạn có thể tải toàn bộ tài liệu XML từ Tài
nguyên.

Ví dụ 1. Ví dụ tài liệu XML cho khóa học

<?xml version="1.0"?>
<!
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
>
<!
===================================================================

Read the README file for build instruction.

Authors:
Stefano Mazzocchi <>
Anupam Bagchi <>
Andy Clark, IBM

$Id: build.xml 567790 2007-08-20 19:16:53Z mrglavas $

====================================================================

>
<project default="usage" basedir=".">

<! Xerces Java directories >
<property name="build.dir" value="./build"/>
<property name="data.dir" value="./data"/>
<property name="docs.dir" value="./docs"/>
<property name="samples.dir" value="./samples"/>
<property name="src.dir" value="./src"/>
<property name="tests.dir" value="./tests"/>
<property name="tools.dir" value="./tools"/>

<! enable compilation under JDK 1.4 and above >
<taskdef name="xjavac" classname="org.apache.xerces.util.XJavac">
<classpath>
<pathelement location="${tools.dir}/bin/xjavac.jar"/>
</classpath>
</taskdef>

<! Allow properties following these statements to be overridden >
<! Note that all of these don't have to exist. They've just been defined
in case they are used. >
<property file="build.properties"/>
<property file=".ant.properties"/>
<property file="${user.home}/.ant.properties"/>
<property file="default.properties"/>

<target name="init">
<property name='parser.Name' value='Xerces-J'/>
<property name='parser.name' value='xerces-j'/>

<property name='parser.shortname' value='xerces'/>
<property name='parser.Version' value='2.9.1'/>
<property name='parser.version' value='2.9.1'/>
<property name='parser_version' value='2_9_1'/>

<property name='deprecatedjar.parser' value='xerces.jar'/>
<property name='jar.apis' value='xml-apis.jar'/>
<property name='jar.parser' value='xercesImpl.jar'/>
<property name='jar.samples' value='xercesSamples.jar'/>
<property name='jar.dv' value='xercesDV.jar'/>
<property name='jar.resolver' value='resolver.jar'/>
<property name='jar.serializer' value='serializer.jar'/>
<property name='jar.junit' value='junit.jar'/>

<! Lots more properties here >

<!
===================================================================
>
<! Prepares the build directory >
<!
===================================================================
>
<target name="prepare" depends="init">
<mkdir dir="${build.dir}"/>
</target>

<!
===================================================================
>

<! directory creation and file copying common to all configurations >
<!
===================================================================
>
<target name="prepare-common" depends="prepare">
<! create directories >
<mkdir dir="${build.src}"/>
<mkdir dir="${build.dest}"/>
<mkdir dir="${build.dest}/META-INF"/>
<mkdir dir="${build.dest}/META-INF/services"/>

<copy
file="${src.dir}/org/apache/xerces/jaxp/javax.xml.parsers.DocumentBuilderFactory"
tofile="${build.dest}/META-INF/services/javax.xml.parsers.DocumentBuilderFactory"/>

<copy
file="${src.dir}/org/apache/xerces/jaxp/javax.xml.parsers.SAXParserFactory"
tofile="${build.dest}/META-INF/services/javax.xml.parsers.SAXParserFactory"/>

<copy
file="${src.dir}/org/apache/xerces/jaxp/datatype/javax.xml.datatype.DatatypeFactory"
tofile="${build.dest}/META-INF/services/javax.xml.datatype.DatatypeFactory"/>

<copy file=
"${src.dir}/org/apache/xerces/jaxp/validation/javax.xml.validation.SchemaFactory"
tofile="${build.dest}/META-INF/services/javax.xml.validation.SchemaFactory"/>

<copy file="${src.dir}/org/apache/xerces/parsers/org.xml.sax.driver"
tofile="${build.dest}/META-INF/services/org.xml.sax.driver"/>

</target>

<! Lots more targets and tasks here >

</project>

Bạn phải chắc chắn rằng bạn đã có tệp xerces-build.xml được lưu trữ ở một nơi dễ
dàng truy cập và đồng thời công cụ XPath đã được cài đặt để sẵn sàng sử dụng.
Lựa chọn các thành phần
XPath có một công việc cơ bản chủ yếu là việc thực hiện lựa chọn các nút. Ở phần
sau sẽ trình bày nhiều hơn các thao tác về nút nhưng ở phần này chỉ đưa ra ý
tưởng để biết được XPath làm thế nào lựa chọn được các nhiệm vụ. Các nhiệm vụ
ở đây bao gồm các thành phần, các thuộc tính và dữ liệu gốc — trong tài liệu
XML. Tuy nhiên, XPath không phải là API để thực hiện thao tác đánh giá. XPath
đạt hiệu quả nhất trong việc khôi phục từng phần của dữ liệu.
Thêm vào đó, các tài liệu XML rất phức tạp và dài. Thậm chí kể cả tài liệu ví dụ
cho khóa học này mặc dù đã rất đơn giản nhưng cũng đã gồm hơn 1,400 dòng
khác nhau. Bạn có thể lựa chọn ngôn ngữ lập trình phù hợp để có thể thực hiện
thao tác thay đổi và xóa dữ liệu khi cần.
Chọn lựa nút gốc
Tất cả các thành phần cơ bản chủ yếu của tài liệu XML — ngoại trừ phần mô tả
của tệp XML được đặt ở dòng đầu tiên trong tài liệu bắt đầu bằng từ <?xml —
được coi phần tử gốc của tài liệu. Phần tử gốc là phần tử bao quanh toàn bộ tài
liệu, chứa trong đó gồm các thành phần, các thuộc tính và các văn bản.
Điều quan trọng phải nhớ rằng phần tử gốc là không khác nhiều so với bất kỳ
thành phần nào khác. Nó cũng gồm thuộc tính và chứa các thành phần khác nữa
như là dữ liệu mở rộng. Tuy nhiên không có nguyên tắc nào cho việc đặt tên cũng
như nội dung chứa trong nút gốc đó. Theo nguyên tắc của XPath việc lựa chọn
phần tử gốc cũng giống như việc lựa chọn bất kỳ thành phần nào khác. Chỉ có
khác XPath phải xác định điều kiện để bắt đầu tìm kiếm; Nói theo nghĩa khác,

phần tử gốc cũng chỉ là một thành phần trong tài liệu luôn luôn biết được chính
xác vị trí lưu trữ và mọi lúc nó luôn luôn chứa các thành phần bên trong.
Để chỉ ra rằng công việc tìm kiếm bắt đầu từ phần tử gốc thì XPath của bạn phải
bắt đầu với ký tự / (dấu gạch chéo). Ví dụ, nếu bạn có phần tử gốc được đặt tên
project, đường dẫn trong Ví dụ 2 lựa chọn thành phần đó.

Ví dụ 2. Lựa chọn phần tử gốc tên project

/project

Không chỉ thực hiện lựa chọn phần tử gốc xác định project, mà còn mô tả hai phần
cơ bản của một xác định XPath:
 Mô tả sự di chuyển và sự kế thừa: Cú pháp có dạng như /hoặc để định
hướng việc kế thừa trong XML. Hầu hết các cú pháp có dạng tương tự như
vậy được sử dụng để định hướng xác định thư mục trong cửa sổ dòng lệnh
shell trên Unix hoặc Windows.
 Các tên của nút: Các tên như "project" hay "name" hay "property" để chỉ
tới các thành phần hay các thuộc tính trong tài liệu XML. Các tham chiếu
này cho phép chỉ đến một phần của tài liệu ở mức (level) hiện tại từ đó có
thể mô tả vị ví bạn đang làm việc của tài liệu
Trong Ví dụ 2, ví dụ đơn giản nhất mô tả sự hoạt động được sử dụng: /. Chỉ dẫn
này XPath xác định là bắt đầu từ phần tử gốc của tài liệu. Vì vậy để thực hiện
/project, bộ đánh giá XPath bắt đầu công việc tìm kiếm luôn luôn từ phần tử gốc
của tài liệu. Vì thế ở mức này công việc thực hiện là tìm kiếm thành phần có tên
project.
Để xem hành động này, cố gắng tải tài liệu xerces-build.xml vào công cụ xử lý
XPath của bạn và xem /project trong kết quả thu được trong XPath. Bạn sẽ nhìn
thấy màn hình có kết quả giống như sau Hình 3.

Hình 3. Định vị phần tử gốc

Kết quả này mô phỏng thao tác lựa chọn phần tử gốc của bạn. Tuy nhiên phải chú
ý rằng điều đó là chưa đủ để sử dụng chính xác /, mặc dù vậy; bạn cũng cần thiết
để có thể lấy được tên của thành phần gốc một cách chính xác.
Có một vài miêu tả sự thay đổi khi đó bạn sẽ phải học về sự tiến triển của bài
hướng dẫn này.
Đánh giá XPaths trên Stylus Studio
Stylus Studio là một công cụ thực sự hiệu quả để làm việc. Bởi vì bạn chỉ mất một
chút ít thời gian là có thể bắt đầu thực hiện đánh giá xử lý các biểu thức XPath của
bạn. Mặc dù không yêu cầu bạn phải làm việc với hết các thành phần của ứng
dụng Stylus Studio nhưng để làm việc hiệu quả hơn bạn cũng nên tìm hiểu một
chút về các thành phần trong ứng dụng này. Trước tiên hãy bắt đầu với Stylus
Studio. Sau đó mở tệp nguồn XML để bắt đầu, trong bài này các bạn sử dụng tệp
xerces-build.xml. Tiến theo phía trên của cửa sổ tài liệu — cái phía dưới biểu
tượng thoát của toàn bộ ứng dụng sẽ cho phép hiển thị thẻ chứa tên tài liệu của bạn
— có một vài biểu tượng. Các biểu tượng này là các ký hiệu không được rõ nghĩa.
Các ký hiệu bên phải của dấu "X" được đặt trong phần mũi tên trỏ lên giữa hai
thanh ngang màu đen ( ). Bấm vào đây, và thêm một khung mới nằm bên phải
của tài liệu bạn đang làm. Đây là phần viết câu lệnh truy vấn của XPath, tại đây
bạn có thể nhập các câu lệnh XPath của bạn vào. Thực hiện đánh lệnh XPath vào
khung thứ hai từ trên xuống và đánh dấu với tên là Query1. Sau đó bạn hãy nhập
câu lệnh XPath của bạn vào và bấm vào mũi tên màu xanh ( ) tại phía trên cùng
của vùng làm việc XPath để tiến hành đánh giá câu lệnh XPath của ban(Stylus
Studio thực hiện xử lý truy vấn của bạn dưới dạng sử dụng XQuery). Các kết quả
sẽ xuất hình ở phần khung phía dưới, nhìn vào Hình 4.

Hình 4. Xác định phần tử gốc trong Stylus Studio

Bắt đầu sử dụng bằng cách mở hai cửa sổ làm việc, một cho tài liệu nguồn (cửa sổ
chính) và một cho các kết quả xử lý XPath (tại khung bên phải). Thêm vào đó bạn

có thể mở rộng các thành phần làm việc để nhìn thấy các thành phần con và các
thuộc tính cũng như các tham số khác của thành phần. AquaPath trên hệ điều hành
Mac OS X không hiển thị trực tiếp các thành phần trên giao diện người dùng
nhưng nó sẽ hỗ trợ để bạn tìm được kết quả xử lý của bạn.


Chọn lựa các thành phần con chứa bên trong
Như đã biết, việc chọn lựa phần tử gốc được thực hiện một cách nhanh chóng. Tuy
nhiên bạn sẽ mất rất nhiều thời gian khi làm việc với các thành phần khác không
phải phần tử gốc trong XPath. Để làm việc với các phần tử trong tài liệu bạn bắt
buộc phải duyệt qua phần tử gốc.
Giả sử rằng bạn đã có phần tử tên là property là con của phần tử gốc project
(project là tên chính xác của phần tử gốc nằm trong tệp xerces-build.xml ví dụ).
Bạn đã biết cách làm thế nào để có thể lựa chọn được phần tử gốc cho nên cái bạn
cần quan tâm tiếp theo là tên của phần tử con property. Bạn làm việc với XPath
dưới dạng như sau Ví dụ 3.

Ví dụ 3. Lựa chọn trực tiếp phần tử property thông qua phần tử gốc
/project/property

Đánh biểu thức trên vào công cụ của bạn và sẽ nhìn thấy kết quả có dạng Hình 5.

Hình 5. Lựa chọn phần tử con

Tham khảo thêm AquaPath nhưng không tập trung vào
Công cụ AquaPath cho hệ điều hành Mac OS X cho phép lựa chọn các thành phần,
các thuộc tính và văn bản sau đó để xử lý biểu thức XPath. Các nút được lựa chọn
sẽ xuất hiện với màu vàng để phân biệt. Tuy nhiên AquaPath không di chuyển
ngay kết quả đến nút đầu tiên hay chỉ hiển thị các nút được lựa chọn. Bạn có thể
nhận được nhiều tài liệu tương ứng phù hợp bên trong cửa sổ của AquaPath. Điều

này có nghĩa là bạn cũng sẽ nhìn thấy cả các kết quả mà bạn không lựa chọn và
khi đó bạn phải cuộn để tìm được kết quả cần chọn lựa. Điều này thực sự là không
thuận tiện khi làm việc với hệ điều hành Mac OS X.
Một lần nữa, đường dẫn thư mục tượng trưng lại được đề cập đến. Dấu gạch chéo
(/) dùng để phân biệt các phần tử khác nhau và vì thế bạn dùng nó để có thể làm
việc với các phần tử ở mức sâu hơn.
Ví dụ 4 là một ví dụ XPath biểu diễn biểu thức phức tạp nhưng rất dễ hiểu.

Ví dụ 4. Lựa chọn phần tử property trực tiếp dựa trên phần tử gốc

/project/taskdef/classpath/pathelement


Hình 6 hiển thị các phần tử được lựa chọn bằng cách thực thi biểu thức XPath trên.

Hình 6. Lựa chọn một số phần tử ở một số mức khác nhau

Trước khi chuyển sang làm việc với các thuộc tính bạn cố gắng thử làm với một số
phần tử con khác bằng XPath trên máy của bạn. Dưới đây là một số ví dụ bạn có
thể áp dụng để làm việc với XPaths:
 Tất cả property của các thành phần con bên trong các phần tử target. target
được chỉ rõ dưới phần tử gốc (có tên là project).
 Tất cả phần tử fileset được đặt trong các phần tử copy. copy được sử dụng
như là con của phần tử target, cái được chỉ trực tiếp dưới phần tử gốc.
 Tất cả các phần tử patternset lồng trong các phần tử unzip. unzip là được
lồng trong phần tử target, là phần tử trực tiếp của phần tử gốc.
 Tất cả các phần tử jar lồng bên trong phần tử target.
Khi bạn làm được các ví dụ XPaths này thì bạn đã sẵn sàng chuyển sang một phần
mới đó là tìm kiếm các phần tử bất kỳ trong một tài liệu.
Lựa chọn các phần tử mà không quan tâm đến sự lồng nhau

Vì lý do bạn chỉ có thế tìm đến được vị trí cần xử lý khi bạn bắt đầu đi qua phần tử
gốc của tài liệu XML. Nên bạn luôn luôn phải biết chính xác đường dẫn tới các
thành phần mà bạn muốn xử lý. Ví dụ đường dẫn XPath kiểu
/project/taskdef/classpath/pathelement được sử dụng hiệu quả nếu thỏa mãn hai
điều sau:
1. Bạn biết rằng pathelement là con của classpath, classpath lại là con của
taskdef, và taskdef là con của project.
2. Bạn chỉ muốn pathelement trong bộ xếp lồng riêng biệt, thậm chí nếu
classpath là các phần khác nhau của tài liệu XML dưới dạng chứa khác
nhau.
Lựa chọn các phần tử khi bạn không có một bộ xếp lồng vào nhau
Bạn sẽ mất nhiều thời gian để có thể xác định được các thành phần trong cấu trúc
lồng nhau kể cả khi bạn biết được mô hình ràng buộc của tài liệu. Nhưng nếu bạn
muốn có tất cả property của các thành phần thì bạn phải xác định được nó được
định vị ở vị trí nào? Hoặc nếu bạn muốn xác định mọi thành phần javac nhưng bạn
không biết về ràng buộc của tài liệu? Trong trường hợp này bạn cần phải có được
cấu trúc thư mục xác định rõ hơn để cho phù hợp.


Sử dụng dấu gạch chéo kép để xác định được vị trí phù hợp của thành phần
Tất cả các biểu thức XPath bạn đã làm trước đó đều bắt đầu với dấu gạch chéo
phía trước rồi sau đó đến phần tử gốc. Với cách làm như vậy mặc định hiểu rằng
bắt đầu là dấu gạch chéo và ngay sau đó thì phần tử đầu tiên chính là phần tử gốc.
Tuy nhiên, bạn có thể sử dụng nhiều hơn một dấu gạch chéo để làm việc với
XPath. Xem biểu thức XPath sau Ví dụ 5.

Ví dụ 5. XPath được bắt đầu bằng dấu gạch chéo kép
//property

Biểu thức này trả lại tất cả property các phần tử, mặc dù không có thành phần gì

được xuất hiện phía sau. Vì vậy thay vì bắt đầu với phần tử gốc, dấu gạch chéo
kép (//) chỉ ra rằng bộ xử lý XPath sẽ tìm kiếm ở bất kỳ vị trí nào trong tài liệu
XML. Khi thực hiện xử lý biểu thức này, bộ công cụ của bạn sẽ trả lại property
các thành phần nằm trong phần tử gốc, project, cũng tương tự như phần tử target
với name giá trị của init (đích đầu tiên gần nhất với phần tử bắt đầu của tài liệu).
Bạn có thể xem các kết quả của ví dụ tại trang Hình 7.

Hình 7. Lựa chọn một thành phần bằng cách ẩn đi vị trí xác định



Tìm kiếm từ bất kỳ vị trí nào trong tài liệu
Bạn đã học hai cách tiếp cận để có được các phần tử thích hợp bằng cách sử dụng
XPath:
 Bắt đầu với phần tử gốc và xác định các vị trí lưu giữ bằng dấu gạch chéo
đơn
 Chỉ dùng tên phần tử cần xác định bằng cách sử dụng dấu gạch chéo kép
Cách tiếp cận này chỉ mới là rất cơ bản nhưng bạn có thể kết hợp hai công nghệ
này lại với nhau để có thể làm việc với những yêu cầu phức tạp hơn một cách
nhanh chóng. Ví dụ, bạn muốn tìm property các thành phần, nhưng chỉ có được
target của các thành phần. Vì thế bạn không muốn property các phần tử nằm trong
gốc project element.
Trường hợp này nếu bắt đầu làm việc với phần tử gốc thì không hiệu quả. Trước
tiên, bạn xác định không muốn các phần tử đặt lồng trực tiếp vào trong phần tử
gốc. Thứ hai, bạn không quan tâm đến vị trí mà property phân tử được đặt vào
cũng như nó được đặt vào target. Vì thế rõ ràng bạn muốn sử dụng dấu gạch chéo
kép cho một số dạng làm việc vì lúc này hoàn toàn độc lập với việc xác định sự
lồng nhau.
Tuy nhiên, bạn muốn chỉ ra một phần tử lồng nhau: cái mà property phải được chỉ
rõ được lồng vào property. Ví dụ 6 là thể hiện cái bạn muốn.

Ví dụ 6. Kết hợp dấu gạch chéo kép với sự lồng nhau
//target/property

Theo cách biểu diễn này bạn sẽ nhìn thấy cách làm việc hiệu quả hơn. Trước tiên
bạn muốn tất cả target thành phần được đặt ở bất kỳ vị trí nào trong tài liệu. Sau
đó //target phân chia của biểu thức XPath cho phép nhận được cái bạn muốn. Tuy
nhiên thay vì trả lại các phần tử này bạn muốn tất cả các phần tử property nằm
trong đó: //target/property. Vì thế bạn kết hợp phần tử lồng nhau xác định với dấu
gạch chéo kép. Thực hiện xử lý biểu thức XPath và bạn sẽ thu được kết quả có
dạng như sau Hình 8.

Hình 8. Sử dụng dấu gạch chéo kép với sự lồng nhau

Bạn có thể viết câu lệnh XPath để xác định theo các thành phần sau:
 Tất cả các phần tử jar ở bất kỳ vị trí nào trong tài liệu XML.
 Tất cả các phần tử attribute lồng vào trong phần tử manifest cái được lồng
vào trong phần tử jar
 Tất cả các phần tử fileset lồng vào trong các phần tử copy


XPath được xử lý từng phần một
Thỉnh thoảng bạn phải xác định trước cách tiếp cận đánh giá XPath để có thể xử lý
các XPath của bạn. Đặc biệt, XPath được xử lý từng phần từng phần một. Trước
tiên, bộ xử lý xác định phần đầu của cú pháp, sẽ xảy ra hai trường hợp hoặc là dấu
gạch chéo đơn hoặc là dấu gạch chéo kép. Điều này để chỉ ra xem công việc tìm
kiếm bắt đầu từ phần tử gốc của tài liệu hay bắt đầu từ một phần tử bất kỳ của tài
liệu. Sau đó, bộ xử lý tìm tất cả các phần tử phù với tên của phần tử được đưa ra
(giống như phần tử project) luôn luôn được coi là điểm bắt đầu việc xử lý.
Tại thời điểm này, công việc của bạn là định vị được bộ xử lý tới vị trí xác định

trong tài liệu. Ví dụ, đối với biểu thức XPath có dạng /project, thì bất kỳ phần tử
nào sau phần của biểu thức XPath được xử lý đều phải liên quan tới phần tử hiện
tại đang xác định. Đó chính là lý do tại sao bạn có thể định vị được các phần tử
được lồng vào: Bộ xử lý luôn luôn đánh giá từng phần của biểu thức và cập nhập
vị trí bên trong của tài liệu. Vì vậy biểu thức /project/task/property trước tiên di
chuyển tới phần tử gốc, sau đó tới phần tử project , sau đó tới bất kỳ phần tử chứa
trong task, và cuối cùng di chuyển tới phần tử property.
Mọi thứ bạn nhận được có thể có một chút ít rắc rối khi bạn thực hiện biểu thức
XPath mà lại phù hợp với nhiều phần tử cùng lúc; ví dụ như biểu thức XPath
/project/task phù hợp với nhiều thành phần task được lồng vào trong /project. Thật
may mắn, bộ xử lý là đủ thông minh để có lưu giữ từng phần định vị và tiếp tục
làm việc nhiều hơn nữa dựa trên các định vị của biểu thức đó.
Điều này tạo nên một sự thú vị, ví dụ biểu thức XPath có dạng như
//java/classpath. Trong trường hợp này, bộ xử lý bắt đầu bằng xác định tất cả các
thành phần của java ở bất kỳ vị trí nào trong tài liệu — thậm chí tại một mức khác
của sự lồng nhau. Đối với từng vị trí trong số các vị trí này, sự lồng nhau của phần
tử classpath được xác định để tìm kiếm. Bạn nhận thấy rằng bộ xử lý XPath đang
cất giữ nhiều định vị khác nhau.
Từ đó bạn nhận thấy rằng, tư tưởng chính của bộ xử lý luôn luôn làm việc từng
phần từng phần một và cập nhật kết quả thu được trong tài liệu và nó là nền tảng
mỗi khi bạn bắt đầu để giải quyết cho các xử lý khác trong tài liệu — dưới dạng
như là các thuộc tính.