Go语言Marshal序列化遇到的问题

go语言将struct Marshal()序列化成json，默认按照一定格式进行转换。可以实现Marshaler接口的MarshalJSON()方法，实现自定义序列化。反序列化实现Unmarshaler接口。

1、Marshal和Unmarshal使用

 type dog struct {Name stringAge  int}type person struct {Id   stringDogs []dog}dogs := []dog{dog{Name: "一",Age:  1,}}per := person{Id:   "小明",Dogs: dogs,}s, _ := json.Marshal(per)  //序列化成json格式的[]bytefmt.Println(string(s))  //输出：{"Id":"小明","Dogs":[{"Name":"一","Age":1}]}per2 := person{}_ = json.Unmarshal(s, &per2)  //将json反序列化放入结构体&per2中fmt.Println(per)    //输出：{小明 [{一 1}]}

注意：

json.Marshal(per)中，结构体per的字段名必须大写，小写字段名返回的[]byte是nil。
json.Unmarshal(s, &per2)中，&per2必须是指针且不是nil，否则err InvalidUnmarshalError。

2、序列化对应数据类型的编码

json格式有自己的数据格式规范，包括：

string：必须要用双引号引起来
number：数值，没有双引号
object：对象，{ key:value }表示方式，可嵌套。
List：数组，[ value,value ]
boolean：true/false，没有双引号
null：空值

Marshal和Unmarshal的Go语言数据类型和json格式的数据类型对应关系如下：

Go语言类型	json类型
bool	boolean
string	string
int，unit，float，rune	number
array，slice	List
struct，map	object
nil	null
chan，func，complex*	不支持
[]byte	Base64编码的string
time.Time	RFC3339格式string

[]byte和time.Time两种类型序列化较为特殊，对数据做格式编码，保存成json字符串形式。

序列化时对两种类型编码，反序列时对类型解码。编码格式如下：

[]byte："5ZaE6Imv"

time.Time："2022-09-05T11:04:40.3491328+08:00"

    per := person{Id: "小明",T: time.Now(),B: []byte("善良"),}s, _ := json.Marshal(per)fmt.Println(string(s))
//{"Id":"小明","T":"2022-09-05T11:04:40.3491328+08:00","B":"5ZaE6Imv"}per2 := person{}_ = json.Unmarshal(s, &per2)fmt.Println(per2)
//{小明 2022-09-05 11:04:40.3491328 +0800 CST [229 150 132 232 137 175]}fmt.Println(string(per2.B))
//善良

3、自定义序列化格式

[]byte和time.Time类型序列化是格式编码后的值，大部分场景可能不是我们希望的格式。我们使用自定义格式进行序列化。

3.1、Marshaler和Unmarshaler接口

Marshal序列化，递归遍历对象V，如果V实现了Marshaler接口，调用接口下的MarshalJSON（）方法生成JSON。

// Marshaler is the interface implemented by types that
// can marshal themselves into valid JSON.
type Marshaler interface {MarshalJSON() ([]byte, error)
}

Unmarshal反序列化，如果对象V实现了Unmarshaler接口，调用接口下的UnmarshalJSON（）方法获得对象V。

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

3.2、实现Marshaler接口设置序列化字段格式

自定义格式的字段，将[]btye定义成新类型ByteArr，time.Time定义成新类型NewTime。方便后面实现接口。

type ByteArr []byte
type NewTime time.Timetype dogg struct {Name ByteArrTime NewTime
}

自定义格式效果：

[]byte不使用base64编码，直接显示string形式。
time显示格式：2020-09-09 18:11:34

ByteArr 实现Marshaler接口和Unmarshaler接口，自定义 []byte 序列化和反序列化原样显示（string格式）。

// MarshalJSON returns m as the JSON encoding of m.
func (m ByteArr) MarshalJSON() ([]byte, error) {if m == nil {return []byte("null"), nil}return m, nil
}// UnmarshalJSON sets *m to a copy of data.
func (m *ByteArr) UnmarshalJSON(data []byte) error {if m == nil {return errors.New("UnmarshalJSON on nil pointer")}*m = append((*m)[0:0], data...)return nil
}

