何为序列

对于计算机而言，一切数据皆为二进制序列。但编程人员为了以人类可读可控的形式处理这些二进制数据，于是发明了数据类型和结构的概念，数据类型用以标注一段二进制数据的解析方式，数据结构用以标注多段(连续/不连续)二进制数据的组织方式。

例如以下程序结构体：

type User struct {
 Name string
 Email string
}

Name 和 Email 分别表示两块独立(或连续，或不连续)的内存空间（数据），结构体变量本身也有一个内存地址。

在单进程中，我们可以通过分享该结构体地址来交换数据。但如果要将该数据通过网络传输给其他机器的进程，我们需要现将该 User 对象中不同的内存空间，编码成一段连续二进制表示，此即为「序列化」。而对端机器收到了该二进制流以后，还需要能够认出该数据为 User 对象，解析为程序内部表示，此即为「反序列化」。

序列化和反序列化，就是将同一份数据，在人的视角和机器的视角之间相互转换。

序列化过程

定义接口描述（IDL）

为了传递数据描述信息，同时也为了多人协作的规范，我们一般会将描述信息定义在一个由 IDL(Interface Description Languages) 编写的定义文件中，例如下面这个 Protobuf 的 IDL 定义：

message User {
 string name = 1;
 string email = 2;
}

生成 Stub 代码

无论使用什么样的序列化方法，最终的目的是要变成程序中里的一个对象，虽然序列化方法往往是语言无关的，但这段将内存空间与程序内部表示（如 struct/class）相绑定的过程却是语言相关的，所以很多序列化库才会需要提供对应的编译器，将 IDL 文件编译成目标语言的 Stub 代码。

Stub 代码内容一般分为两块：

类型结构体生成（即目标语言的 Struct[Golang]/Class[Java] ）
序列化/反序列化代码生成（将二进制流与目标语言结构体相转换）

下面是一段 Thrift 生成的的序列化 Stub 代码：

type User struct {
 Name string `thrift:"name,1" db:"name" json:"name"`
 Email string `thrift:"email,2" db:"email" json:"email"`
}

//写入 User struct
func (p *User) Write(oprot thrift.TProtocol) error {
 if err := oprot.WriteStructBegin("User"); err != nil {
 return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
 if p != nil {
 if err := p.writeField1(oprot); err != nil { return err }
 if err := p.writeField2(oprot); err != nil { return err }
 }
 if err := oprot.WriteFieldStop(); err != nil {
 return thrift.PrependError("write field stop error: ", err) }
 if err := oprot.WriteStructEnd(); err != nil {
 return thrift.PrependError("write struct stop error: ", err) }
 return nil
}

// 写入 name 字段
func (p *User) writeField1(oprot thrift.TProtocol) (err error) {
 if err := oprot.WriteFieldBegin("name", thrift.STRING, 1); err != nil {
 return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:name: ", p), err) }
 if err := oprot.WriteString(string(p.Name)); err != nil {
 return thrift.PrependError(fmt.Sprintf("%T.name (1) field write error: ", p), err) }
 if err := oprot.WriteFieldEnd(); err != nil {
 return thrift.PrependError(fmt.Sprintf("%T write field end error 1:name: ", p), err) }
 return err
}

// 写入 email 字段
func (p *User) writeField2(oprot thrift.TProtocol) (err error) {
 if err := oprot.WriteFieldBegin("email", thrift.STRING, 2); err != nil {
 return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:email: ", p), err) }
 if err := oprot.WriteString(string(p.Email)); err != nil {
 return thrift.PrependError(fmt.Sprintf("%T.email (2) field write error: ", p), err) }
 if err := oprot.WriteFieldEnd(); err != nil {
 return thrift.PrependError(fmt.Sprintf("%T write field end error 2:email: ", p), err) }
 return err
}

可以看到，为了把 User 对象给序列化成二进制，它 hard code 了整个结构体在内存中的组织方式和顺序，并且分别对每个字段去做强制类型转换。如果我们新增了一个字段，就需要重新编译 Stub 代码并要求所有 Client 进行升级更新（当然不需要用到新字段可以不用更新）。反序列化的步骤也是类似。