XML Parsing with JAVA with Example

Writing XML documents is very straightforward, but reading them is not nearly as

simple. Fortunately, we can use an XML parser to read the document for us. The

XML parser exposes the contents of an XML document through an API. A client

application reads an XML document through this API. As well as reading the

document and providing the contents to the client application, the parser also checks

the document for well-formedness and (optionally) validity. If it finds an error, it

informs the client application.

XML parser is a software module to read documents and a means to provide access to

their content. XML parser generates a structured tree to return the results to the

browser. An XML parser is similar to a processor that determines the structure and

properties of the data. An XML parser can read a XML document to create an output

to generate a display form. Now, XML parser for Java runs on any platform where

there is Java virtual machine. It is sometimes called XML4J. It has an interface which

allows you to take a string of XML formatted text, pick the XML tags and use them to

extract the tagged information.

Among the various XML parsers, the two mostly used ones are SAX parser & DOM

parser. Here is a brief description of these two different parsers.

SAX

SAX, the Simple API for XML, is the gold standard of XML APIs. It is the most

complete and correct by far. Given a fully validating parser that supports all its

optional features, there is very little you can’t do with it. It has one or two holes, but

they're really off in the weeds of the XML specifications, and you have to look pretty

hard to find them. SAX is an event driven API. The SAX classes and interfaces model

the parser, the stream from which the document is read, and the client application

receiving data from the parser. However, no class models the XML document itself.

Instead the parser feeds content to the client application through a callback interface,

much like the ones used in Swing and the AWT. This makes SAX very fast and very

memory efficient (since it doesn’t have to store the entire document in memory).

However, SAX programs can be harder to design and code because you normally

need to develop your own data structures to hold the content from the document.

SAX works best when your processing is fairly local; that is, when all the information

you need to use is close together in the document. For example, you might process

one element at a time. Applications that require access to the entire document at once

in order to take useful action would be better served by one of the tree-based APIs

like DOM or JDOM. Finally, because SAX is so efficient, it’s the only real choice for

truly huge XML documents. Of course, “truly huge” has to be defined relative to

available memory. However, if the documents you're processing are in the gigabyte

range, you really have no choice but to use SAX.

DOM

DOM, the Document Object Model, is a fairly complex API that models an XML

document as a tree. Unlike SAX, DOM is a read-write API. It can both parse existing

XML documents and create new ones. Each XML document is represented as

Document object. Documents are searched, queried, and updated by invoking methods

on this Document object and the objects it contains. This makes DOM much more

convenient when random access to widely separated parts of the original document is

required. However, it is quite memory intensive compared to SAX, and not nearly as

well suited to streaming applications.

Ahead in the document I have included example of XML parsing with Java using both

of these parsers.

XML Parsing with JAVA

I would like to start with an example of how to parse a XML file create Java Objects

and manipulate them.

The idea here is to parse the employees.xml file with content as below

<?xml version="1.0" encoding="UTF-8"?>

<Office>

<Employee type="permanent">

<Name>Debamalya</Name>

<Id>235960</Id>

<Age>25</Age>

</Employee>

<Employee type="contract">

<Name>Rishin</Name>

<Id>3675</Id>

<Age>24</Age>

</Employee>

<Employee type="permanent">

<Name>Debalina</Name>

<Id>3676</Id>

<Age>28</Age>

</Employee>

</Office>

From the parsed content create a list of Employee objects and print it to the console.

The output would be something like

Employee Details - Name:Debamalya, Type:permanent, Id:235960, Age:25.

Employee Details - Name:Rishin, Type:contract, Id:3675, Age:24.

Employee Details - Name:Debalina, Type:permanent, Id:3676, Age:28.

I will start with a DOM parser to parse the xml file, create Employee value objects

and add them to a list. To ensure we parsed the file correctly let's iterate through the

list and print the employees data to the console. Later we will see how to implement

the same using SAX parser.

In a real world situation you might get an xml file from a third party vendor which

