Go语言将结构体数据保存为JSON格式数据-Go语言教程

Go语言将结构体数据保存为JSON格式数据

JSON 格式是一种用途广泛的对象文本格式。在 Go语言中，结构体可以通过系统提供的 json.Marshal() 函数进行序列化。为了演示怎样通过反射获取结构体成员及各种值的过程，下面使用反射将结构体序列化为文本数据。

数据结构及入口函数

将结构体序列化为 JSON 的步骤如下：

准备数据结构体。

准备要序列化的结构体数据。

调用序列化函数。

具体代码如下所示：


func main() {
    // 声明技能结构
    type Skill struct {
        Name  string
        Level int
    }
    // 声明角色结构
    type Actor struct {
        Name string
        Age  int
        Skills []Skill
    }
    // 填充基本角色数据
    a := Actor{
        Name: "cow boy",
        Age:  37,
        Skills: []Skill{
            {Name: "Roll and roll", Level: 1},
            {Name: "Flash your dog eye", Level: 2},
            {Name: "Time to have Lunch", Level: 3},
        },
    }
    if result, err := MarshalJson(a); err == nil {
        fmt.Println(result)
    } else {
        fmt.Println(err)
    }
}

代码说明如下：

第 4～15 行声明了一些结构体，用于描述一个角色的信息。

第 18～27 行，实例化了 Actor 结构体，并且填充了一些基本的角色数据。

第 29 行，调用自己实现的 MarshalJson() 函数，将 Actor 实例化的数据转换为 JSON 字符串。

第 30 行，如果操作成功将打印出数据。

第 32 行，如果操作有错误将打印错误。

完整代码输出如下：

{"Name":"cow boy","Age":37,"Skills":[{"Name":"Roll and roll","Level":1},{"Name":"Flash your dog eye","Level":2},{"Name":"Time to have Lunch","Level":3}]}

序列化主函数

MarshalJson() 是序列化过程的主要函数入口，通过这个函数会调用不同类型的子序列化函数。MarshalJson() 传入一个 interface{} 的数据，并将这个数据转换为 JSON 字符串返回，如果发生错误，则返回错误信息。


func MarshalJson(v interface{}) (string, error) {
    // 准备一个缓冲
    var b bytes.Buffer
    // 将任意值转换为json并输出到缓冲
    if err := writeAny(&b, reflect.ValueOf(v)); err == nil {
        return b.String(), nil
    } else {
        return "", err
    }
}

代码说明如下：

第 4 行，使用 bytes.Buffer 构建一个缓冲，这个对象类似于其他语言中的 StringBuilder，在大量字符串连接时，推荐使用这个结构。

第 7 行，调用 writeAny() 函数，将 bytes.Buffer 以指针的方式传入，以方便将各种类型的数据都写入这个 bytes.Buffer 中。同时，将 v 转换为反射值对象并传入。

第 8 行，如果没有错误发生时，将 bytes.Buffer 的内容转换为字符串井返回。

第 10 行，发生错误时，远回空字符串结果和错误。

MarshalJson() 这个函数其实是对 writeAny() 函数的一个封装，将外部的 interface{} 类型转换为内部的 reflect.Value 类型，同时构建输出缓冲，将一些复杂的操作简化，方便外部使用。

任意值序列化

writeAny() 函数传入一个字节缓冲和反射值对象，将反射值对象转换为 JSON 格式并写入字节缓冲中。代码如下所示。


// 将任意值转换为json并输出到缓冲
func writeAny(buff *bytes.Buffer, value reflect.Value) error {
    switch value.Kind() {
    case reflect.String:
        // 写入带有双引号括起来的字符串
        buff.WriteString(strconv.Quote(value.String()))
    case reflect.Int:
        // 将整形转换为字符串并写入缓冲
        buff.WriteString(strconv.FormatInt(value.Int(), 10))
    case reflect.Slice:
        return writeSlice(buff, value)
    case reflect.Struct:
        return writeStruct(buff, value)
    default:
        // 遇到不认识的种类，返回错误
        return errors.New("unsupport kind: " + value.Kind().String())
    }
    return nil
}

