Golang：实现自定义对象的序列化和反序列化

在开发过程中，我们经常需要将对象转换成二进制格式进行存储、传输等操作。这个过程被称为序列化。而将二进制数据反向转换为对象的过程，则被称为反序列化。在Golang中，可以使用编码/解码库实现自定义对象的序列化和反序列化。

1. 序列化：

当需要将一个对象序列化成二进制数据时，我们需要将该对象的各个属性一个个转换为对应的二进制数据，并将它们按照一定规则进行拼接。因此，序列化需要注意以下几个问题：

1.1 序列化方式

在Golang中，我们常用的序列化方式有JSON、XML、protobuf等。下面以JSON为例，介绍序列化的实现。

1.2 编码器

在Golang中，可以使用encoding/json中的Marshal函数，将一个对象序列化为JSON字符串。它的定义如下：

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

其中，v代表需要序列化的对象。该函数的返回值为序列化后的JSON字符串和一个错误信息。下面是一个示例代码：

type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{Name: "Tom", Age: 18}
    b, err := json.Marshal(p)
    if err != nil {
        fmt.Println("json.Marshal failed:", err)
    }
    fmt.Println(string(b))
}

输出结果为：{"Name":"Tom","Age":18}

1.3 序列化中文字符

在序列化中文字符时，需要使用unicode/utf8包将中文字符转换为Unicode编码，或者使用第三方库将序列化后的数据进行base64编码。下面是一个使用base64编码的示例代码：

type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{Name: "张三", Age: 18}
    b, err := json.Marshal(p)
    if err != nil {
        fmt.Println("json.Marshal failed:", err)
    }
    fmt.Println(base64.StdEncoding.EncodeToString(b))
}

输出结果为：eyJOb21lIjoi5byg5LiJIiwiQWdlIjoxOH0=

2. 反序列化：

反序列化的过程是将序列化后的二进制数据解析为一个对象。在Golang中，可以使用encoding/json中的Unmarshal函数，将JSON字符串反序列化为一个对象。它的定义如下：

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

其中，data代表需要解析的二进制数据，v代表需要反序列化为的对象。该函数的返回值为错误信息。下面是一个示例代码：

type Person struct {
    Name string
    Age  int
}

func main() {
    s := `{"Name":"Tom","Age":18}`
    var p Person
    err := json.Unmarshal([]byte(s), &p)
    if err != nil {
        fmt.Println("json.Unmarshal failed:", err)
    }
    fmt.Println(p)
}

输出结果为：{Tom 18}

需要注意的是，在反序列化时，需要确保JSON字符串的格式与目标对象的结构相同，否则会解析失败。

3. 自定义对象的序列化和反序列化：

当需要序列化自定义对象时，我们需要实现encoding/json中的Marshaler和Unmarshaler接口。下面是一个实现该接口的示例代码：

type Person struct {
    Name string
    Age  int
}

func (p *Person) MarshalJSON() ([]byte, error) {
    m := map[string]interface{}{
        "Name": p.Name,
        "Age":  p.Age,
    }
    return json.Marshal(m)
}

func (p *Person) UnmarshalJSON(data []byte) error {
    var m map[string]interface{}
    err := json.Unmarshal(data, &m)
    if err != nil {
        return err
    }
    p.Name = m["Name"].(string)
    p.Age = int(m["Age"].(float64))
    return nil
}

func main() {
    p := Person{Name: "Tom", Age: 18}
    b, err := json.Marshal(p)
    if err != nil {
        fmt.Println("json.Marshal failed:", err)
    }
    fmt.Println(string(b))
    var p2 Person
    err = json.Unmarshal(b, &p2)
    if err != nil {
        fmt.Println("json.Unmarshal failed:", err)
    }
    fmt.Println(p2)
}

输出结果为：

{"Age":18,"Name":"Tom"}

{Tom 18}

通过实现Marshaler和Unmarshaler接口，我们可以将自定义对象序列化为JSON字符串，并能够实现JSON字符串的反序列化为自定义对象。

总结：

在Golang中，可以使用encoding/json库实现对象的序列化和反序列化。在序列化时，需要注意序列化方式、序列化中文字符等问题；在反序列化时，需要确保JSON字符串的格式与目标对象的结构相同，否则会解析失败。对于自定义对象的序列化和反序列化，我们需要实现encoding/json中的Marshaler和Unmarshaler接口。