传递XML路径并计算

我正在从事一个项目，需要解析一个XML文件，并在100个不同的XML路径/节点上执行完全相同的代码。我的代码目前看起来像这样

def items = parser.parseText(inputFile.text)

items.item.each { item ->
    try {
        // do stuff with item.some_node
    } catch(Exception ex) {
        //exception stuff
    }
    try {
        // do stuff with item.weight_node
    } catch(Exception ex) {
        //exception stuff
    }
    try {
        // do stuff with item.another_node[3].sub_node
    } catch(Exception ex) {
        //exception stuff
    }
    try {
        // do stuff with item.some_node
    } catch(Exception ex) {
        //exception stuff
    }
    // do this a 100 times or so with other item node paths
}

def myMethod(currentNode) {
    try {
        // do stuff
    } catch(Exception ex) {
        //exception stuff
    }
}

items.item.each { item ->
    myMethod(item.some_node)
    myMethod(item.weight_node)
    myMethod(item.another_node[3].sub_node)
    myMethod(item.some_node)
}

// OR

def myProcess(NodeList n){
    try {
        // do stuff
    } catch(Exception ex) {
        //exception stuff
    }
}
NodeList.metaClass.myProcess = { -> myProcess(delegate) }

items.item.each { item ->
    item.some_node.myMethod()
    item.weight_node.myMethod()
    item.another_node[3].sub_node.myMethod()
    item.some_node.myMethod()
}

因为每次“stuff to do”和异常“stuff”都是完全相同的，唯一改变的是我正在使用的节点。因此，我宁愿将节点表达式发送到一个方法，或者像这样扩展节点类

def items = parser.parseText(inputFile.text)

items.item.each { item ->
    try {
        // do stuff with item.some_node
    } catch(Exception ex) {
        //exception stuff
    }
    try {
        // do stuff with item.weight_node
    } catch(Exception ex) {
        //exception stuff
    }
    try {
        // do stuff with item.another_node[3].sub_node
    } catch(Exception ex) {
        //exception stuff
    }
    try {
        // do stuff with item.some_node
    } catch(Exception ex) {
        //exception stuff
    }
    // do this a 100 times or so with other item node paths
}

def myMethod(currentNode) {
    try {
        // do stuff
    } catch(Exception ex) {
        //exception stuff
    }
}

items.item.each { item ->
    myMethod(item.some_node)
    myMethod(item.weight_node)
    myMethod(item.another_node[3].sub_node)
    myMethod(item.some_node)
}

// OR

def myProcess(NodeList n){
    try {
        // do stuff
    } catch(Exception ex) {
        //exception stuff
    }
}
NodeList.metaClass.myProcess = { -> myProcess(delegate) }

items.item.each { item ->
    item.some_node.myMethod()
    item.weight_node.myMethod()
    item.another_node[3].sub_node.myMethod()
    item.some_node.myMethod()
}

对于方法尝试，我无法理解如何将XPath传递给该方法，然后使用它。使用类扩展方法，只要节点实际存在，它就会工作。如果没有，我会在尝试调用myProcess时出错

---

有什么想法吗？

因为没有xml，所以以xml为例

您确实需要像最初提到的那样为每个节点编写代码

在groovy中，使用

find

（返回单个值）或

findAll

（多个值）可以轻松实现这一点。请参见下面的示例

def jdbcResponse = """<Results>
    <ResultSet fetchSize="10">
        <Row rowNumber="1">
            <T1>TEXT1</T1>
            <T2>TASK1</T2>
            <T3>Value1</T3>
            <T4>xyz</T4>
      </Row>
       <Row rowNumber="2">
            <T1>TEXT2</T1>
            <T2>TASK2</T2>
            <T3>Value1a</T3>
            <T4>ABC</T4>
      </Row>
     </ResultSet>
</Results>"""

def xml = new XmlSlurper().parseText(jdbcResponse)

//Return the matching element
def getData = { elementName ->
    xml.'**'.findAll{it.name() == elementName}
}

//Coerced result to List of string as T1/2 is not complex
def t1s = getData('T1') as List<String>
def t2s = getData('T2') as List<String>
println t1s

//Here you get Rows which is complex, so not coerced
def rows = getData('Row')
//Check if first row T1 is TEXT1
assert rows[0].T1.text() == 'TEXT1'

def jdbcsponse=“”
文本1
任务1
价值1
xyz
文本2
任务2
价值1a
基础知识
"""
def xml=new XmlSlurper（）.parseText（jdbcResponse）
//返回匹配的元素
def getData={elementName->
xml.'**'.findAll{it.name（）==elementName}
}
//强制将结果作为T1/2写入字符串列表并不复杂
def t1s=getData（'T1'）作为列表
def t2s=getData（'T2'）作为列表
println-t1s
//这里得到的行很复杂，所以不是强制的
def rows=getData（'行'）
//检查第一行T1是否为TEXT1
断言行[0]。T1.text（）=“TEXT1”

对于第二种情况

NodeList.metaClass.myProcess = { -> myProcess(delegate) }

items.item.each { item ->
    item.some_node.myMethod()
    item.weight_node.myMethod()
    ...
}

您可以使用空安全访问器来避免不存在节点上的异常：

items.item.each { item ->
    item?.some_node?.myMethod()
    item?.weight_node?.myMethod()
    ...
}

---

dscl，你试过这个解决方案吗？