WT UNIT-2 XML.pdf

1
XML-Introduction
What is XML?
• XML stands for eXtensible Markup Language
• It is a text-based markup language derived from
Standard Generalized Markup Language (SGML).
• XML was designed to store and transport data
• XML was designed to be self-descriptive
• XML is a markup language that defines set of rules for
encoding documents in a format that is both human-
readable and machine-readable.
• XML is a W3C Recommendation

2
• These document reference a Document Type Definition
(DTD) or schema, which defines the structure for the
document .
• Markup is information added to a document that
enhances its meaning in certain ways, in that it identifies
the parts and how they relate to each other.
• More specifically, a markup language is a set of symbols
that can be placed in the text of a document and label the
parts of that document
XML-Introduction

XML
• It is a method for putting structured data into a text file;
these files are
• - easy to read
• - unambiguous
• - extensible
• - platform-independent
• XML documents are used to transfer data from one
place to another often over the Internet.
April 29th, 2003 Organizing and Searching Information with XML 3

4
XML
XML is a meta markup language
for text documents / textual data
XML allows to define languages
(„applications“) to represent text
documents / textual data

5
XML Does Not DO Anything
<note>
<to> SAM</to>
<from> JOHN</from>
<heading>Reminder</heading>
<body>Don't forget me this weekend!</body>
</note>
The XML above is quite self-descriptive:
It has sender, receiver information
It has a heading and a message body.

XML
• XML can work behind the scene to simplify the creation
of HTML documents for large web sites
• XML can be used to exchange the information between
organizations and systems
• XML can easily be merged with style sheets to create
almost any desired output.

Differences between XML and HTML
HTML XML
HTML tags have a fixed
meaning and browsers know
what it is
XML tags are different for
different applications, and
users know what they mean
HTML tags are used for
display.
XML tags are used to
describe documents and data
Tags and attributes are
predetermined
allows user to specify what
each tag and attribute means

8
Differences between XML and HTML
HTML XML
content and formatting can
be placed together
content and format are
separate; formatting is
contained in a stylesheet
Designed to represent the
presentation structure of a
document
Designed to represent the
logical structure of a
document
HTML was designed to
display data - with focus on
how data looks
XML was designed to carry
data - with focus on what
data is

9
XML
• XML is Extensible
Most XML applications will work as
expected even if new data is added
• XML Simplifies Things
It simplifies data sharing
It simplifies data transport
It simplifies platform changes
It simplifies data availability

10
XML-Uses
• XML is used in many aspects of web
development.
• XML is often used to separate data from
presentation.
• Web searching and automating Web tasks
• e-business applications

XML-uses

XML-uses
• Web publishing:
• XML allows you to create interactive pages, allows the
customer to customize those pages, and makes creating
e-commerce applications more intuitive.
• With XML, you store the data once and then render that
content for different viewers or devices based on style
sheet processing using an Extensible Style Language
(XSL)/XSL Transformation (XSLT) processor.

XML
• <?xml version="1.0" encoding="UTF-8"?>
<contact-info>
<name>John</name>
<company>Techsolution</company>
<phone>(011) 123-4567</phone>
</contact-info>
13

XML Syntax Rules

XML Syntax Rules
• XML Declaration
• The XML document can optionally have an XML
declaration. It is written as below:
• <?xml version="1.0" encoding="UTF-8"?>
Syntax Rules for XML declaration
The XML declaration is case sensitive and must begin with
"<?xml>" where "xml" is written in lower-case.
If document contains XML declaration, then it strictly needs to be
the first statement of the XML document

XML Syntax Rules
• Tags and Elements
• An XML file is structured by several XML-elements,
also called XML-nodes .
• XML-elements' names are enclosed by angular brackets
< > as shown below:
• <element-name>
• Syntax Rules for Tags and Elements
• Element Syntax: <element> text </element>

XML Syntax Rules
• Root element:
An XML document can have only one root element.
Case sensitivity:
The names of XML-elements are case-sensitive.
The name of the start and the end elements need to
be exactly in the same case.

XML Syntax Rules
• Attributes
An attribute specifies a single property for the element,
using a name/value pair
XML References
References usually allow you to add or include additional
text or markup in an XML document.
References always begin with the symbol "&" ,which is a
reserved character and end with the symbol ";".
XML has two types of references:

