Home > Articles > Web Services > XML

  • Print
  • + Share This
This chapter is from the book

This chapter is from the book

Using Parsers

We have seen a previous code example that uses a SAX parser. This section presents some more code examples.

Let's look at an example in Listing 3.1.

Listing 3.1 Java Code Using a SAX Parser

import org.xml.sax.*;
import org.xml.sax.helpers.*;
import java.io.*;
import java.util.*;
import common.*;

public class SAXSample extends DefaultHandler {

  // The following variable stores the XML string in sort of stack
  private Stack tagStack = new Stack();

  // List of item names stored as Vector
  private Vector items = new Vector();

  // Client name
  private String client;

  // Collecting data in the buffer from
  // the "characters" SAX event.
  private CharArrayWriter contents = new CharArrayWriter();

  // Override methods of the DefaultHandler class
  // to receive of SAX Events.

  public void startElement( String namespaceURI,
        String localName,
       String qName,
       Attributes attr ) throws SAXException {


   // push the tag name in the stack
   tagStack.push( localName );

   // display the current path that has been found...
   System.out.println( "Path: [" + getTagPath() + "]" );


  public void endElement( String namespaceURI,
        String localName,
       String qName ) throws SAXException {

   if ( getTagPath().equals( "/Order/Customer/Name" ) ) {
     client = contents.toString().trim();
   else if ( getTagPath().equals( "/Order/Items/Item/Name" ) ) {
     items.addElement( contents.toString().trim() );

   // clean the stack

  public void characters( char[] ch, int start, int length )
         throws SAXException {
   // collect the contents into a buffer.
   contents.write( ch, start, length );


  // Build the path string from the current stack 
  private String getTagPath( ){

   // construct path string
   String buffer = "";
   Enumeration e = tagStack.elements();
   while( e.hasMoreElements()){
        buffer = buffer + "/" + (String) e.nextElement();
   return buffer;

  public Vector getItems() {
      return items;

  public String getClientName() {
     return client;

  public static void main( String[] argv ){

   System.out.println( "SAXExample:" );
   try {

     // Start using SAX 2 parser
     XMLReader xr = XMLReaderFactory.createXMLReader();

     // Set ContentHandler
     SAXExample ex1 = new SAXExample();
     xr.setContentHandler( ex1 );

     System.out.println("Tag Paths:");

     // File parsing
     xr.parse( new InputSource(new FileReader( "Sample.xml" )) );


     // Display Client
     System.out.println( "Client Name: " + ex1.getClientName() );

     // Display all item names 
     System.out.println( "Order Items list: " );
     String itemName;
     Vector items = ex1.getItems();
     Enumeration e = items.elements();
     while( e.hasMoreElements()){
          itemName = (String) e.nextElement();
      System.out.println( itemName );

   }catch ( Exception e ) {
     System.out.println( "ERROR: Stack Trace: ");



The XML file used to test the preceding code is shown in Listing 3.2.

Listing 3.2 XML Input File for Code Example in Listing 3.1

<?xml version="1.0"?>
   <Name>EvolveWare Inc</Name>
     <Name>XML Framework</Name>
     <Name>XMLUI 4x</Name>

Unlike a previous example, the code in Listing 3.1 includes all the handlers within one class, as seen by noting that the default class itself extends DefaultHandler. The rest of the code pushes all the retrieved elements on to a simple plain string variable. This is referred to as the stack in the code.

Let's look at the DOM example code in Java using IBM's XML DOM Parser (IBM XML4J). To begin with, consider the XML document to be parsed, as shown in Listing 3.3 (the DTD for the same in Listing 3.4 for reference).

Listing 3.3 Product XML Document

<?xml version="1.0">
<catalog category="software">
  <name>EvolveWare Software Products></name>
      <itemname>XML Framework</itemname>
      <description>Framework for financial enterprise_solution</description>

Listing 3.4 DTD for XML Document in Listing 3.2

<!DOCTYPE catalog [
<!ELEMENT catalog (category, itemlist*) >
 <!ELEMENT category (#PCDATA) >
  <!ATTLIST catalog category(software|hardware|network) #REQUIRED>
 <!ELEMENT itemlist (itemname,cost,description,id) >
  <!ELEMENT itemname (#PCDATA) >  
  <!ELEMENT cost (#PCDATA) >
  <!ELEMENT description (#PCDATA) >
  <!ELEMENT id (#PCDATA) >

The DOM representation of the XML document is shown in Figure 3.1.

Figure 3.1 DOM representation of Listing 3.2.

The following needs to be imported for use by the IBM parser:

import com.ibm.xml.parsers.DOMParser;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.w3c.dom.Element;import org.w3c.dom.NamedNodeMap;

The following code parses the source XML string and returns the DOM object pointing to it:

public static Document parseDOM(String sourceFile) throws Exception{
  try {
    // Get a new parser and attach an error handler
    DOMParser objParser = new DOMParser();
    // Parse the source file
    // Return the document
    return objParser.getDocument();
  } catch (Exception ex) {
    System.err.println("Failed with exception: " + ex);
  return null;

As shown, the code creates the instance of the parser, parses the XML source, and returns the DOM object reference to it.

The following code resides in the main() method call of the Java code: it simply calls the printXMLfromDOM() method:

if (document != null) {
  System.out.println("*******Print XML document from DOM Tree**************");
  } else{
      System.out.println("*********In main()*****");

The printXMLfromDOM() method is as follows:

private static void printXMLfromDOMt(Element element) {
 int k;
 NamedNodeMap attributes;
 NodeList children = element.getChildNodes();
 // Start from this element
 System.out.print("<" + element.getNodeName());
 // print attibutes inside the element start tag
 attributes = element.getAttributes();
 if (attributes != null) {
  for (k = 0; k < attributes.getLength(); k++) {
    System.out.print(" " + attributes.item(k).getNodeName());
    System.out.print("=" + attributes.item(k).getNodeValue());
// check for element value or sub-elements
 if (element.hasChildNodes()) { 

 // print all child elements in the DOM tree 

 for (k = 0; k < children.getLength(); k++) {
  if (children.item(k).getNodeType() == org.w3c.dom.Node.ELEMENT_NODE) {
  printElement((Element) children.item(k));
  } else if (children.item(k).getNodeType() == org.w3c.dom.Node.TEXT_NODE) {
 }  // for loop ends here
 // print end tag
 System.out.print("</" + element.getNodeName() + ">");

} else {  
  // element seems to be empty
  System.out.print(" />");
}// else ends here
}// printXMLfromDOM ends here

The preceding code is simple because it loops through the child elements and prints the entire XML document to the console.

  • + Share This
  • 🔖 Save To Your Account