Objective:
In the previous article XML, WEB SERVICES AND API'S IN JAVA we learned  about Role of XML in java platform, Introducing web services concept, Web services standard, API’s and tools to develop Java Services. In this article we will learn about the parsing an XML file using SAX.

Parsing an XML file using SAX:
In real-life applications, you will want to use the SAX parser to process XML data and do something useful with it. This section examines an example JAXP program, SAXLocalNameCount, that counts the number of elements using only the localName component of the element, in an XML document. Namespace names are ignored for simplicity. This example also shows how to use a SAX ErrorHandler.

Creating the Skeleton:
The SAXLocalNameCount program is created in a file named SAXLocalNameCount.java.

public class SAXLocalNameCount {
   static public void main(String[] args) {
       // ...
   }
}

Because you will run it standalone, you need a main() method. And you need command-line arguments so that you can tell the application which file to process.

Importing Classes:
The import statements for the classes the application will use are the following.

package sax;
import javax.xml.parsers.*;
import org.xml.sax.*;
import org.xml.sax.helpers.*;

import java.util.*;
import java.io.*;

public class SAXLocalNameCount {
   // ...
}

The javax.xml.parsers package contains the SAXParserFactory class that creates the parser instance used. It throws a ParserConfigurationException if it cannot produce a parser that matches the specified configuration of options. (Later, you will see more about the configuration options). The javax.xml.parsers package also contains the SAXParser class, which is what the factory returns for parsing. The org.xml.sax package defines all the interfaces used for the SAX parser. The org.xml.sax.helpers package contains DefaultHandler, which defines the class that will handle the SAX events that the parser generates. The classes in java.util and java.io, are needed to provide hash tables and output.

Setting Up I/O:
The first order of business is to process the command-line arguments, which at this stage only serve to get the name of the file to process. The following code in the main method tells the application what file you want SAXLocalNameCountMethod to process.

static public void main(String[] args) throws Exception {
   String filename = null;

   for (int i = 0; i < args.length; i++) {
       filename = args[i];
       if (i != args.length - 1) {
           usage();
       }
   }

   if (filename == null) {
       usage();
   }
}

This code sets the main method to throw an Exception when it encounters problems, and defines the command-line options which are required to tell the application the name of the XML file to be processed. Other command line arguments in this part of the code will be examined later in this lesson, when we start looking at validation.

The filename String that you give when you run the application will be converted to a java.io.File URL by an internal method, convertToFileURL(). This is done by the following code inSAXLocalNameCountMethod.

public class SAXLocalNameCount {
   private static String convertToFileURL(String filename) {
       String path = new File(filename).getAbsolutePath();
       if (File.separatorChar != '/') {
           path = path.replace(File.separatorChar, '/');
       }

       if (!path.startsWith("/")) {
           path = "/" + path;
       }
       return "file:" + path;
   }

   // ...
}
If the incorrect command-line arguments are specified when the program is run, then the SAXLocalNameCount application's usage() method is invoked, to print out the correct options onscreen.

private static void usage() {
   System.err.println("Usage: SAXLocalNameCount <file.xml>");
   System.err.println("       -usage or -help = this message");
   System.exit(1);
}

Further usage() options will be examined later in this lesson, when validation is addressed.

Implementing the ContentHandler Interface

The most important interface in SAXLocalNameCount is ContentHandler. This interface requires a number of methods that the SAX parser invokes in response to various parsing events. The major event-handling methods are: startDocument, endDocument, startElement, and endElement.

The easiest way to implement this interface is to extend the DefaultHandler class, defined in the org.xml.sax.helpers package. That class provides do-nothing methods for all the ContentHandlerevents. The example program extends that class.

public class SAXLocalNameCount extends DefaultHandler {
   // ...
}

Handling Special Characters:

Setting up the Parser:

The following code sets up the parser and gets it started:

Varun Kapila

Add comment