Versions Compared

Key

  • This line was added.
  • This line was removed.
  • Formatting was changed.

GPath is a path expression language integrated into Groovy which allows parts of nested structured data to be identified. In this sense, it has similar aims and scope as XPath does for XML. The two main places where you use GPath expressions is when dealing with nested POJOs or when dealing with XML.

As an example, you can specify a path to an object or element of interest:
a.b.c -> for XML, yields all the <c> elements inside <b> inside <a>
a.b.c -> all POJOs, yields the <c> properties for all the <b> properties of <a> (sort of like a.getB().getC() in JavaBeans)

For XML, you can also specify attributes, e.g.:
a["@href"] -> the href attribute of all the a elements
a.'@href' -> an alternative way of expressing this
a.@href -> an alternative way of expressing this when using XmlSlurper

Example

The best example of GPath for xml is test-new/groovy/util/XmlSlurperTest.groovy.

Code Block
package groovy.util

class XmlSlurperTest extends GroovyTestCase {

void testXmlParser() {
    def text = """
<characters>
  <props>
    <prop>dd</prop>
  </props>
  <character id="1" name="Wallace">
     <likes>cheese</likes>
  </character>
  <character id="2" name="Gromit">
    <likes>sleep</likes>
  </character>
</characters>
"""

    def node = new XmlSlurper().parseText(text);

    assert node != null
    assert node.children().size() == 3 //, "Children ${node.children()}"

    def characters = node.character
    println "node:" + node.children().size()
    println "characters:" + node.character.size()
    for (c in characters) {
        println c['@name']
    }

    assert characters.size() == 2

    assert node.character.likes.size() == 2 //, "Likes ${node.character.likes}"

    // lets find Gromit
    def gromit = node.character.find { it['@id'] == '2' }
    assert gromit != null //, "Should have found Gromit!"
    assert gromit['@name'] == "Gromit"

    // lets find what Wallace likes in 1 query
    def answer = node.character.find { it['@id'] == '1' }.likes.text()
    assert answer == "cheese"
}
}

Outline

1.Accessing element as property
Code Block
def  characters = node.character
def  gromit =  node.character[1]
2.Accessing attributes
Code Block
println gromit['@name']
or
println gromit.@name
3.Accessing element body
Code Block
println gromit.likes[0].text()
println node.text()

If the element is a father node,it will print all children's text.

3.Explore the DOM use children() and parent()
Code Block
def characters = node.children()
for (c in characters) {
    println c.@name
}
4.Find elements use expression
Code Block
def gromit = node.character.find { it.@id == '2' }

Another Example

Here is a two line example of how to get a list of all the links to .xml files listed on a web page. The Neko parser is used to parse non-well formed html. It no longer ships as part of the standard Groovy distribution but can be downloaded and dropped into the lib directory of your Groovy distribution. You'll need to also add a copy of xercesImpl.jar to the groovy lib directory.

Code Block
def myDocument = new XmlParser( new org.cyberneko.html.parsers.SAXParser() ).parse("http://myUrl.com")
def links = myDocument.depthFirst().A['@href'].findAll{ it.endsWith(".xml") }

More Information

See also: Processing XML