在Go语言中高效迭代XML元素并映射到结构体

<data>
  <entry id="1">
    <title>First Entry</title>
    <content>Details for the first entry.</content>
    <tags>
        <tag>Go</tag>
        <tag>XML</tag>
    </tags>
  </entry>
  <entry id="2">
    <title>Second Entry</title>
    <content>More details for the second entry.</content>
    <tags>
        <tag>Parsing</tag>
    </tags>
  </entry>
  <!-- 更多 <entry> 元素 -->
</data>

package main

import (
    "encoding/xml"
    "fmt"
    "io"
    "log"
    "os"
)

// Tag represents a nested tag element within an entry
type Tag struct {
    Name string `xml:",chardata"` // chardata captures the text content of the tag
}

// Entry represents the structure of an <entry> element
type Entry struct {
    ID      string `xml:"id,attr"` // id,attr maps to the 'id' attribute
    Title   string `xml:"title"`
    Content string `xml:"content"`
    Tags    []Tag  `xml:"tags>tag"` // tags>tag specifies nested path for multiple <tag> elements
}

// Data represents the root element (optional, but good for full context)
type Data struct {
    Entries []Entry `xml:"entry"`
}

func main() {
    filename := "data.xml" // 假设存在一个名为 data.xml 的文件

    xmlFile, err := os.Open(filename)
    if err != nil {
        log.Fatalf("Error opening XML file '%s': %v", filename, err)
    }
    defer xmlFile.Close() // 确保文件在函数结束时关闭

    decoder := xml.NewDecoder(xmlFile)
    // 可选：设置解码器的一些属性，例如是否跳过未知元素
    // decoder.Strict = false
}

func main() {
    // ... (文件打开和解码器初始化部分)

    fmt.Println("Starting XML iteration and processing...")
    for {
        // 获取下一个XML令牌
        token, err := decoder.Token()
        if err == io.EOF {
            break // 到达文件末尾，退出循环
        }
        if err != nil {
            log.Fatalf("Error getting XML token: %v", err)
        }

        // 使用类型断言检查令牌是否为 StartElement
        switch startElement := token.(type) {
        case xml.StartElement:
            // 检查 StartElement 的本地名称是否为 "entry"
            if startElement.Name.Local == "entry" {
                var entry Entry
                // 当找到 <entry> 标签时，使用 DecodeElement 将其内容解析到 Entry 结构体中
                // DecodeElement 会读取直到匹配的 </entry> 标签
                err := decoder.DecodeElement(&entry, &startElement)
                if err != nil {
                    log.Printf("Warning: Error decoding <entry> element: %v. Skipping this entry.", err)
                    // 根据错误类型和业务需求，可以选择跳过当前元素或终止程序
                    continue
                }

                // 成功解析后，对 'entry' 结构体执行所需操作
                fmt.Printf("Processed Entry ID: %s\n", entry.ID)
                fmt.Printf("  Title: %s\n", entry.Title)
                fmt.Printf("  Content: %s\n", entry.Content)
                fmt.Print("  Tags: [")
                for i, tag := range entry.Tags {
                    fmt.Printf("%s", tag.Name)
                    if i < len(entry.Tags)-1 {
                        fmt.Print(", ")
                    }
                }
                fmt.Println("]\n")

                // 在这里可以对 entry 对象进行数据库存储、进一步处理等操作
            }
        }
    }
    fmt.Println("Finished XML iteration and processing.")
}

<data>
  <entry id="1">
    <title>First Entry</title>
    <content>Details for the first entry.</content>
    <tags>
        <tag>Go</tag>
        <tag>XML</tag>
    </tags>
  </entry>
  <entry id="2">
    <title>Second Entry</title>
    <content>More details for the second entry.</content>
    <tags>
        <tag>Parsing</tag>
    </tags>
  </entry>
  <entry id="3">
    <title>Third Entry</title>
    <content>Yet another entry with more content.</content>
    <tags>
        <tag>Tutorial</tag>
        <tag>Streaming</tag>
    </tags>
  </entry>
</data>