First Code School

Java read XML file

by · Published · Updated

XML, or Extensible Markup Language, is a popular web data storage and exchange standard. It provides a standardized way to structure data, making it easier to parse and manipulate. As a Java developer, understanding how to read and process XML files is an important skill to have.

The article covers the basics of reading XML files in Java. It provides an overview of different Java XML processing libraries. The article includes examples of how to read and parse XML files using these libraries. By the end of this article, you’ll have a solid understanding of how to read and process XML files in Java.

Overview of XML Parsing in Java

Introduction to XML Parsing

XML, or eXtensible Markup Language, is widely used for storing and exchanging data. Parsing XML files in Java is a common task in many applications.

Explanation of Different Java XML Processing Libraries

There are several Java XML processing libraries available, including:

1. DOM Parser: A DOM parser loads the entire XML document into memory and creates a tree representation of the document.

2. SAX Parser: A SAX parser is an event-based parser that processes an XML document using callbacks without loading the whole document into memory.

3. StAX Parser: A StAX parser is a median between the DOM and SAX parser, which allows developers to process the XML document in a streaming manner.

4. JAXB: JAXB is an abbreviation for Java Architecture for XML Binding. It converts Java objects into XML and vice versa.

5. XStream: XStream is a simple library used to serialize Java objects to/from XML.

6. Jackson XML: Jackson XML is an extension of the Jackson JSON processor, used to read and write XML encoded data.

7. Apache CXF Aegis: Aegis is a data binding subsystem that can map between Java objects and XML documents described by XML schemas.

8. JiBX: JiBX is a tool used for binding XML data to Java objects.

Comparison of these libraries and their use cases

Each of these Java XML processing libraries has its unique features and use cases. Developers can select the one that best meets their requirements.

For example, DOM parsers are suitable for processing small XML files, whereas SAX parsers are more efficient in processing large XML files. JAXB is best suited for working with complex XML structures, while XStream is ideal for simple XML serialization. Jackson XML and Apache CXF Aegis are better suited for processing and mapping XML data between Java objects. JiBX is a good choice when performance is a crucial factor.

In the next section, we will take a closer look at each of these Java XML processing libraries and learn how to use them.

Java DOM Parser

Explanation of DOM Parser

The Document Object Model (DOM) parser works on the entire XML document, loads it into memory, and constructs a tree representation of the document. This tree can be traversed and manipulated programmatically.

How to use DOM Parser in Java

To use the DOM parser in Java, we first need to create an instance of the DocumentBuilder class, which is part of the javax.xml.parsers package. We can then use this instance to parse an XML file and create a Document object. Here’s an example:

import java.io.File;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.w3c.dom.Node;
import org.w3c.dom.Element;

