Go by Example - JSON and XML

介绍go中对 JSON 和 XML 的支持

JSON

Go 提供对 JSON 编码和解码的内置支持，包括内置数据类型和自定义数据类型之间的转换。

json.go

package main

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

// 下面我们将使用这两个结构来演示自定义类型的编码和解码
type response1 struct {
	Page   int
	Fruits []string
}

// 只有导出的字段才会以 JSON 编码/解码。导出的字段必须以大写字母开头
type response2 struct {
	Page   int      `json:"page"`
	Fruits []string `json:"fruits"`
}

func main() {
	// 首先，我们来看看如何将基本数据类型编码为 JSON 字符串
	// 下面是一些原子值的示例
	bolB, _ := json.Marshal(true)
	fmt.Println(string(bolB))

	intB, _ := json.Marshal(1)
	fmt.Println(string(intB))

	fltB, _ := json.Marshal(2.34)
	fmt.Println(string(fltB))

	strB, _ := json.Marshal("gopher")
	fmt.Println(string(strB))

	// 下面是一些用于切片和映射的代码，它们按照您的预期编码为 JSON 数组和对象
	slcD := []string{"apple", "peach", "pear"}
	slcB, _ := json.Marshal(slcD)
	fmt.Println(string(slcB))

	mapD := map[string]int{"apple": 5, "lettuce": 7}
	mapB, _ := json.Marshal(mapD)
	fmt.Println(string(mapB))

	// JSON 软件包可自动编码自定义数据类型
	// 它只会在编码输出中包含导出字段，并默认使用这些名称作为 JSON 键
	res1D := &response1{
		Page:   1,
		Fruits: []string{"apple", "peach", "pear"}}
	res1B, _ := json.Marshal(res1D)
	fmt.Println(string(res1B))

	// 您可以在 struct 字段声明中使用标记来自定义编码后的 JSON 键名
	// 请查看上文 response2 的定义，了解此类标记的示例
	res2D := &response2{
		Page:   1,
		Fruits: []string{"apple", "peach", "pear"}}
	res2B, _ := json.Marshal(res2D)
	fmt.Println(string(res2B))

	// 现在我们来看看如何将 JSON 数据解码为 Go 值。下面是一个通用数据结构的示例
	byt := []byte(`{"num":6.13,"strs":["a","b"]}`)

	// 我们需要提供一个变量，以便 JSON 包可以将解码后的数据放入其中
	// 这个 map[string]interface{} 将保存字符串到任意数据类型的映射
	var dat map[string]interface{}

	// 下面是实际解码和相关错误检查
	if err := json.Unmarshal(byt, &dat); err != nil {
		panic(err)
	}
	fmt.Println(dat)

	// 为了使用解码映射中的值，我们需要将它们转换为相应的类型
	// 例如，在这里我们将 num 中的值转换为预期的 float64 类型
	num := dat["num"].(float64)
	fmt.Println(num)

	// 访问嵌套数据需要进行一系列转换
	strs := dat["strs"].([]interface{})
	str1 := strs[0].(string)
	fmt.Println(str1)

	// 我们还可以将 JSON 解码为自定义数据类型
	// 这样做的好处是为我们的程序增加了额外的类型安全性，并且在访问解码数据时无需类型断言
	str := `{"page": 1, "fruits": ["apple", "peach"]}`
	res := response2{}
	json.Unmarshal([]byte(str), &res)
	fmt.Println(res)
	fmt.Println(res.Fruits[0])

	// 在上面的示例中，我们总是使用字节和字符串作为数据与标准输出上的 JSON 表示之间的中介
	// 我们还可以将 JSON 编码直接流式传输到 os.Writers（如 os.Stdout 甚至 HTTP 响应体）
	enc := json.NewEncoder(os.Stdout)
	d := map[string]int{"apple": 5, "lettuce": 7}
	enc.Encode(d)
}

log

$ go run json.go
true
1
2.34
"gopher"
["apple","peach","pear"]
{"apple":5,"lettuce":7}
{"Page":1,"Fruits":["apple","peach","pear"]}
{"page":1,"fruits":["apple","peach","pear"]}
map[num:6.13 strs:[a b]]
6.13
a
{1 [apple peach]}
apple
{"apple":5,"lettuce":7}

我们在这里介绍了 Go 中 JSON 的基本知识，但要了解更多信息，请查看 JSON 与 Go 博文和 JSON 包文档。

XML

Go 通过 encoding/xml 软件包为 XML 和类 XML 格式提供内置支持。

xml.go

package main

import (
	"encoding/xml"
	"fmt"
)

// Plant将被映射为 XML。与 JSON 示例类似，字段标记包含编码器和解码器的指令
// 在这里，我们使用了 XML 包的一些特殊功能:
// XMLName 字段名称决定了代表此结构的 XML 元素的名称
// id,attr 表示 Id 字段是一个 XML 属性，而不是嵌套元素
type Plant struct {
	XMLName xml.Name `xml:"plant"`
	Id      int      `xml:"id,attr"`
	Name    string   `xml:"name"`
	Origin  []string `xml:"origin"`
}

func (p Plant) String() string {
	return fmt.Sprintf("Plant id=%v, name=%v, origin=%v",
		p.Id, p.Name, p.Origin)
}

func main() {
	coffee := &Plant{Id: 27, Name: "Coffee"}
	coffee.Origin = []string{"Ethiopia", "Brazil"}

	// 输出代表我们工厂的 XML；使用 MarshalIndent 生成更易于人类阅读的输出
	out, _ := xml.MarshalIndent(coffee, " ", "  ")
	fmt.Println(string(out))

	// 要在输出中添加通用 XML 标头，请明确添加
	fmt.Println(xml.Header + string(out))

	// 使用 Unmarshal 将包含 XML 的字节流解析为数据结构
	// 如果 XML 是畸形的或无法映射到 Plant 上，将返回一个描述性错误
	var p Plant
	if err := xml.Unmarshal(out, &p); err != nil {
		panic(err)
	}
	fmt.Println(p)

	tomato := &Plant{Id: 81, Name: "Tomato"}
	tomato.Origin = []string{"Mexico", "California"}

	// parent > child > plant 字段标记告诉编码器将所有植物嵌套在<parent><child>...
	type Nesting struct {
		XMLName xml.Name `xml:"nesting"`
		Plants  []*Plant `xml:"parent>child>plant"`
	}

	nesting := &Nesting{}
	nesting.Plants = []*Plant{coffee, tomato}

	out, _ = xml.MarshalIndent(nesting, " ", "  ")
	fmt.Println(string(out))
}

log

$ go run xml.go
 <plant id="27">
   <name>Coffee</name>
   <origin>Ethiopia</origin>
   <origin>Brazil</origin>
 </plant>
<?xml version="1.0" encoding="UTF-8"?>
 <plant id="27">
   <name>Coffee</name>
   <origin>Ethiopia</origin>
   <origin>Brazil</origin>
 </plant>
Plant id=27, name=Coffee, origin=[Ethiopia Brazil]
 <nesting>
   <parent>
     <child>
       <plant id="27">
         <name>Coffee</name>
         <origin>Ethiopia</origin>
         <origin>Brazil</origin>
       </plant>
       <plant id="81">
         <name>Tomato</name>
         <origin>Mexico</origin>
         <origin>California</origin>
       </plant>
     </child>
   </parent>
 </nesting>

参考链接

• Go by Example