如何在 Go 中解析具有相同标签名但不同属性值的嵌套 XML 数组-Golang-PHP中文网

如何在 Go 中解析具有相同标签名但不同属性值的嵌套 XML 数组

本文介绍一种绕过 Go 标准库 xml 包字段标签冲突限制的方法：通过分步解析，先保留原始 XML 片段，再基于 name 属性动态区分并解码同名元素，从而正确处理攻击者与物品两类数据。

本文介绍一种绕过 go 标准库 `xml` 包字段标签冲突限制的方法：通过分步解析，先保留原始 xml 片段，再基于 `name` 属性动态区分并解码同名 `` 元素，从而正确处理攻击者与物品两类数据。

在 Go 中解析结构复杂的 XML 时，常遇到多个同名容器元素（如 <rowset></rowset>）嵌套在相同路径下、仅靠 name 属性区分语义的情况。此时若直接使用结构体字段标签（如 xml:"rowset>row"）声明多个字段，编译器会报错：field "Attackers" with tag "rowset>row" conflicts with field "Items" —— 因为 encoding/xml 不支持基于属性值的条件性字段绑定。

解决该问题的核心思路是延迟解析（deferred unmarshaling）：不依赖单一 Unmarshal 调用完成全部映射，而是分两阶段处理：

第一阶段：粗粒度解析
将含歧义的 <rowset></rowset> 内容整体作为 []byte 原始 XML 数据捕获，避免标签冲突；
第二阶段：按需精解析
使用 xml.Decoder 手动遍历 Token 流，根据 <rowset name="attackers"></rowset> 或 <rowset name="items"></rowset> 的 name 属性动态切换目标结构体类型，逐个解码 <row></row> 元素。

以下为完整实现示例：

type Kill struct {
    KillID        int64  `xml:"killID,attr"`
    SolarSystemID int64  `xml:"solarSystemID,attr"`
    Victim        Victim `xml:"victim"`
    // 关键：将冲突的 rowset 暂存为原始字节
    RawAttackersItems []byte `xml:",innerxml" json:"-"`
    // 运行时填充的切片，不参与初始 XML 解析
    Attackers []Attacker `xml:"-"`
    Items     []Item     `xml:"-"`
}

type Kills struct {
    Kills []Kill `xml:"result>rowset>row"`
}

解析逻辑如下：

v := &Kills{}
if err := xml.Unmarshal([]byte(xmlText), v); err != nil {
    log.Fatal("XML unmarshal failed:", err)
}

// 对每个 Kill，解析其内部 raw XML
for i := range v.Kills {
    attackers, items := decodeAttackerAndItems(v.Kills[i].RawAttackersItems)
    v.Kills[i].Attackers = attackers
    v.Kills[i].Items = items
}

核心解码函数 decodeAttackerAndItems 利用 xml.Decoder.Token() 逐项扫描，识别 <rowset name="..."></rowset> 属性并切换上下文状态：

func decodeAttackerAndItems(data []byte) ([]Attacker, []Item) {
    decoder := xml.NewDecoder(bytes.NewReader(data))
    var (
        state      = 0 // 0: unknown, 1: attackers, 2: items
        attackers  []Attacker
        items      []Item
    )

    for {
        t, err := decoder.Token()
        if err != nil || t == nil {
            break
        }

        switch se := t.(type) {
        case xml.StartElement:
            if se.Name.Local == "rowset" {
                // 检查 name 属性决定当前上下文
                for _, attr := range se.Attr {
                    if attr.Name.Local == "name" {
                        switch attr.Value {
                        case "attackers":
                            state = 1
                        case "items":
                            state = 2
                        }
                        break
                    }
                }
            } else if se.Name.Local == "row" && (state == 1 || state == 2) {
                // 根据当前 state 解码对应结构体
                switch state {
                case 1:
                    var a Attacker
                    if err := decoder.DecodeElement(&a, &se); err == nil {
                        attackers = append(attackers, a)
                    }
                case 2:
                    var it Item
                    if err := decoder.DecodeElement(&it, &se); err == nil {
                        items = append(items, it)
                    }
                }
            }
        }
    }
    return attackers, items
}

⚠️ 注意事项：

xml.Decoder 是状态机驱动，必须严格匹配起始/结束标签；本例中仅处理 <row></row>，忽略其他节点，确保健壮性；
RawAttackersItems 字段使用 ,innerxml 标签，可捕获 <rowset></rowset> 开闭标签之间的全部内容（含子元素），而非仅文本；
若 XML 存在命名空间或 CDATA，需在 decoder 上额外配置（如 decoder.Strict = false）；
此方案牺牲了部分声明式简洁性，但换来了对非标准 XML 结构的完全控制力——尤其适用于解析第三方 API（如 EVE Online XML 接口）等无法修改源格式的场景。