Giáo trình Lập trình web nâng cao (XML)
ỦY BAN NHÂN DÂN TỈNH LÂM ĐỒNG
TRƯỜNG CAO ĐẲNG NGHỀ ĐÀ LẠT
GIÁO TRÌNH
MÔN HỌC/ MÔ ĐUN: LẬP TRÌNH WEB NÂNG CAO (XML)
NGÀNH/ NGHỀ: THIẾT KẾ TRANG WEB
TRÌNH ĐỘ: CAO ĐẲNG
Ban hành kèm theo Quyết định số: 1157/QĐ-CĐNĐL ngày 11 tháng 12 năm
2019 của Hiệu trưởng Trường Cao đẳng Nghề Đà Lạt
(LƯU HÀNH NỘI BỘ)
Lâm Đồng, năm 2019
LỜI GIỚI THIỆU
Vài nét về xuất xứ giáo trình:
Giáo trình này được viết theo căn cứ Thông tư số 03/2017/TT-BLĐTBXH ngày
01 tháng 03 năm 2017 của Bộ Lao động – Thương binh và Xã hội về việc Quy định về
quy trình xây dựng, thẩm định và ban hành chương trình; tổ chức biên soạn, lựa chọn,
thẩm định giáo trình đào tạo trình độ trung cấp, trình độ cao đẳng.
Quá trình biên soạn:
Giáo trình này được biên soạn có sự tham gia tích cực của các giáo viên có kinh
nghiệm, cùng với những ý kiến đóng góp quý báu của các chuyên gia về lĩnh vực công
nghệ thông tin.
Mối quan hệ của tài liệu với chương trình, mô đun/môn học:
Căn cứ vào chương trình đào tạo nghề Thiết kế trang web, giáo trình giúp cung
cấp cho người học những kiến thức cơ bản về lập trình web với XML cũng như kỹ
năng lập trình web trên công cụ Microsoft Visual Studio .NET.
Để học được mô đun này người học cần có kiến thức cơ bản về thiết kế trang
web với HTML, XML và lập trình cơ bản.
Cấu trúc chung của giáo trình này bao gồm 4 bài:
Bài 1: TỔNG QUAN VỀ TÍCH HỢP CÁC ỨNG DỤNG TRÊN MÔI TRƯỜNG
WEB DỰA VÀO XML
BàI 2: XÂY DỰNG CÁC ỨNG DỤNG TRÊN WEB THEO HƯỚNG DỰA
VÀO XML
Bài 3: CÁC CHỦ ĐỀ PHÁT TRIỂN ỨNG DỤNG TÍCH HỢP TRÊN NHIỀU
NẾN TẢNG,TRÊN CÁC HỆ THÔNG TIN HIỆN HÀNH VÀ TRÊN CÁC DÒNG
THIẾT BỊ KHÁC NHAU
Bài 4: LIÊN HỆ GIỮA XML VÀ .NET
Lời cảm ơn
Giáo trình được biên soạn trên cơ sở các văn bản quy định của Nhà nước và tham
khảo nhiều tài liệu liên quan có giá trị. Song chắc hẳn quá trình biên soạn không tránh
khỏi những thiếu sót nhất định. Ban biên soạn mong muốn và thực sự cảm ơn những ý
kiến nhận xét, đánh giá của các chuyên gia, các thầy cô đóng góp cho việc chỉnh sửa
để giáo trình ngày một hoàn thiện hơn.
Lâm Đồng, ngày 10 tháng 12 năm 2019
Tham gia biên soạn
1. Phạm Đình Nam
2. Ngô Thiên Hoàng
3. Nguyễn Quỳnh Nguyên
4. Phan Ngọc Bảo
MỤC LỤC
ĐỀ MỤC
TRANG
LỜI TỰA ..................................................................................................................3
MỤC LỤC ................................................................................................................4
GIỚI THIỆU VỀ MÔ ĐUN/MÔN HỌC ...............................................................5
SƠ ĐỒ QUAN HỆ THEO TRÌNH TỰ HỌC NGHỀ ..........................................7
CÁC HÌNH THỨC HỌC TẬP CHÍNH TRONG MÔ ĐUN/MÔN HỌC ..........8
YÊU CẦU VỀ ĐÁNH GIÁ HOÀN THÀNH MÔ ĐUN/MÔN HỌC ..................9
Bài 1:TỔNG QUAN VỀ TÍCH HỢP CÁC ỨNG DỤNG TRÊN MÔI
TRƯỜNG WEB DỰA VÀO XML .......................................................................10
I- Tổng quan về XML .......................................................................................10
II-Cơ bản về XML.............................................................................................11
III-Parsing tài liệu XML....................................................................................37
BàI 2:XÂY DỰNG CÁC ỨNG DỤNG TRÊN WEB THEO HƯỚNG
DỰA VÀO XML .....................................................................................................44
I-Tích hợp mức CSDL.......................................................................................44
II-Phát triển web................................................................................................75
III-Xây dựng giao diện người sử dụng dựa vào XML ......................................76
IV-Messaging dựa vào XML...........................................................................127
V-Xây dựng ứng dụng mức server..................................................................189
VI-Xây dựng mức client..................................................................................208
Bài 3:CÁC CHỦ ĐỀ PHÁT TRIỂN ỨNG DỤNG TÍCH HỢP TRÊN
NHIỀU NẾN TẢNG,TRÊN CÁC HỆ THÔNG TIN HIỆN HÀNH
VÀ TRÊN CÁC DÒNG THIẾT BỊ KHÁC NHAU..........................239
I-Cơ chế xác lập ứng dụng liên quan đến nhiều nền tảng ...............................239
II-Xây dựng các ứng dụng liên quan đến nhiều nền tảng dựa vào
web service...................................................................................................241
III-Tích hợp các hệ thông tin hiện có ..............................................................242
IV-Tạo các giao diện giữa các hệ thống hiện hành ........................................243
V-Kiến trúc hệ ứng dụng tích hợp ..................................................................245
Bài 4:LIÊN HỆ GIỮA XML VÀ .NET.................................................................249
I-Vấn đề XMLP(SOAP)..................................................................................249
II-Cài đặt các ứng dụng hướng e-Business bằng Biztalk server .....................256
III-Truy cập dữ liệu và XML...........................................................................257
IV-Parsing và tạo các tài liệu XML.................................................................262
THUẬT NGỮ CHUYÊN MÔN ............................................................................267
TÀI LIỆU THAM KHẢO......................................................................................268
1
BÀI 1
TÊN BÀI : TỔNG QUAN VỀ TÍCH HỢP CÁC ỨNG DỤNG TRÊN MỘI TRƯỜNG WEB DỰA
VÀO XML
Mã bài : 01
Giới thiệu :
Trong nội dung bài học này , chúng ta sẽ hiểu sơ lược về lịch sử và cú pháp của XML. Ngoài
ra, chúng ta còn nghiên cứu lý thuyết về phương pháp xây dựng trang Web đa nền tảng và
đa thiết bị cũng như sử dụng .NET để phân giải XML.
Mục tiêu thực hiện:
Học xong bài này học viên sẽ có khả năng:
-
-
-
Nắm cơ bàn về lập trình XML (Extensible Markup Language) như là một hướng tích hợp
ứng dụng đầy tiềm năng.
Tích hợp được các ứng dụng đang có thành các ứng dụng khai thác tài nguyên thông tin
phục vụ quản lý, điều hành.
Tích hợp được trên nhiều nến tảng (Multiplatform) và nhiều dòng thiết bị (Cross Device
Development)
-
-
Giải quyết được lớp các bài toán tích hợp đặt ra ngày nay.
Biết phối hợp giữa lập trình XML với công nghệ Microsoft .NET
Nội dung chính:
1. Tổng quan về XML.
XML có tầm ảnh hưởng rất lớn đến công nghệ truyền tin hiện tại, nhất là môi trường
Web. Trong số chúng ta, chắc chắn đã từng nghe qua Web Services. Đó là những dịch vụ
trên Web ta có thể dùng on-demand , tức là khi nào cần cho chương trình của mình, bằng
cách gọi nó theo phương pháp giống như gọi một hàm. Web Services được triển khai dựa
vào XML và Http, chuẩn dùng để gởi các trang Web.
Điểm quan trọng của kỹ thuật XML là nó không thuộc riêng về một công ty nào, nhưng
là một tiêu chuẩn được mọi người công nhận vì được soạn ra bởi World Wide Web
thân của XML tuy không có gì khó hiểu, nhưng các công cụ chuẩn được định ra để làm việc
với XML như Document Object Model - DOM, XPath, XSL, v.v.. thì rất hữu hiệu, và chính
các chuẩn nầy được phát triển không ngừng.
Microsoft đã cố gắng hỗ trợ XML ngay từ đầu. Chẳng những có đại diện để làm việc
thường trực trong W3C mà còn tích cực đóng góp bằng cách gởi những đề nghị. Vị trí của
Microsoft về XML là khi tiêu chuẩn chưa được hoàn thành thì các sản phẩm của Microsoft
tuân thủ những gì có vẽ được đa số công nhận và khi tiêu chuẩn hoàn thành thì tuân thủ
hoàn toàn.
Công cụ XML sáng giá nhất của Microsoft là ActiveX MSXML. Nó được dùng trong
Visual Basic 6, ASP (Active Server Pages) của IIS và Internet Explorer từ version 5.5. Hiện
nay MSXML đã có version 4.0. MSXML parse (đọc và phân tích) và validate (kiểm tra sự
hợp lệ) XML file để cho ta DOM, một cây của các Các nút đại diện các thành phần bên trong
XML. MSXML cũng giúp ta dựa vào một XSL file để chuyển đổi một XML file thành một trang
Web (HTML) hay một XML khác.
XML là viết tắt cho chữ eXtensible Markup Language - nhưng Markup Language (ngôn
ngữ đánh dấu) là gì? Trong ngành ấn loát, để chỉ thị cho thợ sắp chữ về cách in một bài vỡ,
tác giả hay chủ bút thường vẽ các vòng tròn trong bản thão và chú thích bằng một ngôn ngữ
đánh dấu tương tự như tốc ký. Ngôn ngữ ấy được gọi là Markup Language.
XML là một ngôn ngữ đánh dấu tương đối mới vì nó là một một tập hợp con của và dẫn
xuất từ một ngôn ngữ đánh dấu tên là Standard Generalized Markup Language (SGML).
Ngôn ngữ HTML cũng dựa vào SGML, nói đúng ra nó là một áp dụng của SGML.
SGML được phát minh bởi Ed Mosher, Ray Lorie và Charles F. Goldfarb của nhóm IBM
research vào năm 1969, khi con người đặt chân lên mặt trăng. Lúc đầu nó có tên là
Generalized Markup Language (GML), và được thiết kế để dùng làm meta-language, một
ngôn ngữ được dùng để diễn tả các ngôn ngữ khác - văn phạm, ngữ vựng của chúng ,.v.v..
2
Năm 1986, SGML được cơ quan ISO (International Standard Organisation) thu nhận
(adopted) làm tiêu chuẩn để lưu trữ và trao đổi dữ liệu. Khi Tim Berners-Lee triển khai
HyperText Markup Language - HTML để dùng cho các trang Web hồi đầu thập niên 1990,
ông ta cứ nhắc nhở rằng HTML là một áp dụng của SGML. Vì SGML rất rắc rối, và HTML có
nhiều giới hạn nên năm 1996 tổ chức W3C thiết kế XML. XML phiên bản 1.0 được định
nghĩa trong hồ sơ February 1998 W3C Recommendation, giống như một Internet Request
for Comments (RFC), là một "tiêu chuẩn".
Trong một trang Web, ngôn ngữ đánh dấu HTML dùng các cặp Tags để đánh dấu vị trí
đầu và cuối của các mảnh dữ liệu để giúp chương trình trình duyệt (browser) parse (ngắt
khúc để phân tích) trang Web và hiển thị các phần theo ý người thiết kế trang Web. Thí dụ
như một câu HTML dưới đây:
<P align="center">Chào mừng chúng ta đến thăm
<STRONG>Vovisoft</STRONG>Web site
</P>
Đoạn lệnh HTML trên có chứa hai tag đánh dấu <P> và <STRONG>. Mỗi cặp Tag gói
dữ liệu nó đánh dấu giữa tag mở và tag đóng. Hai tag đóng ở đây là </P> và </STRONG>.
Tất cả những gì nằm bên trong một cặp Tags được gọi là phần tử (Phần tử). Để nói thêm
đặc tính của một Phần tử, ta có thể có thuộc tính (Thuộc tính) như align trong tag mở của
Phần tử ấy dưới dạng Thuộc tínhName="value", thí dụ như align="center".
Vì Tag trong HTML được dùng để định dạng hiển thị tài liệu nên trình duyệt (browse)
cần biết ý nghĩa của mỗi Tag. Một trình duyệt hay HTML parser sẽ thu thập các chỉ thị sau từ
câu HTML trên:
Bắt đầu một Paragraph mới và đặt Text ở giữa trang (<P align="center">).
Hiển thị câu Chào mừng chúng ta đến thăm
Hiển thị chữ Vovisoft cách mạnh mẽ (<STRONG>Vovisoft</STRONG>).
Hiển thị câu Web site
Gặp điểm cuối của Paragraph (</P>)
Để xử lý đoạn mã lệnh HTML trên, chẳng những trình duyệt cần phải xác định vị trí các
Tags mà còn phải hiểu ý nghĩa của mỗi Tag. Vì mỗi Tag có ý ngĩa riêng của nó, thí dụ P cho
Paragraph, STRONG để nhấn mạnh, thí dụ như dùng chữ đậm (Bold).
II. Cơ bản về XML
Như đã đề cập ở trên, các tài liệu HTML dùng các tag để đánh dấu và nó là một áp
dụng của SGML. Giống như HTML, XML cũng đến từ SGML. Nó cũng dùng Tag để định
nghĩa dữ liệu. Điểm khác biệt chánh giữa HTML và XML là trong khi các Tags của HTML
chứa ý nghĩa về các định dạng trình bày các dữ liệu, thì các Tag của XML chứa ý nghĩa về
cấu trúc của các dữ liệu. Thí dụ như một tài liệu đặt hàng (order) XML dưới đây:
<Order OrderNo="1023">
<OrderDate>2002-3-27</OrderDate>
<Customer>Peter Collingwood</Customer>
<Item>
<ProductID>1</ProductID>
<Quantity>5</Quantity>
</Item>
<Item>
<ProductID>4</ProductID>
<Quantity>3</Quantity>
</Item>
</Order>
Tài liệu nầy chỉ chứa dữ liệu, không nhắc nhở gì đến cách trình bày. Điều nầy có nghĩa
là một XML parser (chương trình ngắt khúc và phân tích) không cần phải hiểu ý nghĩa cũa
các Tags. Nó chỉ cần tìm các Tags và xác định rằng đây là một tài liệu XML hợp lệ. Trình
duyệt không cần phải hiểu ý nghĩa của các Tags, nên ta có thể dùng Tag nào cũng được. Đó
là lý do người ta dùng chữ eXtensible (mở rộng thêm được), nhưng khi dùng chữ để viết tắt
thì lại chọn X thay vì e, có lẽ vì X nghe có vẽ kỳ bí, hấp dẫn hơn.
Chúng ta hãy quan sát kỹ hơn cấu trúc của một XML. Trước hết, phần tử Order có
thuộc tính OrderNo với giá trị 1023. Bên trong phần tử Order có:
3
Một phần tử con OrderDate với giá trị 2002-3-27
Một phần tử con Customer với giá trị Peter Collingwood.
Hai phần tử con Item, mỗi phần tử Item lại chứa một phần tử con ProductID và một
phần tử con Quantity.
Đôi khi ta để một phần tử với một tên nhưng không chứa một giá trị, lý do là ta muốn
dùng nó như một phần tử tùy chọn, có cũng được, không có cũng không sao. Cách tự nhiên
nhất là gắn cái tag đóng ngay sau tag mở. Thí dụ như phần tử rỗng MiddleInitial trong phần
tử customer dưới đây:
<Customer>
<FirstName>Stephen</FirstName>
<MiddleInitial></MiddleInitial>
<LastName>King</LastName>
</Customer>
Có một cách khác để biểu diễn phần tử rỗng là bỏ tag đóng và thêm một dấu "/" ở cuối
tag mở. Ta có thể viết lại thí dụ customer như sau:
<Customer>
<FirstName>Stephen</FirstName>
<MiddleInitial/>
<LastName>King</LastName>
</Customer>
Dĩ nhiên phần tử rỗng cũng có thể có thuộc tính như phần tử PhoneNumber thứ nhì
dưới đây:
<Customer>
<FirstName>Stephen</FirstName>
<MiddleInitial></MiddleInitial>
<LastName>King</LastName>
<PhoneNumber Location="Home">9847 2635</PhoneNumber>
<PhoneNumber Location="Work"></PhoneNumber>
</Customer>
Một tài liệu XML phải well-formed (hợp khuôn dạng) và hợp lệ. Mặc dầu hai từ nầy nghe
hơi giống nhau, nhưng chúng có ý nghĩa khác nhau. Một XML well-formed là một XML thích
hợp cho parser xử lý. Tức là XML tuân thủ các luật lệ về Tag, phần tử, thuộc tính , giá trị
.v.v.. chứa bên trong để parser có thể nhận diện và phân biệt mọi thứ.
Cần chú ý là một XML well-formed chưa chắc chứa đựng những dữ liệu hữu dụng trong
công việc làm ăn. Là well-formed chỉ có nghĩa là XML có cấu trúc đúng. Để hữu dụng cho
công việc làm ăn, XML chẳng những well-formed mà còn cần phải hợp lệ. Một tài liệu XML
hợp lệ khi nó chứa những dữ liệu cần có trong loại tài liệu hay lớp ấy. Thí dụ một XML đặt
hàng có thể bị đòi hỏi phải có một thuộc tính OrderNo và một phần tử con Orderdate. Parser
validate xử lý một tài liệu XML bằng cách kiểm tra dữ liệu trong XML xem có đúng như định
nghĩa trong một chỉ định về loại tài liệu XML ấy. Chỉ định này có thể là một Document Type
Definition (DTD) hay một Schema (giản đồ).
Vậy làm thế nào để tạo được một tài liệu XML well-formed?
Để well-formed, một tài liệu XML phải theo đúng các luật sau đây:
- Phải có một root (gốc) Phần tử duy nhất, gọi là Document Phần tử, nó chứa tất cả các
Phần tử khác trong tài liệu.
- Mỗi tag mở phải có một tag đong1 giống như nó.
- Các Tag trong XML thì phân biệt chữ hoa và chữ thường.
- Mỗi phần tử con phải nằm trọn bên trong phần tử cha của nó.
- Giá trị thuộc tính trong XML phải được gói giữa một cặp nháy kép hay một cặp dấu
nháy đơn.
Luật thứ nhất đòi hỏi phải có một phần tử gốc duy nhất, nên tài liệu dưới đây không
well-formed vì nó không có một phần tử gốc:
<Product ProductID="1">Chair</Product>
<Product ProductID="2">Desk</Product>
Một tài liệu XML không có phần tử gốc được gọi là một tài liệu XML phân mảnh. Để làm
cho nó well-formed ta cần phải thêm một phần tử gốc như dưới đây:
<Catalog>
4
<Product ProductID="1">Chair</Product>
<Product ProductID="2">Desk</Product>
</Catalog>
Luật thứ hai nói rằng mỗi tag mở phải có một tag đóng giống như nó. Tức là mỗi Tag
mở ra phải được đóng lại. Phần tử rỗng viết cách gọn như <MiddleInitial/> được gọi là có
Tag tự đóng lại. Các Tag khác phải có tag đóng. Tài liệu XML dưới đây không well-formed vì
nó có chứa một một Tag <Item> thiếu closing Tag </Item>:
<Order>
<OrderDate>2002-6-14</OrderDate>
<Customer>Helen Mooney</Customer>
<Item>
<ProductID>2</ProductID>
<Quantity>1</Quantity>
<Item>
<ProductID>4</ProductID>
<Quantity>3</Quantity>
</Item>
</Order>
Để làm cho nó well-formed ta phải thêm cái tag đóng cho phần tử Item thứ nhất:
<Order>
<OrderDate>2002-6-14</OrderDate>
<Customer>Helen Mooney</Customer>
<Item>
<ProductID>2</ProductID>
<Quantity>1</Quantity>
</Item>
<Item>
<ProductID>4</ProductID>
<Quantity>3</Quantity>
</Item>
</Order>
Luật thứ ba nói là tên Tag thì phân biệt chữ hoa và chữ thường. Như thế <order> khác
với <Order>, ta không thể dùng Tag </Order> để đóng Tag <order>. Cái XML dưới đây
không well-formed vì tag mở và tag đóng của phần tử OrderDate không đánh vần giống
nhau:
<Order>
<OrderDate>2001-01-01</Orderdate>
<Customer>Graeme Malcolm</Customer>
</Order>
Muốn làm cho nó well formed, ta phải sửa chữ d thành chữ hoa D như sau:
<Order>
<OrderDate>2001-01-01</OrderDate>
<Customer>Graeme Malcolm</Customer>
</Order>
Luật thứ tư nói mỗi phần tử con phải nằm trọn bên trong phần tử cha của nó, tức là
không thể bắt đầu một phần tử mới khi phần tử này chưa chấm dứt. Thí dụ như tài liệu XML
dưới đây không well-formed vì tag đóng của Category hiện ra trước tag đóng của Product.
<Catalog>
<Category CategoryName="Beverages">
<Product ProductID="1">
Coca-Cola
</Category>
</Product>
</Catalog>
Muốn sửa cho nó well-formed ta cần phải đóng Tag Product trước như dưới đây:
<Catalog>
<Category CategoryName="Beverages">
5
<Product ProductID="1">
Coca-Cola
</Product>
</Category>
</Catalog>
Luật cuối cùng về tài liệu XML well-formed đòi hỏi giá trị của thuộc tính phải được gói
trong một cặp dấu nháy đơn hay cặp dấu nháy kép. Tài liệu dưới đây không well-form vì các
giá trị của thuộc tính không được ngoặc đàng hoàng, số 1 không có dấu ngoặc, số 2 có một
cái là nháy đơn và một cái là nháy kép:
<Catalog>
<Product ProductID=1>Chair</Product>
<Product ProductID='2">Desk</Product>
</Catalog>
Ngoài các dữ liệu cần thiết, một tài liệu XML cũng có chứa các Processing Instructions
(chỉ thị về cách xử lý) cho parser và Comments (ghi chú) cho người đọc.
Processing Instruction nằm trong cặp Tags <? và ?>. Thông thường nó cho biết phiên
bản của XML nhằm chỉ định parser cần làm theo. Có khi nó cũng cho biết dữ liệu trong XML
dùng bảng mã mã hóa nào, thí dụ như uft-8. Còn một thuộc tính nữa là standalone.
standalone cho parser biết là tài liệu XML có thể được hợp lệ một mình mà không cần đến
một DTD hay Schema.
Mặc dầu một tài liệu XML well-formed không cần có một Processing Instruction, nhưng
thông thường ta để một Processing Instruction ở dòng đầu tài liệu, phần ấy được gọi là đoạn
mở đầu. Dưới đây là một thí dụ có Processing Instruction trong đoạn mả đầu của một tài liệu
XML:
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<Order>
<OrderDate>2002-6-14</OrderDate>
<Customer>Helen Mooney</Customer>
<Item>
<ProductID>1</ProductID>
<Quantity>2</Quantity>
</Item>
<Item>
<ProductID>4</ProductID>
<Quantity>1</Quantity>
</Item>
</Order>
Có một loại Processing Instruction khác cũng rất thông dụng là cho biết tên của
stylesheet (kiểu dáng) của XML nầy, thí dụ như:
<?xml-stylesheet type="text/xsl" href="order.xsl"?>
Ở đây ta cho XML stylesheet parser biết rằng stylesheet thuộc loại text/xsl và nó được
chứa trong file tên order.xsl. Chúng ta cũng có thể cho thêm chú thích bằng cách dùng cặp
Tags <!-- và --> như sau:
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<!-- Below are details of a purchase order. -->
<Order>
<OrderDate>2002-6-14</OrderDate>
<Customer>Helen Mooney</Customer>
<Item>
<ProductID>1</ProductID>
<Quantity>2</Quantity>
</Item>
<Item>
<ProductID>4</ProductID>
<Quantity>1</Quantity>
</Item>
</Order>
6
Ngoài những vấn đề đề cập ở trên nhưng có một ý niệm rất quan trọng trong XML là
Namespace (không gian tên). Nó cho ta cách cùng một tên của phần tử để nói đến hai thứ
dữ liệu khác nhau trong cùng một tài liệu XML. Giống như có hai học sinh trùng tên Tuấn
trong lớp học, ta phải dùng thêm họ của chúng để phân biệt, ta gọi Tuấn Trần hay Tuấn Lê.
Thí dụ như có một order được người ta đặt trong tiệm sách như sau:
<?xml version="1.0"?>
<BookOrder OrderNo="1234">
<OrderDate>2001-01-01</OrderDate>
<Customer>
<Title>Mr.</Title>
<FirstName>Graeme</FirstName>
<LastName>Malcolm</LastName>
</Customer>
<Book>
<Title>Treasure Island</Title>
<Author>Robert Louis Stevenson</Author>
</Book>
</BookOrder>
Khi quan sát kỹ, ta thấy có thể có sự nhầm lẫn về cách dùng phần tử Title. Trong tài liệu
có hai loại Title, một cái dùng cho khách hàng Customer nói đến danh hiệu Mr., Mrs., Dr.,
còn cái kia để nói đến đề tựa của một quyển sách Book.
Để tránh sự lầm lẫn, chúng ta có thể dùng không gian tên để nói rõ tên phần tử ấy thuộc
về giòng họ nào. Giòng họ ấy là một Universal Resource Identifier (URI). Một URI có thể là
một URL hay một chỗ nào định nghĩa tính cách độc đáo của nó. Một không gian tên cũng
không cần phải nói đến một địa chỉ Internet, nó chỉ cần phải là có một, không hai.
Chúng ta có thể khai báo các không gian tên trong một phần tử bằng cách dùng thuộc
tính xmlns (ns trong chữ xmlns là viết tắt cho namespace) chúng ta cũng có thể khai báo một
không gian tên mặc định để áp dụng cho những gì nằm bên trong một phần tử, nơi chúng ta
khai báo không gian tên. Thí dụ cái tài liệu đặt hàng có thể được viết lại như sau:
<?xml version="1.0"?>
<BookOrder OrderNo="1234">
<OrderDate>2001-01-01</OrderDate>
<Customer xmlns="http://www.northwindtraders.com/customer">
<Title>Mr.</Title>
<FirstName>Graeme</FirstName>
<LastName>Malcolm</LastName>
</Customer>
<Book xmlns="http://www.northwindtraders.com/book">
<Title>Treasure Island</Title>
<Author>Robert Louis Stevenson</Author>
</Book>
</BookOrder>
Ta đã tránh được sự nhầm lẫn vì bên trong Customer thì dùng namespace
Tuy nhiên, ta sẽ giải quyết làm sao nếu trong order có nhiều customer và nhiều book.
Nếu cứ thay đổi không gian tên hoài trong tài liệu thì rất khó khăn. Một cách giải quyết là
khai báo chữ viết tắt cho các không gian tên ngay ở đầu tài liệu, trong phần tử góc (tức là
phần tử tài liệu). Sau đó bên trong tài liệu ta sẽ sử dụng tiếp đầu ngữ cho các phần tử cần
xác nhận không gian tên bằng chữ viết tắt của không gian tên của nó. Thí dụ như sau:
<?xml version="1.0"?>
<BookOrder xmlns="http://www.northwindtraders.com/order"
xmlns:cust="http://www.northwindtraders.com/customer"
<OrderDate>2001-01-01</OrderDate>
<cust:Customer>
<cust:Title>Mr.</cust:Title>
7
<cust:FirstName>Graeme</cust:FirstName>
<cust:LastName>Malcolm</cust:LastName>
</cust:Customer>
<book:Book>
<book:Title>Treasure Island</book:Title>
<book:Author>Robert Louis Stevenson</book:Author>
</book:Book>
</BookOrder>
Trong tài liệu XML trên ta dùng 3 không gian tên và một không gian tên mặc định.
Không
gian
tên
(viết tắt là cust)
namespace
namespace
và
không có tiếp đầu (tức là không có chữ tắt đứng trước) như BookOrder, OrderNo, và
OrderDate, được coi như thuộc về không gian tên mặc định. Để đánh dấu một phần tử hay
thuộc tính không thuộc về không gian tên mặc định, một chữ tắt, đại diện không gian tên sẽ
được gắn làm tiếp đầu ngữ cho tên phần tử hay thuộc tính. Thí dụ như cust:LastName,
book:Title.
Trong tài liệu XML còn có CDATA, là khúc dữ liệu trong tài liệu XML nằm giữa
<![CDATA[ và ]]>. Dữ liệu nằm bên trong những CDATA được cho thông qua parser y
nguyên, không bị sửa đổi. Điểm nầy rất quan trọng khi chúng ta muốn cho vào những dữ
liệu có chứa những văn bản được xem như đánh dấu. Chúng ta có thể đặt những thí dụ cho
XML trong những CDATA và chúng sẽ được parser bỏ qua. Khi dùng XSL stylesheets để
transform một XML file thành HTML, có bất cứ scripting nào chúng ta cũng phải đặt trong
những CDATA. Dưới đây là các thí dụ dùng CDATA:
<![CDATA[...place your data here...]]>
<SCRIPT>
<![CDATA[
function warning()
{
alert("Watch out!");
}]]>
</SCRIPT>
Dữ liệu trong XML không cho phép dùng một số ký hiệu đặc biệt. Do đó, XML yêu cầu
chúng ta sử dụng một số cụm từ thay thế.
Cụm từ
'
&
>
<
"
Ý nghĩa
dấu nháy trên
dấu &
dấu lớn hơn
dấu nhỏ hơn
dấu ngoặc kép
Chúng ta đã thấy cấu trúc và cú pháp của XML tương đối đơn giãn. XML cho ta một
cách chuẩn để trao đổi tin tức giữa các computers. Bước tiếp theo là tìm hiểu cách nào một
chương trình xử lý một tài liệu XML.
Dĩ nhiên để xử lý một XML chương trình ứng dụng phải có cách đi lại bên trong tài liệu
để lấy ra các giá trị của các phần tử hay thuộc tính. Do đó người ta thiết kế ra ngôn ngữ
XML Path language, mà ta gọi tắt là XPath. XPath đóng một vai trò quan trọng trong công
tác trao đổi dữ liệu giữa các computers hay giữa các chương trình ứng dụng vì nó cho phép
ta lựa chọn hay lọc ra những tin tức nào mình muốn để trao đổi hay hiển thị.
Nếu khi làm việc với cơ sở dữ liệu ta dùng cấu câu lệnh SQL Select .. from TableXYZ
WHERE ... để trích ra một số bản ghi từ một table, thì khi làm việc với XML, một table dữ
liệu nho nhỏ, XPath cho ta những biểu thức về điều kiện giống giống như mệnh đề WHERE
trong SQL.
XPath là một chuẩn để xử lý XML, cũng giống như SQL là một chuẩn để làm việc với cơ
sở dữ liệu. Tiên phuông trong việc triển khai các chương trình áp dụng XPath là công tác
của các công ty phần mềm lớn như Microsoft, Oracle, Sun, IBM, v.v. Sở dĩ ta cần có một
8
chuẩn XPath là vì nó được áp dụng trong nhiều hoàn cảnh, nên cần phải có một lý thuyết rõ
ràng, chính xác.
Lý thuyết về XPath hơi khô khan nhưng nó được áp dụng trong mọi kỹ thuật của gia
đình XML. Cho nên chúng ta hãy kiên nhẫn nắm vững những điều căn bản về nó để khi nào
gặp chỗ người ta dùng XPath thì mình nhận diện và hiểu được. Chúng ta ta sẽ chỉ nghiên
cứu những nội dung thường dùng trong XPath thôi, nếu chúng ta muốn có đầy đủ chi tiết về
Một tài liệu XML như một cây đối với XPath
XPath cho ta cú pháp để diễn tả cách đi lại trong XML. Ta coi một tài liệu XML như
được đại diện bằng một tree (cây) có nhiều các nút. Mỗi phần tử hay thuộc tính là một nút.
Để minh họa ý niệm nầy, chúng ta hãy quan sát tài liệu đặt hàng (order) XML sau:
<?xml version="1.0"?>
<Order OrderNo="1047">
<OrderDate>2002-03-26</OrderDate>
<Customer>John Costello</Customer>
<Item>
<Product ProductID="1" UnitPrice="70">Chair</Product>
<Quantity>6</Quantity>
</Item>
<Item>
<Product ProductID="2" UnitPrice="250">Desk</Product>
<Quantity>1</Quantity>
</Item>
</Order>
Ta có thể biểu diễn XML trên bằng một cây như dưới đây, trong đó nút phần tử màu
nâu, nút thuộc tính màu xanh:
9
Chúng ta có thể dùng biểu thức XPath để chỉ định đường dẫn đến nút (nút) nào hay
trích ra (trả về) một hay nhiều nút thỏa đúng điều kiện yêu cầu. Biếu thức XPath có thể là
tuyệt đối, tức là lấy nút gốc làm chuẩn hay tương đối, tức là khởi đầu từ nút vừa mới được
chọn. Nút ấy được gọi là context nút (nút vai chính trong tình huống).
Có hai cách viết để diễn tả XPath, viết nguyên và viết tắt. Trong cả hai cách ta đều dùng
dấu slash (/) để nói đến phần tử tài liệu, tức là nút gốc. Ta có thể đi lại trong các nút của
Tree giống như các nút của Windows System Directory mà ta thấy trong Panel bên trái của
Window Explorer. Ta cũng sẽ dùng những ký hiệu như slash /, một chấm . và hai chấm ..
của Windows System File Folder cho cách viết tắt trong XPath Location để đi xuống các các
nút con, cháu, chỉ định context nút, hay đi ngược lên các các nút tổ tiên.
Đường dẫn tuyệt đối
Chúng ta hãy tìm vài location paths trong cái Tree của tài liệu XML về đặt hàng nói trên.
Muốn chọn cái nút của Phần tử Order (nó cũng là Root Phần tử) bằng cú pháp nguyên, ta sẽ
dùng XPath Biểu thức sau đây:
/child::Order
Dịch ra cú pháp tắt, Biểu thức nầy trở nên:
/Order
Đi ra nhánh của Tree, ta sẽ tìm được nút Customer bằng cách dùng XPath Biểu thức
sau:
/child::Order/child::Customer
Sau đây là XPath Biểu thức viết tắt tương đương:
/Order/Customer
Nếu chúng ta muốn lấy ra một nút Thuộc tính, chúng ta phải nói rõ điều nầy bằng cách
dùng từ chìa khóa (keyword) thuộc tính trong cách viết nguyên hay dùng character @ trong
cú pháp tắt. Do đó để lấy thuộc tính OrderNo của phần tử Order, ta sẽ dùng XPath Biểu thức
sau:
/child::Order/thuộc tính::OrderNo
Cú pháp tắt cho Thuộc tính OrderNo là:
/Order/@OrderNo
Để trích ra các các nút con cháu, tức là các các nút nhánh xa hơn, ta dùng keyword
descendant trong cú pháp nguyên hay một double slash (//) trong cú pháp tắt. Thí dụ, để lấy
ra các các nút Product trong tài liệu, chúng ta có thể dùng Biểu thức location path sau:
/child::Order/descendant::Product
Cú pháp tắt tương đương là:
/Order//Product
Chúng ta cũng có thể dùng wildcards (lá bài Joker) để nói đến những các nút mà tên
của chúng không thành vấn đề. Thí dụ, dấu asterisk (*) wildcard chỉ định bất cứ nút tên nào.
Location path sau đây chọn tất cả các các nút con của Phần tử Order:
/child::Order/child::*
Cú pháp tắt tương đương là:
/Order/*
Đường dẫn tương đối:
Nhiều khi XPath location paths là tương đối với context nút, trong trường hợp ấy
location path diễn tả cách lấy ra một nút hay một số (set of) các nút tương đối với context
nút. Thí dụ như, nếu Phần tử Item thứ nhất trong order là context nút, thì location path tương
đối để trích ra Phần tử con Quantity là:
child::Quantity
Trong cú pháp tắt, location path tương đối là:
Quantity
Tương tự như vậy, để lấy ra Thuộc tính ProductID của Phần tử con Product, cái location
path tương đối là:
child::Product/thuộc tính::ProductID
Biểu thức ấy dịch ra cú pháp tắt là:
Product/@ProductID
Để đi ngược lên phía trên của Tree, ta dùng keyword parent (cha). Dạng tắt tương
đương của keyword nầy là hai dấu chấm (..). Thí dụ nếu context nút là Phần tử OrderDate,
10
thì Thuộc tính OrderNo có thể được lấy ra từ Phần tử Order bằng cách dùng location path
tương đối sau:
parent::Order/thuộc tính::OrderNo
Để ý là cú pháp nầy chỉ trả về một trị số khi nút cha tên Order. Nếu muốn lấy ra Thuộc
tính OrderNo từ nút cha không cần biết nó tên gì chúng ta phải dùng Biểu thức sau:
parent::*/thuộc tính::OrderNo
Viết theo kiểu tắt đơn giản hơn vì chúng ta không cần phải cung cấp tên của nút cha.
Chúng ta có thể nói đến nút cha bằng cách dùng hai dấu chấm (..) như sau:
../@OrderNo
Ngoài ra, chúng ta có thể nói đến chính context nút bằng cách dùng hoặc keyword self
hoặc một dấu chấm (.). Điều nầy rất tiện trong vài trường hợp, nhất là khi chúng ta muốn biết
current context nút là nút nào.
Chúng ta có thể giới hạn số các nút lấy về bằng cách gắn thêm điều kiện sàng lọc vào
location path. Cái điều kiện giới hạn một hay nhiều các nút được tháp vào Biểu thức bên
trong một cặp ngoặc vuông ([]). Thí dụ, để lấy ra mọi Phần tử Product có Thuộc tính
UnitPrice lớn hơn 70, chúng ta có thể dùng XPath Biểu thức sau đây:
/child::Order/child::Item/child::Product[thuộc tính::UnitPrice>70]
Trong cú pháp tắt, nó là:
/Order/Item/Product[@UnitPrice>70]
Trong Biểu thức của điều kiện chúng ta cũng có thể dùng Xpath tương đối , do đó trong
Biểu thức điều kiện chúng ta có thể dùng bất cứ nút nào trong thứ bậc. Thí dụ sau đây lấy về
những các nút Item có Phần tử con Product với Attibute ProductID trị số bằng 1:
/child::Order/child::Item[child::Product/thuộc tính::ProductID=1]
Dịch ra cú pháp tắt, ta có:
/Order/Item[Product/@ProductID=1]
Tập hợp các Các nút do XPath trả về được gọi là Collection. Thông thường trong lập
trình, từ "Collection" được dùng để nói đến một tập hợp các objects đồng loại. Ta có thể lần
lượt đi qua (iterate through) các objects trong một Collection nhưng không được bảo đảm
thứ tự của chúng, tức là gặp object nào trước hay object nào sau.
Trái lại, trong chuẩn XPath, khi một Collection được trả về bởi một XPath Query (hỏi),
nó giữ nguyên thứ tự các Các nút và cấp bậc của chúng trong tài liệu XML. Tức là nếu
XPath trả về một cành các các nút thì trừ những các nút không thỏa điều kiện, các nút còn
lại vẫn giữ đúng vị trí trên cành.
Vì các thuộc tính của một phần tử không có thứ tự, nên chúng có thể nằm lộn xộn trong
một Collection.
Một Collection của Các nút được xem như một Array. Muốn nói trực tiếp đến một Nút
trong Collection ta có thể dùng một index trong cặp ngoặc vuông. Nút thứ nhất có Index là 1.
Cặp ngoặc vuông ([]) có precedence cao hơn (được tính trước) dấu slash(/) hay hai dấu
slash (//). Dưới đây là hai thí dụ:
Biểu thức
Ý nghĩa
author[1]
Phần tử author đầu tiên.
author[firstname][3]
Phần tử author thứ ba có một phần tử con là firstname
Một location path dùng một Axis để chỉ định mối liên hệ giữa các Các nút được chọn đối
với context nút. Sau đây là bảng liệt kê đầy đủ các axes:
Axes
Ý nghĩa
ancestor::
Tổ tiên của context nút.
Những tổ tiên của context nút gồm có cha, ông nội, ông cố .v.v., do đó
ancestor:: axis luôn luôn kể cả root nút trừ khi chính context nút là root nút.
ancestor-
Chính context nút và tổ tiên của nó.
or-self::
Cái ancestor-or-self:: axis luôn luôn kể cả root nút.
thuộc
Các Thuộc tínhs của context nút.
tính::
child::
Nếu context nút không phải là một Phần tử thì chắc chắn axis sẽ trống
rỗng.
Con cái của context nút.
11
Một con là bất cứ nút nào nằm ngay dưới context nút trong tree. Tuy
nhiên, Thuộc tính hay Namespace các nút không được xem là con cái của
context nút.
descenda
Con cháu của context nút.
nt::
Con cháu là con, cháu, chít, .v.v., do đó descendant:: axis không bao
giờ chứa Thuộc tính hay Namespace các nút.
following::
following-
Mọi các nút hiện ra sau context nút trên tree, không kể con cháu,
Thuộc tính các nút, hay Namespace các nút.
Mọi các nút em (nằm sau) context nút.
sibling::
following-sibling:: axis nói đến chỉ những Các nút con, của cùng một
Nút cha, nằm trên tree sau context nút. Axis không kể các Các nút anh nằm
trước context nút.
Nếu context nút là Thuộc tính hay Namespace thì following-sibling::
axis sẽ trống rỗng.
namespac
Những Namespace các nút của context nút.
Mỗi namespace có một namespace nút trong scope (phạm vi hoạt
động) của context nút.
e::
Nếu context nút không phải là một Phần tử thì Axis sẽ trống rỗng.
parent::
Nút cha của context nút, nếu nó có cha.
Nút cha là nút nằm ngay phía trên context nút trên tree.
preceding:
Mọi các nút hiện ra trước context nút trên tree, không kể các các nút tổ
tiên, Thuộc tính các nút, hay Namespace các nút.
:
Một cách để nhận diện preceding:: axis là mọi các nút đã kết thúc hoàn
toàn trước khi context nút bắt đầu.
preceding-
sibling::
Mọi các nút anh (nằm trước) context nút.
preceding-sibling:: axis nói đến chỉ những Các nút con, của cùng một
Nút cha, nằm trên tree trước context nút.
Nếu context nút là Thuộc tính hay Namespace thì preceding-sibling::
axis sẽ trống rỗng.
self::
Là chính context nút.
Như ta đã thấy ở trên, để giới hạn chỉ lấy ra những Các nút thỏa đáng một điều kiện, ta
gắn một Filter (sàng lọc) vào Collection. Filter ấy là một Clause giống giống Clause WHERE
trong ngôn ngữ SQL của cơ sở dữ liệu.
Nếu một Collection nằm giữa một filter, nó sẽ cho kết quả TRUE nếu Collection trả về ít
nhất một Nút và FALSE nếu Collection trống rỗng (empty). Thí dụ Biểu thức author/degree
có nghĩa rằng hàm biến đổi Collection ra trị số Boolean sẽ có giá trị TRUE nếu hiện hữa một
Phần tử author có Phần tử con tên degree.
Filters luôn luôn được tính theo context của nó. Nói một cách khác, cái Biểu thức
book[author] có nghĩa là cho mỗi Phần tử book tìm thấy, nó sẽ được thử xem có chứa một
Phần tử con tên author không. Tương tự như vậy, book[author = 'Brown'] có nghĩa rằng cho
mỗi Phần tử book tìm thấy, nó sẽ được thử xem có chứa một Phần tử con tên author với trị
số bằng Brown không.
Ta có thể dùng dấu chấm (.) để khám current context nút. Thí dụ như, book[. = 'Dreams']
có nghĩa rằng cho mỗi Phần tử book tìm thấy trong current context, nó sẽ được thử xem có
trị số bằng Dreams không. Dưới đây là một ít thí dụ:
Biểu thức
Ý nghĩa
Book[excerpt]
Book[excerpt]/title
Mọi Phần tử book có chứa ít nhất một Phần tử excerpt.
Mọi Phần tử title nằm trong những Phần tử book có chứa ít
nhất một Phần tử excerpt.
12
Book[excerpt]/author[degree] Mọi Phần tử author có chứa ít nhất một Phần tử degree và
nằm trong những Phần tử book có chứa ít nhất một Phần tử
excerpt.
Book[author/degree]
Mọi Phần tử book có chứa ít nhất một Phần tử author với ít
nhất một Phần tử degree con.
Book[excerpt][title]
Mọi Phần tử book có chứa ít nhất một Phần tử excerpt và ít
nhất một Phần tử title.
Để so sánh hai objects trong XPath ta dùng dấu (=) cho bằng nhau và (!= ) cho không
bằng nhau. Mọi Phần tử và Thuộc tínhs là string, nhưng được Typecast (xem như ) những
con số khi đem ra so sánh.
Biểu thức
Ý nghĩa
author[lastname = "Smith"]
Mọi Phần tử author có chứa ít nhất một Phần tử lastname với
trị số bằng Smith.
author[lastname[1]
"Smith"]
= Mọi Phần tử author có Phần tử lastname con đầu tiên với trị
số bằng Smith.
author/degree[@from
"Harvard"]
!= Mọi Phần tử degree, là con một Phần tử author, và có một
Thuộc tính from với trị số không phải là "Harvard".
author[lastname
/editor/lastname]
= Mọi Phần tử author có chứa một Phần tử lastname bằng với
Phần tử lastname là con của root Phần tử editor.
author[. = "John Hamilton"]
Mọi Phần tử author có trị số string là John Hamilton.
Ngôn ngữ Xpath hỗ trợ Operator Union (phép toán hợp), giống như Logical OR (hoặc
là). Dưới đây là vài thí dụ:
Biểu thức
firstname | lastname
Ý nghĩa
Mọi Phần tử firstname và lastname trong current
context.
(bookstore/book
| Mọi Phần tử book hay magazine là con một Phần tử
bookstore/magazine)
bookstore.
book | book/author
Mọi Phần tử book hay Phần tử author là con những
Phần tử book.
(book | magazine)/price
Mọi Phần tử price là con của Phần tử book hay Phần
tử magazine.
Để chọn những loại Nút khác hơn là Phần tử nút, ta dùng kiểu tra kiểu nút. Mục đích
của việc dùng kiểm tra kiểu nút là để chỉ định sự lựa chọn khác thường. Thí dụ như,
descendant::text() cho ta mọi text các nút là con cháu của context nút, dù rằng loại nút chính
của con cháu context nút là Phần tử. Có 4 loại kiểu tra kiểu nút như liệt kê dưới đây.
Kiểu nút
comment()
Trả về
Thí dụ
Mọi comment nút.
following::comment() chọn mọi comment các nút
hiện ra sau context nút.
nút()
Mọi nút.
preceding::nút() chọn mọi các nút hiện ra trước
context nút.
processing-
instruction()
Mọi
processing self::processing instruction() chọn mọi processing
instruction nút.
instruction các nút trong context nút.
text()
Mọi text nút.
child::text() chọn mọi text các nút là con của the
context nút.
13
Thử Nút nhắm vào loại Processing Instruction
Một nút test có thể chọn processing instruction thuộc loại nào, tức là chọn mục tiêu
(target). Cú pháp của một loại test như thế là:
processing-
instruction("target")
Thí dụ nút test sau đây trả về mọi processing instruction các nút có nhắc đến một XSL
stylesheet trong tài liệu:
/child::processing-instruction("xml-
stylesheet")
Thêm một số thí dụ Location Path
Biểu thức
Ý nghĩa
./author
Mọi Phần
tử
author
trong
current
context.
Expresion nầy tương đương với Biểu thức trong hàng kế.
author
Mọi Phần tử author trong current context.
/bookstore
//author
Document (Root) Phần tử tên bookstore của tài liệu nầy.
Mọi Phần tử author trong tài liệu.
book[/bookstore/@specialty
@style]
= Mọi Phần tử book có Thuộc tính style với value bằng
value của Thuộc tính specialty của Document Phần tử
bookstore của tài liệu.
author/firstname
bookstore//title
Mọi Phần tử firstname con của các Phần tử author.
Mọi Phần tử title một hay nhiều bậc thấp hơn, tức là con
cháu của, Phần tử bookstore. Lưu ý là Biểu thức nầy
khác với Biểu thức trong hàng kế.
bookstore/*/title
Mọi Phần tử title cháu của các bookstore.
bookstore//book/excerpt//emph
Mọi Phần tử emph bất cứ nơi nào dưới excerpt là con của
những Phần tử book , bất cứ nơi nào dưới phần tử
bookstore.
.//title
Mọi Phần tử title một hay nhiều bậc thấp hơn current
context nút.
author/*
Mọi Phần tử là con của các Phần tử con author.
Mọi Phần tử lastname là cháu của các Phần tử con book.
Mọi Phần tử cháu của current context nút.
Mọi Phần tử con có Thuộc tính specialty.
Book/*/lastname
*/*
*[@specialty]
@style
Thuộc tính style của current context nút.
Price/@exchange
Thuộc tính exchange của những Phần tử price trong
current context, tức là những Phần tử price của current
context nút.
Price/@exchange/total
Book[@style]
Trả về một nút set trống rỗng, vì Thuộc tínhs không có
Phần tử con. Biểu thức nầy được chấp nhận trong văn
phạm của XML Path Language, nhưng không thật sự hợp
lệ.
Mọi Phần tử book có Thuộc tính style trong current
14
context
nút.
Lưu ý phần nằm trong ngoặc vuông là điều kiện của Phần
tử book
Book/@style
Thuộc tính style của mọi Phần tử booktrong current
context
nút.
Ở đây không có điều kiện như hàng trên. Ta nói đến
Thuộc tính hay Phần tử nằm bên phải nhất.
@*
Mọi Thuộc tínhs của current context nút.
Phần tử author thứ nhất trong current context nút.
Phần tử author thứ ba có một Phần tử con firstname.
Phần tử book từ namespace my.
author[1]
author[firstname][3]
my:book
my:*
Mọi Phần tử trong namespace my.
XML là cách tuyệt diệu cho ta sắp xếp dữ liệu để trao đổi chúng giữa các tổ chức và
giữa các chương trình ứng dụng. Tuy nhiên, chẳng chóng thì chầy, ta sẽ khám phá sự đa
diện của cơ sở dữ liệu khắp nơi. Và ngay cả có chuẩn XML rồi, ta vẫn cần một công cụ hiệu
lực để trình bày dữ liệu trong nhiều kiểu khác nhau thích hợp cho áp dụng xử lý ở một nơi
khác.
XSL - eXtensible Style Sheet (những trang diễn tả dáng điệu) là một ngôn ngữ chuẩn
giúp ta biến đổi (transform) một tài liệu XML ra format khác, như HTML, Wireless (vô tuyến
điện) Markup Language (WML), và ngay cả một XML khác. Lúc nguyên thủy, XSL được thiết
kế để sanh ra nhiều HTML trong những dạng khác nhau tùy theo Style sheet. Tức là XSL
thêm dáng điệu cho XML, vì chính bản chất của XML chỉ là một cấu trúc của những mảnh
dữ liệu.
Thí dụ ta có hai Style sheet versions cho một XML, một cái dùng để tạo ra HTML cho
trang Web thông thường trên computer, còn cái kia để tạo ra trang Web dùng cho Mobile
Phone hay Pocket PC, những dụng cụ có màn ảnh nhỏ. Cả hai trang Web đều chứa cùng
một số dữ liệu, có thể trên màn ảnh nhỏ thì giới hạn những dữ liệu quan trọng thôi, nhưng
cách trình bày có thể rất khác nhau.
Tuy nhiên, sau đó không lâu, người ta thấy XML có thể được XSL biến đổi ra bất cứ
định dạng nào, ngay cả chính XML. Có một version mới, rất hay của XSL vừa ra đời. Nó
được gọi là XSL Transformations (XSLT).
Chúng ta sẽ lần lượt học các cú pháp thông dụng của XSL. Tuy không nhiều, nhưng nó
giúp chúng ta có một ý niệm căn bản về kỹ thuật nầy để chúng ta có thể bắt đầu dùng XSL
style sheets biến chế dữ liệu trong tài liệu XML. Muốn có một XSL reference đầy đủ , chúng
Nên nhớ là giống như XPath, XSL và XSLT chỉ là những tiêu chuẩn ấn định những gì ta
đòi hỏi một chương trình áp dụng được thực hiện để hổ trợ chúng cần phải có. Tuy nhiên, ai
triển khai chương trình đó, và bằng ngôn ngữ lập trình nào cũng được. Thí dụ như Microsoft
cho ta MSXML version 3 để dùng XSL và XSLT.
Những trang XSL định nghĩa những style sheets (trang dáng điệu) để ta có thể áp dụng
vào những tài liệu XML. Một style sheet chứa những chỉ dẫn (instructions) để bảo một XML
parser làm cách nào phát sinh (generate) ra một tài liệu trình duyệt kết quả cho những dữ
liệu trong một tài liệu XML.
Bản thân XSL style sheet cũng là một XML well-formed nhưng nó chứa những lệnh
(commands) XSL và những câu HTML text dùng y nguyên cho output.
Để XML parser nhận diện được các lệnh trong một XSL, chúng ta phải khai báo
(declare) một namespace trong root phần tử, thường thường với một prefix xsl. Một Style
sheet thường thường chứa một trong hai namespaces: cái namespace XSL nguyên thủy
(http://www.w3.org/TR/WD-xsl)
hay
cái
namespace
mới
XSLT
lên đều hỗ trợ cả hai namespaces.
15
Xin lưu ý là Internet Explorer version 5.x dùng MSXML 2.5, nên không hỗ trợ
namespace XSLT. Muốn khắc phục trở ngại ấy, hoặc là chúng ta cài đặt Internet Explorer
version 6, hoặc là chúng ta cài MSXML3 trong Replace mode bằng cách dùng công cụ tên
Xmlinst.exe để thêm chức năng hỗ trợ namespace XSLT trong IE v5.x.
Cái Root Phần tử trong một tài liệu XSL document thường thường là một Phần tử
stylesheet. Nó chứa một hay nhiều Phần tử Template để được matched (cặp đôi vì giống
nhau) với dữ liệu trong tài liệu XML, thí dụ như tài liệu đặt hàng (order) dưới đây:
<?xml version="1.0"?>
<Order OrderNo="1047">
<OrderDate>2002-03-26</OrderDate>
<Customer>John Costello</Customer>
<Item>
<Product ProductID="1" UnitPrice="70">Chair</Product>
<Quantity>6</Quantity>
</Item>
<Item>
<Product ProductID="2" UnitPrice="250">Desk</Product>
<Quantity>1</Quantity>
</Item>
</Order>
Vì chính XSL style sheet cũng là một tài liệu XML, nên nó phải tuân theo mọi luật về một
XML well-formed. Sau đây là một XSL style sheet đơn giãn có thể được áp dụng vào tài liệu
order:
<?xml version="1.0"?>
<xsl:template match="/">
<HTML>
<HEAD>
<TITLE>Northwind Home Page</TITLE>
</HEAD>
<BODY>
<P>Customer Order</P>
</BODY>
</HTML>
</xsl:template>
</xsl:stylesheet>
Style sheet nầy dựa trên namespace XSLT và chứa vỏn vẹn một template (bảng kẻm in)
được áp dụng vào Root (biểu hiệu bằng dấu slash / là trị số của Thuộc tính match) của tài
lịệu XML và mọi Phần tử bên trong của nó.
Một template thật thì gồm có một loạt Tags HTML sẽ hiện ra trong hồ sơ kết quả, nhưng
trong trường hợp nầy cái Template không làm chuyện gì hữu ích; nó chỉ output (cho ra) một
tài liệu HTML y nguyên như nằm trong XSL và không có chứa dữ liệu gì từ hồ sơ input XML.
Để merge (hòa đồng) các dữ liệu trong XML vào XSL template, chúng ta cần phải dùng một
ít lệnh (commands) XSL.
XSL định nghĩa một số lệnh xử lý (processing commands) để trích dữ liệu ra từ một tài
liệu XML và hòa nó vào một hồ sơ kết quả. Cái lệnh căn bản và hữu dụng nhất trong số nầy
là lệnh value-of. Lệnh value-of chọn trị số (value) của một Phần tử hay Thuộc tính nào đó
trong XML và hòa nó với hồ sơ output.
Lệnh value-of có dạng một XML Phần tử trong XSL. Nó dùng một Thuộc tính tên select
có value là một XPath Location Path để trích ra một Nút. Kết quả là value của (value-of) Nút
ấy. Do đó, khá hơn lần trước, bây giờ ta có thể trình bày dữ liệu của XML với lệnh value-of
như sau:
<?xml version="1.0"?>
<xsl:template match="/">
<HTML>
<HEAD>
16
<TITLE>Northwind Home Page</TITLE>
</HEAD>
<BODY>
<P>Customer Order</P>
<P>Order No:
<xsl:value-of select="Order/@OrderNo"/>
</P>
<P>Date:
<xsl:value-of select="Order/OrderDate"/>
</P>
<P>Customer:
<xsl:value-of select="Order/Customer"/>
</P>
</BODY>
</HTML>
</xsl:template>
</xsl:stylesheet>
Cái Style sheet kỳ nầy trích ra Thuộc tính OrderNo và trị số của các Phần tử OrderDate
và Customer từ Phần tử Order bằng cách dùng một XPath location path. Lưu ý là các XPath
Biểu thứcs ở đây thì tương đối với context nút chỉ định trong match parameter của Phần tử
template (trong trường hợp nầy là Root Phần tử, biểu hiệu bằng dấu slash /).
Áp dụng Style sheet nầy vào hồ sơ đặt hàng (order) XML ta sẽ được HTML sau đây:
<HTML>
<HEAD>
<TITLE>Northwind Home Page</TITLE>
</HEAD>
<BODY>
<P>Customer Order</P>
<P>Order No: 1047</P>
<P>Date: 2002-03-26</P>
<P>Customer: John Costello</P>
</BODY>
</HTML>
Trong một tài liệu XML, có thể có nhiều Phần tử mang cùng một tên để nói đến một
danh sách những thứ tưong tư. Thí dụ trong tài liệu đặt hàng có hai Phần tử Item để diễn tả
hai món hàng được đặt.
Hầu hết ngôn ngữ lập trình cho ta phương tiện để áp dụng cùng một cách xử lý cho mọi
món trong nhóm. Như trong Visual Basic ta có FOR loop hay DO loop để iterate qua từng
món trong bộ. Trong XSL cũng thế, chúng ta có thể dùng lệnh for-each để đi lần lượt qua
từng Phần tử trong nhóm, bằng cách dùng Thuộc tính select để chỉ định những các nút mà
chúng ta muốn làm việc.
Thí dụ ta có thể làm cho cái Style sheet hay hơn bằng cách liệt kê các Item trong Order
thành một table:
<?xml version="1.0"?>
<xsl:template match="/">
<HTML>
<HEAD>
<TITLE>Northwind Home Page</TITLE>
</HEAD>
<BODY>
<P>Customer Order</P>
<P>Order No:
<xsl:value-of select="Order/@OrderNo"/>
</P>
<P>Date:
<xsl:value-of select="Order/OrderDate"/>
17
</P>
<P>Customer:
<xsl:value-of select="Order/Customer"/>
</P>
<TABLE Border="0">
<TR>
<TD>ProductID</TD>
<TD>Product Name</TD>
<TD>Price</TD>
<TD>Quantity Ordered</TD>
</TR>
<xsl:for-each select="Order/Item">
<TR>
<TD>
<xsl:value-of select="Product/@ProductID"/>
</TD>
<TD>
<xsl:value-of select="Product"/>
</TD>
<TD>
<xsl:value-of select="Product/@UnitPrice"/>
</TD>
<TD>
<xsl:value-of select="Quantity"/>
</TD>
</TR>
</xsl:for-each>
</TABLE>
</BODY>
</HTML>
</xsl:template>
</xsl:stylesheet>
Lần nầy trong Style sheet, ta bảo parser đi qua từng Phần tử Item để lấy ra Thuộc tínhs
ProductID và UnitPrice của Phần tử Product , và values của Phần tử Product và Quantity, rồi
cho vào table.
Lưu ý ở đây các XPath Biểu thứcs tương đối dùng cái Nút chỉ định trong lệnh for-each
làm context nút. Trong trường hợp nầy nó là Nút Item. Cuối của for-each loop là closing Tag
của Phần tử for-each (</xsl:for-each>). Style sheet trên nầy khi áp dụng vào tài liệu đặt hàng
sẽ cho ra HTML sau đây:
<HTML>
<HEAD>
<TITLE>Northwind Home Page</TITLE>
</HEAD>
<BODY>
<P>Customer Order</P>
<P>Order No: 1047</P>
<P>Date: 2002-03-26</P>
<P>Customer: John Costello</P>
<TABLE Border="0">
<TR>
<TD>ProductID</TD>
<TD>Product Name</TD>
<TD>Price</TD>
<TD>Quantity Ordered</TD>
</TR>
<TR>
<TD>1</TD>
18
Tải về để xem bản đầy đủ
253 trang
23760
Free
Bạn đang xem 20 trang mẫu của tài liệu "Giáo trình Lập trình web nâng cao (XML)", để tải tài liệu gốc về máy hãy click vào nút Download ở trên
File đính kèm:
- giao_trinh_lap_trinh_web_nang_cao_xml.pdf
