In Java Wie erstelle ich eine XML-Datei mit dem DOM-Parser? Schreiben eines DOM als XML-Datei

Veröffentlicht: 2019-01-11
In Java Wie erstelle ich eine XML-Datei mit dem DOM-Parser? Schreiben eines DOM als XML-Datei

Wie wir zuvor „Einfache Methode zum Zählen der Anzahl von XML-Elementen in Java“ gelernt haben, ist hier ein weiterer einfacher Java-Code, der XML-Dateien in Java schreibt (DOM Parser).

  • Schreiben eines DOM als XML-Datei
  • Java DOM Tutorial – XML mit DOM in Java schreiben
  • So schreiben Sie eine XML-Datei in Java (DOM Parser)
  • Java: Einfache Möglichkeit, XML (DOM)-Dateien in Java zu schreiben

Das mache ich hier:

  • Root-XML-Element mit dem Namen erstellen: Companies
  • Erstellen von 4 Company
  • Jedes Unternehmenselement hat eine Attribut- id
  • Jedes Unternehmenselement hat 3 Elemente – 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 ;
     }
}
 

DocumentBuilderFactory:

Definiert eine Factory-API, die es Anwendungen ermöglicht, einen Parser zu erhalten, der DOM-Objektbäume aus XML-Dokumenten erstellt.

DocumentBuilder:

Definiert die API zum Abrufen von DOM-Dokumentinstanzen aus einem XML-Dokument.

appendChild():

fügt den Knoten newChild am Ende der Liste der Kinder dieses Knotens hinzu. Wenn das newChild bereits im Baum vorhanden ist, wird es zunächst entfernt.

Transformator:

Eine Instanz dieser abstrakten Klasse kann einen Quellbaum in einen Ergebnisbaum umwandeln.

DOMQuelle:

Fungiert als Halter für einen Transformationsquellbaum in Form eines Document Object Model (DOM)-Baums.

StreamErgebnis:

Fungiert als Halter für ein Transformationsergebnis, das XML, einfacher Text, HTML oder eine andere Form von Markup sein kann.

  • The Node -Schnittstelle ist der primäre Datentyp für das gesamte Document Object Model. Es stellt einen einzelnen Knoten im Dokumentbaum dar.
  • The Document -Schnittstelle repräsentiert das gesamte HTML- oder XML-Dokument.
  • The Element Java Interface repräsentiert ein Element in einem HTML- oder XML-Dokument.

Ausgabe der Eclipse-Konsole:

Führen Sie das obige Programm als Java-Anwendung aus, um ein ähnliches Ergebnis wie unten zu erhalten.

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