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 属性获取
    Score     int      // 期望从 blockA -> a 的 score 属性获取
    Id        int      // 期望从 blockB -> b 的 id 属性获取
    Name      string   // 期望从 blockB -> b 的 name 属性获取
}

package main

import (
    "encoding/xml"
    "fmt"
)

// Main 结构体对应 XML 的 <main> 根元素
type Main struct {
    XMLName xml.Name `xml:"main"`
    Symbol  string   `xml:"symbol,attr"` // 解析 <main> 元素的 symbol 属性
    BlockA  BlockA   `xml:"blockA"`      // 嵌套 BlockA 结构体对应 <blockA> 元素
    BlockB  BlockB   `xml:"blockB"`      // 嵌套 BlockB 结构体对应 <blockB> 元素
}

// BlockA 结构体对应 XML 的 <blockA> 元素
type BlockA struct {
    MainScore int `xml:"main_score,attr"` // 解析 <blockA> 元素的 main_score 属性
    A         A   `xml:"a"`               // 嵌套 A 结构体对应 <blockA> 内部的 <a> 元素
}

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

// BlockB 结构体对应 XML 的 <blockB> 元素
type BlockB struct {
    B B `xml:"b"` // 嵌套 B 结构体对应 <blockB> 内部的 <b> 元素
}

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

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("Error unmarshaling XML: %v\n", err)
        return
    }

    fmt.Println("--- 解析结果 ---")
    fmt.Printf("Symbol: %s\n", result.Symbol)
    fmt.Printf("Main Score: %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")
    fmt.Printf("Flat Result: %+v\n", flat)
}