SAP PI 7 3 Training Material1

Why do we need XML parser

We need XML parser because we do not want to do everything in our

application from scratch and we need some helper programs or libraries

to do something very low-level but very necessary to us These low-level

but necessary things include checking the well-formedness validating the

document against its DTD or schema (just for validating parsers)

resolving character reference understanding CDATA sections and so on

XML parsers are just such helper programs and they will do all these

jobsl With XML parsers we are shielded from a lot of these

complexicities and we could concentrate ourselves on just programming at

high-level through the APIs implemented by the parsers and thus gain

programming efficiency

What is the difference between a DOMParser and a SAXParser

DOM parsers and SAX parsers work in different ways

A DOM parser creates a tree structure in memory from the

input document and then waits for requests from client But a SAX parser

does not create any internal structure Instead it takes the occurrences

of components of a input document as events and tells the client what it

reads as it reads through the input document

A DOM parser always serves the client application with the

entire document no matter how much is actually needed by the client But

a SAX parser serves the client application always only with pieces of the

document at any given time

With DOM parser method calls in client application have to be explicit

and forms a kind of chain

The DOM interface is perhaps the easiest to understand It parses an

entire XML document and constructs a complete in-memory representation of

the document using the classes modeling the concepts found in the

Document Object Model(DOM) Level 2 Core Specification

Page 2 of 160

The DOM parser is called a DocumentBuilder as it builds an in-memory

Document representation The javaxxmlparsersDocumentBuilder is created

by the javaxxmlparsersDocumentBuilderFactory The DocumentBuilder

creates an orgw3cdomDocument instance which is a tree structure

containing nodes in the XML Document Each tree node in the structure

implements the orgw3cdomNode interface There are many different types

of tree nodes representing the type of data found in an XML document

The most important node types are

element nodes that may have attributes

text nodes representing the text found between the start and end

tags of a document element

SAX interface

The SAX parser is called the SAXParser and is created by the

javaxxmlparsersSAXParserFactory Unlike the DOM parser the SAX parser

does not create an in-memory representation of the XML document and so is

faster and uses less memory Instead the SAX parser informs clients of

the XML document structure by invoking callbacks that is by invoking

methods on a orgxmlsaxhelpersDefaultHandler instance provided to the

parser This way of accessing document is called Streaming XML

The DefaultHandler class implements the ContentHandler the ErrorHandler

the DTDHandler and the EntityResolver interfaces Most clients will be

interested in methods defined in the ContentHandler interface that are

called when the SAX parser encounters the corresponding elements in the

XML document The most important methods in this interface are

Page 3 of 160

startDocument() and endDocument() methods that are called at the

start and end of a XML document

startElement() and endElement() methods that are called at the

start and end of an document element

characters() method that is called with the text data contents

contained between the start and end tags of an XML document element

Clients provide a subclass of the DefaultHandler that overrides these

methods and processes the data This may involve storing the data into a

database or writing it out to a stream

During parsing the parser may need to access external documents It is

possible to store a local cache for frequently-used documents using an

XML Catalog

This was introduced with Java 13 in May 2000

With SAX some certain methods (usually over ridden by the client) will

be invoked automatically (implicitly) in a way which is called callback

when some certain events occur These methods do not have to be called

explicitly by the client though we could call them explicitly

Given the following XML document

ltxml version=10 encoding=UTF-8gt

ltRootElement param=valuegt

ltFirstElementgt

Some Text

ltFirstElementgt

ltsome_pi some_attr=some_valuegt

ltSecondElement param2=somethinggt

Pre-Text ltInlinegtInlined textltInlinegt Post-text

Page 4 of 160

ltSecondElementgt

ltRootElementgt

This XML document when passed through a SAX parser will generate a

sequence of events like the following

XML Element start named RootElement with an attribute param equal

to value

XML Element start named FirstElement

XML Text node with data equal to Some Text (note text

processing with regard to spaces can be changed)

XML Element end named FirstElement

Processing Instruction event with the target some_pi and data

some_attr=some_value

