go语言的魔幻旅程27-针对xml、json数据的解析

好事不出门，坏事传千里

编程语言从某种程度上来说就是为了方便操作数据而诞生的,现实生活中出于各种各样的原因人为的将数据按照不同的格式划分了类别，而针对每种类别的数据，处理的方式也各不相同，数据的种类众多不可能所有的都涉及到，本文主要针对xml、json两类高频的数据类型展开讲解。

xml数据的解析

//xml数据
/*
<?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数据解析
/*
type Recurlyservers struct {

	XMLName xml.Name `xml:"servers"`
	Version string `xml:"version,attr"`
	Svs []server `xml:"server"`
	Description string `xml:"innerxml"`
}

type server struct {
	XMLName xml.Name `xml:"server"`
	ServerName string	`xml:"serverName"`
	ServerIP string `xml:"serverIP"`
}

func main() {
	file, err := os.Open("servers.xml")
	if err != nil {
		fmt.Printf("error:%v", err)
		return
	}

	defer file.Close()
	data, err := ioutil.ReadAll(file)
	if err != nil {
		fmt.Printf("error: %v", err)
		return
	}

	v := Recurlyservers{}
	err = xml.Unmarshal(data, &v)
	if err != nil {
		fmt.Printf("error:%v", err)
		return
	}
	fmt.Println(v)
}
*/

//xml文件生成
/*
type Servers struct {
	XMLName xml.Name `xml:"servers"`
	Version string `xml:version, attr`
	Svs []server `xml:"server"`
}

type server struct {
	ServerName string `xml:"serverName"`
	ServerIP string `xml:"serverIP"`
}


func main() {
	v := &Servers{Version: "1"}
	v.Svs = append(v.Svs, server{"Shanghai_VPN", "127.0.0.1"})
	v.Svs = append(v.Svs, server{"Beijing_VPN", "127.0.0.1"})
	output, err := xml.MarshalIndent(v, "", " ")
	if err != nil {
		fmt.Printf("error:%v\n", err)
	}

	os.Stdout.Write([]byte(xml.Header))
	os.Stdout.Write(output)
}
*/

json数据解析

//针对基本数据结构已知的情况
/*
type Server struct {
	ServerName string
	ServerIP string
}

type Serverslice struct {
	Servers []Server
}


func main() {
	var s Serverslice
	str := `{"servers":[{"serverName":"Shanghai_VPN","serverIP":"127.0.0.1"},{"serverName":"Beijing_VPN","serverIP":"127.0.0.2"}]}`
	json.Unmarshal([]byte(str), &s)
	fmt.Println(s)
}
*/

//针对数据结构未知的情况

/*
func main() {
	b := []byte(`{"Name":"Wednesday","Age":6,"Parents":["Gomez","Morticia"]}`)
	var f interface{}
	json.Unmarshal(b, &f)
	fmt.Println(f)

	//通过断言的方式来访问存储的数据
	m := f.(map[string]interface{})
	for k, v := range m {
		switch vv := v.(type) {
		case string:
			fmt.Println(k, "is string", vv)
		case int:
			fmt.Println(k, "is int", vv)
		case float64:
			fmt.Println(k, "is float64", vv)
		case []interface{}:
			fmt.Println(k, "is an array:", vv)
			for i, u := range vv {
				fmt.Println(i, u)
			}
		default:
			fmt.Println(k, "is of a type I don't know how to handle")
		}
	}
}
*/


//数据结构已知的各种情况
/*
简单的json数据
func main() {

	type FruitBasket struct {
		Name string
		Fruit []string
		Id int64 `json:"ref"` //声明对应的json key
		Created time.Time
	}


	jsonData := []byte(`  {
        "Name": "Standard",
        "Fruit": [
             "Apple",
            "Banana",
            "Orange"
        ],
        "ref": 999,
        "Created": "2018-04-09T23:00:00Z"
    }`)

	var basket FruitBasket

	err := json.Unmarshal(jsonData, &basket)

	if err != nil {
		fmt.Println(err)
		return
	}

	fmt.Println(basket.Id, basket.Fruit, basket.Name,basket.Created)
}
*/