public class DomParserExample {
    public static void main(String[] args) {
        try {
            File inputFile = new File("input.xml");
            DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
            Document doc = dBuilder.parse(inputFile);
            doc.getDocumentElement().normalize();
            
            // Get a list of all the "company" elements in the document
            NodeList nodeList = doc.getElementsByTagName("company");
            
            // Traverse the list of "company" elements and print out their names and scores
            for (int i = 0; i < nodeList.getLength(); i++) {
                Node node = nodeList.item(i);
                if (node.getNodeType() == Node.ELEMENT_NODE) {
                    Element element = (Element) node;
                    String name = element.getElementsByTagName("name").item(0).getTextContent();
                    String score = element.getElementsByTagName("score").item(0).getTextContent();
                    System.out.println("Name: " + name + ", Score: " + score);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

‘input.xml’:

<?xml version="1.0" encoding="UTF-8"?>
<companies>
     <company>
        <name>FirstCode</name>
        <score>90</score>
    </company>
    <company>
        <name>Google</name>
        <score>92</score>
    </company>
    <company>
        <name>Microsoft</name>
        <score>88</score>
    </company>
</companies>

The code is large and can be downloaded here: (link)

Output:
Name: FirstCode, Score: 90
Name: Google, Score: 92
Name: Microsoft, Score: 88

Code examples for DOM Parser

We can use various methods provided by the Document object to traverse and manipulate the document tree. For example, we can get the root element of the document using the ‘getDocumentElement()’ method, and then get its child nodes using the ‘getChildNodes()’ method. Here’s an example:

import java.io.File;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.w3c.dom.Node;
import org.w3c.dom.Element;

public class DomParser {
    public static void main(String[] args) {
        try {
            File inputFile = new File("input.xml");
            DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
            Document doc = dBuilder.parse(inputFile);
            doc.getDocumentElement().normalize();
            
            // Get a list of all the "person" elements in the document
            // Get the root element of the document
            Element root = doc.getDocumentElement();
            
            // Get all child nodes of the root element
            NodeList nodeList = root.getChildNodes();
            
            // Traverse the child nodes and print their names and values
            for (int i = 0; i < nodeList.getLength(); i++) {
                Node node = nodeList.item(i);
                if (node.getNodeType() == Node.ELEMENT_NODE) {
                    Element element = (Element) node;
                    System.out.println("Node Name: " + element.getNodeName());
                    System.out.println("Node Value: " + element.getTextContent());
                }
            }

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

The code is large and can be downloaded here: (link)

Output:
Node Name: Company
Node Value:
FirstCode
90

Node Name: Company
Node Value:
Google
92

Node Name: Company
Node Value:
Microsoft
88

Advantages and disadvantages of DOM Parser

Advantages:

  • Allows easy navigation and manipulation of the XML document tree
  • Provides access to the entire XML document at once, which can be useful in certain use cases

Disadvantages:

  • Loading the entire XML document into memory can be memory-intensive, which can be a problem for large documents
  • Parsing can be slow for large documents

Java SAX Parser

Explanation of SAX parser

SAX stands for Simple API for XML. It’s a lightweight and event-based parser that reads XML documents from top to bottom without loading the whole document into memory.

How to use SAX parser in Java

To use SAX parser in Java, we need to create a new instance of SAXParser and an implementation of DefaultHandler class. We can then parse the XML document using the parse() method.

Code examples for SAX parser

Here’s an example of how to use SAX parser in Java:

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
public class MySaxParser extends DefaultHandler {
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
        System.out.println("Start Element: " + qName);
    }
    public void endElement(String uri, String localName, String qName) throws SAXException {
        System.out.println("End Element: " + qName);
    }
    public void characters(char ch[], int start, int length) throws SAXException {
        System.out.println("Characters: " + new String(ch, start, length));
    }
    public static void main(String[] args) throws Exception {
        SAXParserFactory factory = SAXParserFactory.newInstance();
        SAXParser parser = factory.newSAXParser();
        MySaxParser handler = new MySaxParser();
        parser.parse("example.xml", handler);
    }
}

This example prints the start and end elements of the XML document and the characters between the elements.

‘example.xml’

<?xml version="1.0" encoding="UTF-8"?>
<companies>
  <company>
    <name>FirstCode</name>
    <score>90</score>
    <address>
      <street>Main St.</street>
      <city>WhiteField</city>
      <state>Bengaluru</state>
    </address>
  </company>
  <company>
    <name>Google</name>
    <score>92</score>
    <address>
      <street>Second St.</street>
      <city>Mountain View</city>
      <state>CA</state>
    </address>
  </company>
  <company>
    <name>Microsoft</name>
    <score>88</score>
    <address>
      <street>Third St.</street>
      <city>Redmond</city>
      <state>WA</state>
    </address>
  </company>
</companies>

Output:
Start Element: companies
Characters:

Start Element: Company
Characters:

Start Element: name
Characters: FirstCode
End Element: name
Characters:

Start Element: score
Characters: 90
End Element: score
Characters:

Start Element: address
Characters:

Start Element: street
Characters: Main St.
End Element: street
Characters:

Start Element: City
Characters: WhiteField
End Element: City
Characters:

Start Element: state
Characters: Bengaluru
End Element: state
Characters:

End Element: address
Characters:

End Element: Company
Characters:

Start Element: Company
Characters:

Start Element: name
Characters: Google
End Element: name
Characters:

Start Element: score
Characters: 92
End Element: score
Characters:

Start Element: address
Characters:

Start Element: street
Characters: Second St.
End Element: street
Characters:

Start Element: City
Characters: Mountain View
End Element: City
Characters:

Start Element: state
Characters: CA
End Element: state
Characters:

End Element: address
Characters:

End Element: Company
Characters:

Start Element: Company
Characters:

Start Element: name
Characters: Microsoft
End Element: name
Characters:

Start Element: score
Characters: 88
End Element: score
Characters:

Start Element: address
Characters:

Start Element: street
Characters: Third St.
End Element: street
Characters:

Start Element: City
Characters: Redmond
End Element: City
Characters:

Start Element: state
Characters: WA
End Element: state
Characters:

End Element: address
Characters:

End Element: Company
Characters:

End Element: companies

Advantages and disadvantages of SAX parser

The advantages of SAX parser are that it’s memory-efficient, fast, and can handle large XML documents. However, it’s not suitable for random access to elements and can be more difficult to use than other parsers.

Java StAX Parser

Explanation of StAX parser

StAX stands for Streaming API for XML and is a Java-based XML processing API. It is designed to provide a simpler and more efficient way of parsing XML documents compared to DOM and SAX parsers. StAX parser works by reading XML documents as a stream of events, allowing for faster and more memory-efficient processing.

How to use StAX parser in Java

To use the StAX parser in Java, you need to follow these steps:

  1. Create a new instance of the XMLInputFactory class
  2. Create a new instance of the XMLStreamReader class using the XMLInputFactory object and the XML document as input
  3. Traverse through the XML document and process the events using the XMLStreamReader object
  4. Close the XMLStreamReader object and any associated resources once the parsing is complete

Code examples for StAX parser

Here’s an example of using a StAX parser to read and print the contents of an XML file:

import javax.xml.stream.*;
import java.io.*;

public class StAXParserExample {
   public static void main(String[] args) throws XMLStreamException, IOException {
      XMLInputFactory factory = XMLInputFactory.newInstance();
      InputStream is = new FileInputStream("example.xml");
      XMLStreamReader reader = factory.createXMLStreamReader(is);
      while (reader.hasNext()) {
         int event = reader.next();
         if (event == XMLStreamConstants.START_ELEMENT) {
            System.out.print("<" + reader.getLocalName() + ">");
         }
         if (event == XMLStreamConstants.CHARACTERS) {
            System.out.print(reader.getText());
         }
         if (event == XMLStreamConstants.END_ELEMENT) {
            System.out.println("</" + reader.getLocalName() + ">");
         }
      }
      reader.close();
   }
}

Output:

<companies>
  <company>
    <name>FirstCode</name>

    <score>90</score>

    <address>
      <street>Main St.</street>

      <city>WhiteField</city>

      <state>Bengaluru</state>

    </address>

  </company>

  <company>
    <name>Google</name>

    <score>92</score>

    <address>
      <street>Second St.</street>

      <city>Mountain View</city>

      <state>CA</state>

    </address>

  </company>

  <company>
    <name>Microsoft</name>

    <score>88</score>

    <address>
      <street>Third St.</street>

      <city>Redmond</city>

      <state>WA</state>

    </address>

  </company>

</companies>

Advantages and disadvantages of StAX parser

Advantages:

  • Faster and more memory-efficient processing compared to DOM and SAX parsers
  • Provides a simple and intuitive API for parsing XML documents
  • Allows for both forward and backward navigation of XML documents

Disadvantages:

  • Limited support for advanced XML processing features such as XSLT and XPath
  • Requires more code compared to DOM and SAX parsers for simple XML processing tasks

Java JAXB Parser

Explanation of JAXB parser

The Java Architecture for XML Binding (JAXB) framework allows for the mapping of XML documents to Java objects. It simplifies the process of reading and writing XML documents by generating Java classes based on an XML schema and vice versa.

How to use the JAXB parser in Java

To use JAXB in Java, you need to follow these steps:

  1. Create a JAXBContext object
  2. Create an Unmarshaller object from the JAXBContext
  3. Unmarshal the XML file into a Java object using the Unmarshaller
    Example code:
JAXBContext jaxbContext = JAXBContext.newInstance(Employee.class);
Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
Employee employee = (Employee) unmarshaller.unmarshal(new File("employee.xml"));

Code examples for the JAXB parser

Here is an example of how to use JAXB to marshal and unmarshal an XML file:

@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class Employee {
    private String name;
    private int age;

    // getters and setters
}

// Marshalling example
Employee employee = new Employee();
employee.setName("John");
employee.setAge(30);

JAXBContext jaxbContext = JAXBContext.newInstance(Employee.class);
Marshaller marshaller = jaxbContext.createMarshaller();
marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
marshaller.marshal(employee, new File("employee.xml"));

// Unmarshalling example
JAXBContext jaxbContext = JAXBContext.newInstance(Employee.class);
Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
Employee employee = (Employee) unmarshaller.unmarshal(new File("employee.xml"));

Advantages and disadvantages of JAXB parser

Advantages:

  • JAXB can easily convert XML data into Java objects and vice versa
  • It provides an easy way to map XML schemas to Java classes
  • It supports XML validation, which ensures that the XML document conforms to a given schema

Disadvantages:

  • JAXB requires a lot of annotations to be added to Java classes
  • It can be slow when processing large XML files
  • It requires a pre-defined XML schema to generate Java classes, which may not always be available.

Other Java XML Parsers

Introduction to XStream, Jackson XML, Apache CXF Aegis, and JiBX

In addition to DOM, SAX, StAX, and JAXB, there are other Java XML parsing libraries that developers can use. Some of these libraries are XStream, Jackson XML, Apache CXF Aegis, and JiBX.

Explanation of their use cases

XStream is a lightweight and easy-to-use library for converting Java objects to and from XML. Jackson XML is a Jackson JSON processor plugin that handles XML data. Apache CXF Aegis is a data binding framework that can convert Java objects to and from XML, JSON, and other formats. JiBX is a high-performance framework that can bind XML data to Java objects and vice versa.

Code examples for each parser

Let’s take a look at some code examples for each parser:

Example code for XStream:

XStream xstream = new XStream();
xstream.alias("person", Person.class);
Person person = (Person) xstream.fromXML("<person><name>John</name><age>30</age></person>");
System.out.println(person.getName()); // Output: John

Example code for Jackson XML:

XmlMapper xmlMapper = new XmlMapper();
Person person = xmlMapper.readValue("<person><name>John</name><age>30</age></person>", Person.class);
System.out.println(person.getName()); // Output: John

Example code for Apache CXF Aegis:

AegisContext context = new AegisContext();
AegisReader<XMLStreamReader> reader = context.createXMLStreamReader();
Person person = (Person) reader.read("<person><name>John</name><age>30</age></person>");
System.out.println(person.getName()); // Output: John

Example code for JiBX:

IBindingFactory bindingFactory = BindingDirectory.getFactory(Person.class);
IUnmarshallingContext unmarshallingContext = bindingFactory.createUnmarshallingContext();
Person person = (Person) unmarshallingContext.unmarshalDocument(new StringReader("<person><name>John</name><age>30</age></person>"), null);
System.out.println(person.getName()); // Output: John

Advantages and disadvantages of each parser

XStream is a great choice for developers who need a lightweight and easy-to-use library for converting Java objects to and from XML. Jackson XML is a good choice for those who already know Jackson JSON. The library can handle both JSON and XML data. Apache CXF Aegis is a powerful data binding framework that can handle a variety of data formats, including XML and JSON. JiBX is a high-performance framework that can bind XML data to Java objects and vice versa. However, it may not be as easy to use as some of the other libraries, and it may not be the best choice for all use cases. Developers should evaluate their specific needs and choose the library that best meets those needs.

Best Practices for Reading XML Files in Java

Explanation of Best Practices:

While reading XML files in Java, it’s important to follow some best practices to ensure the code is efficient and easy to maintain. Some best practices are:

  • Use the appropriate XML parser library based on the use case.
  • Use a namespace-aware parser to avoid conflicts with similarly named elements from different namespaces.
  • Avoid using absolute paths for accessing XML files.
  • Use try-with-resources to properly close the file and stream objects after use.
  • Use error-handling mechanisms such as try-catch blocks and loggers to handle exceptions and errors.

How to apply Best Practices for Reading XML Files in Java:

To apply best practices for reading XML files in Java, you can follow these steps:

  • Determine the appropriate XML parser library based on the use case (e.g. DOM, SAX, StAX, JAXB, etc.)
  • Use a namespace-aware parser to avoid conflicts with similarly named elements from different namespaces.
  • Use relative paths for accessing XML files.
  • Use try-with-resources to properly close the file and stream objects after use.
  • Use error-handling mechanisms such as try-catch blocks and loggers to handle exceptions and errors.

Code Examples for Applying Best Practices:

Here are some code examples for applying best practices while reading XML files in Java:

  • Using a namespace-aware parser:
DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
dbFactory.setNamespaceAware(true);
  • Using relative paths to access XML files:
File xmlFile = new File("src/main/resources/data.xml");
InputStream inputStream = new FileInputStream(xmlFile);
  • Using try-with-resources to properly close file and stream objects:
try (InputStream inputStream = new FileInputStream(xmlFile)) {
   // code to read XML file
} catch (IOException e) {
   // exception handling code
}

By following these best practices, you can ensure that your Java code for reading XML files is efficient, reliable, and easy to maintain.

Conclusion

In conclusion, XML is a popular format for storing and exchanging data, and Java provides several libraries for parsing XML files. We covered different Java XML processing libraries, including DOM, SAX, StAX, JAXB, XStream, Jackson XML, Apache CXF Aegis, and JiBX. Each library has its advantages and disadvantages, and the choice of the library depends on the specific use case. We also discussed the best practices for reading XML files in Java and provided code examples for applying these best practices.

Tags:

Leave a Reply

Your email address will not be published. Required fields are marked *