XML Element start named SecondElement with an attribute param2

equal to something

XML Text node with data equal to Pre-Text

XML Element start named Inline

XML Text node with data equal to Inlined text

XML Element end named Inline

XML Text node with data equal to Post-text

XML Element end named SecondElement

XML Element end named RootElement

Note that the first line of the sample above is the XML Declaration and

not a processing instruction as such it will not be reported as a

processing instruction event

The result above may vary the SAX specification deliberately states that

a given section of text may be reported as multiple sequential text

Page 5 of 160

events Thus in the example above a SAX parser may generate a different

series of events part of which might include

XML Element start named FirstElement

XML Text node with data equal to Some

XML Text node with data equal to Text

XML Element end named FirstElement

Whats the difference between tree-based API and event-based API

A tree-based API is centered around a tree structure and therefore

provides interfaces on components of a tree (which is a DOM document)

such as Document interfaceNode interface NodeList interface Element

interface Attr interface and so on By contrast however an event-based

API provides interfaces on handlers There are four handler interfaces

ContentHandler interface DTDHandler interface EntityResolver interface

and ErrorHandler interface

The main interface involved in SAX is a ContentHandler You write your

own class that implments this interface You supply methods to respond to

events One method is called when the document starts another when the

document ends One is called when an element starts one when it ends

Between these two there may be calls to a characters method if there

are text character specified between the start end end tags If elements

are nested you may get two starts then two ends

The entire procesing is up to you The sequence follows the input source

If you dont care about a specific element when it is processed do

nothing

When the document end method is called SAX is finished Whatever you

have kept in whatever format is all that is kept

Page 6 of 160

This is in contrast to DOM which reads the entire input and constructs a

tree of elements Then the tree represents entire source You can move

elements or attributes around to make a different file you can run it

through a transformer You can search it using XPath to find sequences of

elements or structures in the document and process them as you wish When

