Golang中实现通用的XML到JSON转换：利用接口和指针处理动态结构体

func Xml2Json(xmlString string, DataStruct interface{}) (jsobj string, err error) {
    // 错误：DataStruct 是一个接口类型，不能直接用于声明变量
    var dataStruct DataStruct 
    xml.Unmarshal([]byte(xmlString), &dataStruct)
    js, _ := json.Marshal(dataStruct)
    return fmt.Sprintf("%s\n", js), nil
}

func main() {
    // 错误：Persons 是一个类型，不能作为表达式传递
    jsonstring, _ := Xml2Json(personXml, Persons) 
}

package main

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

// 定义示例结构体
type Persons struct {
    XMLName xml.Name `xml:"Persons"` // 明确XML根元素名称
    Person  []struct {
        Name string `xml:"Name"`
        Age  int    `xml:"Age"`
    } `xml:"Person"`
}

type Places struct {
    XMLName xml.Name `xml:"Places"`
    Place   []struct {
        Name    string `xml:"Name"`
        Country string `xml:"Country"`
    } `xml:"Place"`
}

// 注意：原始parkXml示例中存在格式问题，此处修正结构体以匹配正确的XML格式
// 正确的XML应为：<Park><Name>National Park</Name><Capacity>10000</Capacity></Park>
// 如果XML中Name和Capacity是多个，则需要修改XML结构或Park结构体
// 假设Name和Capacity是单个元素，但Park可以有多个
type Parks struct {
    XMLName xml.Name `xml:"Parks"`
    Park    []struct { // 假设有多个Park
        Name     string `xml:"Name"`
        Capacity int    `xml:"Capacity"`
    } `xml:"Park"`
}


// 示例XML常量
const personXml = `
    <Persons>
        <Person><Name>Koti</Name><Age>30</Age></Person>
        <Person><Name>Kanna</Name><Age>29</Age></Person>
    </Persons>
`

const placeXml = `
    <Places>
        <Place><Name>Chennai</Name><Country>India</Country></Place>
        <Place><Name>London</Name><Country>UK</Country></Place>
    </Places>
`

// 修正后的parkXml，确保每个Park元素都是完整的
const parkXml = `
    <Parks>
        <Park><Name>National Park</Name><Capacity>10000</Capacity></Park>
        <Park><Name>Asian Park</Name><Capacity>20000</Capacity></Park>
    </Parks>
`

// Xml2Json 是一个通用函数，用于将XML字符串转换为JSON字符串
// value 参数必须是一个指向目标结构体的指针
func Xml2Json(xmlString string, value interface{}) (string, error) {
    // 1. 将XML字符串解析到传入的value（必须是指针）
    if err := xml.Unmarshal([]byte(xmlString), value); err != nil {
        return "", fmt.Errorf("XML Unmarshal failed: %w", err)
    }

    // 2. 将已填充的value（现在包含解析后的数据）转换为JSON
    js, err := json.Marshal(value)
    if err != nil {
        return "", fmt.Errorf("JSON Marshal failed: %w", err)
    }

    return string(js), nil
}

func main() {
    fmt.Println("--- Persons XML to JSON ---")
    // 方式一：仅获取JSON字符串，不关心解析后的结构体实例
    // 使用 new(Persons) 创建一个 Persons 结构体的零值指针
    jsonString1, err := Xml2Json(personXml, new(Persons))
    if err != nil {
        fmt.Printf("Error converting Persons: %v\n", err)
    } else {
        fmt.Printf("%s\n", jsonString1)
    }

    fmt.Println("\n--- Places XML to JSON ---")
    // 方式二：获取JSON字符串，并保留解析后的结构体实例供后续使用
    var myPlaces Places // 声明一个Places结构体变量
    jsonString2, err := Xml2Json(placeXml, &myPlaces) // 传递其地址
    if err != nil {
        fmt.Printf("Error converting Places: %v\n", err)
    } else {
        fmt.Printf("%s\n", jsonString2)
        // 现在 myPlaces 变量已经填充了来自XML的数据
        fmt.Printf("First place name from struct: %s\n", myPlaces.Place[0].Name)
    }

    fmt.Println("\n--- Parks XML to JSON ---")
    var myParks Parks
    jsonString3, err := Xml2Json(parkXml, &myParks)
    if err != nil {
        fmt.Printf("Error converting Parks: %v\n", err)
    } else {
        fmt.Printf("%s\n", jsonString3)
        fmt.Printf("First park name from struct: %s\n", myParks.Park[0].Name)
    }
}