Web Data: XML

Web Data: XML
XML: XML stands for eXtensible Markup Language, developed by W3C in 1996. XML 1.0
was officially adopted as a W3C recommendation in 1998. XML was designed to carry data, not to
display data. XML is designed to be self-descriptive. XML is a subset of SGML that can define your
own tags. A Meta Language and tags describe the content. XML Supports CSS, XSL, DOM.
The Difference between XML and HTML

1. HTML is about displaying information, where as XML is about carrying information. In
other words, XML was created to structure, store, and transport information. HTML was designed to
display the data.
2. Using XML, we can create own tags where as in HTML it is not possible instead it offers
several built in tags.
3. XML is platform independent neutral and language independent.
4. XML tags and attribute names are case sensitive where as in HTML it is not.
5. XML attribute values must be single or double quoted where as in HTML it is not
compulsory
6. XML elements must be properly nested
7. All XML elements must have a closing tag
8. XML is used to create new internet languages. Here are some examples:
- WSDL for describing available web services

- WAP and WML as markup languages for handheld devices
- RSS languages for news feeds
- RDF and OWL for describing resources and ontology
- SMIL for describing multimedia for the web
Well Formed XML Documents

XML with correct syntax is "Well Formed" XML. XML validated against a DTD is "Valid" XML.
A "Well Formed" XML document must have the following correct XML syntax:
- XML documents must have a root element
- XML elements must have a closing tag
- XML tags are case sensitive
- XML elements must be properly nested
- XML attribute values must be quoted
Example for XML Document