/*
//解析内嵌对象的json数据
func main() {
	type Fruit struct {
		Name string `json:"name"`
		PriceTag string `json:"PriceTag"`
	}

	type FruitBasket struct {
		Name string
		Fruit Fruit
		id int64 `json:"ref"`
		Created time.Time

	}

	jsonData := []byte(`{
        "Name": "Standard",
        "Fruit" : {"Name": "Apple", "PriceTag": "$1"},
        "ref": 999,
        "Created": "2018-04-09T23:00:00Z"
    }`)

	var  basket  FruitBasket

	err := json.Unmarshal(jsonData, &basket)

	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(basket.Created, basket.id, basket.Fruit)
}
*/

//解析包含对象数组的json数据
/*
func main() {

	type Fruit struct {
		Name string `json:"name"`
		PriceTag string `json:"PriceTag"`
	}

	type FruitBasket struct {
		Name string
		Fruit []Fruit
		Id int64 `json:"ref"`
		Created time.Time
	}


	jsonData := []byte(`{
        "Name": "Standard",
        "Fruit" : [
			{
				"Name": "Apple",
					"PriceTag": "$1"
			},
			{
				"Name": "Pear",
				"PriceTag": "$1.5"
			}
		],
        "ref": 999,
        "Created": "2018-04-09T23:00:00Z"
    }`)

	var  basket  FruitBasket

	err := json.Unmarshal(jsonData, &basket)

	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(basket.Created, basket.Id, basket.Fruit)
}
*/

//解析具有动态key的对象

/*
func main() {
	type Fruit struct {
		Name string `json:"Name"`
		PriceTag string `json:"PriceTag"`
	}

	type FruitBasket struct {
		Name    string
		Fruit   map[string]Fruit
		Id      int64 `json:"ref"`// 声明对应的json key
		Created time.Time

	}
	jsonData := []byte(`
    {
        "Name": "Standard",
        "Fruit" : {
	    "1": {
		"Name": "Apple",
		"PriceTag": "$1"
	    },
	    "2": {
		"Name": "Pear",
		"PriceTag": "$1.5"
	    }
        },
        "ref": 999,
        "Created": "2018-04-09T23:00:00Z"
    }`)

	var basket FruitBasket
	err := json.Unmarshal(jsonData, &basket)
	if err != nil {
		fmt.Println(err)
	}
	for _, item := range basket.Fruit {
		fmt.Println(item.Name, item.PriceTag)
	}
}
*/

//解析包含任意层级的数组和对象

/*
func main() {

	jsonData := []byte(`{"Name":"Eve","Age":6,"Parents":["Alice","Bob"]}`)
	var v interface{}
	json.Unmarshal(jsonData, &v)
	data := v.(map[string]interface{})

	for k, v := range data {
		switch v := v.(type) {
		case string:
			fmt.Println(k, v, "(string)")
		case float64:
			fmt.Println(k, v, "(float64)")
		case []interface{}:
			fmt.Println(k, "(array):")
			for i, u := range v {
				fmt.Println("    ", i, u)
			}
		default:
			fmt.Println(k, v, "(unknown)")
		}
	}
}
*/
//生成json
/*
type Server struct {
	ServerName string
	ServerIP string
}

type Serverslice struct {
	Servers []Server
}

func main() {
	var s Serverslice
	s.Servers = append(s.Servers, Server{ServerName: "Shanghai_VPN", ServerIP: "127.0.0.1"})
	s.Servers = append(s.Servers, Server{ServerName: "Beijing_VPN", ServerIP: "127.0.0.2"})
	b, err := json.Marshal(s)
	if err != nil {
		fmt.Println("json err:", err)
	}
	fmt.Println(string(b))

	//如果想要输出的字段以小写的方式进行输出，可以在定义结构体变量的时候指定
	//ServerName  string `json:"serverName"`
	//ServerName2 string `json:"serverName2,string"

	//如果不想字段导出到json中,首字母小写或者定义成如下格式
	//ID int `json:"-"`
}
*/

小结

xml、json两类格式的数据应用相对较多，尤其是针对json的数据处理，所以这部分的内容是必须掌握的。

参考博客