Introduction
XML (eXtensible Markup Language) serves as a standardized format for transferring and storing data across different applications. While HTML focuses on presenting information visually, XML prioritizes structured data representation. This technology has become one of the most widely adopted mechanisms for data interchange between disparate systems.
Document Structure
XML documents follow a hierarchical tree structure. Consider this example representing a collection of books:
<library>
<volume type="FICTION">
<bookTitle language="en">The Great Gatsby</bookTitle>
<writer>F. Scott Fitzgerald</writer>
<published>1925</published>
<cost>12.99</cost>
</volume>
<volume type="MYSTERY">
<bookTitle language="en">Murder on the Orient Express</bookTitle>
<writer>Agatha Christie</writer>
<published>1934</published>
<cost>15.99</cost>
</volume>
<volume type="TECHNICAL">
<bookTitle language="en">Clean Code</bookTitle>
<writer>Robert C. Martin</writer>
<published>2008</published>
<cost>45.00</cost>
</volume>
</library>
In this structure, <library> acts as the root element containing all child <volume> elements. Each book entry contains four child elements: <bookTitle>, <writer>, <published>, and <cost>.
Core Syntax Rules
XML Declaration
The XML declaration is optional but must appear on the first line if used:
<?xml version="1.0" encoding="UTF-8"?>
Root Element Requirement
Every valid XML document requires exactly one root element that encompasses all other elements:
<organization>
<department>
<team>Development</team>
</department>
</organization>
Element Composition
XML documents consist of elements, each comprising an opening tag, closing tag, and content between them.
Attribute Syntax
Attributes provide additional metadata within opening tags and must always be quoted:
<employee id="E-1001" department="Engineering">Jane Smith</employee>
Tag Naming Conventions
XML elements require closing tags, though self-closing tags (empty elements) are permitted:
<selfClosing tag="value" />
XML tags are case-sensitive, so <Name> and <name> represent different elements.
Entity References
Certain characters hold special significance in XML. Placing a literal < character triggers parsing errors because parsers interpret it as the start of a new element tag. This causes an error:
<message>if revenue < 50000 then invest</message>
Use entity references to escape special characters:
<message>if revenue < 50000 then invest</message>
Predefined XML entity references:
| Entity | Character | Description |
|---|---|---|
< |
< | Less than |
> |
> | Greater than |
& |
& | Ampersand |
' |
' | Apostrophe |
" |
" | Quotation mark |
Note: Only < and & are strictly illegal in XML. While > is technically valid, using > is recommended as best practice.
XML Elements in Depth
An XML element is the fundamental building block of any XML document, comprising opening tag, closing tag, and intermediate content:
<article>
<headline>Design Patterns Explained</headline>
<author>Erich Gamma</author>
<pages>395</pages>
</article>
Here, the <article> element contains three child elements: <headline>, <author>, and <pages>. Each child element contains its own text content.
Elements can include attributes for additional classsification:
<article category="TECHNICAL">
<headline>Design Patterns Explained</headline>
<author>Erich Gamma</author>
<pages>395</pages>
</article>
Proper nesting is mandatory—each opening tag must have a corresponding closing tag in the correct order. This example demonstrates incorrect nesting:
<article>
<headline>Design Patterns Explained
<author>Erich Gamma</author>
</headline>
<pages>395</pages>
</article>
XML Attributes
Attributes supplement elements with metadata, defined within opening tags as name-value pairs:
<document id="DOC-42">
<title>Technical Specification</title>
<author>Martin Fowler</author>
</document>
Attribute values require quotation marks (double or single). Attributes typically convey categorical information, type specifications, or state indicators for elements.
Validation Mechanisms
Well-Formed vs Valid XML
Well-formed XML adheres to syntax rules. Valid XML additionally conforms to a Document Type Definition (DTD). The foundational syntax requirements include:
- Presence of exactly one root element
- Matching closing tags for all elements
- Case-sensitive tag naming
- Proper element nesting
- Quoted atttribute values
<?xml version="1.0" encoding="ISO-8859-1"?>
< memorandum>
<recipient>Alice</recipient>
<sender>Bob</sender>
<subject>Project Update</subject>
<content>Schedule shift notice</content>
</memorandum>
Document Type Definition (DTD)
DTD establishes the structural blueprint for XML documents, specifying allowed elements, their sequence, allowable attributes, and content models.
Internal DTD definition:
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE memorandum [
<!ELEMENT recipient (#PCDATA)>
<!ELEMENT sender (#PCDATA)>
<!ELEMENT subject (#PCDATA)>
<!ELEMENT content (#PCDATA)>
]>
<memorandum>
<recipient>Alice</recipient>
<sender>Bob</sender>
<subject>Project Update</subject>
<content>Schedule shift notice</content>
</memorandum>
External DTD reference:
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE memorandum SYSTEM "http://localhost/memo.dtd">
<memorandum>
<recipient>Alice</recipient>
<sender>Bob</sender>
<subject>Project Update</subject>
<content>Schedule shift notice</content>
</memorandum>
When referencing external DTDs, ensure proper parser configuration to mitigate potential security risks from external entity inclusion.
XML Schema (XSD)
W3C Schema provides XML-based validation with enhanced type support and constraint definitions:
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="memorandum">
<xs:complexType>
<xs:sequence>
<xs:element name="recipient" type="xs:string"/>
<xs:element name="sender" type="xs:string"/>
<xs:element name="subject" type="xs:string"/>
<xs:element name="content" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
Error Handling and Parsing
Parser Behavior
XML parsers halt processing upon encountering errors. The W3C specification mandates that applications cease execution when detecting malformed XML, promoting lean, fast, and interoperable XML processors. Unlike HTML browsers that tolerate extensive markup errors, XML demands strict compliance.
Validation Process
DTD validation confirms XML structure matches preestablished rules. A typical DTD file (memo.dtd):
<!ELEMENT memorandum (recipient,sender,subject,content)>
<!ELEMENT recipient (#PCDATA)>
<!ELEMENT sender (#PCDATA)>
<!ELEMENT subject (#PCDATA)>
<!ELEMENT content (#PCDATA)>
The parser validates each element against DTD definitions, throwing errors for violations.
XSD validation using Python:
from lxml import etree
# Load schema definition
with open('schema.xsd', 'r') as f:
schema_root = etree.XML(f.read())
validator = etree.XMLSchema(schema_root)
# Load target document
with open('data.xml', 'r') as f:
xml_doc = etree.XML(f.read())
# Validate structure
validator.assertValid(xml_doc)
The assertValid method raises exceptions when document structure violates schema constraints.
XMLHttpRequest
XMLHttpRequest enables asynchronous client-server communication, a cornerstone of Ajax technology:
var request = new XMLHttpRequest();
request.open("GET", 'https://api.example.com/users', true);
request.onreadystatechange = function () {
if (request.readyState == 4 && request.status == 200)
console.log(request.responseText);
}
request.send();
This implementation creates an XMLHttpRequest instance, initializes a GET request, and sets a callback handler for server responses. Upon receiving a completed response with status 200, the handler processes the response data. The send() method transmits the request asynchronously without blocking execution.
While the technology name references XML, modern implementations commonly exchange JSON and other formats.
XML Parsing in Browsers
Contemporary browsers incorporate native XML parsing capabilities, converting XML documents into manipulable DOM objects accessible via JavaScript.
Cross-Origin Restrictions
Browser security policies restrict cross-origin requests, requiring documents and fetched resources to originate from identical servers unless CORS (Cross-Origin Resource Sharing) mechanisms permit otherwise.
The Same-Origin Policy blocks interactions between resources from different origins. Origins are considered different when protocol, hostname, or port diverges. For a page at http://portal.example.com/docs/index.html, the following differ in origin:
http://api.example.com/docs/index.html (different subdomain)
https://portal.example.com/docs/index.html (different protocol)
http://portal.example.com:9090/docs/index (different port)
CORS enables cross-origin access through HTTP headers. The server determines whether to grant access by evaluating origin information in request headers. Approved responses include authorization headers instructing the browser to accept the data. CORS implementation rests entirely with the server—the browser enforces server decisions without client-side configuration options.