1. SDPL 2002Notes 3.2: Document Object Model1 The Misconceived Web n The original vision of the WWW was as a hyperlinked document-retrieval system. n It did not anticipate presentation, session, or interactivity. n If the WWW were still consistent with TBL's original vision, Yahoo would still be two guys in a trailer.

2. SDPL 2002Notes 3.2: Document Object Model2 How We Got Here n Rule Breaking n Corporate Warfare n Extreme Time Pressure

3. SDPL 2002Notes 3.2: Document Object Model3 The Miracle n It works! n Java didn't. n Nor did a lot of other stuff.

4. SDPL 2002Notes 3.2: Document Object Model4 The Scripted Browser n Introduced in Netscape Navigator 2 (1995) n Eclipsed by Java Applets n Later Became the Frontline of the Browser War n Dynamic HTML n Document Object Model (DOM)

5. SDPL 2002Notes 3.2: Document Object Model5 Viewing XML n XML is designed to be processed by computer programs, not to be displayed to humans n Nevertheless, almost all current Web browsers can display XML documents –They do not all display it the same way –They may not display it at all if it has errors n This is just an added value. Remember: HTML is designed to be viewed, XML is designed to be used

6. SDPL 2002Notes 3.2: Document Object Model6 Stream Model n Stream seen by parser is a sequence of elements n As each XML element is seen, an event occurs –Some code registered with the parser (the event handler) is executed n This approach is popularized by the Simple API for XML (SAX) n Problem: –Hard to get a global view of the document –Parsing state represented by global variables set by the event handlers

7. SDPL 2002Notes 3.2: Document Object Model7 Data Model n The XML data is transformed into a navigable data structure in memory –Because of the nesting of XML elements, a tree data structure is used –The tree is navigated to discover the XML document n This approach is popularized by the Document Object Model (DOM) n Problem: –May require large amounts of memory –May not be as fast as stream approach »Some DOM parsers use SAX to build the tree

8. SDPL 2002Notes 3.2: Document Object Model8 SAX and DOM n SAX and DOM are standards for XML parsers –DOM is a W3C standard –SAX is an ad-hoc (but very popular) standard n There are various implementations available n Java implementations are provided as part of JAXP (Java API for XML Processing) n JAXP package is included in JDK starting from JDK 1.4 –Is available separately for Java 1.3

9. SDPL 2002Notes 3.2: Document Object Model9 Difference between SAX and DOM n DOM reads the entire document into memory and stores it as a tree data structure n SAX reads the document and calls handler methods for each element or block of text that it encounters n Consequences: –DOM provides "random access" into the document –SAX provides only sequential access to the document –DOM is slow and requires huge amount of memory, so it cannot be used for large documents –SAX is fast and requires very little memory, so it can be used for huge documents »This makes SAX much more popular for web sites

10. SDPL 2002Notes 3.2: Document Object Model10 Parsing with SAX n SAX uses the source-listener-delegate model for parsing XML documents –Source is XML data consisting of a XML elements –A listener written in Java is attached to the document which listens for an event –When event is thrown, some method is delegated for handling the code

11. SDPL 2002Notes 3.2: Document Object Model11 Callbacks n SAX works through callbacks: –The program calls the parser –The parser calls methods provided by the program parse(...) The SAX parser Program main(...) startDocument(...) startElement(...) characters(...) endElement( ) endDocument( )

12. SDPL 2002Notes 3.2: Document Object Model12 Problems with SAX n SAX provides only sequential access to the document being processed n SAX has only a local view of the current element being processed –Global knowledge of parsing must be stored in global variables –A single startElement() method for all elements »In startElement() there are many “if-then-else” tests for checking a specific element »When an element is seen, a global flag is set »When finished with the element global flag must be set to false

13. SDPL 2002Notes 3.2: Document Object Model13 DOM n DOM represents the XML document as a tree –Hierarchical nature of tree maps well to hierarchical nesting of XML elements –Tree contains a global view of the document »Makes navigation of document easy »Allows to modify any subtree »Easier processing than SAX but memory intensive! n As well as SAX, DOM is an API only –Does not specify a parser –Lists the API and requirements for the parser n DOM parsers typically use SAX parsing