<?xml version="1.0" encoding="ISO-8859- 1"?>
<note>
<to>Tove</to>
<from>Jani</from>
<heading>Reminder</heading>
<body>Don't forget me!</body>
</note>
Xml document begins with XML declaration statement: <? xml version="1.0"
encoding="ISO-8859-1"?> . The next line describes the root element of the document:
<note>. This element is "the parent" of all other elements. The next 4 lines describe 4 child elements of
the root: to, from, heading, and body. And finally the last line defines the end of the root element : <
/note>
XML Element
An XML element is everything from (including) the element's start tag to (including) the
element's end tag.
An element can contain:
- other elements
- text
- attributes
- Or a mix of all of the above...
XML vocabulary:
XML vocabulary is used to define - element and attribute names
- element content
- Semantics of elements and attributes
Some of the xml vocabularies are XHTML, RSS, XSL, DTD, and Schema
XML DTD:
Document Type Definition purpose is to define the structure of an XML document. It defines
the structure with a list of defined elements in the xml document.
<!DOCTYPE note
[
<!ELEMENT note (to,from,heading,body)> <!ELEMENT to (#PCDATA)> <!ELEMENT from
(#PCDATA)> <!ELEMENT heading (#PCDATA)> <!ELEMENT body (#PCDATA)>
]>
Where PCDATA refers parsed character data. In the above xml document the elements to, from,
heading, body carries some text, so that, these elements are declared to carry text in DTD file.
This definition file is stored with .dtd extension.
XML Schema:
It is an alternative to DTD to define the structure of an XML document.

<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>
This definition file is stored with .xsl extension.
XML DTD vs XML Schema:
The schema has more advantages over DTD. A DTD can have two types of data in it, namely
the CDATA and the PCDATA. The CDATA is not parsed by the parser whereas the PCDATA is
parsed. In a schema you can have primitive data types and custom data types like you have used in
programming.
XML Parsers:
An XML parser converts an XML document into an XML DOM object - which can then be
manipulated with a JavaScript.
Two types of XML parsers:
– Validating Parser
• It requires document type declaration
• It generates error if document does not
Conform with DTD and
Meet XML validity constraints
– Non-validating Parser
• It checks well-formedness for xml document
• It can ignore external DTD
XML Namespaces
It is a collection of element and attributes names associated with an XML vocabulary. XML
Namespaces provide a method to avoid element name conflicts.
XML document 1
<table>
<tr>
<td>Apples</td>
<td>Bananas</td>
</tr>
</table>
XML document2
<table>
<name> Coffee Table</name>
<width>80</width>
<length>120</length>
</table>
If these XML fragments were added together, there would be a name conflict. Both contain a
<table> element, but the elements have different content and meaning. Such name conflicts in
XML can easily be avoided using a name prefix as shown below:

<h:table>
<h:tr>
<h:td>Apples</h:td>
<h:td>Bananas</h:td>
</h:tr>
</h:table>
<f:table>
<f:name> Coffee Table</f:name>
<f:width>80</f:width>
<f:length>120</f:length>
</f:table>
When using prefixes in XML, a so-called namespace for the prefix must be defined. The
namespace is defined by the xmlns attribute in the start tag of an element. The namespace declaration
has the following syntax.
xmlns:prefix="URI"
For example,
<h:table xmlns:h="http://www.w3.org/table">
<h:tr>
<h:td>Apples</h:td>
<h:td>Bananas</h:td>
</h:tr>
</h:table>
<f:table xmlns:f="http://www.w3.org/furniture">
<f:name> Coffee Table</f:name>
<f:width>80</f:width>
<f:length>120</f:length>
</f:table>
Default namespace
Default xml namespace uri for elements of a document is xmlns:http://www.w3.org/1999/xhtml
XML DOM
Document Object Model is for defining the standard for accessing and manipulating
XML documents. XML DOM is used for
Loading the xml document
Accessing the xml document
Deleting the elements of xml document
Changing the elements of xml document
According to the DOM, everything in an XML document is a node. It considers The entire
document is a document node every XML element is an element node The text in the XML elements
are text nodes Every attribute is an attribute node Comments are comment nodes
DOM Levels
Level 1 Core: W3C Recommendation, October 1998
It has feature for primitive navigation and manipulation of XML trees
other Level 1 features are: All HTML features
Level 2 Core: W3C Recommendation, November 2000
It adds Namespace support and minor new features
other Level 2 features are: Events, Views, Style, Traversal and Range
Level 3 Core: W3C Working Draft, April 2002
It supports: Schemas, XPath, XSL, XSLT
We can access and parse the XML document in two ways:
Parsing using DOM (tree based)

Parsing using SAX (Event based)
Parsing the XML doc. using DOM methods and properties are called as tree based approach
whereas using SAX (Simple Api for Xml) methods and properties are called as event based approach.
1. DOM based XML Parsing:(tree based)

JAXP is a tool, stands for Java Api for Xml Processing, used for accessing and manipulating
xml document in a tree based manner. In this approach, to access XML document, the document object
model implementation is defined in the following packages:
javax.xml.parsers org.w3c.dom
The following DOM java Classes are necessary to process the XML document:
DocumentBuilderFactory class creates the instance of DocumentBuilder. DocumentBuilderproduces
a Document (a DOM) that conforms to the DOM specification
The following methods and properties are necessary to process the XML document:
To Count the Elements in a XML File

This program takes a file name from the console and checks its availability. If the file exists then a
parser is created using Document Builder. This object parses the given XML document. It searches the
specified element name and counts its occurrence in the xml file. If the given element doesn't exist it
displays the '0' element.
Step 1: Create an xml file: Employee- Detail.xml

<?xml version = "1.0" ?>
<Employee- Detail>
<Employee>
<Emp_Id> E-001 </Emp_Id>
<Emp_Name> Vinod </Emp_Name>
<Emp_E- mail> Vinod@yahoo.com </Emp_E-mail>
</Employee>
<Employee>
<Emp_Name> Arun </Emp_Name>
<Emp_E-mail> Arun@yahoo.com </Emp_E- mail>
</Employee>
</Employee-Detail>
Step 2: Create a java based dom for counting the number of elements in xml file.
import org.w3c.dom.*;
import javax.xml.parsers.*;
import java.io.*;
public class CountNodes

{
public static void main(String[] args)
{
try
{
File file = new File(args[0]); // Employee_Detail.xml is a file to be parsed is given as
//input from command prompt
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

DocumentBuilder builder = factory.newDocumentBuilder(); // parser is created
Document doc = builder.parse(file); // file is parsed
NodeList list = doc.getElementsByTagName(“Emp_Id”); // the element to be searched is specified
System.out.println("Number of nodes: " + list.getLength()); // counting no. of occurrences
}
catch (Exception e){ }
}
}
Output:
Number of nodes: 2
Event oriented XML Parsing: SAX
SAX stands for Simple API for XML

SAX provides a mechanism for reading data from an XML document, SAX parsers operate on
each piece of the XML document sequentially. It is a kind of event oriented approach for parsing the
xml document.
An XML tree is not viewed as a data structure, but as a stream of events generated by the parser.
The kinds of events are:

the start of the document is encountered
theend of the document is encountered
thestart tag of an element is encountered
theend tag of an element is encountered
character data is encountered
a processing instruction is encountered
Scanning the XML file from start to end, each event invokes a
corresponding callback method that the programmer writes.
SAX (Simple API for XML) is an event-based parser for XML documents. Unlike a DOM parser, a
SAX parser creates no parse tree. SAX is a streaming interface for XML, which means that applications
using SAX receive event notifications about the XML document being processed an element, and
attribute, at a time in sequential order starting at the top of the document, and ending with the closing of
the ROOT element.
 Reads an XML document from top to bottom, recognizing the tokens that make up a well-formed XML
document.
 Tokens are processed in the same order that they appear in the document.
 Reports the application program the nature of tokens that the parser has encountered as they occur.
 The application program provides an "event" handler that must be registered with the parser.
 As the tokens are identified, callback methods in the handler are invoked with the relevant information.
ContentHandler Interface
This interface specifies the callback methods that the SAX parser uses to notify an application program
of the components of the XML document that it has seen.
 void startDocument() − Called at the beginning of a document.
 void endDocument() − Called at the end of a document.
 void startElement(String uri, String localName, String qName, Attributes atts) − Called at the beginning
of an element.
 void endElement(String uri, String localName,String qName) − Called at the end of an element.
 void characters(char[] ch, int start, int length) − Called when character data is encountered.
 void ignorableWhitespace( char[] ch, int start, int length) − Called when a DTD is present and ignorable
whitespace is encountered.
 void processingInstruction(String target, String data) − Called when a processing instruction is
recognized.
 void setDocumentLocator(Locator locator)) − Provides a Locator that can be used to identify positions
in the document.
 void skippedEntity(String name) − Called when an unresolved entity is encountered.
 void startPrefixMapping(String prefix, String uri) − Called when a new namespace mapping is defined.
 void endPrefixMapping(String prefix) − Called when a namespace definition ends its scope.
Attributes Interface
This interface specifies methods for processing the attributes connected to an element.
 int getLength() − Returns number of attributes.
 String getQName(int index)
 String getValue(int index)
 String getValue(String qname)
SAX packages
javax.xml.parsers: Describing the main classes needed for parsing org.xml.sax: Describing few
interfaces for parsing
SAX classes
SAXParser Defines the API that wraps an XMLReader implementation class SAXParserFactory
Defines a factory API that enables applications to configure and obtain a SAX based parser to parse
XML documents ContentHandler Receive notification of the logical content of a document.
DTDHandler Receive notification of basic DTD-related events. EntityResolver Basic interface for
resolving entities. ErrorHandler Basic interface for SAX error handlers. DefaltHandler Default base
class for SAX event handlers.
SAX parser methods
startDocument() and endDocument() – methods called at the start and end of an XML
document.
startElement() and endElement() – methods called at the start and end of a document element.
characters() – method called with the text contents in between the start and end tags of an XML
document element.
Understanding SAX Parser
At the very first, create an instance of the SAXParserFactory class which generates an instance
of the parser. This parser wraps a SAXReader object. When the parser's parse() method is invoked, the
reader invokes one of the several callback methods (implemented in the application). These callback
methods are defined by the interfaces ContentHandler, ErrorHandler, DTDHandler, and
EntityResolver.
Features of SAX Parser

It does not create any internal structure.
Clients does not know what methods to call, they just overrides the methods of the API and place his
own code inside method.
It is an event based parser, it works like an event handler in Java.
Advantages
1) It is simple and memory efficient.
2) It is very fast and works for huge documents.
Disadvantages
1) It is event-based so its API is less intuitive.
2) Clients never know the full information because the data is broken into pieces.
SAX Example :Selecting XML data
<?xml version = "1.0"?>

