如何用Groovy/Java实现任意深度XML节点的递归遍历？

没问题，我来帮你解决这个递归遍历XML节点的问题！你当前的代码只能遍历顶层的TestSuite1和TestSuite2，是因为缺少处理子节点的递归逻辑。下面针对你的XML结构，给出Groovy和Java两种实现方案：

你的XML结构 #

<testItems> 
  <children> 
    <testItem name=TestSuite1> 
      <children> 
        <testItem name=test1> </testItem> 
        <testItem name=test2> </testItem> 
        <testItem name=test3> </testItem> 
      </children> 
    </testItem> 
    <testItem name=TestSuite2> 
      <children> 
        <testItem name=test3> </testItem> 
        <testItem name=test4> </testItem> 
        <testItem name=test5> </testItem> 
      </children> 
    </testItem> 
  </children> 
</testItems>

Groovy 递归实现 #

Groovy对XML的处理非常简洁，我们可以写一个递归函数来处理每个testItem，自动深入子节点：

// 递归处理单个testItem节点的函数
def traverseTestItem(testItem) {
    // 这里写你对当前节点的处理逻辑，比如打印节点名称
    println "当前节点: ${testItem.@name}"
    
    // 使用安全导航符避免空指针，检查当前节点是否有子testItem
    if (testItem.children?.testItem) {
        testItem.children.testItem.each { child ->
            traverseTestItem(child)
        }
    }
}

// 从顶层testItem开始遍历
root.testItems.children.testItem.each { topItem ->
    traverseTestItem(topItem)
}

这段代码的核心是traverseTestItem函数：先处理当前节点，然后检查该节点下是否有children里的testItem，如果有就递归调用自己，这样就能覆盖所有层级的节点，不管深度是多少。

Java 递归实现（DOM解析） #

如果用Java实现，我们可以借助DOM解析器来遍历所有节点：

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.File;

public class TestItemRecursiveTraverser {
    public static void main(String[] args) {
        try {
            // 加载XML文件（替换成你的XML路径）
            File xmlFile = new File("test-items.xml");
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document doc = builder.parse(xmlFile);
            doc.getDocumentElement().normalize();
            
            // 获取所有顶层testItem节点
            NodeList topTestItems = doc.getElementsByTagName("testItem");
            for (int i = 0; i < topTestItems.getLength(); i++) {
                Node node = topTestItems.item(i);
                if (node.getNodeType() == Node.ELEMENT_NODE) {
                    processTestItem((Element) node);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 递归处理单个testItem节点
    private static void processTestItem(Element testItem) {
        // 获取当前节点的name属性
        String nodeName = testItem.getAttribute("name");
        System.out.println("当前节点: " + nodeName);
        
        // 获取当前节点的children子节点
        NodeList childrenNodes = testItem.getElementsByTagName("children");
        if (childrenNodes.getLength() > 0) {
            Element childrenElement = (Element) childrenNodes.item(0);
            // 获取children下的所有testItem子节点
            NodeList childTestItems = childrenElement.getElementsByTagName("testItem");
            for (int i = 0; i < childTestItems.getLength(); i++) {
                Node childNode = childTestItems.item(i);
                if (childNode.getNodeType() == Node.ELEMENT_NODE) {
                    processTestItem((Element) childNode);
                }
            }
        }
    }
}

这个Java代码通过递归调用processTestItem方法，逐层遍历所有testItem节点，无论XML的深度如何变化都能覆盖到。

核心思路总结 #

不管是Groovy还是Java，核心逻辑都是递归自调用：

1. 处理当前节点的业务逻辑（比如打印名称、执行测试等）
2. 检查当前节点是否包含子testItem节点
3. 如果存在子节点，对每个子节点重复执行上述步骤

这样就能完美解决你遇到的只能遍历顶层节点的问题啦！

内容的提问来源于stack exchange，提问作者George Cimpoies