Java XML parser Tutorial

In this tutorial, we will discuss the Java XML parser or how to read XML files. XML is a markup language that defines a set of rules for encoding documents. Java offers a number of libraries in order to parse and process XML documents. Java xml parser examples provides the required functionality to read and modify an XML file.

The XML language is used to provide a general way in order for different machines to communicate and exchange data. Like Java, XML is also platform independent. An XML document consists of elements. Each element has a start tag, its content and an end tag. Also, an XML document must have exactly one root element. Finally, an XML file has a strict syntax and form.

1. Example of an XML File

In the following java XML parser examples, we will declare the employees of a company. Each employee has a unique ID, first and last name, age, and salary. The employees are separated by their IDs. We create a new file called Employees.xml as shown below:

Employees.xml

Also, in order to capture the notion of an employee, we create its respective Java class, called Employee.java as shown below:

Employee.java:

2. Parse an XML File using the DOM Parser

The DOM parser implementation is included in the release of JDK. The Document Object Model provides APIs that let you create, modify, delete, and rearrange nodes. The DOM parser parses the entire XML document and loads the XML content into a Tree structure. Using the Node and NodeList classes, we can retrieve and modify the content of an XML file.

A sample example that loads the content of an XML file and prints its contents is shown below:

DomParserExample.java:

Inside the main method, we create a DocumentBuilder from the DocumentBuilderFactory and then, parse and store the XML file in an instance of the Document class. Then, we parse that document and when we find a node of type Node.ELEMENT_NODE, we retrieve all its information and store them in an instance of the Employee class. Finally, we print the information of all stored employees.

A sample execution is shown below:

<1, Lebron, James, 30, 2500.0>
<2, Anthony, Davis, 22, 1500.0>
<3, Paul, George, 24, 2000.0>
<4, Blake, Griffin, 25, 2250.0>

3. Parse an XML File using the SAX Parser

SAX is an event-based sequential access parser API and provides a mechanism for reading data from an XML document that is an alternative to that provided by a DOM parser. A SAX parser only needs to report each parsing event as it happens and the minimum memory required for a SAX parser is proportional to the maximum depth of the XML file.

Our SAX parser extends the DefaultHandler class, in order to provide the following callbacks:

• startElement: this event is triggered when a start tag is encountered.
• endElement: – this event is triggered when an end tag is encountered.
• characters: – this event is triggered when some text data is encountered.

A sample example of a SAX parser is shown below:

SaxParserExample.java:

A sample execution is shown below:

<1, Lebron, James, 30, 2500.0>
<2, Anthony, Davis, 22, 1500.0>
<3, Paul, George, 24, 2000.0>
<4, Blake, Griffin, 25, 2250.0>

4. Parse an XML File using the StAX Parser

Streaming API for XML (StAX) is an application programming interface to read and write XML documents. The StAX parser is an XML parser that is able to process tree-like structured data as the data gets streamed-in. StAX was designed as a median between DOM and SAX parsers. In a StAX parser, the entry point is a cursor that represents a point within the XML document. The application moves the cursor forward, in order to pull the information from the parser. In contrast, a SAX parser pushes data to the application, instead of pulling.

A sample example of a StAX parser is shown below:

StaxParserExample.java:

A sample execution is shown below:

<1, Lebron, James, 30, 2500.0>
<2, Anthony, Davis, 22, 1500.0>
<3, Paul, George, 24, 2000.0>
<4, Blake, Griffin, 25, 2250.0>

5. Parse an XML using JAXB

Java Architecture for XML Binding (JAXB) provides a fast and convenient way to bind XML schemas and Java representations, making it easy for Java developers to incorporate XML data and processing functions in Java applications. As part of this process, JAXB provides methods for unmarshalling (reading) XML instance documents into Java content trees and then marshaling (writing) Java content trees back into XML instance documents. JAXB also provides a way to generate XML schema from Java objects.