14. SDPL 2002Notes 3.2: Document Object Model14 Document Object Model (DOM) n How to provide uniform access to structured documents in diverse applications (parsers, browsers, editors, databases)? n Overview of W3C DOM Specification –second one in the “XML-family” of recommendations »Level 1, W3C Rec, Oct. 1998 »Level 2, W3C Rec, Nov. 2000 »Level 3, W3C Working Draft (January 2002) n What does DOM specify, and how to use it?

15. SDPL 2002Notes 3.2: Document Object Model15 DOM: What is it? n An object-based, language-neutral API for XML and HTML documents –allows programs and scripts to build documents, navigate their structure, add, modify or delete elements and content –Provides a foundation for developing querying, filtering, transformation, rendering etc. applications on top of DOM implementations n In contrast to “Serial Access XML” could think as “Directly Obtainable in Memory”

16. SDPL 2002Notes 3.2: Document Object Model16 DOM structure model n Based on O-O concepts: –methods (to access or change object’s state) –interfaces (declaration of a set of methods) –objects (encapsulation of data and methods) n Roughly similar to the XSLT/XPath data model (to be discussed later)  a parse tree –Tree-like structure implied by the abstract relationships defined by the programming interfaces; Does not necessarily reflect data structures used by an implementation (but probably does)

17. SDPL 2002Notes 3.2: Document Object Model17 invoice invoicepage name addressee addressdata address form="00"type="estimatedbill" Leila Laskuprintti streetaddresspostoffice 70460 KUOPIO Pyynpolku 1 <invoice> <invoicepage form="00" <invoicepage form="00" type="estimatedbill"> type="estimatedbill"> Leila Laskuprintti Leila Laskuprintti Pyynpolku 1 Pyynpolku 1 70460 KUOPIO 70460 KUOPIO......Document Element NamedNodeMap Text DOM structure model

18. SDPL 2002Notes 3.2: Document Object Model18 Structure of DOM Level 1 I: DOM Core Interfaces –Fundamental interfaces »basic interfaces to structured documents –Extended interfaces »XML specific: CDATASection, DocumentType, Notation, Entity, EntityReference, ProcessingInstruction II: DOM HTML Interfaces –more convenient to access HTML documents –(we ignore these)

19. SDPL 2002Notes 3.2: Document Object Model19 DOM Level 2 –Level 1: basic representation and manipulation of document structure and content (No access to the contents of a DTD) n DOM Level 2 adds –support for namespaces –accessing elements by ID attribute values –optional features »interfaces to document views and style sheets »an event model (for, say, user actions on elements) »methods for traversing the document tree and manipulating regions of document (e.g., selected by the user of an editor) –Loading and writing of docs not specified (-> Level 3)

20. SDPL 2002Notes 3.2: Document Object Model20 DOM Language Bindings n Language-independence: –DOM interfaces are defined using OMG Interface Definition Language (IDL; Defined in Corba Specification) n Language bindings (implementations of DOM interfaces) defined in the Recommendation for –Java and –ECMAScript (standardised JavaScript)

21. SDPL 2002Notes 3.2: Document Object Model21 Document Tree Structure document document.body document. documentElement

22. SDPL 2002Notes 3.2: Document Object Model22 child, sibling, parent

23. SDPL 2002Notes 3.2: Document Object Model23 child, sibling, parent

24. SDPL 2002Notes 3.2: Document Object Model24 child, sibling, parent

25. SDPL 2002Notes 3.2: Document Object Model25 child, sibling, parent

26. SDPL 2002Notes 3.2: Document Object Model26 Core Interfaces: Node & its variants Node Comment DocumentFragmentAttr Text Element CDATASection ProcessingInstruction CharacterData EntityDocumentTypeNotation EntityReference “Extended interfaces” Document

27. SDPL 2002Notes 3.2: Document Object Model27 DOM interfaces: Node invoice invoicepage name addressee addressdata address form="00" type="estimatedbill" Leila Laskuprintti streetaddresspostoffice 70460 KUOPIOPyynpolku 1NodegetNodeTypegetNodeValuegetOwnerDocumentgetParentNode hasChildNodesgetChildNodes getFirstChildgetLastChildgetPreviousSiblinggetNextSibling hasAttributesgetAttributes appendChild(newChild)insertBefore(newChild,refChild)replaceChild(newChild,oldChild)removeChild(oldChild)Document Element NamedNodeMap Text

