Go语言中实现XML到JSON的通用转换：结构体作为参数的技巧

func Xml2Json(xmlString string, DataStruct interface{}) (jsobj string, err error) {
    var dataStruct DataStruct // 错误：DataStruct is not a type
    // ...
}

func main() {
    // ...
    jsonstring, _ := Xml2Json(personXml, Persons) // 错误：type Persons is not an expression
}

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

// 注意：原始的Parks结构体定义可能导致解析问题，因为Park下的Name和Capacity是切片，
// 但XML中每个Park只有一个Name和Capacity。这里假设每个Park包含一个Name和Capacity。
// 如果需要处理多个Name/Capacity，XML结构应有所不同。
// 为了与原始问题保持一致，我们修正一下Parks的结构定义，使其能正确解析。
type Parks struct {
    XMLName xml.Name `xml:"Parks"`
    Park    []struct { // 假设有多个Park元素
        Name     string `xml:"Name"` // 假设每个Park只有一个Name
        Capacity int    `xml:"Capacity"` // 假设每个Park只有一个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>
`

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 参数必须是一个指向结构体的指针，xml.Unmarshal才能填充数据。
func Xml2Json(xmlString string, value interface{}) (string, error) {
    // 1. 将XML字符串反序列化到传入的结构体指针中
    // xml.Unmarshal 需要一个字节切片和目标值的指针。
    if err := xml.Unmarshal([]byte(xmlString), value); err != nil {
        return "", fmt.Errorf("XML反序列化失败: %w", err)
    }

    // 2. 将反序列化后的结构体（现在已填充数据）序列化为JSON
    // json.Marshal 可以接受值或指针，这里value已经是一个填充了数据的结构体指针。
    js, err := json.Marshal(value)
    if err != nil {
        return "", fmt.Errorf("JSON序列化失败: %w", err)
    }

    return string(js), nil
}

func main() {
    // 示例1: 仅获取JSON字符串，不保留原始结构体实例
    // 使用 new(Persons) 创建一个指向Persons结构体的指针
    jsonPersons, err := Xml2Json(personXml, new(Persons))
    if err != nil {
        fmt.Printf("转换Persons失败: %v\n", err)
    } else {
        fmt.Printf("Persons JSON:\n%s\n", jsonPersons)
    }

    // 示例2: 获取JSON字符串，并保留原始结构体实例以供后续处理
    var places Places // 声明一个Places结构体变量
    jsonPlaces, err := Xml2Json(placeXml, &places) // 传递places变量的地址
    if err != nil {
        fmt.Printf("转换Places失败: %v\n", err)
    } else {
        fmt.Printf("Places JSON:\n%s\n", jsonPlaces)
        // 现在，places变量已经被XML数据填充，可以继续使用
        fmt.Printf("第一个地点名称: %s\n", places.Place[0].Name)
    }

    // 示例3: 转换Parks数据
    var parks Parks
    jsonParks, err := Xml2Json(parkXml, &parks)
    if err != nil {
        fmt.Printf("转换Parks失败: %v\n", err)
    } else {
        fmt.Printf("Parks JSON:\n%s\n", jsonParks)
    }
}