Using Java to Read XML Data

You're going to create a Java application to read in and extract all the data from the XML document you worked with yesterday, which you can see in Listing 16.1.

Example 16.1. A Sample XML Document for Today's Work (ch16_01.xml)

<?xml version="1.0" encoding="UTF-8"?>
<session>
   <committee type="monetary">
       <title>Finance</title>
       <number>17</number>
       <subject>Donut Costs</subject>
       <date>7/15/2005</date>
       <attendees>
           <senator status="present">
               <firstName>Thomas</firstName>
               <lastName>Smith</lastName>
           </senator>
           <senator status="absent">
               <firstName>Frank</firstName>
               <lastName>McCoy</lastName>
           </senator>
           <senator status="present">
               <firstName>Jay</firstName>
               <lastName>Jones</lastName>
           </senator>
       </attendees>
   </committee>
</session>

The Java application you'll create will show how to read in the entire XML document and display it, much as we did in JavaScript yesterday. You start by creating a DocumentBuilderFactory object, which you'll use to create a DocumentBuilder object, and that object will actually read in the XML document. Here's how to use DocumentBuilderFactory in the new application's main method, which is called when the application starts:

import javax.xml.parsers.*;
import org.w3c.dom.*;

public class ch16_02
{
    public static void main(String args[])
    {
        try {
            DocumentBuilderFactory factory =

                   DocumentBuilderFactory.newInstance();
        .
        .
        .
    }

Table 16.1 lists the methods for the DocumentBuilderFactory class.

Table 16.1. Methods of the javax.xml.parsers.DocumentBuilderFactory Class

Method

What It Does

protected DocumentBuilderFactory()

Acts as the default DocumentBuilderFactory constructor.

abstract Object getAttribute(String name)

Returns attribute values.

boolean isCoalescing()

Returns True if the factory is configured to produce parsers that convert CDATA nodes to text nodes.

boolean isExpandEntityReferences()

Returns True if the factory is configured to produce parsers that expand XML entity reference nodes.

boolean isIgnoringComments()

Returns True if the factory is configured to produce parsers that ignore comments.

boolean isIgnoringElementContentWhitespace()

Returns True if the factory is configured to produce parsers that ignore ignorable whitespace (such as that used to indent elements) in element content.

boolean isNamespaceAware()

Returns True if the factory is configured to produce parsers that can use XML namespaces.

boolean isValidating()

Returns True if the factory is configured to produce parsers that validate the XML content during parsing operations.

abstract DocumentBuilder newDocumentBuilder()

Returns a new DocumentBuilder object.

static DocumentBuilderFactory newInstance()

Returns a new DocumentBuilderFactory object.

abstract void setAttribute-(String name, Object value)

Sets attribute values.

void setCoalescing(boolean coalescing)

Specifies that the parser produced will convert CDATA nodes to text nodes.

void setExpandEntityReferences-(boolean expandEntityRef)

Specifies that the parser produced will expand XML entity reference nodes.

void setIgnoringComments-(boolean ignoreComments)

Specifies that the parser produced will ignore comments.

void setIgnoringElementContentWhitespace-(boolean whitespace)

Specifies that the parser produced must eliminate ignorable whitespace.

void setNamespaceAware(boolean awareness)

Specifies that the parser produced will provide support for XML namespaces.

void setValidating(boolean validating)

Specifies that the parser produced will validate documents as they are parsed.

To actually parse the XML document and extract data from it, we need a DocumentBuilder object, which is created by the DocumentBuilderFactory object. Here's what that looks like in code:

public class ch16_02
{
    public static void main(String args[])
    {
        try {
            DocumentBuilderFactory factory =
                DocumentBuilderFactory.newInstance();

            DocumentBuilder builder = null;

               try {

                   builder = factory.newDocumentBuilder();

               }

               catch (ParserConfigurationException e) {}
        .
        .
        .
    }

Table 16.2 lists the methods of the DocumentBuilder class.

Table 16.2. Methods of the javax.xml.parsers.DocumentBuilder Class

Method

What It Does

protected DocumentBuilder()

Acts as the default DocumentBuilder constructor.

abstract boolean isNamespaceAware()

Returns True if this parser is configured to understand namespaces.

abstract boolean isValidating()

Returns True if this parser is configured to validate XML documents.

abstract Document newDocument()

Returns a new instance of a DOM Document object to build a DOM tree with.

Document parse(File f)

Indicates to parse the content of the file as an XML document and return a new DOM Document object.

Document parse(InputStream is)

Indicates to parse the content of a given InputStream object as an XML document and return a new DOM Document object.

Document parse(InputStream is, String systemId)

Indicates to parse the content of an InputStream object as an XML document and return a new DOM Document object.

Document parse(String uri)

Indicates to parse the content of a URI as an XML document and return a new DOM Document object.

abstract void setErrorHandler(ErrorHandler eh)

Sets the ErrorHandler object to be used to report errors.

When the user starts the Java application ch16_02.class, he or she will type the name of the XML document to read, as we do in the following example, where we want to read and display the data in ch16_01.xml:

%java ch16_02 ch16_01.xml

You can access the name of the XML document the user wants to read as args[0]. Here's how to create a Java Document object that corresponds to the XML document, using the DocumentBuilder object:

import javax.xml.parsers.*;
import org.w3c.dom.*;

public class ch16_02
{
    public static void main(String args[])
    {
        try {
            DocumentBuilderFactory factory =
                DocumentBuilderFactory.newInstance();

            DocumentBuilder builder = null;
            try {
                builder = factory.newDocumentBuilder();
            }
            catch (ParserConfigurationException e) {}

            Document document = null;

               document = builder.parse(args[0]);
        .
        .
        .
    }

At this point, then, we have a Java Document object (actually an org.w3c.dom.Document object) that corresponds to the XML document, and we can use the various methods of that object to work with the XML document. Table 16.3 lists the methods of Document objects.

Table 16.3. Methods of the org.w3c.dom.Document Interface

Method

What It Does

Attr createAttribute(String name)

Returns a new attribute object.

Attr createAttributeNS-(String namespaceURI, String qualifiedName)

Returns a new attribute that has the given name and namespace.

CDATASection createCDATASection(String data)

Returns a new CDATASection node whose value is the given string.

Comment createComment(String data)

Returns a new Comment node created using the given string.

DocumentFragment createDocumentFragment()

Returns a new empty DocumentFragment object.

Element createElement(String tagName)

Returns a new element of the type given.

Element createElementNS-(String namespaceURI, String qualifiedName)

Returns a new element of the given qualified name and namespace URI.

ProcessingInstruction createProcessingInstruction-(String target, String data)

Returns a new ProcessingInstruction node.

Text createTextNode(String data)

Returns a new text node, given the specified string.

DocumentType getDoctype()

Returns the DTD for this document.

Element getDocumentElement()

Gives direct access to document element.

Element getElementById(String elementId)

Returns an element whose ID is given.

NodeList getElementsByTagName(String tagname)

Returns all elements with a given tag name.

NodeList getElementsByTagNameNS-(String namespaceURI, String localName)

Returns all elements with a given name and namespace.

Node importNode(Node importedNode, boolean deep)

Imports a node from another document.

The next step is to work through the XML document recursively, as you did with JavaScript yesterday. You'll do that in a method named childLoop that you can call recursively. Just as you did with JavaScript, you'll also pass an indentation string to this method, which will be increased for each successive generation of a node's children. This method will fill an array of strings, displayText, with the XML data from the document and store the total number of strings in the array in a variable named numberLines. When childLoop is done filling the array of strings, you'll display them, like this:

import javax.xml.parsers.*;
import org.w3c.dom.*;

public class ch16_02
{
    static String displayText[] = new String[1000];

       static int numberLines = 0;

    public static void main(String args[])
    {
        try {
            DocumentBuilderFactory factory =
                DocumentBuilderFactory.newInstance();

            DocumentBuilder builder = null;
            try {
                builder = factory.newDocumentBuilder();
            }
            catch (ParserConfigurationException e) {}

            Document document = null;
            document = builder.parse(args[0]);

            childLoop(document, "");

        } catch (Exception e) {
            e.printStackTrace(System.err);
        }

        for(int loopIndex = 0; loopIndex < numberLines; loopIndex++){

               System.out.println(displayText[loopIndex]);

           }
    }

The next order of business is to write childLoop, the method that will loop over all nodes in the XML document and store their data in the displayText array.

Looping Over Nodes

As in JavaScript, you're using the W3C DOM in Java today, so you're treating our XML document as a tree of nodes. Table 16.4 lists the fields of Java org.w3c.dom.Node objects, and Table 16.5 lists the methods of Java org.w3c.dom.Node objects.

Table 16.4. The Fields of the org.w3c.dom.Node Object

Field Summary

Stands For

static short ATTRIBUTE_NODE

An attribute

static short CDATA_SECTION_NODE

A CDATA section

static short COMMENT_NODE

A comment

static short DOCUMENT_FRAGMENT_NODE

A document fragment

static short DOCUMENT_NODE

A document

static short DOCUMENT_TYPE_NODE

A DTD

static short ELEMENT_NODE

An element

static short ENTITY_NODE

An entity

static short ENTITY_REFERENCE_NODE

An entity reference

static short NOTATION_NODE

A notation

static short PROCESSING_INSTRUCTION_NODE

A processing instruction

static short TEXT_NODE

A text node

Table 16.5. Methods of the org.w3c.dom.Node Interface

Method

What It Does

Node appendChild(Node newChild)

Appends the given node to the end of the children of the current node.

NamedNodeMap getAttributes()

Returns the attributes of an element node.

NodeList getChildNodes()

Gets the children of this node.

Node getFirstChild()

Gets the first child of this node.

Node getLastChild()

Gets the last child of this node.

String getLocalName()

Gets the local part of the full name of this node.

String getNamespaceURI()

Gets the namespace URI of this node.

Node getNextSibling()

Gets the node following this node.

String getNodeName()

Gets the name of this node.

short getNodeType()

Gets the type of this node.

String getNodeValue()

Gets the value of this node.

Document getOwnerDocument()

Gets the Document object for this node.

Node getParentNode()

Gets the parent of this node.

String getPrefix()

Gets the namespace prefix of this node.

Node getPreviousSibling()

Gets the node preceding the current node.

boolean hasAttributes()

Returns True if this node has any attributes.

boolean hasChildNodes()

Returns True if this node has any children.

Node insertBefore(Node newChild, Node refChild)

Inserts the new node before a reference child node.

void normalize()

Transforms all text nodes into XML normalized form.

Node removeChild(Node oldChild)

Removes a child node and returns it.

Node replaceChild(Node newChild, Node oldChild)

Replaces the child node.

void setNodeValue(String nodeValue)

Sets the node's value.

void setPrefix(String prefix)

Sets the namespace prefix of the node.

The childLoop method has a node and an indentation string passed to it. To handle the current node and store its data in the displayText array, first check whether the current node is valid, and if it is, get its type by using the getNodeType method:

public static void childLoop(Node node, String indentation)
{
    if (node == null) {

           return;

       }


       int type = node.getNodeType();
        .
        .
        .
}

Now that you know the type of the node you've been passed, how do you handle it and store its data in the array of strings that will be printed out? You have to handle different types of nodes in different ways, and in this case, you'll use a Java switch statement to work with different node types, starting with the document node itself.

Handling Document Nodes

You can compare the type of the current node to the fields listed in Table 16.4 to determine what kind of node you're dealing with. For example, if the current node is a document node, you'll just put a generic XML declaration into the display string's array, storing that text in the displayText array and incrementing the array's index value, numberLines, like this:

public static void childLoop(Node node, String indentation)
{
    if (node == null) {
        return;
    }

    int type = node.getNodeType();

    switch (type) {

           case Node.DOCUMENT_NODE: {

               displayText[numberLines] = indentation;

               displayText[numberLines] += "<?xml version=\"1.0\" encoding=\""+

                 "UTF-8" + "\"?>";

               numberLines++;

               childLoop(((Document)node).getDocumentElement(), "");

               break;

            }

   
              .
   

   
              .
   

   
              .
   

Now you've displayed a generic XML declaration for the start of the XML document. Next, you'll handle elements.

Handling Elements

Elements have the type Node.ELEMENT_NODE, and you can get the name of the element by using the W3C DOM method getNodeName. Here's what it looks like in the childLoop method's switch statement, which lets you handle the various node types:

case Node.ELEMENT_NODE: {
    displayText[numberLines] = indentation;
    displayText[numberLines] += "<";
    displayText[numberLines] += node.getNodeName();
        .
        .
        .

This gives us the name of the current element, but what if it has attributes? You'll check that next.

Handling Attributes

To see whether the element you're working on has any attributes, you can use the getAttributes method, which returns NamedNodeMap object, which contains the element's attributes. If there are any attributes, you'll store them in an array and then use the getNodeName method to get the attribute's name, and you'll use the getNodeValue method to get the attribute's value:

int length = (node.getAttributes() != null) ?
    node.getAttributes().getLength() : 0;
Attr attributes[] = new Attr[length];
for (int loopIndex = 0; loopIndex < length; loopIndex++) {
    attributes[loopIndex] = (Attr)node.getAttributes().item(loopIndex);
}

for (int loopIndex = 0; loopIndex < attributes.length; loopIndex++) {
    Attr attribute = attributes[loopIndex];
    displayText[numberLines] += " ";
    displayText[numberLines] += attribute.getNodeName();
    displayText[numberLines] += "=\"";
    displayText[numberLines] += attribute.getNodeValue();
    displayText[numberLines] += "\"";
}
displayText[numberLines] += ">";

numberLines++;

Table 16.6 lists the methods of NamedNodeMap.

Table 16.6. NamedNodeMap Methods

Method

What It Does

int getLength()

Returns the number of nodes.

Node getNamedItem(java.lang.String name)

Gets a node specified by the name.

Node getNamedItemNS(java.lang.String namespaceURI, java.lang.String localName)

Gets a node specified by the local name and namespace URI.

Node item(int index)

Gets an item in the map by index.

Node removeNamedItem(java.lang.String name)

Removes a node.

Node removeNamedItemNS(java.lang.String namespaceURI, java.lang.String localName)

Removes the given node with a local name and namespace URI.

Table 16.7 lists the methods of Attr objects, which hold attributes.

Table 16.7. Attr Interface Methods

Method

What It Does

java.lang.String getName()

Gets the name of this attribute.

Element getOwnerElement()

Gets this attribute's element node.

boolean getGiven()

Returns True if this attribute was given a value in the original document.

java.lang.String getValue()

Gets the value of the attribute.

void setValue(String value)

Sets the value of the attribute.

Now you've handled the current element's name and attributes. But what if the element has child nodes, such as text nodes or child elements? That's coming up next.

Handling Child Nodes

Elements can have child nodes, so before you finish up with elements, you'll also loop over those child nodes by calling the childLoop again recursively. You can use the following to get a NodeList interface of child nodes by using the getChildNodes method, increase the indentation level by four spaces, and call childLoop for each child node:

    NodeList childNodes = node.getChildNodes();
    if (childNodes != null) {
        length = childNodes.getLength();
        indentation += "    ";
        for (int loopIndex = 0; loopIndex < length; loopIndex++ ) {
           childLoop(childNodes.item(loopIndex), indentation);
        }
    }
    break;
}

The NodeList interface supports an ordered collection of nodes. Table 26.8 lists the methods of the NodeList interface.

Table 16.8. NodeList Methods

Method

What It Does

int getLength()

Returns the number of nodes.

Node item(int index)

Gets the item at a specified index.

Now that you have handled elements, attributes, and child nodes, you'll take a look at how to work with text nodes.

Handling Text Nodes

Text nodes are of type Node.TEXT_NODE, and after you check to make sure a node is a valid text node, you can trim extra spaces (such as indentation text) from the text node's value and add it to the displayText array, like this:

case Node.TEXT_NODE: {
    displayText[numberLines] = indentation;
    String trimmedText = node.getNodeValue().trim();
    if(trimmedText.indexOf("\n") < 0 && trimmedText.length() > 0) {
        displayText[numberLines] += trimmedText;
        numberLines++;
    }
    break;
}

Handling Processing Instructions

Handling processing instructions is not difficult; you just use getNodeName to get the processing instruction and the getNodeValue method to get the processing instruction's data. Here's how that works in the childLoop method's switch statement:

case Node.PROCESSING_INSTRUCTION_NODE: {
    displayText[numberLines] = indentation;
    displayText[numberLines] += "<?";
    displayText[numberLines] += node.getNodeName();
    String text = node.getNodeValue();
    if (text != null && text.length() > 0) {
        displayText[numberLines] += text;
    }
    displayText[numberLines] += "?>";
    numberLines++;
    break;
}

Handling CDATA Sections

Handling CDATA sections is just as easy as handling other nodes: You just use the getNodeValue method to get the CDATA section's data. Here's what that looks like in the childLoop method's switch statement:

case Node.CDATA_SECTION_NODE: {
    displayText[numberLines] = indentation;
    displayText[numberLines] += "<![CDATA[";
    displayText[numberLines] += node.getNodeValue();
    displayText[numberLines] += "]]>";
    numberLines++;
    break;
        }
    }

Ending Elements

Our last task is to add a closing tag for element nodes. Up to this point, you've only displayed an opening tag for each element and its attributes, but no closing tag. Here's how to add the closing tag with some code at the end of the childLoop method:

    if (type == Node.ELEMENT_NODE) {
        displayText[numberLines] = indentation.substring(0,
            indentation.length() - 4);
        displayText[numberLines] += "</";
        displayText[numberLines] += node.getNodeName();
        displayText[numberLines] += ">";
        numberLines++;
        indentation += "    ";
    }
}

That's it; Listing 16.2 shows all the code in ch16_02.java.

Example 16.2. Parsing XML Documents by Using Java (ch16_02.java)

import javax.xml.parsers.*;
import org.w3c.dom.*;

public class ch16_02
{
    static String displayText[] = new String[1000];
    static int numberLines = 0;

    public static void main(String args[])
    {
        try {
            DocumentBuilderFactory factory =
                DocumentBuilderFactory.newInstance();

            DocumentBuilder builder = null;
            try {
                builder = factory.newDocumentBuilder();
            }
            catch (ParserConfigurationException e) {}

            Document document = null;
            document = builder.parse(args[0]);

            childLoop(document, "");

        } catch (Exception e) {
            e.printStackTrace(System.err);
        }

        for(int loopIndex = 0; loopIndex < numberLines; loopIndex++){
            System.out.println(displayText[loopIndex]) ;
        }
    }

    public static void childLoop(Node node, String indentation)
    {
        if (node == null) {
            return;
        }

        int type = node.getNodeType();

        switch (type) {
            case Node.DOCUMENT_NODE: {
                displayText[numberLines] = indentation;
                displayText[numberLines] +=
                    "<?xml version=\"1.0\" encoding=\""+
                  "UTF-8" + "\"?>";
                numberLines++;
                childLoop(((Document)node).getDocumentElement(), "");
                break;
             }

             case Node.ELEMENT_NODE: {
                 displayText[numberLines] = indentation;
                 displayText[numberLines] += "<";
                 displayText[numberLines] += node.getNodeName();

                 int length = (node.getAttributes() != null) ?
                     node.getAttributes().getLength() : 0;
                 Attr attributes[] = new Attr[length];
                 for (int loopIndex = 0; loopIndex < length; loopIndex++) {
                     attributes[loopIndex] =
                         (Attr)node.getAttributes().item(loopIndex);
                 }

                 for (int loopIndex = 0; loopIndex < attributes.length;
                     loopIndex++) {
                     Attr attribute = attributes[loopIndex];
                     displayText[numberLines] += " ";
                     displayText[numberLines] += attribute.getNodeName();
                     displayText[numberLines] += "=\"";
                     displayText[numberLines] += attribute.getNodeValue();
                     displayText[numberLines] += "\"";
                 }
                 displayText[numberLines] += ">";

                 numberLines++;

                 NodeList childNodes = node.getChildNodes();
                 if (childNodes != null) {
                     length = childNodes.getLength();
                     indentation += "    ";
                     for (int loopIndex = 0; loopIndex < length; loopIndex++ ) {
                        childLoop(childNodes.item(loopIndex), indentation);
                     }
                 }
                 break;
             }

             case Node.TEXT_NODE: {
                 displayText[numberLines] = indentation;
                 String trimmedText = node.getNodeValue().trim();
                 if(trimmedText.indexOf("\n") < 0 && trimmedText.length() > 0){
                     displayText[numberLines] += trimmedText;
                     numberLines++;
                 }
                 break;
             }

             case Node.PROCESSING_INSTRUCTION_NODE: {
                 displayText[numberLines] = indentation;
                 displayText[numberLines] += "<?";
                 displayText[numberLines] += node.getNodeName();
                 String text = node.getNodeValue();
                 if (text != null && text.length() > 0) {
                     displayText[numberLines] += text;
                 }
                 displayText[numberLines] += "?>";
                 numberLines++;
                 break;
             }

             case Node.CDATA_SECTION_NODE: {
                 displayText[numberLines] = indentation;
                 displayText[numberLines] += "<![CDATA[";
                 displayText[numberLines] += node.getNodeValue();
                 displayText[numberLines] += "]]>";
                 numberLines++;
                 break;
            }
        }

        if (type == Node.ELEMENT_NODE) {
            displayText[numberLines] = indentation.substring(0,
                indentation.length() - 4);
            displayText[numberLines] += "</";
            displayText[numberLines] += node.getNodeName();
            displayText[numberLines] += ">";
            numberLines++;
            indentation += "    ";
        }
    }
}

Now compile ch16_02.java by using javac, the Java compiler:

%javac ch16_02.java

This creates ch16_02.class, which is ready to be run. Use the following to run this .class file to extract all the data from ch16_01.xml:

%java ch16_02 ch16_01.xml

Figure 16.1 shows the results of this example in a Windows MS-DOS window. So far today, you've been able to extract all the data in an XML document, format it, and display it.

16fig01.gif

Figure 16.1 Parsing an XML document by using Java.

+ Share This