28. SDPL 2002Notes 3.2: Document Object Model28 Object Creation in DOM Each DOM object X lives in the context of a Document: X.getOwnerDocument() Each DOM object X lives in the context of a Document: X.getOwnerDocument() Objects implementing interface X are created by factory methods D.create X (…), where D is a Document object. E.g: Objects implementing interface X are created by factory methods D.create X (…), where D is a Document object. E.g: –createElement("A"), createAttribute("href"), createTextNode("Hello!") Creation and persistent saving of Document s left to be specified by implementations Creation and persistent saving of Document s left to be specified by implementations

29. SDPL 2002Notes 3.2: Document Object Model29 invoice invoicepage name addressee addressdata address form="00"type="estimatedbill" Leila Laskuprintti streetaddresspostoffice 70460 KUOPIO Pyynpolku 1 DocumentgetDocumentElementcreateAttribute(name)createElement(tagName)createTextNode(data)getDocType()getElementById(IdVal) Node Document Element NamedNodeMap Text DOM interfaces: Document

30. SDPL 2002Notes 3.2: Document Object Model30 DOM interfaces: Element invoice invoicepage name addressee addressdata address form="00"type="estimatedbill" Leila Laskuprintti streetaddresspostoffice 70460 KUOPIO Pyynpolku 1 ElementgetTagNamegetAttributeNode(name)setAttributeNode(attr)removeAttribute(name)getElementsByTagName(name)hasAttribute(name) Node Document Element NamedNodeMap Text

31. SDPL 2002Notes 3.2: Document Object Model31 Accessing properties of a Node –Node.getNodeName () »for an Element = getTagName() »for an Attr: the name of the attribute »for Text = "#text" etc –Node.getNodeValue() »content of a text node, value of attribute, …; null for an Element (!!) (in XSLT/Xpath: the full textual content) –Node.getNodeType() : numeric constants (1, 2, 3, …, 12) for ELEMENT_NODE, ATTRIBUTE_NODE,TEXT_NODE, …, NOTATION_NODE

32. SDPL 2002Notes 3.2: Document Object Model32 Content and element manipulation Manipulating CharacterData D : Manipulating CharacterData D : –D.substringData( offset, count ) –D.appendData( string ) –D.insertData( offset, string ) –D.deleteData( offset, count ) –D.replaceData( offset, count, string ) (= delete + insert) Accessing attributes of an Element object E : Accessing attributes of an Element object E : –E.getAttribute( name ) –E.setAttribute( name, value ) –E.removeAttribute( name )

33. SDPL 2002Notes 3.2: Document Object Model33 Additional Core Interfaces (1) NodeList for ordered lists of nodes NodeList for ordered lists of nodes –e.g. from Node.getChildNodes() or Element.getElementsByTagName("name") »all descendant elements of type "name" in document order (wild-card "*" matches any element type) Accessing a specific node, or iterating over all nodes of a NodeList : Accessing a specific node, or iterating over all nodes of a NodeList : –E.g. Java code to process all children: for (i=0; i<node.getChildNodes().getLength(); i++) process(node.getChildNodes().item(i));

34. SDPL 2002Notes 3.2: Document Object Model34 Additional Core Interfaces (2) NamedNodeMap for unordered sets of nodes accessed by their name: NamedNodeMap for unordered sets of nodes accessed by their name: –e.g. from Node.getAttributes() NodeList s and NamedNodeMap s are "live": NodeList s and NamedNodeMap s are "live": –changes to the document structure reflected to their contents

35. SDPL 2002Notes 3.2: Document Object Model35 DOM: Implementations n Java-based parsers e.g. IBM XML4J, Apache Xerces, Apache Crimson n MS IE5 browser: COM programming interfaces for C/C++ and MS Visual Basic, ActiveX object programming interfaces for script languages n XML::DOM (Perl implementation of DOM Level 1) n Others? Non-parser-implementations? (Participation of vendors of different kinds of systems in DOM WG has been active.)

36. SDPL 2002Notes 3.2: Document Object Model36 A Java-DOM Example A stand-alone toy application BuildXml A stand-alone toy application BuildXml –either creates a new db document with two person elements, or adds them to an existing db document –based on the example in Sect. 8.6 of Deitel et al: XML - How to program n Technical basis –DOM support in Sun JAXP –native XML document initialisation and storage methods of the JAXP 1.1 default parser (Apache Crimson)

