# XOM - XML Object Model

# Reading a XML file

In order to load the XML data with XOM (opens new window) you will need to make a Builder from which you can build it into a Document.

Builder builder = new Builder();
Document doc = builder.build(file);

To get the root element, the highest parent in the xml file, you need to use the getRootElement() on the Document instance.

Element root = doc.getRootElement();

Now the Element class has a lot of handy methods that make reading xml really easy. Some of the most useful are listed below:

  • getChildElements(String name) - returns an Elements instance that acts as an array of elements
  • getFirstChildElement(String name) - returns the first child element with that tag.
  • getValue() - returns the value inside the element.
  • getAttributeValue(String name) - returns the value of an attribute with the specified name.

When you call the getChildElements() you get a Elements instance. From this you can loop through and call the get(int index) method on it to retrieve all the elements inside.

Elements colors = root.getChildElements("color");
for (int q = 0; q < colors.size(); q++){
    Element color = colors.get(q);

Example: Here is an example of reading an XML File:

XML File:

example of xml (opens new window)

Code for reading and printing it:

import java.io.File;
import java.io.IOException;
import nu.xom.Builder;
import nu.xom.Document;
import nu.xom.Element;
import nu.xom.Elements;
import nu.xom.ParsingException;

public class XMLReader {
    public static void main(String[] args) throws ParsingException, IOException{
        File file = new File("insert path here");
        // builder builds xml data
        Builder builder = new Builder();
        Document doc = builder.build(file);
        // get the root element <example>
        Element root = doc.getRootElement();
        // gets all element with tag <person>
        Elements people = root.getChildElements("person");
        for (int q = 0; q < people.size(); q++){
            // get the current person element
            Element person = people.get(q);
            // get the name element and its children: first and last
            Element nameElement = person.getFirstChildElement("name");
            Element firstNameElement = nameElement.getFirstChildElement("first");
            Element lastNameElement = nameElement.getFirstChildElement("last");
            // get the age element
            Element ageElement = person.getFirstChildElement("age");
            // get the favorite color element
            Element favColorElement = person.getFirstChildElement("fav_color");
            String fName, lName, ageUnit, favColor;
            int age;
            try {
                fName = firstNameElement.getValue();
                lName = lastNameElement.getValue();
                age = Integer.parseInt(ageElement.getValue());
                ageUnit = ageElement.getAttributeValue("unit");
                favColor = favColorElement.getValue();
                System.out.println("Name: " + lName + ", " + fName);
                System.out.println("Age: " + age + " (" + ageUnit + ")");
                System.out.println("Favorite Color: " + favColor);
            } catch (NullPointerException ex){
            } catch (NumberFormatException ex){

This will print out in the console:

Name: Smith, Dan
Age: 23 (years)
Favorite Color: green
Name: Autry, Bob
Age: 3 (months)
Favorite Color: N/A

# Writing to a XML File

Writing to a XML File using XOM (opens new window) is very similar to reading it except in this case we are making the instances instead of retrieving them off the root.

To make a new Element use the constructor Element(String name). You will want to make a root element so that you can easily add it to a Document.

Element root = new Element("root");

The Element class has some handy methods for editing elements. They are listed below:

  • appendChild(String name) - this will basically set the value of the element to name.
  • appendChild(Node node) - this will make node the elements parent. (Elements are nodes so you can parse elements).
  • addAttribute(Attribute attribute) - will add an attribute to the element.

The Attribute class has a couple of different constructors. The simplest one is Attribute(String name, String value).

Once you have all of your elements add to your root element you can turn it into a Document. Document will take a Element as an argument in it's constructor.

You can use a Serializer to write your XML to a file. You will need to make a new output stream to parse in the constructor of Serializer.

FileOutputStream fileOutputStream = new FileOutputStream(file);
Serializer serializer = new Serializer(fileOutputStream, "UTF-8");



import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import nu.xom.Attribute;
import nu.xom.Builder;
import nu.xom.Document;
import nu.xom.Element;
import nu.xom.Elements;
import nu.xom.ParsingException;
import nu.xom.Serializer;

public class XMLWriter{
    public static void main(String[] args) throws UnsupportedEncodingException, 
        // root element <example>
        Element root = new Element("example");
        // make a array of people to store
        Person[] people = {new Person("Smith", "Dan", "years", "green", 23), 
            new Person("Autry", "Bob", "months", "N/A", 3)};
        // add all the people
        for (Person person : people){
            // make the main person element <person>
            Element personElement = new Element("person");
            // make the name element and it's children: first and last
            Element nameElement = new Element("name");
            Element firstNameElement = new Element("first");
            Element lastNameElement = new Element("last");
            // make age element
            Element ageElement = new Element("age");
            // make favorite color element
            Element favColorElement = new Element("fav_color");
            // add value to names
            // add names to name
            // add value to age
            // add unit attribute to age
            ageElement.addAttribute(new Attribute("unit", person.getAgeUnit()));
            // add value to favColor
            // add all contents to person
            // add person to root
        // create doc off of root
        Document doc = new Document(root);
        // the file it will be stored in
        File file = new File("out.xml");
        if (!file.exists()){
        // get a file output stream ready
        FileOutputStream fileOutputStream = new FileOutputStream(file);
        // use the serializer class to write it all
        Serializer serializer = new Serializer(fileOutputStream, "UTF-8");

    private static class Person {

        private String lName, fName, ageUnit, favColor;
        private int age;

        public Person(String lName, String fName, String ageUnit, String favColor, int age){
            this.lName = lName;
            this.fName = fName;
            this.age = age;
            this.ageUnit = ageUnit;
            this.favColor = favColor;

        public String getLastName() { return lName; }
        public String getFirstName() { return fName; }
        public String getAgeUnit() { return ageUnit; }
        public String getFavoriteColor() { return favColor; }
        public int getAge() { return age; }

This will be the contents of "out.xml":

xml file (opens new window)