you need to parse and update your database.

Using DOM Parser:

This program DomParserExample.java uses DOM API.

The steps are

• Get a document builder using document builder factory and parse the xml file

to create a DOM object.

• Get a list of employee elements from the DOM.

• For each employee element get the id, name, age and type. Create an

employee value object and add it to the list.

• At the end iterate through the list and print the employees to verify we parsed

it right.

a) Getting a document builder

private void parseXmlFile(){ 
 DocumentBuilderFactory dbf = 
   DocumentBuilderFactory.newInstance(); 

 try { 
  //Using factory get an instance of document builder 
  DocumentBuilder db = dbf.newDocumentBuilder(); 
  //parse using builder to get DOM representation of the XML 
  file 
  dom = db.parse("employees.xml"); 

 }catch(ParserConfigurationException pce) { 
  pce.printStackTrace(); 
 }catch(SAXException se) { 
  se.printStackTrace(); 
 }catch(IOException ioe) { 
  ioe.printStackTrace(); 
 } 
}

b) Get a list of employee elements

Get the rootElement from the DOM object. From the root element get all employee

elements. Iterate through each employee element to load the data.

private void parseDocument(){ 
 //get the root element 
 Element docEle = dom.getDocumentElement(); 

 //get a nodelist of elements 
 NodeList nl = 
   docEle.getElementsByTagName("Employee"); 
 if(nl != null && nl.getLength() > 0) { 
  for(int i = 0 ; i < nl.getLength();i++) { 

   //get the employee element 
   Element el = (Element)nl.item(i); 

   //get the Employee object 
   Employee e = getEmployee(el); 

   //add it to list 
   myEmpls.add(e); 
  } 
 } 
}

c) Reading in data from each employee.

/** 
 * I take an employee element and read the values in, create 
 * an Employee object and return it 
 */ 
private Employee getEmployee(Element empEl) { 

 //for each  element get text or int values of //name ,id, age and name 
 String name = getTextValue(empEl,"Name"); 
 int id = getIntValue(empEl,"Id"); 
 int age = getIntValue(empEl,"Age"); 

 String type = empEl.getAttribute("type"); 

 //Create a new Employee with the value read from the xml nodes 
 Employee e = new Employee(name,id,age,type); 

 return e; 
} 

/** 
 * I take a xml element and the tag name, look for the tag 
and  
 * get the text content 
 * i.e for Deb xml snippet 
if 
 * the Element points to employee node and tagName is  
 *'name' I will return Deb 
 */ 
private String getTextValue(Element ele, String tagName) { 
 String textVal = null; 
 NodeList nl = ele.getElementsByTagName(tagName); 
 if(nl != null && nl.getLength() > 0) { 
  Element el = (Element)nl.item(0); 
  textVal = el.getFirstChild().getNodeValue(); 
 } 

 return textVal; 
} 

/** 
 * Calls getTextValue and returns a int value 
 */ 
private int getIntValue(Element ele, String tagName) { 
 //in production application you would catch the exception 
 return Integer.parseInt(getTextValue(ele,tagName)); 
} 

d) Iterating and printing.

private void printData(){ 
 System.out.println("No of Employees '" + myEmpls.size() + 
   "'."); 
 Iterator it = myEmpls.iterator(); 
 while(it.hasNext()) { 
  System.out.println(it.next().toString()); 
 } 
}

Using SAX Parser:

This program SAXParserExample.java parses a XML document and prints it on the

console.

Sax parsing is event based modeling. When a Sax parser parses a XML document and

every time it encounters a tag it calls the corresponding tag handler methods.

When it encounters a Start Tag it calls this method

