In Java How to Create XML File using DOM parser? Writing Out a DOM as an XML File

As we learned “Simple way to count number of XML elements in Java” earlier, here is another simple Java code which writes XML file in Java (DOM Parser).

Writing Out a DOM as an XML File
Java DOM tutorial – write XML with DOM in Java
How to write XML file in Java (DOM Parser)
Java: Simple Way to Write XML (DOM) File in Java

This is what I’m doing here:

Creating Root XML element with name: Companies
Creating 4 Company Element
Every Company Element has an attribute id
Every Company Element have 3 elements – Name, Type, Employee

package crunchify.com.tutorials;

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

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;

/**
 * @author Crunchify.com
 * In Java How to Create XML File using DOM parser? Writing Out a DOM as an XML File.
 * Version: 1.1
 */

public class CrunchifyCreateXMLDOM {

    public static void main(String[] args) {

        // Defines a factory API that enables applications to obtain a parser that produces DOM object trees from XML documents.
        DocumentBuilderFactory crunchifyDocBuilderFactory = DocumentBuilderFactory.newInstance();

        // Defines the API to obtain DOM Document instances from an XML document.
        DocumentBuilder crunchifyDocBuilder;
        try {
            crunchifyDocBuilder = crunchifyDocBuilderFactory.newDocumentBuilder();

            // The Document interface represents the entire HTML or XML document.
            Document crunchifyDoc = crunchifyDocBuilder.newDocument();

            // The Element interface represents an element in an HTML or XML document.
            Element mainRootElement = crunchifyDoc.createElementNS("https://crunchify.com/CrunchifyCreateXMLDOM", "Companies");

            // Adds the node newChild to the end of the list of children of this node.
            // If the newChild is already in the tree, it is first removed.
            crunchifyDoc.appendChild(mainRootElement);

            // append child elements to root element
            mainRootElement.appendChild(getCompany(crunchifyDoc, "1", "Paypal", "Payment", "1000"));
            mainRootElement.appendChild(getCompany(crunchifyDoc, "2", "Amazon", "Shopping", "2000"));
            mainRootElement.appendChild(getCompany(crunchifyDoc, "3", "Google", "Search", "3000"));
            mainRootElement.appendChild(getCompany(crunchifyDoc, "4", "Crunchify", "Java Tutorials", "10"));

            // output DOM XML to console

            // An instance of this abstract class can transform a source tree into a result tree.
            Transformer crunchifyTransformer = TransformerFactory.newInstance().newTransformer();
            crunchifyTransformer.setOutputProperty(OutputKeys.INDENT, "yes");

            // Acts as a holder for a transformation Source tree in the form of a Document Object Model (DOM) tree.
            DOMSource source = new DOMSource(crunchifyDoc);

            // Acts as an holder for a transformation result, which may be XML, plain Text, HTML, or some other form of markup.
            StreamResult console = new StreamResult(System.out);
            crunchifyTransformer.transform(source, console);

            System.out.println("\nTutorial by Crunchify. XML DOM Created Successfully..");

        } catch (TransformerException | ParserConfigurationException e) {
            e.printStackTrace();
        }
    }

    // The Node interface is the primary datatype for the entire Document Object Model.
    // It represents a single node in the document tree.
    private static Node getCompany(Document doc, String id, String name, String age, String role) {
        Element crunchifyCompany = doc.createElement("Company");
        crunchifyCompany.setAttribute("id", id);
        crunchifyCompany.appendChild(getCrunchifyCompanyElements(doc, crunchifyCompany, "Name", name));
        crunchifyCompany.appendChild(getCrunchifyCompanyElements(doc, crunchifyCompany, "Type", age));
        crunchifyCompany.appendChild(getCrunchifyCompanyElements(doc, crunchifyCompany, "Employees", role));
        return crunchifyCompany;
    }

    // Utility method to create text node
    private static Node getCrunchifyCompanyElements(Document doc, Element element, String name, String value) {
        Element node = doc.createElement(name);
        node.appendChild(doc.createTextNode(value));
        return node;
    }
}

DocumentBuilderFactory:

Defines a factory API that enables applications to obtain a parser that produces DOM object trees from XML documents.

DocumentBuilder:

Defines the API to obtain DOM Document instances from an XML document.

appendChild():

adds the node newChild to the end of the list of children of this node. If the newChild is already in the tree, it is first removed.

Transformer:

An instance of this abstract class can transform a source tree into a result tree.

DOMSource:

Acts as a holder for a transformation Source tree in the form of a Document Object Model (DOM) tree.

StreamResult:

Acts as an holder for a transformation result, which may be XML, plain Text, HTML, or some other form of markup.

The Node interface is the primary datatype for the entire Document Object Model. It represents a single node in the document tree.
The Document interface represents the entire HTML or XML document.
The Element Java Interface represents an element in an HTML or XML document.

Eclipse Console Output:

Run above program as a Java Application to get similar result as below.

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<Companies xmlns="https://crunchify.com/CrunchifyCreateXMLDOM">
    <Company id="1">
        <Name>Paypal</Name>
        <Type>Payment</Type>
        <Employees>1000</Employees>
    </Company>
    <Company id="2">
        <Name>Amazon</Name>
        <Type>Shopping</Type>
        <Employees>2000</Employees>
    </Company>
    <Company id="3">
        <Name>Google</Name>
        <Type>Search</Type>
        <Employees>3000</Employees>
    </Company>
    <Company id="4">
        <Name>Crunchify</Name>
        <Type>Java Tutorials</Type>
        <Employees>10</Employees>
    </Company>
</Companies>

Tutorial by Crunchify. XML DOM Created Successfully..

Process finished with exit code 0

Let me know if you face any issue running this program.

The post In Java How to Create XML File using DOM parser? Writing Out a DOM as an XML File appeared first on Crunchify.