给ByteArr实现了两个接口的方法，MarshalJSON（）序列化时调用，UnmarshalJSON（）反序列化时调用。两个方法内没有做Base64的编码，直接原样返回。也可以在方法内转化成其他格式。到此自定义格式已经完成。

测试自定义 []byte 序列化

func main() {d := dogg{Name: []byte(`{"aa":"435","rt":23}`),}jsonD, err := json.Marshal(d)fmt.Println(string(jsonD), err)
//{"Name":{"aa":"435","rt":23},"Time":{}} <nil>d2 := dogg{}err = json.Unmarshal(jsonD, &d2)fmt.Println(string(d2.Name))
//{"aa":"435","rt":23}d3 := dogg{Name: []byte("会err吗"),}jsonD, err = json.Marshal(d3)
//json: error calling MarshalJSON for type main.ByteArr: invalid character 'ä'
//looking for beginning of valuefmt.Println(string(jsonD), err)d4 := dogg{}err = json.Unmarshal(jsonD, &d4)fmt.Println(string(d4.Name))
}

测试结果：d 序列化成功，json字符串为 []byte 原始数据。

d3 序列化失败。 json: error calling MarshalJSON for type main.ByteArr: invalid character 'ä' looking for beginning of value

3.3、MarshalJSON() 方法报错分析

该方法要求返回一个有效的JSON。百度搜索到的答案说：需要给方法的返回值加双引号。修改代码如下：