public void startElement(String uri,..

When it encounters a End Tag it calls this method

public void endElement(String uri,...

Like the DOM example this program also parses the xml file, creates a list of

employees and prints it to the console. The steps involved are

• Create a Sax parser and parse the xml

• In the event handler create the employee object

• Print out the data

Basically the class extends DefaultHandler to listen for call back events. And we

register this handler with the Sax parser to notify us of call back events. We are only

interested in start event, end event and character event.

In start event if the element is employee we create a new instant of employee object

and if the element is Name/Id/Age we initialize the character buffer to get the text

value.

In end event if the node is employee then we know we are at the end of the employee

node and we add the Employee object to the list. If it is any other node like

Name/Id/Age we call the corresponding methods like setName/SetId/setAge on the

Employee object. Java Bean classes can be used for this. In character event we store

the data in a temp string variable.

a) Create a Sax Parser and parse the xml

private void parseDocument() { 

 //get a factory 
 SAXParserFactory spf = 
   SAXParserFactory.newInstance(); 
 try { 

  //get a new instance of parser 
  SAXParser sp = spf.newSAXParser(); 

  //parse the file and also register this class for call backs 
  sp.parse("employees.xml", this); 

 }catch(SAXException se) { 
  se.printStackTrace(); 
 }catch(ParserConfigurationException pce) { 
  pce.printStackTrace(); 
 }catch (IOException ie) { 
  ie.printStackTrace(); 
 } 
} 

b) In the event handlers create the Employee object and call the corresponding setter

methods.

public void startElement(String uri, String localName, String 
  qName, Attributes attributes) throws SAXException { 
 //reset 
 tempVal = ""; 
 if(qName.equalsIgnoreCase("Employee")) { 
  //create a new instance of employee 
  tempEmp = new Employee(); 
  tempEmp.setType(attributes.getValue("type")); 
 } 
} 

public void characters(char[] ch, int start, int length) 
  throws SAXException { 
 tempVal = new String(ch,start,length); 
} 

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

 if(qName.equalsIgnoreCase("Employee")) { 
  //add it to the list 
  myEmpls.add(tempEmp); 

 }else if (qName.equalsIgnoreCase("Name")) { 
  tempEmp.setName(tempVal); 
 }else if (qName.equalsIgnoreCase("Id")) { 
  tempEmp.setId(Integer.parseInt(tempVal)); 
 }else if (qName.equalsIgnoreCase("Age")) { 
  tempEmp.setAge(Integer.parseInt(tempVal)); 
 } 

}

c) Iterating and printing.

private void printData(){ 
 
 System.out.println("No of Employees '" + myEmpls.size() + 
"'."); 
 
  Iterator it = myEmpls.iterator(); 
  while(it.hasNext()) { 
   System.out.println(it.next().toString()); 
  } 
 }

Writing XML with Java

The previous programs illustrated how to parse an existing XML file using both SAX

and DOM Parsers. But generating a XML file from scratch is a different story, for

instance you might like to generate an xml file for the data extracted from a database.

To keep the example simple this program XMLCreatorExample.java generates XML

from a list preloaded with hard coded data. The output will be book.xml file with the

following content.

<?xml version="1.0" encoding="UTF-8"?>

<Books>

<Book Subject="Java 1.5">

<Author>Kathy Sierra .. etc</Author>

<Title>Head First Java</Title>

</Book>

<Book Subject="Java Architect">

<Author>Kathy Sierra .. etc</Author>

<Title>Head First Design Patterns</Title>

</Book>

</Books>

The steps involved are

• Load Data

• Get an instance of Document object using document builder factory

• Create the root element Books

• For each item in the list create a Book element and attach it to Books element

• Serialize DOM to FileOutputStream to generate the xml file "book.xml".

a) Load Data.

/** 
 * Add a list of books to the list 
 * In a production system you might populate the list from a db
 */ 
private void loadData(){ 
 myData.add(new Book("Head First Java", 
   "Kathy Sierra .. etc","Java 1.5")); 
 myData.add(new Book("Head First Design Patterns", 
   "Kathy Sierra .. etc","Java Architect")); 
} 

b) Getting an instance of DOM.

