Sams Teach Yourself XML in 21 Days

Recommended Book

Sams Teach Yourself XML in 21 Days, 3rd Edition

Learn More Buy

Recommended Book

Recommended Book 

Sams Teach Yourself XML in 21 Days, 3rd Edition

Learn More Buy

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

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

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

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

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

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

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

Table 16.7. Attr Interface Methods

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

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

set classpath=.

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.

Figure 16.1 Parsing an XML document by using Java.