代码说明如下：

第 4 行，根据传入反射值对象的种类进行判断，如字符串、整型、切片及结构体。

第 7 行，当传入值为字符串种类时，使用 reflect.Value 的 String 函数将传入值转换为字符串，再将字符串用双引号括起来，strconv.Quote() 函数提供了比较正规的封装。最终使用 bytes.Buffer 的 WriteString() 函数，将前面输出的字符串写入缓冲中。

第 10 行，当传入值为整型时，使用 reflect.Value 的 Int() 函数，将传入值转换为整型，再将整型以十进制格式使用 strconv.FormatInt() 函数格式化为字符串，最后写入缓冲中。

第 11 行，使用 writeSlice() 函数把切片序列化为 JSON 操作。

第 14 行，使用 writeStruct() 函数把切片序列化为 JSON 操作。

第 17 行，遇到不能识别的类型，函数返回错误。

writeAny() 函数是整个序列化中非常重要的环节，可以通过扩充 switch 中的种类扩充序列化能识别的类型。

切片序列化

writeAny() 函数中会调用 writeSlice() 函数将切片类型转换为 JSON 格式的字符串并将数据写入缓冲中。代码如下所示。


// 将切片转换为json并输出到缓冲
func writeSlice(buff *bytes.Buffer, value reflect.Value) error {
    // 写入切片开始标记
    buff.WriteString("[")
    // 遍历每个切片元素
    for s := 0; s < value.Len(); s++ {
        sliceValue := value.Index(s)
        // 写入每个切片元素
        writeAny(buff, sliceValue)
        // 写入每个元素尾部逗号，最后一个字段不添加
        if s < value.Len()-1 {
            buff.WriteString(",")
        }
    }
    // 写入切片结束标记
    buff.WriteString("]")
    return nil
}

代码说明如下：

第 5 行和第 21 行分别写入 JSON 数组的开始标识“[”和结束标识“]”。

第 8 行和第 9 行，使用 reflect.Value 的 Len() 方法和 Index() 方法遍历切片的所有元素。Len() 方法返回切片的长度，Index() 方法根据给定的索引找到对应的索引。

第 12 行，通过 reflect.Value 类型的 Index 方法获得 reflect.Value 类型的 sliceValue，再将 sliceValue 传入 writeAny() 函数并继续对这个值进行递归序列化。

第 15～17 行，JSON 格式规定：每个数组成员由逗号分隔且最后一个元素后不加逗号，这里就是遵守这个规定。

由于 writeAny 的功能较为完善，因此序列化切片只需要添加头尾标识符及元素分隔符就可以了。

结构体序列化

在 JSON 格式中，切片是一系列值的序列，以方括号开头和结尾：结构体由键值对组成，以大括号开始和结束。两种结构的元素均以逗号分隔。序列化结构体的实现过程代码如下所示。


// 将结构体序列化为json并输出到缓冲
func writeStruct(buff *bytes.Buffer, value reflect.Value) error {
    // 取值的类型对象
    valueType := value.Type()
    // 写入结构体左大括号
    buff.WriteString("{")
    // 遍历结构体的所有值
    for i := 0; i < value.NumField(); i++ {
        // 获取每个字段的字段值(reflect.Value)
        fieldValue := value.Field(i)
        // 获取每个字段的类型(reflect.StructField)
        fieldType := valueType.Field(i)
        // 写入字段名左双引号
        buff.WriteString(""")
        // 写入字段名
        buff.WriteString(fieldType.Name)
        // 写入字段名右双引号和冒号
        buff.WriteString("":")
        // 写入每个字段值
        writeAny(buff, fieldValue)
        // 写入每个字段尾部逗号，最后一个字段不添加
        if i < value.NumField()-1 {
            buff.WriteString(",")
        }
    }
    // 写入结构体右大括号
    buff.WriteString("}")
    return nil
}