// MarshalJSON returns m as the JSON encoding of m.
func (m ByteArr) MarshalJSON() ([]byte, error) {s := string(m)if m == nil {//return []byte("null"), nils = "null"}st := "\"" + s + "\"" //加双引号//st := strconv.Quote(s) //加双引号和转义\return []byte(st), nil
}
//输出
//json: error calling MarshalJSON for type main.ByteArr: invalid character 'a' af
//ter top-level value//{"Name":"会err吗","Time":{}} <nil>
//"会err吗"

只加双引号：d 序列化失败， json: error calling MarshalJSON for type main.ByteArr: invalid character 'a' after top-level value

d3 序列化成功。

加双引号并且转义\：序列化全部成功。

分析MarshalJSON()输出结果：

只加双引号，d=“{"aa":"435","rt":23}”，d3="会err吗" 。
加双引号并且转义\，d="{\"aa\":\"435\",\"rt\":23}"，d3="会err吗"

有转义字符显然不是我们要的结果。

最终分析结果

MarshalJSON()方法的返回要求合法的JSON。合法的JSON不单单是网上说的使用双引号。

如果实现接口的对象是某个字段，则返回的JSON为该字段的value。返回值符合value的JSON格式。JSON的value包括string、number、list、boolean、object等，每个数据有不同的格式，string需要双引号。number没有双引号，必须是数值。object是个JSON。list是中括号列表等等。
如果实现接口是整个结构体对象，合法的JSON应该是完整的JSON对象。

因此，想要将 []byte 直接作为json的value显示，只需要满足JSON的value数据格式。

3.4、使用go语言json包中的 json.RawMessage 实现 []byte 直接json显示

json.RawMessage源码如下：

// RawMessage is a raw encoded JSON value.
// It implements Marshaler and Unmarshaler and can
// be used to delay JSON decoding or precompute a JSON encoding.
type RawMessage []byte// MarshalJSON returns m as the JSON encoding of m.
func (m RawMessage) MarshalJSON() ([]byte, error) {if m == nil {return []byte("null"), nil}return m, nil
}// UnmarshalJSON sets *m to a copy of data.
func (m *RawMessage) UnmarshalJSON(data []byte) error {if m == nil {return errors.New("json.RawMessage: UnmarshalJSON on nil pointer")}*m = append((*m)[0:0], data...)return nil
}

json.RawMessage使用

type dogg struct {Name json.RawMessageTime NewTime
}func main() {d := dogg{Name: []byte(`{"aa":"435","rt":23}`),}jsonD, err := json.Marshal(d)fmt.Println(string(jsonD), err)d2 := dogg{}err = json.Unmarshal(jsonD, &d2)fmt.Println(string(d2.Name))}
//{"Name":{"aa":"435","rt":23},"Time":"0001-01-01 00:10:112"} <nil>
//{"aa":"435","rt":23}

3.5、实现TextMarshaler接口自定义序列化格式

序列化时，找不到 MarshalJSON() 函数，会继续判断是否实现TextMarshaler接口。是，则调用接口下的 MarshalText() 函数。反序列化时，继续调用 TextUnmarshaler.UnmarshalText() 函数。接口如下：

// TextMarshaler is the interface implemented by an object that can
// marshal itself into a textual form.
//
// MarshalText encodes the receiver into UTF-8-encoded text and returns the result.
type TextMarshaler interface {MarshalText() (text []byte, err error)
}// TextUnmarshaler is the interface implemented by an object that can
// unmarshal a textual representation of itself.
//
// UnmarshalText must be able to decode the form generated by MarshalText.
// UnmarshalText must copy the text if it wishes to retain the text
// after returning.
type TextUnmarshaler interface {UnmarshalText(text []byte) error
}

MarshalJSON()和MarshalText()两个函数的区别：

MarshalJSON返回的是合法的JSON，返回的值，Marshal() 函数在拼接json字符串时直接使用。实现接口的对象是最外层结构体对象，序列化就是函数返回值。是结构体中字段，返回值是序列化的json串的value值。
MarshalText返回的是UTF-8的文本。序列化过程中，将函数返回值看作的json的字符串类型，Marshal() 函数会对返回值加双引号。实现接口对象是结构体字段，返回值被看作是序列化的json中value的值（字符串类型）。对象是最外层结构体，整个结构体序列化就是含双引号字符串。特殊字符默认转义。

本文的数据格式：

[]byte：全部是json格式的字符串。

time.Time：普通字符串，不含特殊字符。

3.6、最终实现版本

根据数据特点，对 []byte 类型选择实现 Marshaler 接口的MarshalJSON()方法。对 time.Time 类型选择实现 TextMarshaler 接口的 MarshalText() 方法。

type ByteArr []byte
type NewTime time.Timetype dogg struct {Name ByteArrTime NewTime
}func (t NewTime) MarshalText() ([]byte, error) {tm := time.Time(t)if y := tm.Year(); y < 0 || y >= 10000 {return nil, errors.New("Time.MarshalText: year outside of range [0,9999]")}return []byte(tm.Format("2006-01-02 15:04:05")), nil
}func (t *NewTime) UnmarshalText(b []byte) error {
//必须是2006-01-02 15:04:05字符串tm, _ := time.Parse("2006-01-02 15:04:05", string(b))*t = NewTime(tm)return nil
}// MarshalJSON returns m as the JSON encoding of m.
func (m ByteArr) MarshalJSON() ([]byte, error) {if m == nil {return []byte("null"), nil}b := json.Valid(m) //判断是否是json格式（只有json的五种数据类型也合法，“a”，true，et）if !b {s := strconv.Quote(string(m)) //不是json，加双引号作为string返回return []byte(s), nil}return m, nil
}// UnmarshalJSON sets *m to a copy of data.
func (m *ByteArr) UnmarshalJSON(data []byte) error {if m == nil {return errors.New("UnmarshalJSON on nil pointer")}*m = append((*m)[0:0], data...)return nil
}func ByteMarshal() {d := dogg{Name: []byte(`{"aa":"435","rt":23}`),Time: NewTime(time.Now()),}jsonD, err := json.Marshal(d)fmt.Println(string(jsonD), err)d2 := dogg{}err = json.Unmarshal(jsonD, &d2)fmt.Println(string(d2.Name), time.Time(d.Time).Format("2006-01-02 15:04:05"))
}
//{"Name":{"aa":"435","rt":23},"Time":"2022-09-06 15:17:45"} <nil>
//{"aa":"435","rt":23} 2022-09-06 15:17:45

4、除了结构体字段实现上面两个接口，还可以让整个结构体实现这两个接口。更新。。。