/** 
 * Using JAXP in implementation independent manner create a 
document object 
 * using which we create a xml tree in memory 
 */ 
private void createDocument() { 

 //get an instance of factory 
 DocumentBuilderFactory dbf = 
   DocumentBuilderFactory.newInstance(); 
 try { 
  //get an instance of builder 
  DocumentBuilder db = dbf.newDocumentBuilder(); 

  //create an instance of DOM 
  dom = db.newDocument(); 

 }catch(ParserConfigurationException pce) { 
  //dump it 
  System.out.println("Error while trying to 
    instantiate DocumentBuilder " + pce); 
    System.exit(1); 
 } 

} 

}

c) Create the root element Books.

/** 
 * The real workhorse which creates the XML structure 
 */ 
private void createDOMTree(){ 

 //create the root element  

 Element rootEle = dom.createElement("Books"); 
 dom.appendChild(rootEle); 

 //No enhanced for 
 Iterator it  = myData.iterator(); 
 while(it.hasNext()) { 
  Book b = (Book)it.next(); 
  //For each Book object  create element and attach it to root 
  Element bookEle = createBookElement(b); 
  rootEle.appendChild(bookEle); 
 } 

}

d) Creating a book element.

/** 
 * Helper method which creates a XML element 
 * @param b The book for which we need to create an xml 
representation 
 * @return XML element snippet representing a book 
 */ 
private Element createBookElement(Book b){ 
 Element bookEle = dom.createElement("Book"); 
 bookEle.setAttribute("Subject", b.getSubject()); 
 //create author element and author text node and attach it to bookElement 
 Element authEle = dom.createElement("Author"); 
 Text authText = dom.createTextNode(b.getAuthor()); 
 authEle.appendChild(authText); 
 bookEle.appendChild(authEle); 
 //create title element and title text node and attach it to bookElement 
 Element titleEle = dom.createElement("Title"); 
    Text titleText = dom.createTextNode(b.getTitle()); 
 titleEle.appendChild(titleText); 
 bookEle.appendChild(titleEle); 
 return bookEle; 
}

e) Serialize DOM to FileOutputStream to generate the xml file "book.xml".

/** 
 * This method uses Xerces specific classes 
 * prints the XML document to file. 
 */ 
private void printToFile(){ 
 try 
 { 
  //print 
  OutputFormat format = new OutputFormat(dom); 
  format.setIndenting(true); 
  //to generate output to console use this serializer 
  //XMLSerializer serializer = new 
  XMLSerializer(System.out, format); 

  //to generate a file output use fileoutputstream instead of 
  system.out 
  XMLSerializer serializer = new XMLSerializer( 
    new FileOutputStream(new File("book.xml")), 
    format); 
  serializer.serialize(dom); 
 } catch(IOException ie) { 
  ie.printStackTrace(); 
 } 
}

Note:

The Xerces internal classes OutputFormat and XMLSerializer are in different

packages.

In JDK 1.5 with built in Xerces parser they are under

com.sun.org.apache.xml.internal.serialize.OutputFormat

com.sun.org.apache.xml.internal.serialize.XMLSerializer

In Xerces 2.7.1 which we are using to run these examples they are under

org.apache.xml.serialize.XMLSerializer

org.apache.xml.serialize.OutputFormat

We are using Xerces 2.7.1 with JDK 1.4 and JDK 1.3 as the default parser with JDK

1.4 is Crimson and there is no built in parser with JDK 1.3.

Also please remember it is not advisable to use parser implementation specific classes

like OutputFormat and XMLSerializer as they are only available in Xerces and if

you switch to another parser in the future you may have to rewrite.

Another example, of writing a XML containing the first 10 Fibonacci numbers is as

follows.

