go语言学习-json和xml

JSON

• json是完全独立于语言的文本格式，是k-v的形式 name:zs
• 应用场景：前后端交互，系统间数据交互
• json使用go语言内置的encoding/json 标准库
• 编码json使用json.Marshal()函数可以对一组数据进行JSON格式的编码

通过结构体生成json

package main

import (
	"encoding/json"
	"fmt"
)

type Person struct {
	Name  string
	Hobby string
}

func main() {
	//实例化一个结构体
	p := Person{"yangchao", "playgame"}
	//编码json
	b, err := json.Marshal(p)
	if err != nil {
		fmt.Println("json err", err)
	}
	fmt.Println(string(b))

	//格式化输出
	b, err = json.MarshalIndent(p, "", "		")
	if err != nil {
		fmt.Println("json err", err)
	}
	fmt.Println(string(b))
}

序列化和反序列化

package main

import (
	"encoding/json"
	"fmt"
)

/* go语言中使用官方的encodin/json包对 JSON数据进行序列化和反序列化
- 序列化
func Marshal(v interface{}) ([]byte, error)
- 反序列化
func Unmarshal(data []byte, v interface{}) error
*/

func main() {
	var (
		data  = `1`
		value int
	)
	err1 := json.Unmarshal([]byte(data), &value)

	fmt.Println("Unmarshal error is:", err1)
	fmt.Printf("Unmarshal value is: %T, %d \n", value, value)

	value2, err2 := json.Marshal(value)

	fmt.Println("Marshal error is:", err2)
	fmt.Printf("Marshal value is: %s \n", string(value2))
}

示例2

package main

import (
	"encoding/json"
	"fmt"
)

// 使用两个结构体演示自定义数据类型的JSON数据编码和解码
// 结构体中
type Response1 struct {
	Page   int
	Fruits []string
}
type Response2 struct {
	Page    int      `json:"Page"`
	Fruites []string `json:"fruite"`
}

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", "peer"}
	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))

	//可以使用tag来定义编码后的JSON键的名称
	res2D := &Response2{
		Page:    1,
		Fruites: []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{}`将以kye-Value的方式
	//保存解码后的数据，Value可以为任意数据类型
	var dat map[string]interface{}

	//解码过程，并价检测相关的可能存在的错误
	if err := json.Unmarshal(byt, &dat); err != nil {
		panic(dat)
	}
	fmt.Println(dat)

	//为了使用解码后的map的数据，需要将value转为他们合适的类型
	num := dat["num"].(float64)
	fmt.Println(num)
	//访问嵌套的数据需要一些类型转换
	strs := dat["strs"].([]interface{})
	str1 := strs[0].(string)
	fmt.Println(str1)
}

XML

• 是可扩展标记语言，包含声明、根标签、子元素和属性
• 应用场景：配置文件以及webService

    <?xml version="1.0" encoding="UTF-8" ?>
    <servers version="1">
        <server>
            <serverName>Shanghai_VPN</serverName>
            <serverIP>127.0.0.1</serverIP>
        </server>
        <server>
            <serverName>Beijing_VPN</serverName>
            <serverIP>127.0.0.2</serverIP>
        </server>
    </servers>

解析xml

package main

import (
	"encoding/xml"
	"fmt"
	"io/ioutil"
)

// 抽取单个server对象
type Server struct {
	ServerName string `xml:"serverName"`
	ServerIP   string `xml:"serverIP"`
}

type Servers struct {
	Name    xml.Name `xml:"servers"`
	Version int      `xml:"version"`
	Servers []Server `xml:"server"`
}

func main() {
	data, err := ioutil.ReadFile("demo.xml")
	if err != nil {
		fmt.Println(err)
		return
	}
	var servers Servers
	err = xml.Unmarshal(data, &servers)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Printf("xml: %#v\n", servers)
}