Arbeiten mit XML in Groovy

1. Einleitung

Groovy bietet eine beträchtliche Anzahl von Methoden zum Durchlaufen und Bearbeiten von XML-Inhalten.

In diesem Tutorial zeigen wir Ihnen, wie Sie in Groovy mithilfe verschiedener Ansätze Elemente aus XML hinzufügen, bearbeiten oder löschen . Wir zeigen auch, wie Sie eine XML-Struktur von Grund auf neu erstellen .

2. Modell definieren

Definieren wir eine XML-Struktur in unserem Ressourcenverzeichnis, die wir in unseren Beispielen verwenden werden:

  First steps in Java  Siena Kerr  2018-12-01   Dockerize your SpringBoot application  Jonas Lugo  2018-12-01   SpringBoot tutorial  Daniele Ferguson  2018-06-12   Java 12 insights  Siena Kerr  2018-07-22  

Und lesen Sie es in eine InputStream- Variable:

def xmlFile = getClass().getResourceAsStream("articles.xml")

3. XmlParser

Beginnen wir mit der Untersuchung dieses Streams mit der XmlParser- Klasse.

3.1. lesen

Das Lesen und Parsen einer XML-Datei ist wahrscheinlich die häufigste XML-Operation, die ein Entwickler ausführen muss. Der XmlParser bietet eine sehr einfache Oberfläche, die genau dafür gedacht ist:

def articles = new XmlParser().parse(xmlFile)

Zu diesem Zeitpunkt können wir mithilfe von GPath-Ausdrücken auf die Attribute und Werte der XML-Struktur zugreifen.

Lassen Sie uns nun einen einfachen Test mit Spock durchführen, um zu überprüfen, ob unser Artikelobjekt korrekt ist:

def "Should read XML file properly"() { given: "XML file" when: "Using XmlParser to read file" def articles = new XmlParser().parse(xmlFile) then: "Xml is loaded properly" articles.'*'.size() == 4 articles.article[0].author.firstname.text() == "Siena" articles.article[2].'release-date'.text() == "2018-06-12" articles.article[3].title.text() == "Java 12 insights" articles.article.find { it.author.'@id'.text() == "3" }.author.firstname.text() == "Daniele" }

Um zu verstehen, wie auf XML-Werte zugegriffen wird und wie die GPath-Ausdrücke verwendet werden, konzentrieren wir uns für einen Moment auf die interne Struktur des Ergebnisses der XmlParser # -Parseoperation .

Die Artikel - Objekt ist eine Instanz von groovy.util.Node. Jeder Knoten besteht aus einem Namen, einer Attributzuordnung, einem Wert und einem übergeordneten Knoten (der entweder null oder ein anderer Knoten sein kann) .

In unserem Fall ist der Wert von Artikeln eine groovy.util.NodeList- Instanz, die eine Wrapper-Klasse für eine Sammlung von Knoten ist . Die NodeList erweitert die Klasse java.util.ArrayList , mit der Elemente nach Index extrahiert werden können. Um einen Zeichenfolgenwert eines Knotens zu erhalten, verwenden wir groovy.util.Node # text ().

Im obigen Beispiel haben wir einige GPath-Ausdrücke eingeführt:

  • articles.article [0] .author.firstname - Ermittelt den Vornamen des Autors für den ersten Artikel - articles.article [n ] greift direkt auf den n- ten Artikel zu
  • '*' - eine Liste der Kinder des Artikels abrufen - das entspricht groovy.util.Node # children ()
  • author.'@id ‚ - erhalten den Autor des Elements id - Attribut - author.'@attributeName‘ greift auf den Attributwert durch seinen Namen (die Äquivalente sind: Autor [ ‚@ id‘] und [email protected] )

3.2. Hinzufügen eines Knotens

Lesen Sie ähnlich wie im vorherigen Beispiel zuerst den XML-Inhalt in eine Variable. Auf diese Weise können wir einen neuen Knoten definieren und ihn mit groovy.util.Node # append zu unserer Artikelliste hinzufügen .

Lassen Sie uns nun einen Test implementieren, der unseren Standpunkt bestätigt:

def "Should add node to existing xml using NodeBuilder"() { given: "XML object" def articles = new XmlParser().parse(xmlFile) when: "Adding node to xml" def articleNode = new NodeBuilder().article(id: '5') { title('Traversing XML in the nutshell') author { firstname('Martin') lastname('Schmidt') } 'release-date'('2019-05-18') } articles.append(articleNode) then: "Node is added to xml properly" articles.'*'.size() == 5 articles.article[4].title.text() == "Traversing XML in the nutshell" }

Wie wir im obigen Beispiel sehen können, ist der Prozess ziemlich einfach.

Beachten Sie auch, dass wir groovy.util.NodeBuilder verwendet haben, eine gute Alternative zur Verwendung des Node- Konstruktors für unsere Node- Definition.

