【Groovy】自定义 Xml 生成器 BuilderSupport ( 创建 XmlNode 节点 | 管理 XmlNode 节点并将根节点转为 Xml 信息 | 完整代码示例 )

    /**
     * Map 集合
     * Key 为 节点的 name 名称
     * Value 为 节点 XmlNode 对象
     */
    def xmlNodes = [:]

    @Override
    protected Object createNode(Object name, Map attributes, Object value) {
        println "创建节点 名称 : $name, 属性 : $attributes, 值 : $value"
        xmlNodes.put(name, new XmlNode(name, value, attributes))
        return name;
    }

    @Override
    protected void nodeCompleted(Object parent, Object node) {
        super.nodeCompleted(parent, node)
	}

def currentXmlNode = xmlNodes[node]

        if (parent) {
            // 该节点有父节点, 将该节点放入父节点的 children 集合中
            xmlNodes[parent].children << currentXmlNode
        } 

            // 如果该节点没有父节点, 说明该节点就是根节点, 则开始构建 Xml 文件
            currentXmlNode.build(writer)

import groovy.util.BuilderSupport;

import java.util.Map;

public class MyBuilderSupport extends BuilderSupport {

    /**
     * Map 集合
     * Key 为 节点的 name 名称
     * Value 为 节点 XmlNode 对象
     */
    def xmlNodes = [:]

    /**
     * 写用于出 Xml 数据
     */
    Writer writer

    MyBuilderSupport(Writer writer) {
        this.writer = writer
    }

    /**
     * 设置节点之间的关系
     * @param parent Xml 中的父节点
     * @param child Xml 中的父节点下的子节点
     */
    @Override
    protected void setParent(Object parent, Object child) {
        println "setParent 设置子节点 ${child} 的父节点是 ${parent}"
    }

    @Override
    protected Object createNode(Object name) {
        /*
            所有的 createNode 方法都回调到 3 个参数的 createNode 方法
         */
        return createNode(name, null, null);
    }

    @Override
    protected Object createNode(Object name, Object value) {
        /*
            所有的 createNode 方法都回调到 3 个参数的 createNode 方法
         */
        return createNode(name, null, value);
    }

    @Override
    protected Object createNode(Object name, Map attributes) {
        /*
            所有的 createNode 方法都回调到 3 个参数的 createNode 方法
         */
        return createNode(name, attributes, null);
    }

    @Override
    protected Object createNode(Object name, Map attributes, Object value) {
        println "创建节点 名称 : $name, 属性 : $attributes, 值 : $value"
        xmlNodes.put(name, new XmlNode(name, value, attributes))
        return name;
    }

    /**
     * 闭合节点时, 回调该方法
     * @param parent
     * @param node
     */
    @Override
    protected void nodeCompleted(Object parent, Object node) {
        super.nodeCompleted(parent, node)
        println "nodeCompleted 完成了父节点为 parent : $parent  的节点 node : $node 的闭合操作"

        def currentXmlNode = xmlNodes[node]
        if (parent) {
            // 该节点有父节点, 将该节点放入父节点的 children 集合中
            xmlNodes[parent].children << currentXmlNode
        } else {
            // 如果该节点没有父节点, 说明该节点就是根节点, 则开始构建 Xml 文件
            currentXmlNode.build(writer)
        }
    }
}

class XmlNode {
    /**
     * 节点名称
     */
    String name

    /**
     * 节点值
     */
    String value

    /**
     * 节点属性
     */
    Map attributes

    /**
     * 子节点 ArrayList 类型
     */
    def children = []


    XmlNode(String name, String value, Map attributes) {
        this.name = name
        this.value = value
        this.attributes = attributes
    }


/*
<student>
    <name code="utf-8">Tom</name>
    <age>18</age>
</student>
*/

    /**
     * 写出该 XmlNode 节点数据
     * @param writer
     */
    def build(Writer writer) {
        /*
            写出 name 节点名称
            注意 : 此处有 2 种情况
            ① 带属性的节点 <name code="utf-8">Tom</name>
            ② 不带属性的节点 <age/>
            先写出 "<name"
         */
        writer.write("<${name}")

        /*
            假如该节点有节点属性信息
            循环写出节点属性
         */
        if (attributes != null) {
            attributes.each {
                writer.write(" ${it.key}='${it.value}'")
            }
        }

        /*
            可能有如下情况
            节点有值, 没有子节点
            节点没有值, 没有子节点
            节点有值, 有子节点
            节点没有值, 有子节点
            既没有值有没有子节点
            要兼顾处理上述 5 种情况
         */
        if (value != null || children != null) {
            // 处理前 4 种情况

            writer.write(">")

            if (value != null){
                writer.write("${value}")
            }

            if (children != null) {
                children.each {
                    it.build(writer)
                }
            }

            // 节点收尾
            writer.write("</${name}>")

        } else {
            // 既没有值有没有子节点的情况
            // <age/> , 之前写出了 "<age" , 现在写出 "/>"
            writer.write("/>")
        }
    }
}

// 用于输出字符串
StringWriter stringWriter = new StringWriter()

// 创建自定义 Xml 构造器
def myBuilderSupport = new MyBuilderSupport(stringWriter)

// 构建 student 根节点
myBuilderSupport.student {
    // 构建 student 根节点下的 name 节点
    // 该节点有 code: "UTF-8" 属性
    // 节点元素为 "Tom" 字符串
    name("Tom", code: "UTF-8")

    age("18")
}

println ""
println(stringWriter)

创建节点 名称 : student, 属性 : null, 值 : null
创建节点 名称 : name, 属性 : [code:UTF-8], 值 : Tom
setParent 设置子节点 name 的父节点是 student
nodeCompleted 完成了父节点为 parent : student  的节点 node : name 的闭合操作
创建节点 名称 : age, 属性 : null, 值 : 18
setParent 设置子节点 age 的父节点是 student
nodeCompleted 完成了父节点为 parent : student  的节点 node : age 的闭合操作
nodeCompleted 完成了父节点为 parent : null  的节点 node : student 的闭合操作

<student><name code='UTF-8'>Tom</name><age>18</age></student>

<student><name code='UTF-8'>Tom</name><age>18</age></student>