The most commonly used approach for parsing XML with Groovy is to useone of:

• groovy.xml.XmlParser

• groovy.xml.XmlSlurper

Both have the same approach to parse an XML. Both come with a bunch ofoverloaded parse methods plus some special methods such asparseText,parseFile and others. For the next example we will use theparseTextmethod. It parses an XMLString and recursively converts it to a listor map of objects.

Let’s see thesimilarities betweenXMLParser andXMLSlurper first:

• Both are based onSAX so they both are low memory footprint

• Both can update/transform the XML

But they have keydifferences:

• XmlSlurper evaluates the structure lazily. So if you update the xmlyou’ll have to evaluate the whole tree again.

• XmlSlurper returnsGPathResult instances when parsing XML

• XmlParser returnsNode objects when parsing XML

When to use one or the another?

• If you want to transform an existing document to another thenXmlSlurper will be the choice

• If you want to update and read at the same time thenXmlParser isthe choice.

The rationale behind this is that every time you create a node withXmlSlurper it won’t be available until you parse the document againwith anotherXmlSlurper instance. Need to read just a few nodesXmlSlurper is for you ".

• If you just have to read a few nodesXmlSlurper should be yourchoice, since it will not have to create a complete structure inmemory"

In general both classes perform similar way. Even the way of usingGPath expressions with them are the same (both usebreadthFirst() anddepthFirst() expressions). So I guess it depends on the write/readfrequency.

There is another way of parsing XML documents with Groovy with theuse ofgroovy.xml.dom.DOMCategory which is a category class whichadds GPath style operations to Java’s DOM classes.

Having an XML like the following:

You can parse it usinggroovy.xml.DOMBuilder andgroovy.xml.dom.DOMCategory.

static final String books = '''    <response version-api="2.0">        <value>            <books>                <book available="20">                    <title>Don Quixote</title>                    <author>Miguel de Cervantes</author>                </book>                <book available="14">                    <title>Catcher in the Rye</title>                   <author>JD Salinger</author>               </book>               <book available="13">                   <title>Alice in Wonderland</title>                   <author>Lewis Carroll</author>               </book>               <book available="5">                   <title>Don Quixote</title>                   <author>Miguel de Cervantes</author>               </book>           </books>       </value>    </response>'''

First thing we could do is to get a value using POJO’s notation. Let’sget the first book’s author’s name

First we parse the document withXmlSlurper and then we have toconsider the returning value as the root of the XML document, so inthis case is "response".

That’s why we start traversing the document from response and thenvalue.books.book[0].author. Note that inXPath the node arrays startsin [1] instead of [0], but becauseGPath is Java-based it begins atindex 0.

In the end we’ll have the instance of theauthor node and because wewanted the text inside that node we should be calling thetext()method. Theauthor node is an instance ofGPathResult type andtext() a method giving us the content of that node as a String.

When usingGPath with an XML parsed withXmlSlurper we’ll have as aresult aGPathResult object.GPathResult has many other convenientmethods to convert the text inside a node to any other type such as:

• toInteger()

• toFloat()

• toBigInteger()

• …​

All these methods try to convert aString to the appropriate type.

If we were using an XML parsed withXmlParser we could be dealing withinstances of typeNode. But still all the actions applied toGPathResult in these examples could be applied to a Node aswell. Creators of both parsers took into accountGPath compatibility.

Next step is to get some values from a given node’s attribute. In the following samplewe want to get the first book’s author’s id. We’ll be using two different approaches. Let’s see the code first:

As you can see there are two types of notations to get attributes,the

• direct notation with@nameoftheattribute

• map notation using['@nameoftheattribute']

Both of them are equally valid.

If you ever have used XPath, you may have used expressions like:

• /following-sibling::othernode : Look for a node "othernode" in the same level

• // : Look everywhere

More or less we have their counterparts in GPath with the shortcuts* (akachildren()) and** (akadepthFirst()).

The first example shows a simple use of*, which only iterates over the direct children of the node.

This test searches for any child nodes of the "books" node matching the givencondition. In a bit more detail, the expression says:Look for any node witha tag name equal to 'book' having an id with a value of '2' directly underthe 'books' node.

This operation roughly corresponds to thebreadthFirst() method, except thatit only stops atone level instead of continuing to the inner levels.

What if we would like to look for a given valuewithout having to know exactly where it is. Let’s say that theonly thing we know is the id of the author "Lewis Carroll" . How arewe going to be able to find that book? Using** is the solution:

** is the same as looking for somethingeverywhere in thetree from this point down. In this case, we’ve used the methodfind(Closure cl) to find just the first occurrence.

What if we want to collect all book’s titles? That’s easy, just usefindAll:

