Scribd Logo
Upload

Welcome to Scribd!

  • 67 views

    We Can Insert or Delete Nodes We Can't Insert or Delete A Node

    Uploaded by

    prakash reddy
    The document discusses two approaches for parsing XML documents: DOM and SAX. DOM parses the entire XML document into memory and represents it as a tree structure that allows random access. SAX is an event-based model that parses the document sequentially and does not load the entire document into memory. It provides callbacks when elements are encountered. The document provides examples of using both DOM and SAX parsers in Java code to parse an XML document.

    Copyright:

    © All Rights Reserved
    Download as DOC, PDF, TXT or read online from Scribd

    We Can Insert or Delete Nodes We Can't Insert or Delete A Node

    Uploaded by

    prakash reddy
    67 views5 pages
    The document discusses two approaches for parsing XML documents: DOM and SAX. DOM parses the entire XML document into memory and represents it as a tree structure that allows random access. SAX is an event-based model that parses the document sequentially and does not load the entire document into memory. It provides callbacks when elements are encountered. The document provides examples of using both DOM and SAX parsers in Java code to parse an XML document.

    Original Description:

    Uhq

    Original Title

    dom_sax

    Copyright

    © © All Rights Reserved

    Available Formats

    DOC, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    The document discusses two approaches for parsing XML documents: DOM and SAX. DOM parses the entire XML document into memory and represents it as a tree structure that allows random access. SAX is an event-based model that parses the document sequentially and does not load the entire document into memory. It provides callbacks when elements are encountered. The document provides examples of using both DOM and SAX parsers in Java code to parse an XML document.

    Copyright:

    © All Rights Reserved
    Download as DOC, PDF, TXT or read online from Scribd
    Download as doc, pdf, or txt
    67 views5 pages

    We Can Insert or Delete Nodes We Can't Insert or Delete A Node

    Uploaded by

    prakash reddy
    The document discusses two approaches for parsing XML documents: DOM and SAX. DOM parses the entire XML document into memory and represents it as a tree structure that allows random access. SAX is an event-based model that parses the document sequentially and does not load the entire document into memory. It provides callbacks when elements are encountered. The document provides examples of using both DOM and SAX parsers in Java code to parse an XML document.

    Copyright:

    © All Rights Reserved
    Download as DOC, PDF, TXT or read online from Scribd
    Download as doc, pdf, or txt
    of 5

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

    o Parsing using DOM (tree based)


    o 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.

    DOM SAX
    Tree data structure Event based model
    Random access Serial access
    High memory usage Low memory usage
    Used to edit the document Used to process parts of the document
    Used to process multiple times (document is Used to process the document only once
    loaded in memory)
    Stores the entire XML document into memory Parses node by node
    before processing
    Occupies more memory Doesn’t store the XML in memory
    We can insert or delete nodes We can’t insert or delete a node
    Traverse in any direction. Top to bottom traversing
    Document Object Model (DOM) API SAX is a Simple API for XML
    import javax.xml.parsers.*; Packages required to import
    import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.*;
    import import org.xml.sax.*;
    javax.xml.parsers.DocumentBuilderFactory;
    DOM is slow rather than SAX SAX generally runs a little faster than 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 is text nodes
    • Every attribute is an attribute node
    • Comments are comment nodes

    DOM based XML Parsing


    DOM parser parses the entire XML document and loads it into memory; then models it in a “TREE”
    structure for easy traversal or manipulation.
    In short, it turns a XML file into DOM or Tree structure, and you have to traverse a node by node to get
    what you want.
    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.
    • DocumentBuilder produces a Document (a DOM) that conforms to the DOM
    specification

    The following methods and properties are necessary to process the XML document:
    Property Meaning
    nodeName Finding the name of the node
    nodeValue Obtaining value of the node
    parentNode To get parnet node
    childNodes Obtain child nodes
    attributes For getting the attributes values

    Method Meaning
    getElementByTagName(name) To access the element by specifying its name
    appendChild(node) To insert a child node
    removeChild(node) To remove existing child node

    Java Program to Create XML File


    import org.w3c.dom.*;
    import javax.xml.parsers.*;
    import javax.xml.transform.*;
    import javax.xml.transform.dom.*;
    import java.util.Scanner;
    import javax.xml.transform.stream.*;
    import java.io.*;

    public class CreateXML


    {
    public static void main(String[] args) throws Exception
    {
    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    DocumentBuilder builder = factory.newDocumentBuilder(); // parser is created
    Document doc=builder.newDocument();
    Element rootele=doc.createElement("students-details");
    Element studentele=doc.createElement("student");
    Element idele=doc.createElement("studentid");
    Element nameele=doc.createElement("name");
    Element markesele=doc.createElement("markes");

    Text t1=doc.createTextNode("501");
    Text t2=doc.createTextNode("naveen");
    Text t3=doc.createTextNode("90");

    idele.appendChild(t1);
    nameele.appendChild(t2);
    markesele.appendChild(t3);

    studentele.appendChild(idele);
    studentele.appendChild(nameele);
    studentele.appendChild(markesele);

    rootele.appendChild(studentele);
    doc.appendChild(rootele);

    Transformer t = TransformerFactory.newInstance() .newTransformer();


    t.transform(new DOMSource(doc),new StreamResult(new
    FileOutputStream("student.xml")));
    }
    }

    Above code will generate an xml file with a name student.xml


    Student.xml
    <?xml version="1.0" encoding="UTF-8" standalone="no" ?>
    <students-details>
    <student>
    <studentid>501</studentid>
    <name>naveen</name>
    <markes>90</markes>
    </student>
    </students-details>

    Using SAX Parser


    SAX Parser is different from the DOM Parser where SAX parser doesn’t load the complete XML into the
    memory, instead it parses the XML line by line triggering different events as and when it encounters
    different elements like: opening tag, closing tag, character data, and comments and so on. This is the
    reason why SAX Parser is called an event based parser.

    Along with the XML source file, we also register a handler which extends the DefaultHandler class. The
    DefaultHandler class provides different callbacks out of which we would be interested in:

    startElement() – triggers this event when the start of the tag is encountered.
    endElement() – triggers this event when the end of the tag is encountered.
    characters() – triggers this event when it encounters some text data.

    Let’s create a demo program to read xml file with SAX parser to understand fully.
    Student.xml
    <?xml version="1.0" encoding="UTF-8" ?>
    - <students-details>
    - <student>
    <studentid>501</studentid>
    <name>Ramu</name>
    <address>ECIL</address>
    <gender>Male</gender>
    </student>
    - <student>
    <studentid>502</studentid>
    <name>Mahi</name>
    <address>BHEL</address>
    <gender>Male</gender>
    </student>
    </students-details>

    Java program to read data from xml(student.xml) file


    import java.io.*;
    import javax.xml.parsers.SAXParser;
    import javax.xml.parsers.SAXParserFactory;
    import org.xml.sax.Attributes;
    import org.xml.sax.SAXException;
    import org.xml.sax.helpers.DefaultHandler;

    public class SAXParserDemo extends DefaultHandler


    {
    public void startDocument(){
    System.out.println("begin parsing document");
    }

    public void startElement(String url,String localname, String qName, Attributes att){


    System.out.print("<"+qName+">");
    }

    public void characters(char[] ch,int start,int length){


    for(int i=start;i<(start+length);i++)
    {
    System.out.print(ch[i]);
    }
    }

    public void endElement(String url,String localname, String qName){


    System.out.print("</"+qName+">");
    }

    public void endDocument(){


    System.out.println("End parsing document");
    }

    public static void main(String[] arg)throws Exception{


    SAXParser p=SAXParserFactory.newInstance().newSAXParser();
    p.parse(new FileInputStream("student.xml"), new SAXParserDemo());
    }

    You might also like