DOM SAX and DOM n SAX and DOM

DOM

SAX and DOM n SAX and DOM are standards for XML parsers-program APIs to read and interpret XML files n n n There are various implementations available Java implementations are provided in JAXP (Java API for XML Processing) JAXP is included as a package in Java 1. 4 n n DOM is a W 3 C standard SAX is an ad-hoc (but very popular) standard JAXP is available separately for Java 1. 3 Unlike many XML technologies, SAX and DOM are relatively easy 2

Difference between SAX and DOM n n n DOM reads the entire XML document into memory and stores it as a tree data structure SAX reads the XML document and sends an event for each element that it encounters Consequences: n n DOM provides “random access” into the XML document SAX provides only sequential access to the XML document DOM is slow and requires huge amounts of memory, so it cannot be used for large XML documents SAX is fast and requires very little memory, so it can be used for huge documents (or large numbers of documents) n n This makes SAX much more popular for web sites Some DOM implementations have methods for changing the XML document in memory; SAX implementations do not 3

Simple DOM program, I n n n This program is adapted from Code. Notes® for XML by Gregory Brill, page 128 import javax. xml. parsers. *; import org. w 3 c. dom. *; public class Second. Dom { public static void main(String args[]) { try {. . . Main part of program goes here. . . } catch (Exception e) { e. print. Stack. Trace(System. out); } } } 4

Simple DOM program, II n n First we need to create a DOM parser, called a “Document. Builder” The parser is created, not by a constructor, but by calling a static factory method n n This is a common technique in advanced Java programming The use of a factory method makes it easier if you later switch to a different parser Document. Builder. Factory factory = Document. Builder. Factory. new. Instance(); Document. Builder builder = factory. new. Document. Builder(); 5

Simple DOM program, III n n The next step is to load in the XML file Here is the XML file, named hello. xml: <? xml version="1. 0"? > <display>Hello World!</display> n n To read this file in, we add the following line to our program: Document document = builder. parse("hello. xml"); Notes: n n n document contains the entire XML file (as a tree); it is the Document Object Model If you run this from the command line, your XML file should be in the same directory as your program An IDE may look in a different directory for your file; if you get a java. io. File. Not. Found. Exception, this is probably why 6

Simple DOM program, IV n The following code finds the content of the root element and prints it: Element root = document. get. Document. Element(); Node text. Node = root. get. First. Child(); System. out. println(text. Node. get. Node. Value()); n n This code should be mostly self-explanatory; we’ll get into the details shortly The output of the program is: Hello World! 7

Reading in the tree n The parse method reads in the entire XML document and represents it as a tree in memory n n For a large document, parsing could take a while If you want to interact with your program while it is parsing, you need to parse in a separate thread n n n Once parsing starts, you cannot interrupt or stop it Do not try to access the parse tree until parsing is done An XML parse tree may require up to ten times as much memory as the original XML document n n If you have a lot of tree manipulation to do, DOM is much more convenient than SAX If you don’t have a lot of tree manipulation to do, consider using SAX instead 8

Structure of the DOM tree n n The DOM tree is composed of Node objects Node is an interface n Some of the more important subinterfaces are Element, Attr, and Text n n An Element node may have children Attr and Text nodes are leaves Additional types are Document, Processing. Instruction, Comment, Entity, CDATASection and several others Hence, the DOM tree is composed entirely of Node objects, but the Node objects can be downcast into more specific types as needed 9

Operations on Nodes, I n The results returned by get. Node. Name(), get. Node. Value(), get. Node. Type() and get. Attributes() depend on the subtype of the node, as follows: Element Text Attr get. Node. Name() tag name "#text" name of attribute get. Node. Value() null text contents value of attribute get. Node. Type() ELEMENT_NODE TEXT_NODE ATTRIBUTE_NODE get. Attributes() Named. Node. Map null 10

Distinguishing Node types n Here’s an easy way to tell what kind of a node you are dealing with: switch(node. get. Node. Type()) { case Node. ELEMENT_NODE: Element element = (Element)node; . . . ; break; case Node. TEXT_NODE: Text text = (Text)node; . . . break; case Node. ATTRIBUTE_NODE: Attr attr = (Attr)node; . . . break; default: . . . } 11

