Java eLearning Kit For Dummies (2014)

The ProcessElements() method begins by displaying the current level. It then adds a number of tabs to indent the information at higher levels to a greater degree. The method displays the element name next and then displays the value contained within that element, if any. Notice how the code uses the getNodeType() method to obtain the type of the current node and compare it against a known node type, which is Node.TEXT_NODE for an element value.

At this point, the code must ask whether there are any child nodes to process. For example, the <Root> element will have child nodes, but the <Fruit> element doesn’t. When there are child elements to process, the code creates a NodeList object, ChildNodes, to access them. It then processes each node in turn. When the node type is Node.ELEMENT_NODE, the method coerces the type (changes it, essentially) into an Element, ChildElement, and uses ChildElement to recursively call ProcessElements(). Notice that performing this recursive call increases the Levelvalue.

Any time you use recursion, you must provide a method for the recursive routine to stop. In this case, recursion continues only as long as there are nodes of type Node.ELEMENT_NODE to process. When the code runs out of these nodes to process, the application automatically stops calling the ProcessElements() method recursively. If you don’t provide an escape mechanism, the code will continue to run infinitely, and the system will eventually run out of memory (causing a system crash).

3. Type javac ReadXML.java and press Enter.

The compiler compiles your application and creates a .class file from it.

4. Type java ReadXML and press Enter.

The application displays a hierarchical list of the nodes within the XML file, as shown in Figure 13-1. Notice how the level numbering and the indentation show precisely how the data is organized within the file.

Figure 13-1:

Writing XML Data to Disk

Reading XML data and creating a document that is stored in memory from it is only half the process. If you want to use XML to permanently store information on disk, you must also know how to write it.

The following example demonstrates how to create the XML document used in the ReadXML example, MyData.xml. The example will then add some information to the XML document stored in memory and write the data to disk as an XML file.

Files needed: WriteXML.java

1. Open the editor or IDE that you’ve chosen to use for this book.

2. Type the following code into the editor screen.

// Import the required API classes.
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Text;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.dom.DOMSource;
import java.io.File;
import javax.xml.transform.stream.StreamResult;

public class WriteXML
{
public static void main(String[] args)
{
// Create a factory for building an XML document.
DocumentBuilderFactory Factory =
DocumentBuilderFactory.newInstance();

// Create an object to build a document.
DocumentBuilder Builder = null;
try
{
Builder = Factory.newDocumentBuilder();
}
catch (ParserConfigurationException e)
{
// Display an error message and exit.
System.out.println("Could not create document builder!"
+ e.getMessage());
return;
}

// Create a document using the document builder.
Document XMLDoc = Builder.newDocument();

// Every XML document must have a root element.
Element Root = XMLDoc.createElement("Root");

// Add the root element to the document.
XMLDoc.appendChild(Root);

// Add a name element to the root.
Element Child = XMLDoc.createElement("Name");
Text ChildData = XMLDoc.createTextNode("Sally");
Child.appendChild(ChildData);
Root.appendChild(Child);

// Create a favorite fruits list.
Element Fruits = XMLDoc.createElement("Fruits");
Root.appendChild(Fruits);

// Add a favorite fruit element to Fruits.
Child = XMLDoc.createElement("Fruit");
ChildData = XMLDoc.createTextNode("Apple");
Child.appendChild(ChildData);
Fruits.appendChild(Child);

// Add a favorite fruit element to Fruits.
Child = XMLDoc.createElement("Fruit");
ChildData = XMLDoc.createTextNode("Pear");
Child.appendChild(ChildData);
Fruits.appendChild(Child);

// Add a favorite color element to the root.
Child = XMLDoc.createElement("Color");
ChildData = XMLDoc.createTextNode("Blue");
Child.appendChild(ChildData);
Root.appendChild(Child);

// Create a factory for transforming the memory
// representation of the XML document into an
// actual XML document.
TransformerFactory TFactory =
TransformerFactory.newInstance();

// Create a transformer to perform the work.
Transformer CreateResult = null;
try
{
CreateResult = TFactory.newTransformer();
}
catch (TransformerConfigurationException e)
{
// Display an error message and exit.
System.out.println("Could not create transformer!"
+ e.getMessage());
return;
}

// Define a Document Object Model source used as a
// basis for the output document.
DOMSource Source = new DOMSource(XMLDoc);

// Define a file to receive the XML document.
File OutputFile = new File("MyData.xml");

// Define a stream to transfer the file.
StreamResult Result = new StreamResult(OutputFile);

// Perform the transformation required to output
// the document to disk.
try
{
CreateResult.transform(Source, Result);
}
catch (TransformerException e)
{
// Display an error message and exit.
System.out.println("Could not save XML document!"
+ e.getMessage());
}

// Display a success message.
System.out.println("Document successfully saved!");
}
}

As with the ReadXML example, this example requires a relatively large number of imports that are listed in the order in which they’re used. The application begins with the same process used for reading an XML file: creating a DocumentBuilderFactory, using the Factory to create aDocumentBuilder, and then calling on Builder to create a new XML document, XMLDoc. This same process occurs in just about every XML application you create.

Every XML document starts with a RootElement that the code creates using createElement(). The code appends Root to XMLDoc to begin building the XML document.

When working with an Element — Child, in this case — that contains a value, the value is contained within a Text object — ChildData here. The code appends ChildData to Child (the element contains the value) and then appends Child to Root (the root-element contains all of the top level elements). Each top-level element follows the same process.

Second-level elements are appended to first-level elements. For example, Fruits is a first-level element. It contains two second-level Fruit elements, one with a value of Apple and another with a value of Pear. Notice how the code appends the Child elements to the appropriate parent.

At some point, the code has created an XML document. This isn’t XML data suitable for writing to disk because it’s in a form that’s more useful for working with the data in memory. The code creates a TransformerFactory, TFactory, to create a Transformer object, CreateResult, that transforms the XML document into XML data that the application can then write to disk.