Go语言中XML解组：处理嵌套元素与属性的最佳实践

<main symbol="X">
    <blockA main_score="3">
        <a score="0"/>
    </blockA>
    <blockB>
        <b id="3" name="Mike"/>
    </blockB>
</main>

type Result struct {
    XMLName xml.Name `xml:"main"`
    Symbol    string   `xml:"symbol,attr"`
    MainScore int      // 期望从 <blockA main_score="3"> 获取
    Score     int      // 期望从 <blockA><a score="0"/> 获取
    Id        int      // 期望从 <blockB><b id="3"> 获取
    Name      string   // 期望从 <blockB><b name="Mike"> 获取
}

package main

import (
    "encoding/xml"
    "fmt"
)

// 定义对应 <main> 元素的结构体
type Main struct {
    XMLName xml.Name `xml:"main"`
    Symbol  string   `xml:"symbol,attr"`
    BlockA  BlockA   `xml:"blockA"` // 嵌入 BlockA 结构体
    BlockB  BlockB   `xml:"blockB"` // 嵌入 BlockB 结构体
}

// 定义对应 <blockA> 元素的结构体
type BlockA struct {
    MainScore int `xml:"main_score,attr"` // <blockA> 的属性
    A         A   `xml:"a"`               // 嵌入 A 结构体
}

// 定义对应 <a> 元素的结构体
type A struct {
    Score int `xml:"score,attr"` // <a> 的属性
}

// 定义对应 <blockB> 元素的结构体
type BlockB struct {
    B B `xml:"b"` // 嵌入 B 结构体
}

// 定义对应 <b> 元素的结构体
type B struct {
    Id   int    `xml:"id,attr"`   // <b> 的属性
    Name string `xml:"name,attr"` // <b> 的属性
}

func main() {
    xmlData := `
    <main symbol="X">
        <blockA main_score="3">
            <a score="0"/>
        </blockA>
        <blockB>
            <b id="3" name="Mike"/>
        </blockB>
    </main>`

    var result Main
    err := xml.Unmarshal([]byte(xmlData), &result)
    if err != nil {
        fmt.Printf("XML解组失败: %v\n", err)
        return
    }

    // 访问解组后的数据
    fmt.Printf("Symbol: %s\n", result.Symbol)
    fmt.Printf("MainScore: %d\n", result.BlockA.MainScore)
    fmt.Printf("Score: %d\n", result.BlockA.A.Score)
    fmt.Printf("Id: %d\n", result.BlockB.B.Id)
    fmt.Printf("Name: %s\n", result.BlockB.B.Name)

    // 如果需要将这些数据整合到一个扁平的结构体中，可以在解组后手动赋值
    type FlatResult struct {
        Symbol    string
        MainScore int
        Score     int
        Id        int
        Name      string
    }

    flat := FlatResult{
        Symbol:    result.Symbol,
        MainScore: result.BlockA.MainScore,
        Score:     result.BlockA.A.Score,
        Id:        result.BlockB.B.Id,
        Name:      result.BlockB.B.Name,
    }
    fmt.Printf("\n扁平化结果:\n%+v\n", flat)
}