Operations on Nodes, II n Tree-walking operations that return a Node: n n n get. Parent. Node() get. First. Child() get. Next. Sibling() get. Previous. Sibling() get. Last. Child() Tests that return a boolean: n n has. Attributes() has. Child. Nodes() 12

Operations for Elements n String get. Tag. Name() n n boolean has. Attribute(String name) n n Returns true if this Element has the named attribute String get. Attribute(String name) n n Returns the name of the tag Returns the (String) value of the named attribute boolean has. Attributes() n n Returns true if this Element has any attributes This method is actually inherited from Node n n Returns false if it is applied to a Node that isn’t an Element Named. Node. Map get. Attributes() n n Returns a Named. Node. Map of all the Element’s attributes This method is actually inherited from Node n Returns null if it is applied to a Node that isn’t an Element 13

Named. Node. Map n The node. get. Attributes() operation returns a Named. Node. Map n n Because Named. Node. Maps are used for other kinds of nodes (elsewhere in Java), the contents are treated as general Nodes, not specifically as Attrs Some operations on a Named. Node. Map are: n n n get. Named. Item(String name) returns (as a Node) the attribute with the given name get. Length() returns (as an int) the number of Nodes in this Named. Node. Map item(int index) returns (as a Node) the indexth item n n This operation lets you conveniently step through all the nodes in the Named. Node. Map Java does not guarantee the order in which nodes are returned 14

Operations on Texts n Text is a subinterface of Character. Data and inherits the following operations (among others): n public String get. Data() throws DOMException n n public int get. Length() n n Returns the text contents of this Text node Returns the number of Unicode characters in the text public String substring. Data(int offset, int count) throws DOMException n Returns a substring of the text contents 15

Operations on Attrs n String get. Name() n n Element get. Owner. Element() n n Returns the Element node this attribute is attached to, or null if this attribute is not in use boolean get. Specified() n n Returns the name of this attribute. Returns true if this attribute was explicitly given a value in the original document String get. Value() n Returns the value of the attribute as a String 16

Preorder traversal n n The DOM is stored in memory as a tree An easy way to traverse a tree is in preorder You should remember how to do this from your course in Data Structures The general form of a preorder traversal is: n n Visit the root Traverse each subtree, in order 17

Preorder traversal in Java n n static void simple. Preorder. Print(String indent, Node node) { print. Node(indent, node); if(node. has. Child. Nodes()) { Node child = node. get. First. Child(); while (child != null) { simple. Preorder. Print(indent + " ", child); child = child. get. Next. Sibling(); } } } static void print. Node(String indent, Node node) { System. out. print(indent); System. out. print(node. get. Node. Type() + " "); System. out. print(node. get. Node. Name() + " "); System. out. print(node. get. Node. Value() + " "); print. Named. Node. Map(node. get. Attributes()); // see next slide System. out. println(); } 18

Printing a Named. Node. Map n private static void print. Named. Node. Map(Named. Node. Map attributes) throws DOMException { if (attributes != null) { for (int i = 0; i < attributes. get. Length(); i++) { Node attribute = attributes. item(i); System. out. print(attribute. get. Node. Name() + "=" + attribute. get. Node. Value()); } } } 19

Trying out the program Input: Output: 1 novel null <? xml version="1. 0"? > <novel> 3 #text <chapter num="1">The Beginning</chapter> <chapter num="2">The Middle</chapter> 1 chapter null num=1 <chapter num="3">The End</chapter> 3 #text The Beginning </novel> 3 #text Things to think about: What are the numbers? Are the nulls in the right places? Is the indentation as expected? How could this program be improved? 1 chapter null num=2 3 #text The Middle 3 #text 1 chapter null num=3 3 #text The End 3 #text 20

Additional DOM operations n I’ve left out all the operations that allow you to modify the DOM tree, for example: n n n set. Node. Value(String node. Value) insert. Before(Node new. Child, Node ref. Child) Java provides a large number of these operations These operations are not part of the W 3 C specifications There is no standardized way to write out a DOM as an XML document n n It isn’t that hard to write out the XML The previous program is a good start on outputting XML 21

The End 22