使用Go语言解析有序多态XML类型：xml.Decoder的深度实践

package main

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

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

// Play 结构体对应 <Play> XML元素
type Play struct {
    Loops int    `xml:"loops,attr"` // 解析 loops 属性
    File  string `xml:",innerxml"`  // 解析元素内部文本内容
}

// Execute 实现 Executer 接口
func (p *Play) Execute() error {
    for i := 0; i < p.Loops; i++ {
        fmt.Printf("播放文件: %s (第 %d 次)\n", p.File, i+1)
    }
    return nil
}

// Say 结构体对应 <Say> XML元素
type Say struct {
    Voice string `xml:",innerxml"` // 解析元素内部文本内容
}

// Execute 实现 Executer 接口
func (s *Say) Execute() error {
    fmt.Println("说: " + s.Voice)
    return nil
}

// factoryMap 存储了 XML 标签名到创建 Executer 实例函数的映射
var factoryMap map[string]func() Executer = make(map[string]func() Executer)

// init 函数用于注册不同的指令类型到 factoryMap
// 可以在不同的文件中为每个指令结构体编写 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 // 用于存储解析出的 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()
        if err != nil {
            return nil, fmt.Errorf("读取子元素令牌失败: %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() // 使用工厂创建对应的 Executer 实例

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

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

        case xml.EndElement:
            // 发现一个结束标签
            // 如果是根标签的结束标签，则表示所有指令已解析完毕
            // 这里假设根标签只有一个，且我们只关心其直接子元素
            return actions, nil
        }
    }
    // 理论上不会执行到这里，因为 EndElement 会返回
    return nil, nil
}

func main() {
    xmlData := []byte(`<Root>
    <Say>正在播放文件</Say>
    <Play loops="2">https://host/somefile.mp3</Play>
    <Say>播放完成</Say>
</Root>`)

    actions, err := Unmarshal(xmlData)
    if err != nil {
        panic(fmt.Errorf("解析 XML 失败: %w", err))
    }

    fmt.Println("--- 开始执行指令 ---")
    for i, instruction := range actions {
        fmt.Printf("执行指令 %d: ", i+1)
        err = instruction.Execute()
        if err != nil {
            fmt.Printf("执行指令失败: %v\n", err)
        }
    }
    fmt.Println("--- 指令执行完毕 ---")
}

--- 开始执行指令 ---
执行指令 1: 说: 正在播放文件
执行指令 2: 播放文件: https://host/somefile.mp3 (第 1 次)
播放文件: https://host/somefile.mp3 (第 2 次)
执行指令 3: 说: 播放完成
--- 指令执行完毕 ---