En Java, ¿cómo crear un archivo XML usando el analizador DOM? Escribir un DOM como un archivo XML

Publicado: 2019-01-11
En Java, ¿cómo crear un archivo XML usando el analizador DOM? Escribir un DOM como un archivo XML

Como aprendimos anteriormente "Una forma simple de contar el número de elementos XML en Java", aquí hay otro código Java simple que escribe un archivo XML en Java (DOM Parser).

  • Escribir un DOM como un archivo XML
  • Tutorial de Java DOM: escriba XML con DOM en Java
  • Cómo escribir un archivo XML en Java (DOM Parser)
  • Java: forma sencilla de escribir archivos XML (DOM) en Java

Esto es lo que estoy haciendo aquí:

  • Creando elemento raíz XML con nombre: Companies
  • Creación de 4 elementos de Company
  • Cada elemento de la empresa tiene una id de atributo
  • Cada elemento de la empresa tiene 3 elementos: Name, Type, Employee
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
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 ;
     }
}
 

Fábrica de DocumentBuilder:

Define una API de fábrica que permite que las aplicaciones obtengan un analizador que produce árboles de objetos DOM a partir de documentos XML.

Creador de documentos:

Define la API para obtener instancias de documentos DOM de un documento XML.

añadir Niño():

agrega el nodo newChild al final de la lista de hijos de este nodo. Si newChild ya está en el árbol, primero se elimina.

Transformador:

Una instancia de esta clase abstracta puede transformar un árbol de origen en un árbol de resultados.

DOMFuente:

Actúa como titular de un árbol de origen de transformación en forma de árbol de modelo de objeto de documento (DOM).

Resultado de la corriente:

Actúa como contenedor de un resultado de transformación, que puede ser XML, texto sin formato, HTML o alguna otra forma de marcado.

  • The Node es el tipo de datos principal para todo el modelo de objetos del documento. Representa un solo nodo en el árbol del documento.
  • The Document representa todo el documento HTML o XML.
  • The Element Java representa un elemento en un documento HTML o XML.

Salida de la consola de Eclipse:

Ejecute el programa anterior como una aplicación Java para obtener un resultado similar al siguiente.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<? 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