<class>
<student rollno = "393">
<firstname>dinkar</firstname>
<lastname>kad</lastname>
<nickname>dinkar</nickname>
<marks>85</marks>
</student>

<firstname>Vaneet</firstname>
<lastname>Gupta</lastname>
<nickname>vinni</nickname>
<marks>95</marks>
</student>

<firstname>jasvir</firstname>
<lastname>singn</lastname>
<nickname>jazz</nickname>
<marks>90</marks>
</student>
</class>
StAXParserDemo.java
package com.tutorialspoint.xml;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.Iterator;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.events.Attribute;
import javax.xml.stream.events.Characters;
import javax.xml.stream.events.EndElement;
import javax.xml.stream.events.StartElement;
import javax.xml.stream.events.XMLEvent;
public class StAXQueryDemo {

public static void main(String[] args) {
boolean bFirstName = false;
boolean bLastName = false;
boolean bNickName = false;
boolean bMarks = false;
boolean isRequestRollNo = false;
try {
XMLInputFactory factory = XMLInputFactory.newInstance();
XMLEventReader eventReader =
factory.createXMLEventReader(new FileReader("input.txt"));
String requestedRollNo = "393";
while(eventReader.hasNext()) {
XMLEvent event = eventReader.nextEvent();
switch(event.getEventType()) {
case XMLStreamConstants.START_ELEMENT:
StartElement startElement = event.asStartElement();
String qName = startElement.getName().getLocalPart();
if (qName.equalsIgnoreCase("student")) {
Iterator<Attribute> attributes =
startElement.getAttributes();
String rollNo = attributes.next().getValue();
if(rollNo.equalsIgnoreCase(requestedRollNo)) {
System.out.println("Start Element : student");
System.out.println("Roll No : " + rollNo);
isRequestRollNo = true;
}
} else if (qName.equalsIgnoreCase("firstname")) {
bFirstName = true;
} else if (qName.equalsIgnoreCase("lastname")) {
bLastName = true;
} else if (qName.equalsIgnoreCase("nickname")) {
bNickName = true;
}
else if (qName.equalsIgnoreCase("marks")) {
bMarks = true;
}
break;
case XMLStreamConstants.CHARACTERS:
Characters characters = event.asCharacters();
if(bFirstName && isRequestRollNo) {

System.out.println("First Name: " + characters.getData());
bFirstName = false;
}
if(bLastName && isRequestRollNo) {
System.out.println("Last Name: " + characters.getData());
bLastName = false;
}
if(bNickName && isRequestRollNo) {
System.out.println("Nick Name: " + characters.getData());
bNickName = false;
}
if(bMarks && isRequestRollNo) {
System.out.println("Marks: " + characters.getData());
bMarks = false;
}
break;
case XMLStreamConstants.END_ELEMENT:
EndElement endElement = event.asEndElement();
if(endElement.getName().getLocalPart().equalsIgnoreCase(
"student") && isRequestRollNo) {
System.out.println("End Element : student");
System.out.println();
isRequestRollNo = false;
}
break;
}
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (XMLStreamException e) {
e.printStackTrace();
}
}
}
This would produce the following result −
Start Element : student
Roll No : 393
First Name: dinkar
Last Name: kad
Nick Name: dinkar
Marks: 85
End Element : student
Transforming XML document
It is process of extracting one info. From one xml doc. and uses that info to create another xml
doc.
XSL
XSL is stands for eXtensible Style sheet Language which is an xml vocabulary. It contains two
Types of information:Template data: Which is text that is copied to output xml document
with change or no change.
XSL markup: which controls transformation process. It uses two namespaces:
http://www.w3.org/1999/xsl/Transform is the namespace name for xsl namespace
http://www.w3.org/1999/xhtml is the xhtml namesapce name
1. XSL components: Three components
1. XSLT
2. XPATH
3. XSL-FO
XSLT – XSL Transformations (XSLT) is a language to specify transformations of XML

documents. A transformation expressed in XSLT describes rules for transforming a source tree into a
result tree
XPATH- is used to find information in an XML document. It navigates through elements and
attributes in XML documents.
XSL-FO is a XSL Formatter an xml vocabulary for defining style properties of xml document.
To transform xml document the following things are required:

a. Source xml document
b. Xslt style sheet that defines the information of source xml program to be transformed
c. Xslt processor that performs transformation
The following program illustrates that.

The JAXP is a tool which is used as XSLT processor. The XSLT processor receives xslt and
xml program as its input and generates another xml program as its output where we can see the content
retrieved from source xml program.
Example for XSLT

Step 1. Create an XML file and save as myXML.xml The code for the emp.xml file is given below:
<?xml version = "1.0" ? >
<Employee-Detail>
<Employee>
<Emp_Name> Nisha </Emp_Name>
<Emp_E-mail> Nisha1@yahoo.com </Emp_E- mail>
</Employee>
<Employee>
<Emp_Name> Amit</Emp_Name>
<Emp_E-mail> Amit2@yahoo.com </Emp_E- mail> </Employee>
</Employee-Detail>
Step 2: Create an XSLT Stylesheet and save as myXSL.xsl extension

<?xml version="1.0" ?>
<xsl:transform xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:template match="/">
<html><head><title> XSL for Transforamtion </title>
<body><p>
<xsl:for-each select="Employee">
<xsl:value-of select="child::Emp_Id"/>
<xsl:value-of select="child::Emp_Name"/>
<xsl:value-of select="child::Emp_E- mail"/> </xsl:for-each>
</p></body></html>
</xsl:template>
</xsl:stylesheet>
XPATH:
XPATH expression will be applied to parse the xml doc. which constructs a tree like
representation of xml doc. similar to DOM tree. The root of the XPath parse tree is ‘document’.
Location Paths
<xsl:template match="/"> which represents the XPath document root. An XPath expression
such as this represents one or more nodes within XPath parse tree is known as location path.
This location path consists a ‘location step’

Location step has two parts:
An axis name followed by (::) Node test
child::Emp_Id is an example of a location step and has two parts:
Axis name specifies the direction to which we can search a node Node test specifies an element name
selected for transformation
Predicate:
XPath uses some predicate which constructs the node test. Predicate can be either
child::<element name>
(Or)
Attribute::<value> Absolute and Relative Location Path
A location path can consists of several location steps separated by / character.

Web Data: XML

Uploaded by

Web Data: XML

Uploaded by

Web Data: XML

The Difference between XML and HTML

- WSDL for describing available web services

Well Formed XML Documents

Example for XML Document

It is an alternative to DTD to define the structure of an XML document.

This definition file is stored with .xsl extension.

XML DTD vs XML Schema:

XML can easily be avoided using a name prefix as shown below:

Default xml namespace uri for elements of a document is xmlns:http://www.w3.org/1999/xhtml

We can access and parse the XML document in two ways:

Parsing using DOM (tree based)

1. DOM based XML Parsing:(tree based)

To Count the Elements in a XML File

Step 1: Create an xml file: Employee- Detail.xml

public class CountNodes

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

Event oriented XML Parsing: SAX

SAX stands for Simple API for XML

The kinds of events are:

Features of SAX Parser

SAX Example :Selecting XML data

<?xml version = "1.0"?>

<student rollno = "493">

<student rollno = "593">

public class StAXQueryDemo {

String requestedRollNo = "393";

if(bFirstName && isRequestRollNo) {

Transforming XML document

1. XSL components: Three components

XSLT – XSL Transformations (XSLT) is a language to specify transformations of XML

To transform xml document the following things are required:

The following program illustrates that.

Example for XSLT

Step 2: Create an XSLT Stylesheet and save as myXSL.xsl extension

This location path consists a ‘location step’

child::Emp_Id is an example of a location step and has two parts:

A location path can consists of several location steps separated by / character.

You might also like