Golang中XML的序列化与反序列化详解

在Go中处理XML命名空间前缀确实是一个常见问题。标准库encoding/xml对命名空间的支持有限，但可以通过结构体标签和xml.Name来控制序列化和反序列化。

问题分析

当XML包含命名空间前缀时，Go可能无法正确解析或生成预期的前缀格式。主要原因是Go的XML包更关注数据内容而非格式细节。

解决方案

1. 使用结构体标签控制命名空间

package main

import (
    "encoding/xml"
    "fmt"
)

type Person struct {
    XMLName xml.Name `xml:"http://example.com/ns person"`
    Name    string   `xml:"name"`
    Age     int      `xml:"age"`
}

func main() {
    // 序列化
    p := Person{
        Name: "John",
        Age:  30,
    }
    
    data, _ := xml.MarshalIndent(p, "", "  ")
    fmt.Println(string(data))
    // 输出:
    // <person xmlns="http://example.com/ns">
    //   <name>John</name>
    //   <age>30</age>
    // </person>
}

2. 处理带前缀的命名空间

type Order struct {
    XMLName xml.Name `xml:"o:order"`
    ID      string   `xml:"id,attr"`
    Items   []Item   `xml:"item"`
}

type Item struct {
    XMLName xml.Name `xml:"item"`
    Name    string   `xml:"name"`
    Price   float64  `xml:"price"`
}

func marshalWithPrefix() {
    order := Order{
        ID: "123",
        Items: []Item{
            {Name: "Product A", Price: 29.99},
            {Name: "Product B", Price: 39.99},
        },
    }
    
    // 需要手动添加命名空间声明
    output := `<?xml version="1.0"?>` + "\n"
    output += `<o:order xmlns:o="http://example.com/order">` + "\n"
    
    // 手动序列化Items部分
    for _, item := range order.Items {
        output += fmt.Sprintf("  <item><name>%s</name><price>%.2f</price></item>\n", 
            item.Name, item.Price)
    }
    output += `</o:order>`
    
    fmt.Println(output)
}

3. 使用自定义MarshalXML方法

type CustomElement struct {
    Local string
    Value string
}

func (c CustomElement) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
    // 创建带命名空间前缀的起始元素
    start.Name = xml.Name{
        Space: "http://example.com/custom",
        Local: c.Local,
    }
    start.Attr = []xml.Attr{
        {Name: xml.Name{Local: "xmlns:custom"}, Value: "http://example.com/custom"},
    }
    
    if err := e.EncodeToken(start); err != nil {
        return err
    }
    
    if err := e.EncodeToken(xml.CharData(c.Value)); err != nil {
        return err
    }
    
    return e.EncodeToken(xml.EndElement{Name: start.Name})
}

func main() {
    elem := CustomElement{Local: "myElement", Value: "Some content"}
    data, _ := xml.MarshalIndent(elem, "", "  ")
    fmt.Println(string(data))
}

4. 处理复杂命名空间场景

type Document struct {
    XMLName  xml.Name `xml:"doc:document"`
    XMLNSDoc string   `xml:"xmlns:doc,attr"`
    XMLNSXsi string   `xml:"xmlns:xsi,attr"`
    Data     string   `xml:"data"`
}

func complexNamespace() {
    doc := Document{
        XMLNSDoc: "http://example.com/doc",
        XMLNSXsi: "http://www.w3.org/2001/XMLSchema-instance",
        Data:     "Example data",
    }
    
    data, _ := xml.MarshalIndent(doc, "", "  ")
    fmt.Println(string(data))
    // 输出:
    // <doc:document xmlns:doc="http://example.com/doc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    //   <data>Example data</data>
    // </doc:document>
}

反序列化示例

func unmarshalWithNamespace() {
    xmlData := `
    <ns:person xmlns:ns="http://example.com/ns">
        <ns:name>Alice</ns:name>
        <ns:age>25</ns:age>
    </ns:person>`
    
    type Person struct {
        XMLName xml.Name `xml:"person"`
        Name    string   `xml:"name"`
        Age     int      `xml:"age"`
    }
    
    var p Person
    xml.Unmarshal([]byte(xmlData), &p)
    fmt.Printf("Name: %s, Age: %d\n", p.Name, p.Age)
}

注意事项

1. Go的encoding/xml包主要关注数据内容，对命名空间前缀的格式控制有限
2. 对于严格的前缀格式要求，可能需要手动构建XML或使用第三方库
3. 命名空间URI比前缀更重要，Go主要通过URI来匹配元素

这些方法覆盖了大多数XML命名空间处理场景，可以根据具体需求选择适合的方案。