In the last two examples,** is used as a shortcut for thedepthFirst()method. It goes as far down the tree as it can while navigating down thetree from a given node. ThebreadthFirst() method finishes off all nodeson a given level before traversing down to the next level.

The following example shows the difference between these two methods:

In this example, we search for any nodes with an id attribute with value 2 or 3.There are bothbook andauthor nodes that match that criteria. The differenttraversal orders will find the same nodes in each case but in different orderscorresponding to how the tree was traversed.

It is worth mentioning again that there are some useful methodsconverting a node’s value to an integer, float, etc. Those methodscould be convenient when doing comparisons like this:

In this case the number 2 has been hardcoded but imagine that valuecould have come from any other source (database…​ etc.).

Here is an example of using Groovy’s MarkupBuilder to create a new XML file:

Let’s take a look a little bit closer:

Sometimes you may want to use a specific namespace in your xml documents:

What about having some more meaningful example. We may want togenerate more elements, to have some logic when creating our XML:

Of course the instance of a builder can be passed as a parameter torefactor/modularize your code:

The classgroovy.xml.StreamingMarkupBuilder is a builder class forcreating XML markup. This implementation uses agroovy.xml.streamingmarkupsupport.StreamingMarkupWriter to handleoutput.

Thegroovy.xml.MarkupBuilderHelper is, as its name reflects, ahelper forgroovy.xml.MarkupBuilder.

This helper normally can be accessed from within an instance of classgroovy.xml.MarkupBuilder or an instance ofgroovy.xml.StreamingMarkupBuilder.

This helper could be handy in situations when you may want to:

• Produce a comment in the output

• Produce an XML processing instruction in the output

• Produce an XML declaration in the output

• Print data in the body of the current tag, escaping XML entities

• Print data in the body of the current tag

In bothMarkupBuilder andStreamingMarkupBuilder this helper isaccessed by the propertymkp:

Here is another example to show the use ofmkp property accessiblefrom within thebind method scope when usingStreamingMarkupBuilder:

Suppose we have an existing XML document and we want to automategeneration of the markup without having to type it all in? We justneed to useorg.codehaus.groovy.tools.xml.DOMToGroovy as shown inthe following example:

def xml = """<response version-api="2.0">    <value>        <books>            <book>                <title>Don Quixote</title>                <author>Miguel de Cervantes</author>            </book>        </books>    </value></response>"""

The main difference betweenXmlSlurper andXmlParser is that whenformer creates the nodes they won’t be available until the document’sbeen evaluated again, so you should parse the transformed documentagain in order to be able to see the new nodes. So keep that in mindwhen choosing any of both approaches.

If you needed to see a node right after creating it thenXmlParsershould be your choice, but if you’re planning to do many changes tothe XML and send the result to another process maybeXmlSlurper wouldbe more efficient.

You can’t create a new node directly using theXmlSlurper instance,but you can withXmlParser. The way of creating a new node fromXmlParser is through its methodcreateNode(..)

ThecreateNode() method receives the following parameters:

• parent node (could be null)

• The qualified name for the tag (In this case we only use the localpart without any namespace). We’re using an instance ofgroovy.namespace.QName

• A map with the tag’s attributes (None in this particular case)

Anyway you won’t normally be creating a node from the parser instancebut from the parsed XML instance. That is from aNode or aGPathResult instance.

Take a look at the next example. We are parsing the xml withXmlParserand then creating a new node from the parsed document’s instance(Notice the method here is slightly different in the way it receivesthe parameters):

When usingXmlSlurper,GPathResult instances don’t havecreateNode()method.

We know how to parse the document, add new nodes, now I want to changea given node’s content. Let’s start usingXmlParser andNode. Thisexample changes the first book information to actually another book.

When usingreplaceNode() the closure we pass as parameter shouldfollow the same rules as if we were usinggroovy.xml.MarkupBuilder:

Here’s the same example usingXmlSlurper:

Notice how usingXmlSlurper we have to parse the transformed documentagain in order to find the created nodes. In this particular examplecould be a little bit annoying isn’t it?

Finally both parsers also use the same approach for adding a newattribute to a given attribute. This time again the difference iswhether you want the new nodes to be available right away ornot. FirstXmlParser:

AndXmlSlurper:

When usingXmlSlurper, adding a new attribute doesnot require you to perform a new evaluation.

4.3.1. XmlUtil

def response = new XmlParser().parseText(xml)def nodeToSerialize = response.'**'.find { it.name() == 'author' }def nodeAsText = XmlUtil.serialize(nodeToSerialize)assert nodeAsText ==        XmlUtil.serialize('<?xml version="1.0" encoding="UTF-8"?><author>Miguel de Cervantes</author>')