XML反序列化时如何保留元素的全局顺序？

问题背景 #

XML元素的顺序至关重要，现有如下XML代码：

<s>
    <a toto="toto"/>
    <b data="data"/>
    <a toto="tata"/>
    <b data="doto"/>
</s>

使用常规Go结构体反序列化时：

type A struct {
    Toto string `xml:"toto,attr"`
}

type B struct {
    Data string `xml:"data,attr"`
}

type S struct {
    As []A `xml:"a"`
    Bs []B `xml:"b"`
}

// 反序列化调用
xml.Unmarshal(MyXML, &S)

虽然能获取所有A、B的数据且各自内部有序，但两类元素的全局顺序会丢失。在无法修改XML数据源的情况下，可通过以下方案保留元素全局顺序：

解决方案 #

方法1：接口切片存储混合元素 #

定义接口类型，配合xml:",any"标签捕获所有子元素，天然保留顺序：

type Element interface{}

type S struct {
    Elements []Element `xml:",any"`
}

type A struct {
    XMLName xml.Name `xml:"a"`
    Toto    string   `xml:"toto,attr"`
}

type B struct {
    XMLName xml.Name `xml:"b"`
    Data    string   `xml:"data,attr"`
}

反序列化后，Elements切片会严格按XML中的顺序存储A或B实例，通过类型断言区分元素类型：

var s S
err := xml.Unmarshal([]byte(xmlStr), &s)
if err != nil {
    panic(err)
}

for _, elem := range s.Elements {
    switch e := elem.(type) {
    case *A:
        fmt.Printf("A元素：%+v\n", e)
    case *B:
        fmt.Printf("B元素：%+v\n", e)
    }
}

方法2：自定义Unmarshaler接口实现 #

手动解析XML令牌流，完全控制解析逻辑，精准保留顺序：

import (
    "encoding/xml"
    "io"
)

type S struct {
    OrderedElements []interface{}
}

type A struct {
    Toto string `xml:"toto,attr"`
}

type B struct {
    Data string `xml:"data,attr"`
}

func (s *S) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
    s.OrderedElements = []interface{}{}
    for {
        token, err := d.Token()
        if err != nil {
            if err == io.EOF {
                break
            }
            return err
        }

        switch t := token.(type) {
        case xml.StartElement:
            switch t.Name.Local {
            case "a":
                var a A
                if err := d.DecodeElement(&a, &t); err != nil {
                    return err
                }
                s.OrderedElements = append(s.OrderedElements, a)
            case "b":
                var b B
                if err := d.DecodeElement(&b, &t); err != nil {
                    return err
                }
                s.OrderedElements = append(s.OrderedElements, b)
            }
        case xml.EndElement:
            if t == start.End() {
                return nil
            }
        }
    }
    return nil
}

这种方式还能灵活处理未知元素、跳过空节点等特殊场景。

方法3：混合结构体切片（简单场景适配） #

定义包含所有可能元素的结构体，用切片存储，通过非空字段判断元素类型：

type MixedElement struct {
    A *A `xml:"a,omitempty"`
    B *B `xml:"b,omitempty"`
}

type S struct {
    Elements []MixedElement `xml:",any"`
}

反序列化后，每个MixedElement实例只会有一个字段非空，遍历切片时判断即可获取对应元素和顺序。

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