3.3. Ändern eines Knotens

Wir können die Werte von Knoten auch mit dem XmlParser ändern . Dazu analysieren wir noch einmal den Inhalt der XML-Datei. Als nächstes können wir den Inhalt Knoten durch Ändern des bearbeiten Wert Feld des Node - Objekts.

Denken Sie daran, dass XmlParser zwar die GPath-Ausdrücke verwendet, wir jedoch immer die Instanz der NodeList abrufen. Um das erste (und einzige) Element zu ändern, müssen wir über dessen Index darauf zugreifen.

Lassen Sie uns unsere Annahmen überprüfen, indem wir einen kurzen Test schreiben:

def "Should modify node"() { given: "XML object" def articles = new XmlParser().parse(xmlFile) when: "Changing value of one of the nodes" articles.article.each { it.'release-date'[0].value = "2019-05-18" } then: "XML is updated" articles.article.findAll { it.'release-date'.text() != "2019-05-18" }.isEmpty() }

Im obigen Beispiel haben wir auch die Groovy Collections-API verwendet, um die NodeList zu durchlaufen .

3.4. Knoten ersetzen

Als nächstes wollen wir sehen, wie der gesamte Knoten ersetzt wird, anstatt nur einen seiner Werte zu ändern.

Ebenso ein neues Element hinzufügen, werden wir die Verwendung NodeBuilder für die Node - Definition und dann eine der vorhandenen Knoten innerhalb ersetzen mit replaceNode groovy.util.Node # :

def "Should replace node"() { given: "XML object" def articles = new XmlParser().parse(xmlFile) when: "Adding node to xml" def articleNode = new NodeBuilder().article(id: '5') { title('Traversing XML in the nutshell') author { firstname('Martin') lastname('Schmidt') } 'release-date'('2019-05-18') } articles.article[0].replaceNode(articleNode) then: "Node is added to xml properly" articles.'*'.size() == 4 articles.article[0].title.text() == "Traversing XML in the nutshell" }

3.5. Löschen eines Knotens

Das Löschen eines Knotens mit dem XmlParser ist ziemlich schwierig. Obwohl die Node- Klasse die Methode remove (Node child) bereitstellt , würden wir sie in den meisten Fällen nicht alleine verwenden.

Stattdessen zeigen wir, wie ein Knoten gelöscht wird, dessen Wert eine bestimmte Bedingung erfüllt.

By default, accessing the nested elements using a chain of Node.NodeList references returns a copy of the corresponding children nodes. Because of that, we can't use the java.util.NodeList#removeAll method directly on our article collection.

To delete a node by a predicate, we have to find all nodes matching our condition first, and then iterate through them and invoke java.util.Node#remove method on the parent each time .

Let's implement a test that removes all articles whose author has an id other than 3:

def "Should remove article from xml"() { given: "XML object" def articles = new XmlParser().parse(xmlFile) when: "Removing all articles but the ones with id==3" articles.article .findAll { it.author.'@id'.text() != "3" } .each { articles.remove(it) } then: "There is only one article left" articles.children().size() == 1 articles.article[0].author.'@id'.text() == "3" }

As we can see, as a result of our remove operation, we received an XML structure with only one article, and its id is 3.

4. XmlSlurper

Groovy also provides another class dedicated to working with XML. In this section, we'll show how to read and manipulate the XML structure using the XmlSlurper.

4.1. Reading

As in our previous examples, let's start with parsing the XML structure from a file:

def "Should read XML file properly"() { given: "XML file" when: "Using XmlSlurper to read file" def articles = new XmlSlurper().parse(xmlFile) then: "Xml is loaded properly" articles.'*'.size() == 4 articles.article[0].author.firstname == "Siena" articles.article[2].'release-date' == "2018-06-12" articles.article[3].title == "Java 12 insights" articles.article.find { it.author.'@id' == "3" }.author.firstname == "Daniele" }

As we can see, the interface is identical to that of XmlParser. However, the output structure uses the groovy.util.slurpersupport.GPathResult, which is a wrapper class for Node. GPathResult provides simplified definitions of methods such as: equals() and toString() by wrapping Node#text(). As a result, we can read fields and parameters directly using just their names.

4.2. Adding a Node

Adding a Node is also very similar to using XmlParser. In this case, however, groovy.util.slurpersupport.GPathResult#appendNode provides a method that takes an instance of java.lang.Object as an argument. As a result, we can simplify new Node definitions following the same convention introduced by NodeBuilder:

def "Should add node to existing xml"() { given: "XML object" def articles = new XmlSlurper().parse(xmlFile) when: "Adding node to xml" articles.appendNode { article(id: '5') { title('Traversing XML in the nutshell') author { firstname('Martin') lastname('Schmidt') } 'release-date'('2019-05-18') } } articles = new XmlSlurper().parseText(XmlUtil.serialize(articles)) then: "Node is added to xml properly" articles.'*'.size() == 5 articles.article[4].title == "Traversing XML in the nutshell" }

