wt 1

XML (Extensible Markup Language) is a text-based markup language designed to store and
transport data in a structured, human-readable format. It provides a platform-independent way to

encode, share, and manipulate data between different systems, applications, and platforms. XML
is a flexible and extensible language, meaning that users can define their own tags and document
structure to fit specific needs.
Key Features of XML:
1. Self-descriptive Structure:
o XML uses tags to describe the data, making it easy to understand the structure and
meaning of the information contained within.
o Example:
xml
Copy code
<person>
<name>John Doe</name>
<age>30</age>
<city>New York</city>
</person>
2. Platform-Independent:
o XML is text-based and can be read and written by different operating systems and
programming languages, making it ideal for cross-platform data interchange.
3. Hierarchical Structure:
o XML documents follow a tree-like structure, where elements can contain other
elements. This hierarchical structure allows for complex data representation.
o Example:
xml
Copy code
<library>
<book>
<title>XML for Beginners</title>
<author>John Smith</author>
<year>2020</year>
</book>
<book>
<title>Advanced XML</title>
<author>Jane Doe</author>
<year>2019</year>
</book>
</library>
4. Extensibility:
o Unlike other markup languages like HTML, XML does not have a fixed set of tags.
Users can define their own tags based on the data they need to store.
5. Human-Readable and Machine-Readable:
o XML documents are plain text, making them easy for humans to read, but they are
also structured so that machines can process and parse the data efficiently.
6. Validation:
o XML allows for validation against a set of rules, typically defined in a Document
Type Definition (DTD) or XML Schema (XSD), ensuring the data follows a specific
structure.
Why Use XML?
• Data Exchange: XML is commonly used to exchange data between different applications,
especially in web services (e.g., REST, SOAP).
• Storage: XML is often used for storing data in files or databases, particularly in cases where
human-readability is important.
• Interoperability: XML facilitates interoperability between different systems, regardless of