JAXB annotations defined in javax.xml.bind.annotation package can be used to customize Java program elements to XML schema mapping. Let us now check the marshall and unmarshall features using an example.

The EmployeeData class contains all the attributes that will map to XML schema. Notice the annotations @XmlRootElement, @XmlAttribute and @XmlElementto indicate the root XML element, attribute, and elements.

EmployeeData.java

package main.java;

import javax.xml.bind.annotation.*;

/*
* Employee class to map the XML schema
*/
@XmlRootElement(name="employee")
public class EmployeeData {
	@XmlAttribute(name="id")
	private String ID;
	@XmlElement(name="firstName")
    private String Firstname;
	@XmlElement(name="lastName")
    private String Lastname;
	@XmlElement(name="age")
    private Integer age;
	@XmlElement(name="salary")
    private Double salary;
    
    public EmployeeData() {}

    public EmployeeData(String ID, String Firstname, String Lastname, Integer age, Double salary) {
    	this.ID = ID;
    	this.Firstname = Firstname;
    	this.Lastname = Lastname;
    	this.age = age;
    	this.salary = salary;
    }

    public void setID(String ID) {
		this.ID = ID;
	}

	public void setFirstname(String firstname) {
		this.Firstname = firstname;
	}

	public void setLastname(String lastname) {
		this.Lastname = lastname;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	public void setSalary(Double salary) {
		this.salary = salary;
	}

	@Override
    public String toString() {
            return "";
    }
}

The Employees class is created to hold list of all employees. Note that we defined the @XmlRootElement as employees and employeeData as @XmlElement.

Employees.java

package main.java;

import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import java.util.ArrayList;
import java.util.List;
import main.java.EmployeeData;

/*
* Schema to hold multiple employee objects
*/
@XmlRootElement(name = "employees")
public class Employees {
    List employees;
    public List getEmployees() {
        return employees;
    }

    @XmlElement(name = "employeeData")
    public void setEmployees(List employees) {
        this.employees = employees;
    }

    public void add(EmployeeData employeeData) {
        if (this.employees == null) {
            this.employees = new ArrayList();
        }
        this.employees.add(employeeData);

    }
	
	@Override
    public String toString() {
		System.out.println("Our employee list after unmarshall is : ");
            StringBuffer str = new StringBuffer();
			for (EmployeeData emp : employees){
				str = str.append(emp.toString());
			}
			return str.toString();
    }

}

The JAXBExample class provides the marshall and unmarshall operations.

JAXBExample.java

package main.java;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import java.io.File;
import main.java.EmployeeData;
import main.java.Employees;


/*
* Class to check marshall and unmarshall
*/
public class JAXBExample{
	public static void main(String args[]){
		// Create the employee list
		Employees empList = new Employees();
		EmployeeData data1 = new EmployeeData("1","Charlie","Chaplin",35,2000.00);
		EmployeeData data2 = new EmployeeData("2","John","Rambo",36,2500.00);
		empList.add(data1);
		empList.add(data2);
		
		try{
			// Marshall
			JAXBContext jaxbContext = JAXBContext.newInstance(Employees.class);
			Marshaller marshaller = jaxbContext.createMarshaller();
			marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
			marshaller.marshal(empList, new File("employee.xml"));
			marshaller.marshal(empList, System.out);	

			// Unmarshall
			File file = new File("employee.xml");
			jaxbContext = JAXBContext.newInstance(Employees.class);
			Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
			empList = (Employees) unmarshaller.unmarshal(file);
			System.out.println(empList);		
			
		} catch (JAXBException jaxbe){
			jaxbe.printStackTrace();
		} catch (Exception fnfe) {
			fnfe.printStackTrace();
		}
	}
}

Executing the above JAXBExample class gives the below output.

6. Download the Eclipse Project

This was a tutorial about java parser xml or how to read xml file.

Last updated on Oct. 08, 2019

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!

1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design

and many more ....

I agree to the Terms and Privacy Policy

Sign up

Thank you!

We will contact you soon.