Golang实现XML转JSON的高效转换方法

Golang实现XML转JSON的高效转换方法 大家好，

我正在开发一个小模块，它接收一个复杂的XML作为输入，并以特定的格式将其转换为JSON。XML中的并非所有字段都会出现在JSON中，而且不同节点中的列字段在JSON中会合并到一个对象下。是否有优化的方法来实现这一点？

func main() {
    fmt.Println("hello world")
}
2 回复

可以用类似这样的简单方式实现

package main

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

type error struct {
	XMLName xml.Name `xml:"error"`
	Code    int      `json:"code",xml:"code"`
	Message string   `json:"message",xml:"message"`
}

func main() {
   	x := error{xml.Name{"", ""}, 200, "Error message"}
   	j, _ := json.Marshal(x)
    fmt.Printf("%v\n%v\n", x, string(j))
}

更多关于Golang实现XML转JSON的高效转换方法的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


在Go语言中，实现XML到JSON的高效转换可以通过标准库的encoding/xml和encoding/json包结合结构体标签来完成。以下是一个优化的实现方案：

package main

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

// XML输入结构定义
type XMLData struct {
	XMLName xml.Name `xml:"root"`
	Users   []User   `xml:"user"`
	Items   []Item   `xml:"item"`
}

type User struct {
	XMLName xml.Name `xml:"user"`
	ID      string   `xml:"id,attr"`
	Name    string   `xml:"name"`
	Email   string   `xml:"email"`
	// 忽略不需要的字段
	Age     int      `xml:"-"`
}

type Item struct {
	XMLName xml.Name `xml:"item"`
	ID      string   `xml:"id,attr"`
	Title   string   `xml:"title"`
	Price   float64  `xml:"price"`
	// 忽略不需要的字段
	Stock   int      `xml:"-"`
}

// JSON输出结构定义
type JSONOutput struct {
	Data struct {
		Users []UserOutput `json:"users"`
		Items []ItemOutput `json:"items"`
	} `json:"data"`
}

type UserOutput struct {
	UserID    string `json:"userId"`
	UserName  string `json:"userName"`
	UserEmail string `json:"userEmail"`
}

type ItemOutput struct {
	ItemID    string  `json:"itemId"`
	ItemTitle string  `json:"itemTitle"`
	ItemPrice float64 `json:"itemPrice"`
}

func convertXMLToJSON(xmlData []byte) ([]byte, error) {
	// 解析XML
	var xmlInput XMLData
	if err := xml.Unmarshal(xmlData, &xmlInput); err != nil {
		return nil, fmt.Errorf("XML解析失败: %v", err)
	}

	// 构建JSON输出结构
	var output JSONOutput
	
	// 转换用户数据
	for _, user := range xmlInput.Users {
		output.Data.Users = append(output.Data.Users, UserOutput{
			UserID:    user.ID,
			UserName:  user.Name,
			UserEmail: user.Email,
		})
	}

	// 转换项目数据
	for _, item := range xmlInput.Items {
		output.Data.Items = append(output.Data.Items, ItemOutput{
			ItemID:    item.ID,
			ItemTitle: item.Title,
			ItemPrice: item.Price,
		})
	}

	// 生成JSON
	jsonData, err := json.MarshalIndent(output, "", "  ")
	if err != nil {
		return nil, fmt.Errorf("JSON生成失败: %v", err)
	}

	return jsonData, nil
}

func main() {
	// 示例XML数据
	xmlInput := `
<root>
	<user id="1">
		<name>张三</name>
		<email>zhang@example.com</email>
		<age>30</age>
	</user>
	<user id="2">
		<name>李四</name>
		<email>li@example.com</email>
		<age>25</age>
	</user>
	<item id="101">
		<title>笔记本电脑</title>
		<price>5999.99</price>
		<stock>50</stock>
	</item>
	<item id="102">
		<title>智能手机</title>
		<price>2999.50</price>
		<stock>100</stock>
	</item>
</root>`

	// 执行转换
	jsonOutput, err := convertXMLToJSON([]byte(xmlInput))
	if err != nil {
		fmt.Printf("转换失败: %v\n", err)
		return
	}

	fmt.Println("转换结果:")
	fmt.Println(string(jsonOutput))
}

这个实现具有以下优化特点：

  1. 选择性字段映射：使用xml:"-"标签忽略不需要的XML字段
  2. 结构体分离：独立的输入(XML)和输出(JSON)结构体定义
  3. 字段重命名：通过JSON标签自定义输出字段名
  4. 数据合并：将不同XML节点合并到统一的JSON对象结构中
  5. 错误处理：完善的错误处理机制

输出结果示例：

{
  "data": {
    "users": [
      {
        "userId": "1",
        "userName": "张三",
        "userEmail": "zhang@example.com"
      },
      {
        "userId": "2",
        "userName": "李四",
        "userEmail": "li@example.com"
      }
    ],
    "items": [
      {
        "itemId": "101",
        "itemTitle": "笔记本电脑",
        "itemPrice": 5999.99
      },
      {
        "itemId": "102",
        "itemTitle": "智能手机",
        "itemPrice": 2999.5
      }
    ]
  }
}

对于更复杂的XML结构，可以使用xml:",any"标签处理动态字段，或者使用xml.Unmarshal的流式处理来优化大文件的内存使用。

回到顶部