their underlying technology.
1. Document Type Definition (DTD)
A Document Type Definition (DTD) defines the structure and legal elements and attributes of an
XML document. It acts as a set of rules to ensure the document follows a particular format.
Types of DTDs:
• Internal DTD: Defined within the XML document itself.
• External DTD: Defined outside the XML document, typically in a separate file.
Purpose:
• Ensures XML data adheres to a predefined structure.
• Specifies the allowed elements and attributes, their relationships, and the order in which
they appear.
Example of DTD:
xml
Copy code
<!DOCTYPE note [
<!ELEMENT note (to, from, heading, body)>
<!ELEMENT to (#PCDATA)>
<!ELEMENT from (#PCDATA)>
<!ELEMENT heading (#PCDATA)>
<!ELEMENT body (#PCDATA)>
]>
<note>
<to>John</to>
<from>Jane</from>
<heading>Reminder</heading>
<body>Don't forget the meeting!</body>
</note>
In this example:
• note contains to, from, heading, and body elements.
• #PCDATA means parsed character data (simple text).
2. XML Schema (XSD)
An XML Schema (often written as XSD, for XML Schema Definition) is a more powerful alternative to
DTD. It defines both the structure and data types of an XML document. XSD is more flexible and
expressive than DTD and allows specifying data types, constraints, and namespaces.
Key Features:
• Data Types: Supports types like string, integer, boolean, date, etc.
• Namespaces: Can define namespaces to avoid element name conflicts.
• Restrictions: Can define specific restrictions like minimum or maximum length for strings, or
valid ranges for numbers.
Example of XML Schema (XSD):
xml
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="note">
<xs:complexType>
<xs:sequence>
<xs:element name="to" type="xs:string"/>
<xs:element name="from" type="xs:string"/>
<xs:element name="heading" type="xs:string"/>
<xs:element name="body" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
• xs:schema: The root element that defines the XML Schema.
• xs:element: Defines an element in the XML structure.
• xs:complexType: Defines an element that can contain multiple child elements.
XSD is much more precise than DTD and allows you to define specific data constraints.
3. XML Object Models
XML object models represent XML data in memory, allowing for programmatic access. There are two
primary approaches to processing XML data: DOM and SAX.
DOM (Document Object Model)
• How it works: Loads the entire XML document into memory as a hierarchical tree structure.
The tree can be traversed, modified, or queried.
• Pros:
o Allows random access to elements.
o Supports easy navigation and manipulation.
o Best suited for smaller documents or when you need to frequently manipulate or
access data.
• Cons:
o Memory-intensive for large documents.
o Slower for large datasets as it must load the entire document into memory.
SAX (Simple API for XML)
• How it works: A stream-based, event-driven API that processes XML documents sequentially.
It triggers events as it reads through the document (e.g., when encountering a start tag, end
tag, or text).
• Pros:
o Memory-efficient as it doesn’t load the entire document into memory.
o Ideal for large documents or when you only need to process certain portions of the
document.
• Cons:
o No random access to data.
o Once an element is processed, you cannot go back to it.
4. Presenting and Using XML
XML is commonly used to store and transport data across platforms and systems. However, when
XML data needs to be presented in a user-friendly format, it can be transformed using XSLT
(Extensible Stylesheet Language Transformations) or XSL-FO (Extensible Stylesheet Language
Formatting Objects).
XSLT (Extensible Stylesheet Language Transformations)
• Purpose: Transforms XML into other formats like HTML, plain text, or even another XML
format.
• How it works: Defines templates to match elements in the source XML and apply
transformations to them.
Example of XSLT:
xml
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/note">
<html>
<body>
<h2><xsl:value-of select="heading"/></h2>
<p><xsl:value-of select="body"/></p>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
This XSLT file transforms the XML data into a simple HTML document, showing the heading and body
elements.
XSL-FO
• Purpose: Used to transform XML data into a formatted document, such as PDF or print-ready
output.
• Use Case: Primarily used for document formatting.
5. Using XML Processors: DOM vs. SAX
Two of the most popular XML processors are DOM (Document Object Model) and SAX (Simple API
for XML). They differ in how they parse and process XML documents.
DOM (Document Object Model):
• How it works: Loads the entire XML file into memory, creating a tree structure of the
document. This tree can be navigated and manipulated easily.
• Best for: Small to medium-sized documents where you need to access or manipulate
elements at various places in the document.
• Memory usage: Memory-intensive, as the whole document is loaded into memory.
SAX (Simple API for XML):
• How it works: Reads the XML file sequentially, triggering events (such as start tag, end tag,
character data) as it encounters them. No data is stored in memory except the current
element being processed.
• Best for: Large XML files or when memory is a concern. SAX is ideal for read-only operations
and when you need to process data sequentially.
• Memory usage: Memory-efficient, as it doesn’t load the whole document into memory.

wt 1

Uploaded by

Copyright:

Available Formats

wt 1

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

wt 1

Uploaded by

Copyright:

Available Formats

XML (Extensible Markup Language) is a text-based markup language designed to store and

transport data in a structured, human-readable format. It provides a platform-independent way to

Key Features of XML:

<title>XML for Beginners</title>

5. Human-Readable and Machine-Readable:

Why Use XML?

• Interoperability: XML facilitates interoperability between different systems, regardless of

1. Document Type Definition (DTD)

• Internal DTD: Defined within the XML document itself.

• Ensures XML data adheres to a predefined structure.

<!ELEMENT note (to, from, heading, body)>

<!ELEMENT from (#PCDATA)>

<!ELEMENT heading (#PCDATA)>

<!ELEMENT body (#PCDATA)>

<body>Don't forget the meeting!</body>

• note contains to, from, heading, and body elements.

• #PCDATA means parsed character data (simple text).

2. XML Schema (XSD)

• Namespaces: Can define namespaces to avoid element name conflicts.

Example of XML Schema (XSD):

<xs:element name="to" type="xs:string"/>

<xs:element name="from" type="xs:string"/>

<xs:element name="heading" type="xs:string"/>

<xs:element name="body" type="xs:string"/>

• xs:schema: The root element that defines the XML Schema.

• xs:element: Defines an element in the XML structure.

• xs:complexType: Defines an element that can contain multiple child elements.

3. XML Object Models

DOM (Document Object Model)

o Allows random access to elements.

o Supports easy navigation and manipulation.

o Memory-intensive for large documents.

o Memory-efficient as it doesn’t load the entire document into memory.

o No random access to data.

o Once an element is processed, you cannot go back to it.

4. Presenting and Using XML

XSLT (Extensible Stylesheet Language Transformations)

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

• Use Case: Primarily used for document formatting.

5. Using XML Processors: DOM vs. SAX

DOM (Document Object Model):

• Memory usage: Memory-intensive, as the whole document is loaded into memory.

SAX (Simple API for XML):

You might also like

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.