<?xml version="1.0"?>
<Fibonacci_Numbers>
<fibonacci>1</fibonacci>
<fibonacci>1</fibonacci>
<fibonacci>2</fibonacci>
<fibonacci>3</fibonacci>
<fibonacci>5</fibonacci>
<fibonacci>8</fibonacci>
<fibonacci>13</fibonacci>
<fibonacci>21</fibonacci>
<fibonacci>34</fibonacci>
<fibonacci>55</fibonacci>
</Fibonacci_Numbers>

To produce this, just add string literals for the <fibonacci> and </fibonacci> tags

inside the print statements, as well as a few extra print statements to produce the XML

declaration and the root element start- and end-tags. XML documents are just text,

and you can output them any way you’d output any other text document. The

FibonacciXML.java is created for this.

import java.math.BigInteger;

public class FibonacciXML {
 public static void main(String[] args) {
  BigInteger low = BigInteger.ONE;
  BigInteger high = BigInteger.ONE;
  System.out.println("");
  System.out.println("");
  for (int i = 0; i < 10; i++) {
   System.out.print(" ");
   System.out.print(low);
   System.out.println("");
   BigInteger temp = high;
   high = high.add(low);
   low = temp;
  }
  System.out.println("");
 }
}

   

Running Programs in JAVA

The instructions to compile and run these programs vary, based on the JDK that you

are using. This is due to the way the XML parser is bundled with various Java

distributions. These instructions are for Windows OS. For Unix or Linux OS you just

need to change the folder paths accordingly. Xerces parser is bundled with the JDK

1.5 distribution. So you need not download the parser separately.

Running DOMParserExample

1. Place DomParserExample.java, Employee.java, employees.xml to

c:\xercesTest

2. Go to command prompt and type

cd c:\xercesTest

3. To compile, type

javac -classpath . DomParserExample.java

4. To run, type

java -classpath . DomParserExample

Running SAXParserExample

1. Place SAXParserExample.java, Employee.java, employees.xml to

c:\xercesTest

2. Go to command prompt and type

cd c:\xercesTest

3. To compile, type

javac -classpath . SAXParserExample.java

4. To run,type

java -classpath . SAXParserExample

Running XMLCreatorExample

1. Place XMLCreatorExample.java, Book.java to c:\xercesTest

2. Go to command prompt and type

cd c:\xercesTest

3. To compile, type

javac -classpath . XMLCreatorExample.java

4. To run, type

java -classpath . XMLCreatorExample

Running FibonacciXML

1. Place FibonacciXML.java to c:\xercesTest

2. Go to command prompt and type

cd c:\xercesTest

Internal Use 15

XML Parsing with JAVA

3. To compile, type

javac -classpath . FibonacciXML.java

4. To run, type

java -classpath .

Comparison

Both SAX & DOM have there advantages & disadvantages but need to be used

according to the requirement.

SAX:

1.  Parses node by node
2.  Doesn’t store the XML in memory
3.  We can’t insert or delete a node
4.  Top to bottom traversing

DOM

1. Stores the entire XML document into memory before processing.
2. Occupies more memory
3. We can insert or delete nodes
4. Traverse in any direction.

If we need to find a node and doesn’t need to insert or delete we can go with SAX

itself otherwise we can use DOM parser, provided we have enough memory in place.

  

Conclusion

I hope this document will be useable to enlighten a beginner to be able to successfully

code for extracting data from an xml. XMLs are one of the most widely used

structures for storing data, and Java provides the most commonly used parsers. In real

life situations, we receive XMLs from a third party source which are needed to be

parsed & data need to be stored in databases. These motives can be easily met using

DOM or SAX XML parsers in Java.

We can have a JMS configured system where XMLs are received in a

automated way(these can be done using MDB), the same XMLs can be parsed using

Java parsers. The parser code can be scheduled to run automatically using a .ksh

script. The parsed value can be easily stored in oracle databases using simple JDBC

codes. In most of the IT projects XML sizes are usually huge & those are complex. In

such cases it is not possible to use DOM parser, but SAX parser is used frequently.

Although DOM parsers are easier to be coded, SAX parsers are more rapidly used in

case of real-life systems.