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
CompanyElement - 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 Nodeinterface is the primary datatype for the entire Document Object Model. It represents a single node in the document tree.The Documentinterface represents the entire HTML or XML document.The ElementJava 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