- 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
All About XML
Extensible Markup Language, XML, is really all about creating your own markup (technically, XML is a meta-language, which means it's a language that lets you create your own markup languages). Unlike HTML, XML is meant for storing data, not displaying it. XML provides you with a way of structuring your data in documents, and as mentioned at the beginning of today's discussion, the reason it's taken off so quickly is it's perfect for the Internet—because XML documents are text, you can send them using the existing Internet technology that was built for HTML.
You can package your great books collection as XML, or list all the books in a library, or all the types of fish in the sea; that's what XML is all about, and it's popular largely because restricted markup languages like HTML can't do that. Once you've packaged your data, you can send it over the Internet, and either other people or dedicated software you or others have created can understand it. There's an immense need to communicate data these days, from real estate listings to bank holdings, and XML is proving to be the way to do it.
XML was actually derived from Standard Generalized Markup Language, SGML, in 1998. SGML is a complex language, and was around for a long time without gaining widespread acceptance—but XML hasn't suffered from that problem. XML just turned five years old shortly before this book was written, and Jon Bosak, one of the people instrumental in XML's creation, wished XML happy birthday by saying, "The five years since XML was released have seen XML become the lingua franca of the Web." And it's true—using the markup you develop with XML, you can package your data so that data can be read by others. HTML is limited by having a limited amount of available markup; XML is limitless, because the markup you can create with it is also limitless.
XML is a creation of the World Wide Web Consortium (W3C) http://www.w3.org, which is the same group responsible for HTML and many other such specifications. W3C publishes its specifications (they're not called standards, technically, because W3C is not a government-sponsored body) using four types of documents, and if you want to work with XML and all its allied specifications, you have to be familiar with them:
- Notes— Specifications that were submitted to the W3C by an organization that is a member of the World Wide Web Consortium. W3C makes these specifications public, although doesn't necessarily endorse them, by publishing them as a note.
- Working drafts— A working draft is a specification that is under consideration, and open to comment. This is the first stage that W3C specifications must go through on their way to becoming recommendations.
- Candidate recommendations— Working drafts that the W3C has accepted become candidate recommendations, which means they're still open for comment. This is the second stage that W3C specifications must go through on their way to becoming recommendations.
- Recommendations— Candidate recommendations that the W3C has accepted become recommendations, which is the term the W3C uses when it publishes its specifications it considers ready for general use.
XML version 1.0 is in recommendation form, and has been since October 6, 2000, which means it's an established standard. You can find the formal XML 1.0 recommendation at http://www.w3.org/TR/REC-xml. There's a new version of XML now in candidate recommendation form, XML 1.1 (the latest version is October 15, 2002). You can find the XML 1.1 candidate recommendation at http://www.w3.org/TR/xml11/. As we'll discuss tomorrow, XML 1.1 improves on XML 1.0 by fixing a few errors, and by making the support for Unicode stronger.
What does an XML document actually look like? Let's take a look at one to get an idea of what's going on and how XML works. You can see a sample XML document, ch01_02.xml, in Listing 1.2.
Example 1.2. A Sample XML Document (ch01_02.xml)
<?xml version="1.0" encoding="UTF-8"?>
<document>
<heading>
Hello From XML
</heading>
<message>
This is an XML document!
</message>
</document>
We're going to dissect the kind of XML document you see in Listing 1.2 in detail tomorrow, but we'll get familiar with its structure today.
Like all XML documents, this one starts with an XML declaration, <?xml version="1.0" encoding="UTF-8"?>. This XML declaration indicates that we're using XML version 1.0, and using the UTF-8 character encoding, which means that we're using an 8-bit condensed version of Unicode (more on this tomorrow):
<?xml version="1.0" encoding="UTF-8"?>
<document>
<heading>
Hello From XML
</heading>
<message>
This is an XML document!
</message>
</document>
This XML declaration, <?xml?>, uses two attributes, version and encoding, to set the version of XML and the character set we're using (XML declarations also have other attributes, as you'll see tomorrow). XML attributes are much like HTML attributes—they hold additional information, and you create them by assigning a quoted value to the attribute as here: version = "1.0". (Unlike HTML attributes, you must always assign a value to an XML attribute if you use that attribute—there are no standalone attributes as in HTML.)
Next in ch01_02.xml, we create a new XML element named <document>. As in HTML, an element is the fundamental unit that you use to hold your data—all data in an XML document must be inside an element. Elements always start with an opening tag, which is the actual text <document> in this case, and end with a closing tag, which will be </document> here. (Note that this is similar to, but different from, HTML, where you don't always need a closing tag.) XML tags themselves always start with < and end with >. You create an XML element by pairing an opening tag with a closing tag, as we've done here to create the <document> element:
<?xml version="1.0" encoding="UTF-8"?>
<document>
.
.
.
</document>
Now you're free to store other elements in our <document> element, or text data, as we wish.
You're free to make up your own element names in XML, and that's XML's whole power—the capability to create your own markup. You don't have to call this new element <document>; you could have named it <data>, or <record>, or <people>, or <movies>, or <planets>, or many other things. As you'll see tomorrow, in XML 1.0, an element's name can start with a letter or underscore, and the characters following the first one are made up of letters, digits, underscores, dots (.), or hyphens (-)—but no spaces. XML 1.1 is more flexible about names, as you'll also see. Unlike HTML, the case of a tag is important—<DOCUMENT> is not the same tag as <document>, for example.
In between an element's opening tag and its closing tag, you can place the element's content, if there is any. An element's content can be made up of simple text or other elements. Like XML declarations, XML elements can support attributes.
When you create an XML document, you must enclose all elements inside one overall element, called the root element, also called the document element. The root element contains all the other elements in your XML document, and in this case, we've named the root element <document>. XML documents always need a root element, even if they don't have any other elements or text (that is, even if the root element doesn't have any other content).
Inside the root element, we'll add a new element, <heading>, to our XML document, like this:
<?xml version="1.0" encoding="UTF-8"?>
<document>
<heading>
.
.
.
</heading>
.
.
.
</document>
This new element will contain data in the form of text—"Hello from XML":
<?xml version="1.0" encoding="UTF-8"?>
<document>
<heading>
Hello from XML
</heading>
.
.
.
</document>
We will also add another element, which we'll name <message>, to the root element (there is no limit to the number of subelements an element can hold), holding the text data "This is an XML document!":
<?xml version="1.0" encoding="UTF-8"?>
<document>
<heading>
Hello From XML
</heading>
<message>
This is an XML document!
</message>
</document>
And that completes our first XML document. In this case, the root element, <document>, contains two elements, <heading> and <message>, both of which contain text (although they could contain other elements).
As you can see, this XML document looks like the HTML document we created earlier—the elements we've created here are surrounded by tags, just as in the HTML document. However, we just created the elements in the XML document out of thin air; we didn't have to stick to a predefined set. Being able to create your own elements from scratch like this has advantages and disadvantages—you're not restricted to a predefined and limited set of tags, but on the other hand, a standard Web browser can understand HTML tags but will have no idea what to do with a <message> tag.
We've stored our data in an XML document; to start interpreting that data, we'll begin by simply opening it in a browser.