json包

现代的语言都会支持json这种轻量的序列化方式。在golang中使用encoding/json来支持json的各个操作。

序列化方法

json序列化方法是Marshal函数，函数签名是

func Marshal(v interface{}) ([]byte, error)

反序列化方法

json序列化方法是Unmarshal函数，函数签名是

func Unmarshal(data []byte, v interface{}) error

用于json的Struct Tag

json序列号和反序列化只针对可见字段，对于不可见字段这两个过程都会直接忽略。 使用omitempty来处理空值，使用-忽略字段。

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    type Stu struct {
        Name   string `json:"name"`
        Age    int    `json:"age"`
        No     string `json:"no,omitempty"`
        Gender int    `json:"-"`
        group  int    //这个字段不参与序列化
    }

    stu := Stu{
        Name:   "wida",
        Age:    35,
        No:     "8001",
        Gender: 0,
        group:  88,
    }

    b, _ := json.Marshal(&stu)
    fmt.Println(string(b))

    var stu1 Stu

    json.Unmarshal(b, &stu1)
    fmt.Printf("%+v", stu1)
}

$ go run main.go
{"name":"wida","age":35,"no":"8001"}
{Name:wida Age:35 No:8001 Gender:0 group:0}

定制序列化和反序列化方式

在encoding/json包中定义了Marshaler和Unmarshaler

type Marshaler interface {
    MarshalJSON() ([]byte, error)
}
type Unmarshaler interface {
    UnmarshalJSON([]byte) error
}

如果一个类型实现了这两个接口就有实现自定义的json序列化和反序列化。

看下官方文档的一个例子：

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "strings"
)

type Animal int

const (
    Unknown Animal = iota
    Gopher
    Zebra
)

func (a *Animal) UnmarshalJSON(b []byte) error {
    var s string
    if err := json.Unmarshal(b, &s); err != nil {
        return err
    }
    switch strings.ToLower(s) {
    default:
        *a = Unknown
    case "gopher":
        *a = Gopher
    case "zebra":
        *a = Zebra
    }

    return nil
}

func (a Animal) MarshalJSON() ([]byte, error) {
    var s string
    switch a {
    default:
        s = "unknown"
    case Gopher:
        s = "gopher"
    case Zebra:
        s = "zebra"
    }

    return json.Marshal(s)
}

func main() {
    blob := `["gopher","armadillo","zebra","unknown","gopher","bee","gopher","zebra"]`
    var zoo []Animal
    if err := json.Unmarshal([]byte(blob), &zoo); err != nil {
        log.Fatal(err)
    }

    census := make(map[Animal]int)
    for _, animal := range zoo {
        census[animal] += 1
    }

    fmt.Printf("Zoo Census:\n* Gophers: %d\n* Zebras:  %d\n* Unknown: %d\n",
        census[Gopher], census[Zebra], census[Unknown])

}

---