- Sams Teach Yourself XML in 21 Days, Third Edition
- Table of Contents
- About the Author
- Acknowledgments
- We Want to Hear from You!
- Introduction
- Part I: At a Glance
- Day 1. Welcome to XML
- All About Markup Languages
- All About XML
- Looking at XML in a Browser
- Working with XML Data Yourself
- Structuring Your Data
- Creating Well-Formed XML Documents
- Creating Valid XML Documents
- How XML Is Used in the Real World
- Online XML Resources
- Summary
- Q&A
- Workshop
- Day 2. Creating XML Documents
- Choosing an XML Editor
- Using XML Browsers
- Using XML Validators
- Creating XML Documents Piece by Piece
- Creating Prologs
- Creating an XML Declaration
- Creating XML Comments
- Creating Processing Instructions
- Creating Tags and Elements
- Creating CDATA Sections
- Handling Entities
- Summary
- Q&A
- Workshop
- Day 3. Creating Well-Formed XML Documents
- What Makes an XML Document Well-Formed?
- Creating an Example XML Document
- Understanding the Well-Formedness Constraints
- Using XML Namespaces
- Understanding XML Infosets
- Understanding Canonical XML
- Summary
- Q&A
- Workshop
- Day 4. Creating Valid XML Documents: DTDs
- All About DTDs
- Validating a Document by Using a DTD
- Creating Element Content Models
- Commenting a DTD
- Supporting External DTDs
- Handling Namespaces in DTDs
- Summary
- Q&A
- Workshop
- Declaring Attributes in DTDs
- Day 5. Handling Attributes and Entities in DTDs
- Specifying Default Values
- Specifying Attribute Types
- Handling Entities
- Summary
- Q&A
- Workshop
- Day 6. Creating Valid XML Documents: XML Schemas
- Using XML Schema Tools
- Creating XML Schemas
- Dissecting an XML Schema
- The Built-in XML Schema Elements
- Creating Elements and Types
- Specifying a Number of Elements
- Specifying Element Default Values
- Creating Attributes
- Summary
- Q&A
- Workshop
- Day 7. Creating Types in XML Schemas
- Restricting Simple Types by Using XML Schema Facets
- Creating XML Schema Choices
- Using Anonymous Type Definitions
- Declaring Empty Elements
- Declaring Mixed-Content Elements
- Grouping Elements Together
- Grouping Attributes Together
- Declaring all Groups
- Handling Namespaces in Schemas
- Annotating an XML Schema
- Summary
- Q&A
- Workshop
- Part I. In Review
- Well-Formed Documents
- Valid Documents
- Part II: At a Glance
- Day 8. Formatting XML by Using Cascading Style Sheets
- Our Sample XML Document
- Introducing CSS
- Connecting CSS Style Sheets and XML Documents
- Creating Style Sheet Selectors
- Using Inline Styles
- Creating Style Rule Specifications in Style Sheets
- Summary
- Q&A
- Workshop
- Day 9. Formatting XML by Using XSLT
- Introducing XSLT
- Transforming XML by Using XSLT
- Writing XSLT Style Sheets
- Using <xsl:apply-templates>
- Using <xsl:value-of> and <xsl:for-each>
- Matching Nodes by Using the match Attribute
- Working with the select Attribute and XPath
- Using <xsl:copy>
- Using <xsl:if>
- Using <xsl:choose>
- Specifying the Output Document Type
- Summary
- Q&A
- Workshop
- Day 10. Working with XSL Formatting Objects
- Introducing XSL-FO
- Using XSL-FO
- Using XSL Formatting Objects and Properties
- Building an XSL-FO Document
- Handling Inline Formatting
- Formatting Lists
- Formatting Tables
- Summary
- Q&A
- Workshop
- Part II. In Review
- Using CSS
- Using XSLT
- Using XSL-FO
- Part III: At a Glance
- Day 11. Extending HTML with XHTML
- Why XHTML?
- Writing XHTML Documents
- Validating XHTML Documents
- The Basic XHTML Elements
- Organizing Text
- Formatting Text
- Selecting Fonts: <font>
- Comments: <!-->
- Summary
- Q&A
- Workshop
- Day 12. Putting XHTML to Work
- Creating Hyperlinks: <a>
- Linking to Other Documents: <link>
- Handling Images: <img>
- Creating Frame Documents: <frameset>
- Creating Frames: <frame>
- Creating Embedded Style Sheets: <style>
- Formatting Tables: <table>
- Creating Table Rows: <tr>
- Formatting Table Headers: <th>
- Formatting Table Data: <td>
- Extending XHTML
- Summary
- Q&A
- Workshop
- Day 13. Creating Graphics and Multimedia: SVG and SMIL
- Introducing SVG
- Creating an SVG Document
- Creating Rectangles
- Adobe's SVG Viewer
- Using CSS Styles
- Creating Circles
- Creating Ellipses
- Creating Lines
- Creating Polylines
- Creating Polygons
- Creating Text
- Creating Gradients
- Creating Paths
- Creating Text Paths
- Creating Groups and Transformations
- Creating Animation
- Creating Links
- Creating Scripts
- Embedding SVG in HTML
- Introducing SMIL
- Summary
- Q&A
- Workshop
- Day 14. Handling XLinks, XPointers, and XForms
- Introducing XLinks
- Beyond Simple XLinks
- Introducing XPointers
- Introducing XBase
- Introducing XForms
- Summary
- Workshop
- Part III. In Review
- Part IV: At a Glance
- Day 15. Using JavaScript and XML
- Introducing the W3C DOM
- Introducing the DOM Objects
- Working with the XML DOM in JavaScript
- Searching for Elements by Name
- Reading Attribute Values
- Getting All XML Data from a Document
- Validating XML Documents by Using DTDs
- Summary
- Q&A
- Workshop
- Day 16. Using Java and .NET: DOM
- Using Java to Read XML Data
- Finding Elements by Name
- Creating an XML Browser by Using Java
- Navigating Through XML Documents
- Writing XML by Using Java
- Summary
- Q&A
- Workshop
- Day 17. Using Java and .NET: SAX
- An Overview of SAX
- Using SAX
- Using SAX to Find Elements by Name
- Creating an XML Browser by Using Java and SAX
- Navigating Through XML Documents by Using SAX
- Writing XML by Using Java and SAX
- Summary
- Q&A
- Workshop
- Day 18. Working with SOAP and RDF
- Introducing SOAP
- A SOAP Example in .NET
- A SOAP Example in Java
- Introducing RDF
- Summary
- Q&A
- Workshop
- Part IV. In Review
- Part V: At a Glance
- Day 19. Handling XML Data Binding
- Introducing DSOs
- Binding HTML Elements to HTML Data
- Binding HTML Elements to XML Data
- Binding HTML Tables to XML Data
- Accessing Individual Data Fields
- Binding HTML Elements to XML Data by Using the XML DSO
- Binding HTML Tables to XML Data by Using the XML DSO
- Searching XML Data by Using a DSO and JavaScript
- Handling Hierarchical XML Data
- Summary
- Q&A
- Workshop
- Day 20. Working with XML and Databases
- XML, Databases, and ASP
- Storing Databases as XML
- Using XPath with a Database
- Introducing XQuery
- Summary
- Q&A
- Workshop
- Day 21. Handling XML in .NET
- Creating and Editing an XML Document in .NET
- From XML to Databases and Back
- Reading and Writing XML in .NET Code
- Using XML Controls to Display Formatted XML
- Creating XML Web Services
- Summary
- Q&A
- Workshop
- Part V. In Review
- Appendix A. Quiz Answers
- Quiz Answers for Day 1
- Quiz Answers for Day 2
- Quiz Answers for Day 3
- Quiz Answers for Day 4
- Quiz Answers for Day 5
- Quiz Answers for Day 6
- Quiz Answers for Day 7
- Quiz Answers for Day 8
- Quiz Answers for Day 9
- Quiz Answers for Day 10
- Quiz Answers for Day 11
- Quiz Answers for Day 12
- Quiz Answers for Day 13
- Quiz Answers for Day 14
- Quiz Answers for Day 15
- Quiz Answers for Day 16
- Quiz Answers for Day 17
- Quiz Answers for Day 18
- Quiz Answers for Day 19
- Quiz Answers for Day 20
- Quiz Answers for Day 21
Recommended Book
Recommended Book
Recommended Book
Supporting External DTDs
So far, we've stored DTDs internally in XML documents, using <!DOCTYPE> elements. But we can also store DTDs externally, in entirely separate files (which usually use the extension .dtd). It's often a good idea to use an external DTD with an XML application that is shared by many people. That way, if you want to make changes in the XML application, you only need to change the DTD once, not in dozens of separate files. (In fact, that's the way many XML applications, such as XHTML, are implemented.)
Private and Public DTDs
There are two ways to support external DTDs—as private DTDs for personal or limited use and as public DTDs for public use. We'll start with private DTDs.
Creating Private DTDs
You specify that we're using an external private DTD by using the SYSTEM keyword in the <!DOCTYPE> element, like this:
<!DOCTYPE document SYSTEM "ch04_07.dtd">
This example specifies the name of the document element (which is just <document> in this example), the SYSTEM keyword to indicate that the example is using a private external DTD, and the name of the external DTD file. Note that because the XML document now depends on an external file, the external DTD file, we must also change the standalone attribute from "yes" to "no", as shown in ch04_06.xml in Listing 4.6. The external DTD here is in ch04_07.dtd, which is shown in Listing 4.7. Note that the external DTD simply holds the part of the document that was originally between the [ and ] in the earlier versions of the <!DOCTYPE> element.
Example 4.6. A Sample XML Document That Uses a Private External DTD (ch04_06.xml)
<?xml version = "1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE document SYSTEM "ch04_07.dtd">
<document>
<employee>
<name>
<lastname>Kelly</lastname>
<firstname>Grace</firstname>
</name>
<hiredate>October 15, 2005</hiredate>
<projects>
<project>
<product>Printer</product>
<id>111</id>
<price>$111.00</price>
</project>
<project>
<product>Laptop</product>
<id>222</id>
<price>$989.00</price>
</project>
</projects>
</employee>
.
.
.
</document>
Example 4.7. An External DTD (ch04_07.dtd)
<!ELEMENT document (employee)*> <!ELEMENT employee (name, hiredate, projects)> <!ELEMENT name (lastname, firstname)> <!ELEMENT lastname (#PCDATA)> <!ELEMENT firstname (#PCDATA)> <!ELEMENT hiredate (#PCDATA)> <!ELEMENT projects (project)*> <!ELEMENT project (product,id,price)> <!ELEMENT product (#PCDATA)> <!ELEMENT id (#PCDATA)> <!ELEMENT price (#PCDATA) >
The example shown in Listing 4.7 assumes that the external DTD is in the same directory as the XML document itself, so you just need to give the name of the external DTD file in the <!DOCTYPE> element:
<?xml version = "1.0" standalone="no"?> <!DOCTYPE document SYSTEM "ch04_07.dtd">
On the other hand, you can place the external DTD anywhere, as long as you give its full URI (in this case, that's just the full URL, as far as most XML processors are concerned) in the <!DOCTYPE> element, as in this example:
<?xml version = "1.0" standalone="no"?> <!DOCTYPE document SYSTEM "http://www.xmlpowercorp.com/dtds/ch04_07.dtd">
You need to supply a URL like this for an external DTD if you want to use an online XML validator.
Creating Public DTDs
As discussed so far today, it's easy to create and use a private external DTD. Creating and using a public external DTD can take a little more work. In this case, you use the PUBLIC keyword instead of SYSTEM in the <!DOCTYPE> DTD. To use the PUBLIC keyword, you must also create a formal public identifier ( FPI ), which is a quoted string of text, made up of four fields separated by //. For example, the official FPI for transitional XHTML 1.0 is -//W3C//DTD XHTML 1.0 Transitional//EN. Here are the rules for creating the fields in FPIs:
- The first field indicates whether the DTD is for a formal standard. For DTDs you create on your own, this field should be -. If a non-official standards body has created the DTD, you use +. For formal standards bodies, this field is a reference to the standard itself (such as ISO/IEC 19775:2003).
- The second field holds the name of the group or person responsible for the DTD. You should use a name that is unique (for example, W3C just uses W3C).
- The third field specifies the type of the document the DTD is for and should be followed by a unique version number of some kind (such as Version 1.0).
- The fourth field specifies the language in which the DTD is written (for example, EN for English).
When you use a public external DTD, we can use the <!DOCTYPE> element like this: <!DOCTYPE rootname PUBLIC FPI URI >. Listing 4.8 shows an example, ch04_08.xml, which uses the made-up FPI -//DTDS4ALL//Custom DTD Version 1.0//EN. This document uses ch04_07.dtd as the external DTD, as in the previous example, but as we can see, it treats that DTD as a public external DTD, complete with its own FPI.
Example 4.8. A Sample XML Document That Uses a Public External DTD (ch04_08.xml)
<?xml version = "1.0" standalone="no"?>
<!DOCTYPE document PUBLIC "-//DTDS4ALL//Custom DTD Version 1.0//EN"
"http://www.xmlpowercorp.com/dtds/ch04_07.dtd">
<document>
<employee>
<name>
<lastname>Kelly</lastname>
<firstname>Grace</firstname>
</name>
<hiredate>October 15, 2005</hiredate>
<projects>
<project>
<product>Printer</product>
<id>111</id>
<price>$111.00</price>
</project>
<project>
<product>Laptop</product>
<id>222</id>
<price>$989.00</price>
</project>
</projects>
</employee>
.
.
.
</document>
Using Internal and External DTDs at the Same Time
So far, you've seen these versions of the <!DOCTYPE> element:
- <!DOCTYPE rootname [ DTD ]>
- <!DOCTYPE rootname SYSTEM URI >
- <!DOCTYPE rootname PUBLIC identifier URI >
However, you can also use both internal and external DTDs if you use these forms of the <!DOCTYPE> element:
- <!DOCTYPE rootname SYSTEM URI [ DTD ]>
- <!DOCTYPE rootname PUBLIC identifier URI [ DTD ]>
In this case, the external DTD is specified by URL and the internal one by DTD . Listing 4.9 shows an example in ch04_09.xml, where the external DTD—ch04_10.xml in Listing 4.10—specifies the syntax of all elements in ch04_09.xml except the <price> element, which is specified in the <!DOCTYPE> element in the XML document ch04_09.xml.
Example 4.9. A Sample XML Document That Uses an Internal DTD and an External DTD (ch04_09.xml)
<?xml version = "1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE document SYSTEM "http://www.lightlink.com/steve/ch04_10.dtd" [
<!ELEMENT price (#PCDATA)>
]>
<document>
<employee>
<name>
<lastname>Kelly</lastname>
<firstname>Grace</firstname>
</name>
<hiredate>October 15, 2005</hiredate>
<projects>
<project>
<product>Printer</product>
<id>111</id>
<price>$111.00</price>
</project>
<project>
<product>Laptop</product>
<id>222</id>
<price>$989.00</price>
</project>
</projects>
</employee>
.
.
.
</document>
Example 4.10. The External DTD for ch04_09.xml (ch04_10.xml)
<!ELEMENT document (employee)*> <!ELEMENT employee (name, hiredate, projects)> <!ELEMENT name (lastname, firstname)> <!ELEMENT lastname (#PCDATA)> <!ELEMENT firstname (#PCDATA)> <!ELEMENT hiredate (#PCDATA)> <!ELEMENT projects (project)*> <!ELEMENT project (product,id,price)> <!ELEMENT product (#PCDATA)> <!ELEMENT id (#PCDATA) >
Combining internal and external DTDs like this is a good idea if you have a standard DTD that we share with other XML documents but also want to do some customization in certain XML documents. Theoretically, if you specify the syntax for an element or attribute in both an internal and external DTD, the internal DTD is supposed to take precedence. Unfortunately, however, most XML processors these days just treat conflicts in an internal and external DTD as errors.