Java DOM Tutorial

Author:
Java DOM tutorial shows how to use the Java DOM API to read and write XML documents.
Read complete Java XML Tutorial at https://www.javaguides.net/p/java-xml-tutorial.html

DOM

Document Object Model (DOM) is a standard tree structure, where each node contains one of the components from an XML structure. Element nodes and text nodes are the two most common types of nodes. With DOM functions we can create nodes, remove nodes, change their contents, and traverse the node hierarchy.

Java DOM Parser

DOM is part of the Java API for XML Processing (JAXP). Java DOM parser traverses the XML file and creates the corresponding DOM objects. These DOM objects are linked together in a tree structure. The parser reads the whole XML structure into the memory.

SAX is an alternative JAXP API to DOM. SAX parsers are event-based; they are faster and require less memory. On the other hand, DOM is easier to use and there are tasks, such as sorting elements, rearranging elements or looking up elements, that are faster with DOM. A DOM parser comes with JDK, so there is no need to download a dependency.

XML Example Files

Here is the XML file that we use in this tutorial examples:
<?xml version="1.0" encoding="UTF-8"?>
<Users>
    <User>
        <id>1</id>
        <firstName>Ramesh</firstName>
        <lastName>Fadatare</lastName>
        <age>28</age>
        <gender>Male</gender>
    </User>
    <User>
        <id>2</id>
        <firstName>John</firstName>
        <lastName>Cena</lastName>
        <age>45</age>
        <gender>Male</gender>
    </User>
    <User>
        <id>3</id>
        <firstName>Tom</firstName>
        <lastName>Cruise</lastName>
        <age>40</age>
        <gender>Male</gender>
     </User>
</Users>

Create User class (populate XML data into User object)

So this XML is the list of users, to read this XML file we will create a bean object User and then we will parse the XML to get the list of users.
Here is the User bean object.
package net.javaguides.javaxmlparser.dom;

public class User {
    private int id;
    private String firstName;
    private String lastName;
    private int age;
    private String gender;

    public int getId() {
        return id;
    }

    public void setId(int i) {
        this.id = i;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public int getAge() {
        return age;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "User [id=" + id + ", firstName=" + firstName + ", lastName=" + lastName + ", age=" + age + ", gender=" +
            gender + "]";
    }
}

Java DOM Parser - Read XML File Example

Here is the java program that uses DOM Parser to read and parse an XML file to get the list of User objects.
package net.javaguides.javaxmlparser.dom;

import java.io.File;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

/**
 * Java DOM Parser to Read XML File in Java 
 * @author Ramesh Fadatare
 *
 */

public class ReadXMLFileInJava {
    public static void main(String[] args) {
        String filePath = "users.xml";
        File xmlFile = new File(filePath);
        DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder dBuilder;
        try {
            dBuilder = dbFactory.newDocumentBuilder();
            Document doc = dBuilder.parse(xmlFile);
            doc.getDocumentElement().normalize();
            System.out.println("Root element :" + doc.getDocumentElement().getNodeName());
            NodeList nodeList = doc.getElementsByTagName("User");
            // now XML is loaded as Document in memory, lets convert it to Object List
            List < User > userList = new ArrayList < User > ();

            for (int i = 0; i < nodeList.getLength(); i++) {
                userList.add(getUser(nodeList.item(i)));
            }
            // lets print User list information
            for (User emp: userList) {
                System.out.println(emp.toString());
            }
        } catch (SAXException | ParserConfigurationException | IOException e1) {
            e1.printStackTrace();
        }

    }

    private static User getUser(Node node) {
        // XMLReaderDOM domReader = new XMLReaderDOM();
        User user = new User();
        if (node.getNodeType() == Node.ELEMENT_NODE) {
            Element element = (Element) node;
            user.setId(Integer.parseInt(getTagValue("id", element)));
            user.setFirstName(getTagValue("firstName", element));
            user.setLastName(getTagValue("lastName", element));
            user.setGender(getTagValue("gender", element));
            user.setAge(Integer.parseInt(getTagValue("age", element)));
        }
        return user;
    }

