如何在Groovy中使用XmlSlurper处理XML数据？

// 导入XmlSlurper类
import groovy.xml.XmlSlurper

// 示例XML数据，可以是字符串，也可以是文件内容
def xmlContent = """
<catalog>
    <book id="bk101">
        <author>Gambardella, Matthew</author>
        <title>XML Developer's Guide</title>
        <genre>Computer</genre>
        <price>44.95</price>
        <publish_date>2000-10-01</publish_date>
        <description>An in-depth look at creating applications with XML.</description>
    </book>
    <book id="bk102">
        <author>Ralls, Kim</author>
        <title>Midnight Rain</title>
        <genre>Fantasy</genre>
        <price>5.95</price>
        <publish_date>2000-12-16</publish_date>
        <description>A former architect battles an evil sorceress in the present day.</description>
    </book>
    <book id="bk103">
        <author>Corets, Eva</author>
        <title>Maeve Ascendant</title>
        <genre>Fantasy</genre>
        <price>5.95</price>
        <publish_date>2000-11-17</publish_date>
        <description>After the collapse of a nanotechnology society, the survivors...</description>
    </book>
</catalog>
"""

// 1. 解析XML字符串
// 通常我会用parseText()来处理内存中的字符串，或者parse()来处理文件。
def catalog = new XmlSlurper().parseText(xmlContent)

// 2. 访问根节点和子节点
// 你可以像访问对象属性一样访问XML节点
println "根节点名称: ${catalog.name()}" // catalog
println "第一本书的标题: ${catalog.book[0].title}" // XML Developer's Guide
println "第二本书的作者: ${catalog.book[1].author}" // Ralls, Kim

// 3. 访问节点属性
// 使用.@attributeName来访问属性
println "第一本书的ID: ${catalog.book[0].@id}" // bk101

// 4. 遍历节点列表
// XmlSlurper返回的节点集是可迭代的，可以配合each或collect使用
println "\n所有书籍标题和作者:"
catalog.book.each { book ->
    println "  - 标题: ${book.title}, 作者: ${book.author}"
}

// 5. 条件查询 (使用findAll和find)
// 这真是个妙招，你可以用闭包来过滤节点
println "\n查找所有幻想类书籍:"
def fantasyBooks = catalog.book.findAll { it.genre == 'Fantasy' }
fantasyBooks.each { book ->
    println "  - 幻想书: ${book.title} (ID: ${book.@id})"
}

println "\n查找ID为bk101的书籍:"
def bookById = catalog.book.find { it.@id == 'bk101' }
if (bookById) {
    println "  - 找到书籍: ${bookById.title} by ${bookById.author}"
}

// 6. 获取节点文本内容
// 直接访问节点通常会返回其子节点或本身，如果需要纯文本，可以使用.text()
println "\n第一本书的描述文本: ${catalog.book[0].description.text()}"

// 7. 处理深层嵌套
// 无论是多深的嵌套，都可以链式访问
def deepXml = """
<root>
    <data>
        <item>
            <info>
                <detail>Nested Value</detail>
            </info>
        </item>
    </data>
</root>
"""
def root = new XmlSlurper().parseText(deepXml)
println "\n深层嵌套访问: ${root.data.item.info.detail}" // Nested Value

root.node.subNode[0].@attribute

parseText(String)

String

import groovy.xml.XmlSlurper

def largeXmlFile = new File("path/to/your/large.xml")

// 最佳实践：使用InputStream解析
def rootNode
try {
    rootNode = new XmlSlurper().parse(largeXmlFile.newInputStream())
} catch (IOException e) {
    println "读取文件出错: ${e.message}"
    return
}

// 接下来你可以像往常一样遍历和查询
rootNode.someLargeNode.each { item ->
    // 处理每个item，但不要把所有item都collect到一个大列表中
    println "处理节点: ${item.attribute}"
    // 如果需要，这里可以做一些数据转换或写入数据库
}

collect()

List

<record>

def allRecords = root.record.collect { it }

record

allRecords

collect

root.element

XmlSlurper

prefix:elementName

import groovy.xml.XmlSlurper

def nsXml = """
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
    <soap:Body>
        <m:GetStockPriceResponse xmlns:m="http://www.example.com/stock">
            <m:Price>34.50</m:Price>
            <m:Symbol>GOOG</m:Symbol>
        </m:GetStockPriceResponse>
    </soap:Body>
</soap:Envelope>
"""

def slurper = new XmlSlurper()

// 声明命名空间。键是前缀，值是URI。
// 这里我通常会把所有用到的命名空间都声明一遍，避免遗漏。
slurper.declareNamespace([
    soap: "http://schemas.xmlsoap.org/soap/envelope/",
    m: "http://www.example.com/stock"
])

def envelope = slurper.parseText(nsXml)

// 现在你可以使用前缀来访问带有命名空间的元素了
// 注意：即使父节点有命名空间，子节点如果没有声明前缀，也可能需要再次声明或直接访问。
// 但对于这种嵌套结构，通常只要声明了父级和子级可能用到的命名空间，就可以通过链式调用访问。
def price = envelope.'soap:Body'.'m:GetStockPriceResponse'.'m:Price'.text()
def symbol = envelope.'soap:Body'.'m:GetStockPriceResponse'.'m:Symbol'.text()

println "股票价格: ${price}" // 34.50
println "股票代码: ${symbol}" // GOOG

// 如果XML中某个元素没有前缀，但它继承了父级的默认命名空间，
// 那么你可能需要使用特殊的语法来访问，或者将默认命名空间也声明进去。
// 例如：xmlns="http://default.com"
def defaultNsXml = """
<root xmlns="http://default.com">
    <item>
        <value>Default NS Value</value>
    </item>
</root>
"""
def defaultSlurper = new XmlSlurper()
// 声明默认命名空间，通常用一个空字符串作为前缀
defaultSlurper.declareNamespace([
    '': "http://default.com"
])
def defaultRoot = defaultSlurper.parseText(defaultNsXml)
println "\n默认命名空间的值: ${defaultRoot.'item'.'value'}" // Default NS Value
// 注意这里访问时依然要用 '' 作为前缀，或者如果Groovy版本支持，直接访问无前缀的节点名。
// 实际操作中，为了明确性，我倾向于总是使用声明的前缀。

xmlns

''

root.'':elementName