在解组 XML 时保留子类型顺序的可变子类型使用

从现在开始，我们要努力学习啦！今天我给大家带来《在解组 XML 时保留子类型顺序的可变子类型使用》，感兴趣的朋友请继续看下去吧！下文中的内容我们主要会涉及到等等知识点，如果在阅读本文过程中有遇到不清楚的地方，欢迎留言呀！我们一起讨论，一起学习！

我有一个 xml 结构，其中包含一组可变的子元素。我想将这些子对象解组到一个结构中，同时保留它们的顺序。我目前正在使用 encoding/xml 来解组 xml，但这不是严格要求。

示例 xml 结构：

    // ... more packet elements
    
        main npc update message
        
        
        
        
        
        
        
        
    
    // ... more packet elements

我所指的变量元素是 packet 元素的子元素。

我的模型如下所示：

type Protocol struct {
    Packets []ProtocolPacket `xml:"packet"`
}

type ProtocolPacket struct {
    Family       string                `xml:"family,attr"`
    Action       string                `xml:"action,attr"`
    Instructions /* ??? */             `xml:",any"`
    Comment      string                `xml:"comment"`
}

在此 xml 规范中，有许多不同的元素，例如上面示例中所示的 array、break 和 field，需要将它们合并为单个切片，同时保持其顺序。这些通常被称为“指令”。 （示例中的 comment 是一种特殊情况，只能看到一次）。

我完全不知道如何对“指令”列表进行建模。我的一个想法是使用自定义解组器创建一个接口 protocolinstruction ，该解组器根据元素类型分配实现，但我认为这种模式行不通，因为您需要提前知道解组函数的接收器类型以满足适当的接口。

我遇到了这个问题，但建议的答案不保留不同元素名称之间元素的顺序。我的另一个想法是使用此方法，但为每种类型编写自定义解组器，以增加计数器并存储元素索引 - 这样即使未保留顺序，至少可以检索它。然而，这看起来工作量很大，而且实现起来很混乱，所以我正在寻找替代方案。

有没有办法解组可变子 xml 元素，同时保留它们在 go 中的顺序？

正确答案

解决方案1

利用（迄今为止）unmarshal extra attributes 的最高评价答案，您可以创建简单的结构：

type protocol struct {
    packets []packet `xml:"packet"`
}

type packet struct {
    family  string `xml:"family,attr"`
    action  string `xml:"action,attr"`
    comment string `xml:"comment"`

    instructions []instruction `xml:",any"`
}

type instruction struct {
    name  xml.name
    attrs []xml.attr `xml:",any,attr"`
}

数据包中任何未由数据包结构顶部的更精确规则处理的元素都将传递给指令，该指令会将元素解码为其名称及其属性片段。

解组示例 xml 将生成一个包含 packets.instructions 的 var 协议，其中包含相当原始的 xml 值（稍后您可以看到我在 string 方法中处理这些值）：

var protocol protocol
xml.unmarshal([]byte(opxml), &protocol)

for _, it := range protocol.packets[0].instructions {
    fmt.println(it)
}

{name:array attrs:{name:positions type:npcupdateposition}}
{name:break attrs:{}}
{name:array attrs:{name:attacks type:npcupdateattack}}
{name:break attrs:{}}
{name:array attrs:{name:chats type:npcupdatechat}}
{name:break attrs:{}}
{name:field attrs:{name:hp type:short optional:true}}
{name:field attrs:{name:tp type:short optional:true}}

指令的字符串方法：

func (it instruction) string() (s string) {
    s += fmt.sprintf("{name:%s", it.name.local)
    s += " attrs:{"
    sep := ""
    for _, attr := range it.attrs {
        s += fmt.sprintf("%s%s:%s", sep, attr.name.local, attr.value)
        sep = " "
    }
    s += "}}"
    return
}

解决方案2

同一问题的 accepted answer 举例说明了如何制作自己的解组器，就像您所建议的那样。不知道你想要什么样的结构。我不知道泛型（也许有一个更干净的泛型解决方案），所以我想出了以下内容。协议和数据包结构保持不变，最大的变化是指令：

type instruction struct {
    name string

    arrayattrs struct{ name, type_ string }
    fieldattrs struct {
        name, type_ string
        optional    bool
    }
}

及其解组器：

type instruction struct {
    name string

    array *array
    field *field
}

type array struct {
    name, type_ string
}

type field struct {
    name, type_ string
    optional    bool
}