    private static String getTagValue(String tag, Element element) {
        NodeList nodeList = element.getElementsByTagName(tag).item(0).getChildNodes();
        Node node = (Node) nodeList.item(0);
        return node.getNodeValue();
    }

}
The output of the above program:
Root element :Users
User [id=1, firstName=Ramesh, lastName=Fadatare, age=28, gender=Male]
User [id=2, firstName=John, lastName=Cena, age=45, gender=Male]
User [id=3, firstName=Tom, lastName=Cruise, age=40, gender=Male]

Java DOM Parser - Modify or Update XML File in Java

In this example, we have a list of User elements in the XML file and we will modify these User elements in XML with Java program.
We want to change the following for every User element in the XML.
  1. Add a new element
  2. Update existing element value
  3. Delete existing element
Here is the java program that does all the above updates in users.xml file using DOM Parser.
package net.javaguides.javaxmlparser.dom;

import java.io.File;
import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerFactoryConfigurationError;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class ModifyXMLFileInJava {
    public static void main(String[] args) {
        String filePath = "users.xml";
        File xmlFile = new File(filePath);
        DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder dBuilder;
        try {
            dBuilder = dbFactory.newDocumentBuilder();

            // parse xml file and load into document
            Document doc = dBuilder.parse(xmlFile);

            doc.getDocumentElement().normalize();

            // update Element value
            updateElementValue(doc);

            // delete element
            deleteElement(doc);

            // add new element
            addElement(doc);

            // write the updated document to file or console
            writeXMLFile(doc);

        } catch (SAXException | ParserConfigurationException | IOException | TransformerException e1) {
            e1.printStackTrace();
        }
    }

    private static void writeXMLFile(Document doc)
    throws TransformerFactoryConfigurationError, TransformerConfigurationException, TransformerException {
        doc.getDocumentElement().normalize();
        TransformerFactory transformerFactory = TransformerFactory.newInstance();
        Transformer transformer = transformerFactory.newTransformer();
        DOMSource source = new DOMSource(doc);
        StreamResult result = new StreamResult(new File("users_updated.xml"));
        transformer.setOutputProperty(OutputKeys.INDENT, "yes");
        transformer.transform(source, result);
        System.out.println("XML file updated successfully");
    }

    /**
     * Add a new element salary to user element.
     * @param doc
     */
    private static void addElement(Document doc) {
        NodeList users = doc.getElementsByTagName("User");
        Element emp = null;

        // loop for each user
        for (int i = 0; i < users.getLength(); i++) {
            emp = (Element) users.item(i);
            Element salaryElement = doc.createElement("salary");
            salaryElement.appendChild(doc.createTextNode("10000"));
            emp.appendChild(salaryElement);
        }
    }

    /**
     * Delete gender element from User element
     * @param doc
     */
    private static void deleteElement(Document doc) {
        NodeList users = doc.getElementsByTagName("User");
        Element user = null;
        // loop for each user
        for (int i = 0; i < users.getLength(); i++) {
            user = (Element) users.item(i);
            Node genderNode = user.getElementsByTagName("gender").item(0);
            user.removeChild(genderNode);
        }

    }

    /**
     * Update firstName element value to Upper case.
     * @param doc
     */
    private static void updateElementValue(Document doc) {
        NodeList users = doc.getElementsByTagName("User");
        Element user = null;
        // loop for each user
        for (int i = 0; i < users.getLength(); i++) {
            user = (Element) users.item(i);
            Node name = user.getElementsByTagName("firstName").item(0).getFirstChild();
            name.setNodeValue(name.getNodeValue().toUpperCase());
        }
    }
}

Updated users.xml File

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<Users>
    <User>
        <id>1</id>
        <firstName>RAMESH</firstName>
        <lastName>Fadatare</lastName>
        <age>28</age>
        <salary>10000</salary>
    </User>
    <User>
        <id>2</id>
        <firstName>JOHN</firstName>
        <lastName>Cena</lastName>
        <age>45</age>
        <salary>10000</salary>
    </User>
    <User>
        <id>3</id>
        <firstName>TOM</firstName>
        <lastName>Cruise</lastName>
        <age>40</age>
        <salary>10000</salary>
    </User>
</Users>
Note that we have added a new "salary" field to the User element, we have updated firstName from lower case to upper case and we deleted gender element from user tag.

Java DOM Parser - Create an XML file Example

Let's create a program to create an XML file in Java using DOM Parser.
package net.javaguides.javaxmlparser.dom;

import java.io.File;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;

public class CreateXMLFileInJava {
    public static void main(String[] args) {
        DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder dBuilder;
        try {
            dBuilder = dbFactory.newDocumentBuilder();
            Document doc = dBuilder.newDocument();
            // add elements to Document
            Element rootElement = doc.createElement("Users");
            // append root element to document
            doc.appendChild(rootElement);

            // append first child element to root element
            rootElement.appendChild(createUserElement(doc, "1", "Ramesh", "Fadatare", "28", "Male"));

            // append second child
            rootElement.appendChild(createUserElement(doc, "2", "John", "Cena", "45", "Male"));

            // append third child
            rootElement.appendChild(createUserElement(doc, "3", "Tom", "Cruise", "40", "Male"));

            // for output to file, console
            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            Transformer transformer = transformerFactory.newTransformer();
            // for pretty print
            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
            DOMSource source = new DOMSource(doc);

            // write to console or file
            StreamResult console = new StreamResult(System.out);
            StreamResult file = new StreamResult(new File("create_users.xml"));

            // write data
            transformer.transform(source, console);
            transformer.transform(source, file);

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

    private static Node createUserElement(Document doc, String id, String firstName, String lastName, String age,
        String gender) {
        Element user = doc.createElement("User");

        // set id attribute
        user.setAttribute("id", id);

        // create firstName element
        user.appendChild(createUserElements(doc, user, "firstName", firstName));

        // create lastName element
        user.appendChild(createUserElements(doc, user, "lastName", lastName));

        // create age element
        user.appendChild(createUserElements(doc, user, "age", age));

        // create gender element
        user.appendChild(createUserElements(doc, user, "gender", gender));

        return user;
    }

    // utility method to create text node
    private static Node createUserElements(Document doc, Element element, String name, String value) {
        Element node = doc.createElement(name);
        node.appendChild(doc.createTextNode(value));
        return node;
    }
}
An output of the above program:
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<Users>
<User id="1">
<firstName>Ramesh</firstName>
<lastName>Fadatare</lastName>
<age>28</age>
<gender>Male</gender>
</User>
<User id="2">
<firstName>John</firstName>
<lastName>Cena</lastName>
<age>45</age>
<gender>Male</gender>
</User>
<User id="3">
<firstName>Tom</firstName>
<lastName>Cruise</lastName>
<age>40</age>
<gender>Male</gender>
</User>
</Users>
Note that for debugging, you can change the StreamResult to output the XML content to your console.

Java DOM Reading Elements with NodeIterator

DocumentTraversal contains methods that create NodeIterators and TreeWalkers to traverse a node and its children in depth-first, pre-order document order. This order is equivalent to the order in which the start tags occur in the text representation of the document.

The example prints all the node elements of the users.xml file.
package net.javaguides.javaxmlparser.dom;

import java.io.IOException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.traversal.DocumentTraversal;
import org.w3c.dom.traversal.NodeFilter;
import org.w3c.dom.traversal.NodeIterator;
import org.xml.sax.SAXException;

public class JavaXmlDomReadElements {

    public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException {

        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder loader = factory.newDocumentBuilder();
        Document document = loader.parse("users.xml");

        DocumentTraversal trav = (DocumentTraversal) document;

        NodeIterator it = trav.createNodeIterator(document.getDocumentElement(), NodeFilter.SHOW_ELEMENT, null, true);

        int c = 1;

        for (Node node = it.nextNode(); node != null; node = it.nextNode()) {

            String name = node.getNodeName();

            System.out.printf("%d %s%n", c, name);
            c++;
        }
    }
}
Output:
1 Users
2 User
3 id
4 firstName
5 lastName
6 age
7 gender
8 User
9 id
10 firstName
11 lastName
12 age
13 gender
14 User
15 id
16 firstName
17 lastName
18 age
19 gender

Java DOM reading XML with TreeWalker

TreeWalker has more methods for traversing than NodeIterator. The example reads the elements and the text of a users.xml file with TreeWalker.
package net.javaguides.javaxmlparser.dom;

import java.io.IOException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.traversal.DocumentTraversal;
import org.w3c.dom.traversal.NodeFilter;
import org.w3c.dom.traversal.TreeWalker;
import org.xml.sax.SAXException;

public class JavaXmlDomTreeWalkerEx {

    public static void main(String[] args) throws SAXException, IOException,
        ParserConfigurationException {

            DocumentBuilderFactory factory
                = DocumentBuilderFactory.newInstance();
            DocumentBuilder loader = factory.newDocumentBuilder();
            Document document = loader.parse("users.xml");

            DocumentTraversal traversal = (DocumentTraversal) document;

            TreeWalker walker = traversal.createTreeWalker(
                document.getDocumentElement(),
                NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT, null, true);

            traverseLevel(walker, "");
        }

    private static void traverseLevel(TreeWalker walker,
        String indent) {

        Node node = walker.getCurrentNode();

        if (node.getNodeType() == Node.ELEMENT_NODE) {
            System.out.println(indent + node.getNodeName());
        }

        if (node.getNodeType() == Node.TEXT_NODE) {

            String content_trimmed = node.getTextContent().trim();

            if (content_trimmed.length() > 0) {
                System.out.print(indent);
                System.out.printf("%s%n", content_trimmed);
            }
        }

        for (Node n = walker.firstChild(); n != null; n = walker.nextSibling()) {

            traverseLevel(walker, indent + "  ");
        }

        walker.setCurrentNode(node);
    }
}
Output:
Users
  User
    id
      1
    firstName
      Ramesh
    lastName
      Fadatare
    age
      28
    gender
      Male
  User
    id
      2
    firstName
      John
    lastName
      Cena
    age
      45
    gender
      Male
  User
    id
      3
    firstName
      Tom
    lastName
      Cruise
    age
      40
    gender
      Male
In this tutorial, we have read and write XML files with Java DOM API.

References

Comments

Post a Comment

Leave Comment