In case we need to modify the structure of our XML with XmlSlurper, we have to reinitialize our articles object to see the results. We can achieve that using the combination of the groovy.util.XmlSlurper#parseText and the groovy.xmlXmlUtil#serialize methods.

4.3. Modifying a Node

As we mentioned before, the GPathResult introduces a simplified approach to data manipulation. That being said, in contrast to the XmlSlurper, we can modify the values directly using the node name or parameter name:

def "Should modify node"() { given: "XML object" def articles = new XmlSlurper().parse(xmlFile) when: "Changing value of one of the nodes" articles.article.each { it.'release-date' = "2019-05-18" } then: "XML is updated" articles.article.findAll { it.'release-date' != "2019-05-18" }.isEmpty() }

Let's notice that when we only modify the values of the XML object, we don't have to parse the whole structure again.

4.4. Replacing a Node

Now let's move to replacing the whole node. Again, the GPathResult comes to the rescue. We can easily replace the node using groovy.util.slurpersupport.NodeChild#replaceNode, which extends GPathResult and follows the same convention of using the Object values as arguments:

def "Should replace node"() { given: "XML object" def articles = new XmlSlurper().parse(xmlFile) when: "Replacing node" articles.article[0].replaceNode { article(id: '5') { title('Traversing XML in the nutshell') author { firstname('Martin') lastname('Schmidt') } 'release-date'('2019-05-18') } } articles = new XmlSlurper().parseText(XmlUtil.serialize(articles)) then: "Node is replaced properly" articles.'*'.size() == 4 articles.article[0].title == "Traversing XML in the nutshell" }

As was the case when adding a node, we're modifying the structure of the XML, so we have to parse it again.

4.5. Deleting a Node

To remove a node using XmlSlurper, we can reuse the groovy.util.slurpersupport.NodeChild#replaceNode method simply by providing an empty Node definition:

def "Should remove article from xml"() { given: "XML object" def articles = new XmlSlurper().parse(xmlFile) when: "Removing all articles but the ones with id==3" articles.article .findAll { it.author.'@id' != "3" } .replaceNode {} articles = new XmlSlurper().parseText(XmlUtil.serialize(articles)) then: "There is only one article left" articles.children().size() == 1 articles.article[0].author.'@id' == "3" }

Again, modifying the XML structure requires reinitialization of our articles object.

5. XmlParser vs XmlSlurper

As we showed in our examples, the usages of XmlParser and XmlSlurper are pretty similar. We can more or less achieve the same results with both. However, some differences between them can tilt the scales towards one or the other.

First of all,XmlParser always parses the whole document into the DOM-ish structure. Because of that, we can simultaneously read from and write into it. We can't do the same with XmlSlurper as it evaluates paths more lazily. As a result, XmlParser can consume more memory.

On the other hand, XmlSlurper uses more straightforward definitions, making it simpler to work with. We also need to remember that any structural changes made to XML using XmlSlurper require reinitialization, which can have an unacceptable performance hit in case of making many changes one after another.

The decision of which tool to use should be made with care and depends entirely on the use case.

6. MarkupBuilder

Apart from reading and manipulating the XML tree, Groovy also provides tooling to create an XML document from scratch. Let's now create a document consisting of the first two articles from our first example using groovy.xml.MarkupBuilder:

def "Should create XML properly"() { given: "Node structures" when: "Using MarkupBuilderTest to create xml structure" def writer = new StringWriter() new MarkupBuilder(writer).articles { article { title('First steps in Java') author(id: '1') { firstname('Siena') lastname('Kerr') } 'release-date'('2018-12-01') } article { title('Dockerize your SpringBoot application') author(id: '2') { firstname('Jonas') lastname('Lugo') } 'release-date'('2018-12-01') } } then: "Xml is created properly" XmlUtil.serialize(writer.toString()) == XmlUtil.serialize(xmlFile.text) }

In the above example, we can see that MarkupBuilder uses the very same approach for the Node definitions we used with NodeBuilder and GPathResult previously.

To compare output from MarkupBuilder with the expected XML structure, we used the groovy.xml.XmlUtil#serialize method.

7. Conclusion

In this article, we explored multiple ways of manipulating XML structures using Groovy.

Wir haben uns Beispiele für das Parsen, Hinzufügen, Bearbeiten, Ersetzen und Löschen von Knoten mit zwei von Groovy bereitgestellten Klassen angesehen: XmlParser und XmlSlurper . Wir haben auch Unterschiede zwischen ihnen besprochen und gezeigt, wie wir mit MarkupBuilder einen XML-Baum von Grund auf neu erstellen können .

Wie immer ist der vollständige Code, der in diesem Artikel verwendet wird, auf GitHub verfügbar.