func (it *instruction) unmarshalxml(d *xml.decoder, start xml.startelement) error {
    it.name = start.name.local

    switch it.name {
    case "array":
        it.array = &array{}
        for _, attr := range start.attr {
            value := attr.value
            switch attr.name.local {
            case "name":
                it.array.name = value
            case "type":
                it.array.type_ = value
            }
        }
    case "field":
        it.field = &field{}
        for _, attr := range start.attr {
            value := attr.value
            switch attr.name.local {
            case "name":
                it.field.name = value
            case "type":
                it.field.type_ = value
            case "optional":
                vb, _ := strconv.parsebool(value)
                it.field.optional = vb
            }
        }
    }

    return d.skip()
}

func (it instruction) string() (s string) {
    switch it.name {
    case "array":
        s = fmt.sprintf("{array: {name:%s type:%s}}", it.array.name, it.array.type_)
    case "break":
        s = "{break: {}}"
    case "field":
        s = fmt.sprintf("{field: {name:%s type:%s optional:%t}}", it.field.name, it.field.type_, it.field.optional)
    }
    return
}

在 main 中使用相同的解组代码（来自上面）：

{array: {name:positions type:npcupdateposition}}
{break: {}}
{array: {name:attacks type:npcupdateattack}}
{break: {}}
{array: {name:chats type:npcupdatechat}}
{break: {}}
{field: {name:hp type:short optional:true}}
{field: {name:tp type:short optional:true}}

解决方案3

从 RawMessage (Unmarshal) example in the JSON documentation 中汲取灵感，看起来拥抱 any 类型可以实现我迄今为止尝试过的最简单的结构表示：

type protocol struct {
    packets []packet `xml:"packet"`
}

type packet struct {
    family  string `xml:"family,attr"`
    action  string `xml:"action,attr"`
    comment string `xml:"comment"`

    instructions []any `xml:",any"`
}

type array struct {
    name string `xml:"name,attr"`
    type string `xml:"type,attr"`
}

type break struct{}

type field struct {
    name     string `xml:"name,attr"`
    type     string `xml:"type,attr"`
    optional bool   `xml:"optional,attr"`
}

这使得使用结构看起来更直接（就我的感受而言）：

var p protocol
must(xml.unmarshal([]byte(sxml), &p))
for _, it := range p.packets[0].instructions {
    fmt.printf("%t: %+v\n", it, it)
}

获取：

*main.array: &{name:positions type:npcupdateposition}
*main.break: &{}
*main.array: &{name:attacks type:npcupdateattack}
*main.break: &{}
*main.array: &{name:chats type:npcupdatechat}
*main.break: &{}
*main.field: &{name:hp type:short optional:true}
*main.field: &{name:tp type:short optional:true}

所以，我想这意味着 unmarshalxml 必须平衡逻辑和工作：

func (p *packet) unmarshalxml(d *xml.decoder, start xml.startelement) error {
    for _, attr := range start.attr {
        switch attr.name.local {
        case "family":
            p.family = attr.value
        case "action":
            p.action = attr.value
        }
    }

    for {
        t, err := d.token()
        if ateof(err) {
            break
        }

        if ee, ok := t.(xml.endelement); ok {
            if ee.name.local == start.name.local {
                break
            }
        }

        se, ok := t.(xml.startelement)
        if !ok {
            continue
        }

        if se.name.local == "comment" {
            var s string
            must(d.decodeelement(&s, &se))
            p.comment = s
            continue
        }

        var dst any
        switch se.name.local {
        default:
            continue
        case "array":
            dst = new(array)
        case "break":
            dst = new(break)
        case "field":
            dst = new(field)
        }
        must(d.decodeelement(dst, &se))

        p.instructions = append(p.instructions, dst)
    }

    return nil
}

我仍然不明白 xml.unmarshaler 类型文档中的实现说明：

unmarshalxml 解码以给定起始元素开头的单个 xml 元素。如果它返回错误，则对 unmarshal 的外部调用将停止并返回该错误。 unmarshalxml 必须恰好使用一个 xml 元素。一种常见的实现策略是使用 d.decodeelement 解组为布局与预期 xml 匹配的单独值，然后将数据从该值复制到接收器中。另一种常见策略是使用 d.token 一次处理一个标记的 xml 对象。 unmarshalxml 不能使用 d.rawtoken。

我通过反复试验学到的一件事是“unmarshalxml 必须恰好消耗一个 xml 元素”的含义。为了满足该约束，我添加了检查以查看解码器是否遇到名称与起始元素匹配的结束元素：

if ee, ok := t.(xml.EndElement); ok {
    if ee.Name.Local == start.Name.Local {
        break
    }
}

不过，我现在意识到这不适用于嵌套元素。一个简单的深度计数器/跟踪器应该可以解决这个问题。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。