• Entity References: An entity reference contains a name
between the start and the end delimiters.
• For example & where amp is name..
• Character References: These contain references, such
as A, contains a hash mark (“#”) followed by a
number.
• The number always refers to the Unicode code of a
character. In this case, 65 refers to alphabet "A".

20
Entity References
Some characters have a special meaning in XML.
<message>salary < 1000</message>
This will generate an XML error:
To avoid this error, replace the "<" character with an
entity reference:
<message>salary < 1000</message>

XML-Syntax Rules
• All XML Elements Must Have a Closing Tag
• XML Tags are Case Sensitive
• XML Elements Must be Properly Nested
• XML Attribute Values Must Always be Quoted
23

• Comments in XML
• The syntax for writing comments in XML is similar to
that of HTML:
• 
24

Defining XML Tags
• XML tags form the foundation of XML.
• They define the scope of an element in
XML.
• They can also be used to declare settings
required for parsing the environment, and to
insert special instructions.
25

Defining XML Tags
• Start Tag
• The beginning of every non-empty XML element is
marked by a start-tag. Example of start-tag −
<address>
• End Tag
• Every element that has a start tag should end with an
end-tag. Following is an example of end-tag −
</address>
26

Defining XML Tags
• Empty Tag
• The text that appears between start-tag and end-tag is
called content.
• An element which has no content is termed as empty.
An empty element can be represented in two ways as
follows −
• A start-tag immediately followed by an end-tag as
shown below −
• <hr></hr>
• A complete empty-element tag is as shown below −
• <hr />
27

Defining XML Tags
• XML Tags Rules
• Rule 1
• XML tags are case-sensitive.
• Invalid Tag
• <address>This is wrong syntax</Address>
• Valid Tag
• <address>This is correct syntax</address>
28

Defining XML Tags
• Rule 2
• XML tags must be closed in an appropriate order,
i.e., an XML tag opened inside another element
must be closed before the outer element is closed.
For example −
• <outer_element>
• <internal_element>
• This tag is closed before the outer_element
</internal_element>
• </outer_element>
29

XML Elements
• An XML element is everything from (including) the
element's start tag to (including) the element's end tag.
• <price>29.99</price>
• An element can contain:
• text
• attributes
• other elements
• or a mix of the above
30

XML Elements
• Empty Element
• An element with no content is said to be empty.
• In XML, you can indicate an empty element like this:
• <element></element>
• Empty elements can have attributes.
31

XML Naming Rules
• XML elements must follow these naming rules:
• Element names are case-sensitive
• Element names must start with a letter or underscore
• Element names cannot start with the letters xml (or
XML, or Xml, etc)
• Element names can contain letters, digits, hyphens,
underscores, and periods
• Element names cannot contain spaces
• Any name can be used, no words are reserved (except
xml).
32

XML Attributes
• Attributes are part of XML elements.
• An element can have multiple unique
attributes. Attribute gives more information
about XML elements.
• Attributes they define properties of elements.
• An XML attribute is always a name-value
pair.
33

XML Attributes
• XML Attributes Must be Quoted
• Attribute values must always be quoted. Either
single or double quotes can be used.
• An XML attribute has the following syntax −
• <element-name attribute1 attribute2 >
....content..
• </element-name>
<book publisher="Tata McGraw Hill"></book>
34

Element Attribute Rules
• An attribute name must not appear more
than once in the same start-tag or empty-
element tag.
• An attribute must be declared in the
Document Type Definition (DTD) using an
Attribute-List Declaration.
35

Document Type Definition.
• A DTD is a Document Type Definition.
• A DTD defines the structure and the legal
elements and attributes of an XML document.
• The XML Document Type Declaration,
commonly known as DTD, is a way to describe
XML language precisely.
• DTDs check vocabulary and validity of the
structure of XML documents against
grammatical rules of appropriate XML
language.
36

DTD
• Syntax
• Basic syntax of a DTD is as follows −
• <!DOCTYPE element DTD identifier
• [ declaration1
• declaration2
• ........ ]>
37

DTD
• The DTD starts with <!DOCTYPE delimiter.
• An element tells the parser to parse the document from
the specified root element.
• DTD identifier is an identifier for the document type
definition, which may be the path to a file on the system
or URL to a file on the internet.
38

Internal DTD
• Internal DTD
• A DTD is referred to as an internal DTD if elements are
declared within the XML files.
• Syntax
• Following is the syntax of internal DTD −
• <!DOCTYPE root-element [element-declarations]>
where root-element is the name of root element and
element-declarations is where you declare the elements.
39

Internal DTD
• <?xml version="1.0"?>
<!DOCTYPE note [
<!ELEMENT note (to,from,heading,body)>
<!ELEMENT to (#PCDATA)>
<!ELEMENT from (#PCDATA)>
<!ELEMENT heading (#PCDATA)>
<!ELEMENT body (#PCDATA)>
]>
<note>
<to>Tove</to>
<from>Jani</from>
<heading>Reminder</heading>
<body>Don't forget me this weekend</body>
</note>
40

Internal DTD
• !DOCTYPE note defines that the root element of this document
is note
• !ELEMENT note defines that the note element must contain four
elements: "to,from,heading,body"
• !ELEMENT to defines the to element to be of type "#PCDATA"
• !ELEMENT from defines the from element to be of type
"#PCDATA"
• !ELEMENT heading defines the heading element to be of type
"#PCDATA"
• !ELEMENT body defines the body element to be of type
"#PCDATA"
41

DTD
• Rules
• The document type declaration must appear at
the start of the document (preceded only by the
XML header) - it is not permitted anywhere else
within the document.
• Similar to the DOCTYPE declaration, the
element declarations must start with an
exclamation mark.
• The Name in the document type declaration must
match the element type of the root element.
42

External DTD
• In external DTD elements are declared
outside the XML file.
• They are accessed by specifying the system
attributes which may be either the legal .dtd
file or a valid URL.
• To reference it as external DTD, standalone
attribute in the XML declaration must be set
as no. This means, declaration includes
information from the external source.
43

External DTD
• Syntax
• Following is the syntax for external DTD −
• <!DOCTYPE root-element SYSTEM "file-name">
where file-name is the file with .dtd extension.
• Example
• The following example shows external DTD usage
44

External DTD
• −
<?xml version = "1.0" encoding = "UTF-8" standalone = "no" ?>
<!DOCTYPE address SYSTEM "address.dtd">
<address>
<name>Tanmay Patil</name>
<company>Oracle</company>
<phone>(011) 123-4567</phone>
</address>
45

External DTD
• Address.dtd
• <!ELEMENT address (name,company,phone)>
<!ELEMENT name (#PCDATA)>
• <!ELEMENT company (#PCDATA)>
• <!ELEMENT phone (#PCDATA)>
46

External DTD
• Types
• Refer an external DTD by either using system
identifiers or public identifiers.
• System Identifiers
• A system identifier enables to specify the
location of an external file containing DTD
declarations. Syntax is as follows −
• <!DOCTYPE name SYSTEM "address.dtd" [...]>
47

External DTD
• Public Identifiers
• Public identifiers provide a mechanism to locate DTD
resources and are written as below −
• <!DOCTYPE name PUBLIC "-//Beginning
XML//DTD Address Example//EN">
• Public identifiers are used to identify an entry in a
catalog.
• Public identifiers follows, a commonly used format
called Formal Public Identifiers, or FPIs.
48

XML-DTD
• DTD-Element Declarations
• XML elements can be defined as building blocks of an
XML document.
• Elements can behave as a container to hold text,
elements, attributes, media objects or mix of all.
• In a DTD, XML elements are declared with the
following syntax:
• <!ELEMENT element-name type>
or
<!ELEMENT element-name (element-content)>

XML-DTD
• Value of type can be ANY or EMPTY
• Content can be data or another element
Elements are classified as
• Standalone elements- also called Singleton elements
or empty elements-- they are empty.
• <!ELEMENT element-name EMPTY>
• Ex: <!ELEMENT br EMPTY>
• In xml file <br />

XML-DTD
• Simple elements
These are the elements that contain text or Parsed Character Data
( represented as #PCDATA)
<!ELEMENT element-name (#PCDATA) >
Ex: <!ELEMENT greeting (#PCDATA) >
In xml: <greeting>Welcome to XML </greeting>

XML-DTD
• Compound Elements- This elements can contain other
elements. An element contains one element.
• <!ELEMENT element-name (child-element-name)>
EX: <!ELEMENT employee (name)>
Xml : <employee>
<name> ABC </name>
</employee>

XML-DTD
• Occurrence Indicators
• <!ELEMENT employee (contact*)>
• <!ELEMENT company (employee+)>
• <!ELEMENT book (author+)>
• <!ELEMENT employee (PAN?)>

XML-DTD
Declaring Multiple Children
<!ELEMENT element-name (child1,child2,child3)>
EX:
<!ELEMENT employee (name,dept,id)>
<!ELEMENT dept (#PCDATA)>
<!ELEMENT id (#PCDATA)>

XML-DTD
• Sequence operator( , )
• <!ELEMENT employee (name , dept, id)>
• Choice Operator ( | )
• <!ELEMENT product (price | discountprice )>
• Composite Operator [ ( ) ]
• <!ELEMENT biodata ( dob , ( company,title)* )>

XML DTD elements
Mixed content example
<?xml version = "1.0" encoding = "UTF-8" standalone = "yes" ?>
<!DOCTYPE address [
<!ELEMENT address (#PCDATA | name)* >→ mixed content
]>
<address>
Here's a bit of text mixed up with the child element.
<name>
Tanmay Patil
</name>
</address>

Attribute Declarations
• Attribute Declaration
• Attributes are used to associate(name , value) pairs with elements.
• They are useful to provide useful information about the element’s
content.
• Syntax:
• <!ATTLIST element-name attribute-name
attribute-type default-value >
DTD example: <!ELEMENT payment EMPTY>
• <!ATTLIST payment type CDATA "check">
XML example: <payment type="check" />

• Attribute Default Values

Default value

Attribute value: #REQUIRED

Attribute value: #IMPLIED

Attribute value: #FIXED

Entity Declaration
• Entities are variables that represent other values.
• If a text contains entities, the value of the entity is substituted by
its actual value when ever the text is parsed.
• Entities may be parsed or unparsed.
Two types of Entity declarations
• GENERAL ENTITY-They are used with in the document
content
• PARAMETER ENTITY-They are parsed entities for use with
in the DTD.

Entity Declaration
• 3 kinds of General Entity declarations
Internal (parsed ) Entity declaration
• Syntax
• <!ENTITY entity-name "entity-value">
• DTD Example:
<!ENTITY writer "Donald Duck.">
<!ENTITY copyright "Copyright W3Schools.">
XML example:
<author>&writer;&copyright;</author>

Entity Declaration
• External (parsed ) Entity declaration
• <!ENTITY entity-name SYSTEM "URI/URL">
• DTD Example:
• <!ENTITY writer SYSTEM "https://www.xml.com/entities.dtd">
• <!ENTITY copyright SYSTEM
"https://www.xml.com/entities.dtd">
XML example:
<author>&writer;&copyright;</author>

Entity Declaration
• Parameter Entity Declaration
It allows us to assign a collection of elements, attributes and attribute
values to a name and refer them using a name instead of listing them
every time they are used.
Parameter-Entity Declaration
• <!ENTITY % entity-name entity-def>
• Example : <!ENTITY % info “year , make, model”>
DTD: <!ELEMENT car (% info;) >
➔ <!ELEMENT car (year , make, model)>

XML Schema
• XML Schema is commonly known as XML Schema
Definition (XSD).
• A more powerful way of defining the structure and
constraining the contents of XML documents .
• It is used to describe and validate the structure and
the content of XML data.
• XML schema defines the elements, attributes and
data types.
• Supports Namespaces
• It is similar to a database schema that describes the data
in a database.

XML Schema
• XML Schema is an XML-based alternative to DTD.
• XML Schemas Support Data Types
• It is easier to describe document content
• It is easier to define restrictions on data
• It is easier to validate the correctness of data
• It is easier to convert data between different data types
69

XML Schema

XML Schema
<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="values" type="xs:string" />
</xs:schema>

XML Schema
<?xml version = "1.0"?>
< xs:schema
xmlns:xs = "http://www.w3.org/2001/XMLSchema"
targetNamespace = "http://www.xmldata.com"
xmlns = "http://www.xmldata.com" >

XML Schema
<xs:schema
xmlns:xs = "http://www.w3.org/2001/XMLSchema">
The above fragment specifies that elements and datatypes
used in the schema are defined in
http://www.w3.org/2001/XMLSchema namespace
and these elements/data types should be prefixed with xs

• targetNamespace = http://www.xmldata.com
The above fragment specifies that elements used in this
schema are defined in http://www.xmldata.com
namespace. It is optional.
xmlns = http://www.xmldata.com

XML Schemas
• <?xml version = "1.0" encoding = "UTF-8"?>
<xs:schema xmlns:xs = "http://www.w3.org/2001/XMLSchema">
75

XML Schema
• Defining XML Elements in Schema
• An element can be defined within an XSD as follows:
<xs:element name="x" type="y" />

XML Schema
• The valid data values for the element in the XML
document can be further constrained using the fixed and
default properties.
• Default means that if no value is specified in the XML
document then the application reading the document,
typically an XML parser or XML Data Binding Library,
should use the default specified in the XSD.
• Fixed means the value in the XML document can only
have the value specified in the XSD.

XML Schema

XML schema
• Specifying Element Cardinality
• It is possible to constrain the number of instances
(cardinality) of an XML element that appear in an XML
document.
• The cardinality is specified using the minOccurs and
maxOccurs attributes, and allows an element to be
specified as mandatory, optional, or can appear up to a
set number of times.
• The default values for minOccurs and maxOccurs is 1

XML schema

XML schema
Element Definition Types
Simple Type
• Simple type element is used only in the context of the
text. Some of the predefined simple types are:
xs:integer, xs:boolean, xs:string, xs:date. example −
• <xs:element name = "phone_number" type = "xs:integer" />
• <xs:element name="Customer_dob" type="xs:date" />
• <xs:element name="Customer_address" type="xs:string" />

XML schema
• Complex Type
• A complex type is a container for other element
definitions.
• This allows you to specify which child elements an
element can contain and to provide some structure
within XML documents.
• Complex Element is an XML element which can contain
other elements and/or attributes

XML schema
• Example --Complex Type

XML schema
• Defining Compositors
• Compositors provide rules that determine how and in what order
there children can appear within XML document.
• There are three types of compositors
• <xs:sequence>,
• <xs:choice>
• <xs:all>

XML Schemas
• Global Complex Types
• A xs:complexType can also defined globally and given a
name.
• Named xs:complexTypes can then be re-used throughout
the schema, either referenced directly or used as the
basis to define other xs:complexTypes.
86

XML Schemas
<xs:complexType name="AddressType">
<xs:sequence>
<xs:element name="Line1" type="xs:string" />
<xs:element name="Line2" type="xs:string" />
</xs:sequence>
</xs:complexType>
87

XML Schemas
<xs:element name="Supplier">
<xs:complexType>
<xs:sequence>
<xs:element name="Phone" type="xs:integer" />
<xs:element name="Address" type="AddressType" />
</xs:sequence>
</xs:complexType>
</xs:element>
88

XML Schemas
• Attributes
• Attributes in XSD provide extra information
within an element. Attributes have name and type
property as shown below −
• <xs:attribute name = "x" type = "y"/>
• An Attribute can appear 0 or 1 times within
a given element in the XML document.
Attributes are either optional or mandatory
89

XML Schemas
<xs:attribute name="ID" type="xs:string" />
<xs:attribute name="ID" type="xs:string" use="optional" />
Example:
<xs:element name="Order">
<xs:complexType>
<xs:attribute name="OrderID" type="xs:int" />
</xs:complexType>
</xs:element>

XML Schemas
• XML Element Mixed Content

XML Schemas
• XML Schemas are More Powerful than DTD
• XML Schemas are written in XML
• XML Schemas are extensible to additions
• XML Schemas support data types
• With XML Schema, your XML files can carry a
description of its own format.
• With XML Schema, independent groups of people can
agree on a standard for interchanging data.
• With XML Schema, you can verify data.
92

DOCUMENT OBJECT MODEL(DOM)
• The Document Object Model (DOM) is a W3C
standard.
• It defines a standard for accessing documents like
HTML and XML.
• The Document Object Model (DOM) is an
application programming interface (API) for
HTML and XML documents.
• It defines the logical structure of documents and
the way a document is accessed and manipulated.
93

DOCUMENT OBJECT MODEL(DOM)
• DOM defines the objects and properties and
methods (interface) to access all XML elements.
• It is separated into 3 different parts / levels −
• Core DOM − standard model for any structured
document
• XML DOM − standard model for XML
documents
• HTML DOM − standard model for HTML
documents
94

DOCUMENT OBJECT MODEL (DOM)
• XML DOM is a standard object model for XML.
XML documents have a hierarchy of
informational units called nodes;
• DOM is a standard programming interface of
describing those nodes and the relationships
between them.
• The XML DOM makes a tree-structure view for
an XML document.
95

DOCUMENT OBJECT MODEL
• Following is the diagram for the DOM structure.
The diagram depicts that parser evaluates an
XML document as a DOM structure by
traversing through each node.
96

• Advantages of XML DOM
• The following are the advantages of XML DOM.
• XML DOM is language and platform independent.
• XML DOM is traversable - Information in XML DOM
is organized in a hierarchy which allows developer to
navigate around the hierarchy looking for specific
information.
• XML DOM is modifiable - It is dynamic in nature
providing the developer a scope to add, edit, move or
remove nodes at any point on the tree.

• Disadvantages of XML DOM
• It consumes more memory (if the XML structure is
large) as program written once remains in memory all
the time until and unless removed explicitly.
• Due to the extensive usage of memory, its operational
speed, compared to SAX is slower.

XML-DOCUMENT OBJECT MODEL
XML DOM Properties
These are some typical DOM properties:
• x.nodeName - the name of x
• x.nodeValue - the value of x
• x.parentNode - the parent node of x
• x.childNodes - the child nodes of x
• x.attributes - the attributes nodes of x
• Note: In the list above, x is a node object.

• XML DOM Methods
• x.getElementsByTagName(name) - get all
elements with a specified tag name
• x.appendChild(node) - insert a child node to x
• x.removeChild(node) - remove a child node from
x
• Note: In the list above, x is a node object.

• An example to show how an XML document
("note.xml") is parsed into an XML DOM object.
• This example parses an XML document
(note.xml) into an XML DOM object and
extracts information from it with JavaScript.

• <?xml version="1.0" encoding="ISO-8859-1"?>
<note>
<to>john@starone.com</to>
<from>vimal@yahoo.com</from>
<body>Hello XML DOM</body>
</note>

XML-DOM
• <!DOCTYPE html>
• <html>
• <body>
• <h1>Important Note</h1>
• <b>To:</b> <span id="to"></span><br>
• <b>From:</b> <span id="from"></span><br>
• <b>Message:</b> <span id="message"></span>
•

XML-DOM
<script>
if (window.XMLHttpRequest)
{
// code for IE7+, Firefox, Chrome, Opera, Safari
xmlhttp=new XMLHttpRequest();
}
else
{ // code for IE6, IE5
xmlhttp=new ActiveXObject("Microsoft.XMLHTTP"
);
}

XML-DOM
xmlhttp.open("GET","note.xml”);
xmlhttp.send();
xmlDoc=xmlhttp.responseXML;
document.getElementById("to").innerHTML=
xmlDoc.getElementsByTagName("to")[0].childNodes[0].
nodeValue;
document.getElementById("from").innerHTML=
xmlDoc.getElementsByTagName("from")[0].childNodes[
0].nodeValue;

XML-DOM
document.getElementById("message").innerHTML
=
xmlDoc.getElementsByTagName("body")[0].child
Nodes[0].nodeValue;
</script>
</body>
</html>

txt=
xmlDoc.getElementsByTagName("title")[0].
childNodes[0].nodeValue;
code retrieves the text value of the first <title> element
in an XML document:

XHTML
• XHTML stands for EXtensible HyperText Markup
Language.
• XHTML was developed by World Wide Web
Consortium (W3C) to help web developers make the
transition from HTML to XML
• XHTML is almost identical to HTML XHTML is
stricter than HTML

XHTML
Important Differences from HTML:
XHTML DOCTYPE is mandatory
The xmlns attribute in <html> is mandatory
<html>, <head>, <title>, and <body> are mandatory
XHTML Elements
XHTML elements must be properly nested
XHTML elements must always be closed
XHTML elements must be in lowercase
XHTML documents must have one root element

XHTML
XHTML Attributes
Attribute names must be in lower case
Attribute values must be quoted
Attribute minimization is forbidden

• <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML
1.0 Transitional//EN”
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-
transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>Title of document</title>
</head>
<body>
some content
</body>
</html>

USES OF XHTML
• XHTML documents are XML conforming as they are
readily viewed, edited, and validated with standard
XML tools.
• XHTML documents can be written to operate better than
they did before in existing browsers as well as in new
browsers.
• XHTML documents can utilize applications such as
scripts and applets that rely upon either the HTML
Document Object Model or the XML Document Object
Model.
• XHTML gives you a more consistent, well-structured
format so that your webpages can be easily parsed and
processed by present and future web browsers.

XHTML
• The XHTML standard defines three Document Type
Definitions (DTDs). The most commonly used and easy
one is the XHTML Transitional document.
• XHTML 1.0 document type definitions correspond to
three DTDs −
• Strict
• Transitional
• Frameset

XHTML
• XHTML 1.0 Strict
• If you are planning to use Cascading Style Sheet (CSS)
strictly and avoiding to write most of the XHTML
attributes, then it is recommended to use this DTD
• XHTML 1.0 Transitional
• If you are planning to use many XHTML attributes as
well as few Cascading Style Sheet properties, then
you should adopt this DTD and you should write your
XHTML document accordingly.

XHTML
• <!DOCTYPE html PUBLIC "-//W3C//DTD
XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-
strict.dtd">

DOM Parser in JAVA
• DOM is part of the Java API for XML processing
(JAXP).
• Java DOM parser traverses the XML file and
creates the corresponding DOM objects.
• These DOM objects are linked together in a tree
structure.
• The parser reads the whole XML structure into
the memory.

DOM Parser in JAVA
DOM interfaces
• The DOM defines several Java interfaces
• Node − The base datatype of the DOM.
• Element − The vast majority of the objects you'll
deal with are Elements.
• Attr − Represents an attribute of an element.
• Text − The actual content of an Element or Attr.
• Document − Represents the entire XML
document. A Document object is often referred to
as a DOM tree.

• Document.getDocumentElement() − Returns the root
element of the document.
• Node.getFirstChild() − Returns the first child of a
given Node.
• Node.getLastChild() − Returns the last child of a given
Node.
• Node.getNextSibling() − These methods return the next
sibling of a given Node.
• Node.getPreviousSibling() − These methods return the
previous sibling of a given Node.
• Node.getAttribute(attrName) − For a given Node, it
returns the attribute with the requested name.
DOM Methods

USING DOM in JAVA
• Steps to Using JDOM
• Following are the steps used while parsing a document
using JDOM Parser.
• Import XML-related packages.
• Create a DocumentBuilder.
• Create a Document from a file or stream
• Extract the root element
• Examine attributes
• Examine sub-elements

Using DOM in JAVA
• Import XML-related packages
• import org.w3c.dom.*;
• import javax.xml.parsers.*;
• import java.io.*;
• Create a DocumentBuilder
• DocumentBuilderFactory factory =
DocumentBuilderFactory.newInstance();
DocumentBuilder builder =
factory.newDocumentBuilder();

Using DOM in java
• Create a Document from a file
• File inputFile = new File("input.xml");
• Document doc = builder.parse(inputFile);
• Extract the root element
• Element root = document.getDocumentElement();
Examine attributes
• //returns specific attribute
• getAttribute("attributeName");
• //returns a Map (table) of names/values
• getAttributes();

Using DOM in java
• Examine sub-elements
• //returns a list of subelements of specified name
getElementsByTagName("subelementName");
• //returns a list of all child nodes
• getChildNodes();

Using DOM in java
• <?xml version = "1.0"?>
• <class>
• <student rollno = "393">
<firstname>dinkar</firstname>
• <marks>85</marks> </student>
• <student rollno = "493">
<firstname>Vaneet</firstname>
<marks>95</marks> </student>
• </class>
127

SAX Parser
• SAX Stands for Simple API for XML Parsing.
This is an event based XML Parsing and it parse
XML file line by line so much suitable for large
XML Files.
• SAX XML Parser fires an event when it
encountered opening tag, element or attribute,
and the parsing works accordingly.

SAX Parser
• Use SAX XML parser for parsing large XML files in
Java because it doesn't require to load whole XML file
in Java and it can read a big XML file in small parts. J
• Java provides support for SAX parser and you can parse
any XML file in Java using SAX Parser
• One disadvantage of using SAX Parser in java is that
reading XML file in Java using SAX Parser requires
more code in comparison of DOM Parser.
Read more:

SAX Parser in jAVA
• The callback methods of DefaultHandler class:-
• startDocument() – This method called at the start of the
XML document.
• endDocument() – This method called at the end of the
XML document.
• startElement() – This method called at the start of a
document element.
• endElement() – This method called at the end of a
document element.
• characters() – This method called with the text contents
in between the start and end tags of an XML document
element.

WT UNIT-2 XML.pdf

More Related Content

What's hot

Similar to WT UNIT-2 XML.pdf

More from Ranjeet Reddy

Recently uploaded

WT UNIT-2 XML.pdf