37. SDPL 2002Notes 3.2: Document Object Model37 Code of BuildXml (1) n Begin by importing necessary packages: import java.io.*; import org.w3c.dom.*; import org.xml.sax.*; import javax.xml.parsers.*; // Native (parse and write) methods of the // JAXP 1.1 default parser (Apache Crimson): import org.apache.crimson.tree.XmlDocument;

38. SDPL 2002Notes 3.2: Document Object Model38 Code of BuildXml (2) Class for modifying the document in file fileName : Class for modifying the document in file fileName : public class BuildXml { private Document document; private Document document; public BuildXml(String fileName) { File docFile = new File(fileName); File docFile = new File(fileName); Element root = null; // doc root elemen Element root = null; // doc root elemen // Obtain a SAX-based parser: DocumentBuilderFactory factory = DocumentBuilderFactory factory =DocumentBuilderFactory.newInstance();

39. SDPL 2002Notes 3.2: Document Object Model39 Code of BuildXml (3) try { // to get a new DocumentBuilder: documentBuilder builder = factory.newInstance(); if (!docFile.exists()) { //create new doc document = builder.newDocument(); document = builder.newDocument(); // add a comment: // add a comment: Comment comment = document.createComment( Comment comment = document.createComment( "A simple personnel list"); "A simple personnel list"); document.appendChild(comment); document.appendChild(comment); // Create the root element: // Create the root element: root = document.createElement("db"); root = document.createElement("db"); document.appendChild(root); document.appendChild(root);

40. SDPL 2002Notes 3.2: Document Object Model40 Code of BuildXml (4) … or if docFile already exists: } else { // access an existing doc try { // to parse docFile try { // to parse docFile document = builder.parse(docFile); root = document.getDocumentElement(); } catch (SAXException se) { } catch (SAXException se) { System.err.println("Error: " + se.getMessage() ); System.exit(1); } /* A similar catch for a possible IOException */ /* A similar catch for a possible IOException */

41. SDPL 2002Notes 3.2: Document Object Model41 Code of BuildXml (5) Create and add two child elements to root : Node personNode = createPersonNode(document, "1234", "Pekka", "Kilpeläinen"); Create and add two child elements to root : Node personNode = createPersonNode(document, "1234", "Pekka", "Kilpeläinen"); root.appendChild(personNode); root.appendChild(personNode); personNode = createPersonNode(document, "5678", "Irma", "Könönen"); personNode = createPersonNode(document, "5678", "Irma", "Könönen"); root.appendChild(personNode); root.appendChild(personNode);

42. SDPL 2002Notes 3.2: Document Object Model42 Code of BuildXml (6) Finally, store the result document: try { // to write the // XML document to file fileName Finally, store the result document: try { // to write the // XML document to file fileName ((XmlDocument) document).write( new FileOutputStream(fileName)); ((XmlDocument) document).write( new FileOutputStream(fileName)); } catch ( IOException ioe ) { } catch ( IOException ioe ) { ioe.printStackTrace(); } ioe.printStackTrace(); }

43. SDPL 2002Notes 3.2: Document Object Model43 Subroutine to create person elements public Node createPersonNode(Document document, String idNum, String fName, String lName) { Element person = document.createElement("person"); Element person = document.createElement("person"); person.setAttribute("idnum", idNum); person.setAttribute("idnum", idNum); Element firstName = document. createElement("first"); Element firstName = document. createElement("first"); person.appendChild(firstName); firstName. appendChild( document. createTextNode(fName) ); firstName. appendChild( document. createTextNode(fName) ); /* … similarly for a lastName */ /* … similarly for a lastName */ return person; return person;}

44. SDPL 2002Notes 3.2: Document Object Model44 The main routine for BuildXml public static void main(String args[]){ if (args.length > 0) { String fileName = args[0]; BuildXml buildXml = new BuildXml(fileName); BuildXml buildXml = new BuildXml(fileName); } else { } else { System.err.println( "Give filename as argument"); }; }; } // main

45. SDPL 2002Notes 3.2: Document Object Model45 Summary of XML APIs n XML processors make the structure and contents of XML documents available to applications through APIs n Event-based APIs –notify application through parsing events –e.g., the SAX call-back interfaces n Object-model (or tree) based APIs –provide a full parse tree –e.g, DOM, W3C Recommendation –more convenient, but may require too much resources with the largest documents n Major parsers support both SAX and DOM