Go语言 xml.Decoder 实现有序多态XML指令流解析

// Executer 接口定义了所有指令类型必须实现的行为
type Executer interface {
    Execute() error
}

// Play 指令：用于播放文件
type Play struct {
    Loops int    `xml:"loops,attr"` // `loops` 属性映射到 Loops 字段
    File  string `xml:",innerxml"`  // 元素体内容映射到 File 字段
}

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"` // 元素体内容映射到 Voice 字段
}

func (s *Say) Execute() error {
    fmt.Println(s.Voice)
    return nil
}

// factoryMap 存储 XML 标签名到指令构造函数的映射
var factoryMap map[string]func() Executer = make(map[string]func() Executer)

// init 函数在包被导入时自动执行，用于注册指令类型
// 可以在不同的文件中定义各自的 init 函数，实现模块化注册
func init() {
    factoryMap["Play"] = func() Executer { return new(Play) }
    factoryMap["Say"] = func() Executer { return new(Say) }
}

package main

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

// ... (Executer interface, Play/Say structs, factoryMap, init function as defined above) ...

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

    var actions []Executer // 存储解析出的指令序列

    // 1. 查找根元素
    // 循环读取令牌，直到找到第一个 xml.StartElement (即根元素的起始标签)
    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("读取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 列表中
            actions = append(actions, instr)

        case xml.EndElement:
            // 发现一个结束标签
            // 如果是根元素的结束标签，则表示所有指令已解析完成
            return actions, nil
        }
    }
}

package main

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

// Executer 接口
type Executer interface {
    Execute() error
}

// 工厂映射
var factoryMap map[string]func() Executer = make(map[string]func() Executer)

// Play 指令
type Play struct {
    Loops int    `xml:"loops,attr"`
    File  string `xml:",innerxml"`
}

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"`
}

func (s *Say) Execute() error {
    fmt.Println(s.Voice)
    return nil
}

// 注册指令
func init() {
    factoryMap["Play"] = func() Executer { return new(Play) }
    factoryMap["Say"] = func() Executer { return new(Say) }
}

// Unmarshal 函数
func Unmarshal(b []byte) ([]Executer, error) {
    d := xml.NewDecoder(bytes.NewReader(b))

    var actions []Executer

    // 查找根元素
    for {
        v, err := d.Token()
        if err != nil {
            return nil, fmt.Errorf("查找根元素失败: %w", err)
        }
        if _, ok := v.(xml.StartElement); ok {
            break
        }
    }

    // 循环处理根元素内部的子元素
    for {
        v, err := d.Token()
        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("未知指令类型: %