Go语言中处理有序多态XML类型反序列化：xml.Decoder的深度应用

package main

import (
    "bytes"
    "encoding/xml"
    "fmt"
)

// Executer 是所有指令必须实现的接口
type Executer interface {
    Execute() error
}

// Play 指令：播放文件，可指定循环次数
type Play struct {
    Loops int    `xml:"loops,attr"`  // XML属性 "loops"
    File  string `xml:",innerxml"` // XML元素内部文本作为文件路径
}

// Execute 实现 Play 指令的逻辑
func (p *Play) Execute() error {
    for i := 0; i < p.Loops; i++ {
        fmt.Println(`o/ ` + p.File)
    }
    return nil
}

// Say 指令：说出一段文本
type Say struct {
    Voice string `xml:",innerxml"` // XML元素内部文本作为要说出的内容
}

// Execute 实现 Say 指令的逻辑
func (s *Say) Execute() error {
    fmt.Println(s.Voice)
    return nil
}

// factoryMap 用于注册不同指令类型的构造函数
var factoryMap map[string]func() Executer = make(map[string]func() Executer)

// init 函数在包加载时自动执行，用于注册指令
func init() {
    factoryMap["Play"] = func() Executer { return new(Play) }
    factoryMap["Say"] = func() Executer { return new(Say) }
}

// Unmarshal 函数负责解析XML字节数组，返回一个Executer切片
func Unmarshal(b []byte) ([]Executer, error) {
    d := xml.NewDecoder(bytes.NewReader(b)) // 创建XML解码器

    var actions []Executer // 用于存储解析出的指令

    // 1. 寻找根标签
    // 遍历直到找到第一个 StartElement，通常是XML的根标签
    for {
        v, err := d.Token()
        if err != nil {
            return nil, fmt.Errorf("查找根标签失败: %w", err)
        }

        if _, ok := v.(xml.StartElement); ok {
            break // 找到根标签，跳出循环
        }
    }

    // 2. 循环解析根标签内的所有子元素（指令）
    for {
        v, err := d.Token() // 获取下一个XML令牌
        if err != nil {
            return nil, fmt.Errorf("获取XML令牌失败: %w", err)
        }

        switch t := v.(type) {
        case xml.StartElement:
            // 发现一个开始元素，这可能是一个指令
            // 检查工厂映射中是否存在对应的指令类型
            f, ok := factoryMap[t.Name.Local]
            if !ok {
                // 如果指令名称未注册，可以返回错误或跳过
                return nil, fmt.Errorf("未知指令类型: %s", t.Name.Local)
            }
            instr := f() // 通过工厂函数创建指令实例

            // 将当前元素的剩余部分解码到指令结构体中
            err := d.DecodeElement(instr, &t)
            if err != nil {
                return nil, fmt.Errorf("解码指令 %s 失败: %w", t.Name.Local, err)
            }

            // 将填充好的指令添加到切片中
            actions = append(actions, instr)

        case xml.EndElement:
            // 发现一个结束元素，如果它是根标签的结束，则解析完成
            // 这里假设根标签只会有一个，且在所有指令之后
            return actions, nil // 解析完成，返回指令切片
        }
    }
}

func main() {
    xmlData := []byte(`<Root>
    <Say>Playing file</Say>
    <Play loops="2">https://host/somefile.mp3</Play>
    <Say>Done playing</Say>
</Root>`)

    // 调用自定义的Unmarshal函数解析XML
    actions, err := Unmarshal(xmlData)
    if err != nil {
        panic(err) // 处理解析错误
    }

    // 遍历并执行所有解析出的指令
    for _, instruction := range actions {
        err = instruction.Execute()
        if err != nil {
            fmt.Println("执行指令失败:", err)
        }
    }
}

Playing file
o/ https://host/somefile.mp3
o/ https://host/somefile.mp3
Done playing