you are done you can serialize it (to produce an XML file or an xml-

format stream

So SAX is a Simple API for XML as its name implies It does not have

large demands for memory You can process a huge file and if you dont

want to keep much data or you are summing data from the elements that go

by you will not require much memory DOM builds a tree of Nodes to

represent the entire file It takes more space to hold an element than it

takes for the minimal character representation -- ltagt 4 characters vs

dozens or hundreds

Both will process the same input and with SAX you will see all input as

it goes by You may keep what you want in whatever format you want But

if you dont keep it it is not stored somewhere for you to process

unless you run the input source through SAX again

Which one is better SAX or DOM

Both SAX and DOM parser have their advantages and disadvantages Which

one is better should depends on the characteristics of your application

(please refer to some questions below)

Which parser can get better speed DOM or SAX parsers

SAX parser can get better speed

Page 7 of 160

In what cases we prefer DOMParser to SAXParser

In what cases we prefer SAXParser to DOMParser

What are some real world applications where using SAX parser is

advantageous than using DOM parser and vice versa

What are the usual application for a DOM parser and for a SAX parser

In the following cases using SAX parser is advantageous than using

DOM parser

The input document is too big for available memory (actually

in this case SAX is your only choice)

You can process the document in small contiguous chunks of

input You do not need the entire document before you can do useful work

You just want to use the parser to extract the information of

interest and all your computation will be completely based on the data

structures created by yourself Actually in most of our applications we

create data structures of our own which are usually not as complicated as

the DOM tree From this sense I think the chance of using a DOM parser

is less than that of using a SAX parser

In the following cases using DOM parser is advantageous than using

SAX parser

Your application needs to access widely separately parts of

the document at the same time

Your application may probably use a internal data structure

which is almost as complicated as the document itself

Your application has to modify the document repeatedly

Your application has to store the document for a significant

amount of time through many method calls

Example (Use a DOM parser or a SAX parser)

Page 8 of 160

Assume that an instructor has an XML document containing all the

personal information of the students as well as the points his students

made in his class and he is now assigning final grades for the students

using an application What he wants to produce is a list with the SSN

and the grades Also we assume that in his application the instructor

use no data structure such as arrays to store the student personal

information and the points

If the instructor decides to give As to those who earned the class

average or above and give Bs to the others then hed better to use a

DOM parser in his application The reason is that he has no way to know

how much is the class average before the entire document gets processed

What he probably need to do in his application is first to look through

all the students points and compute the average and then look through

the document again and assign the final grade to each student by

comparing the points he earned to the class average

If however the instructor adopts such a grading policy that the

students who got 90 points or more are assigned As and the others are

assigned Bs then probably hed better use a SAX parser The reason is

to assign each student a final grade he do not need to wait for the

entire document to be processed He could immediately assign a grade to a

student once the SAX parser reads the grade of this student

In the above analysis we assumed that the instructor created no

data structure of his own What if he creates his own data structure

such as an array of strings to store the SSN and an array of integers to

sto re the points In this case I think SAX is a better choice before

this could save both memory and time as well yet get the job done

Well one more consideration on this example What if what the

instructor wants to do is not to print a list but to save the original

Page 9 of 160

document back with the grade of each student updated In this case a

DOM parser should be a better choice no matter what grading policy he is

adopting He does not need to create any data structure of his own What

he needs to do is to first modify the DOM tree (ie set value to the

grade node) and then save the whole modified tree If he choose to use

a SAX parser instead of a DOM parser then in this case he has to create

a data structure which is almost as complicated as a DOM tree before he

could get the job done

How does the eventbased parser notice that there is an event happening

since these events are not like click button or move the mouse

Clicking a button or moving the mouse could be thought of as

events but events could be thought of in a more general way For

example in a switch statement of C if the switched variable gets some

value some case will be taken and get executed At this time we may

also say one event has occurred A SAX parser reads the document

character by character or token by token Once some patterns (such as the

start tag or end tag) are met it thinks of the occurrences of these

patterns as events and invokes some certain methods overriden by the

client

To summarize all lets discuss difference between both approach

SAX Parser

Event based model

Serial access (flow of events)

Low memory usage (only events are generated)

To process parts of the document (catching relevant events)

To process the document only once

Backward navigation is not possible as it sequentially processes the

document

Page 10 of 160

Objects are to be created

DOM Parser

(Object based)Tree data structure

Random access (in-memory data structure)

High memory usage (the document is loaded into memory)

To edit the document (processing the in-memory data structure)

To process multiple times (document loaded in memory)

Ease of navigation

Stored as objects

Page 11 of 160

Sample document for the example

ltxml version=10gt

ltDOCTYPE shapes [

ltELEMENT shapes (circle)gt

ltELEMENT circle (xyradius)gt

ltELEMENT x (PCDATA)gt

ltELEMENT y (PCDATA)gt

ltELEMENT radius (PCDATA)gt

ltATTLIST circle color CDATA IMPLIEDgt

]gt

ltshapesgt

ltcircle color=BLUEgt

ltxgt20ltxgt

ltygt20ltygt

ltradiusgt20ltradiusgt

ltcirclegt

ltcircle color=RED gt

ltxgt40ltxgt

ltygt40ltygt

ltradiusgt20ltradiusgt

ltcirclegt

ltshapesgt

Page 12 of 160

Programs for the Example

program with DOMparser

import javaio

import orgw3cdom

import orgapachexercesparsersDOMParser

public class shapes_DOM

static int numberOfCircles = 0 total number of circles seen

static int x[] = new int[1000] X-coordinates of the centers

static int y[] = new int[1000] Y-coordinates of the centers

static int r[] = new int[1000] radius of the circle

static String color[] = new String[1000] colors of the circles

public static void main(String[] args)

try

create a DOMParser

DOMParser parser=new DOMParser()

parserparse(args[0])

get the DOM Document object

Document doc=parsergetDocument()

get all the circle nodes

NodeList nodelist = docgetElementsByTagName(circle)

numberOfCircles = nodelistgetLength()

retrieve all info about the circles

for(int i=0 iltnodelistgetLength() i++)

Page 13 of 160