如何在Golang中使用encoding/gob序列化对象存储和传输数据

在Golang的标准库中，encoding/gob包提供了针对Go原生数据类型的序列化与反序列化能力，能够将Go对象转换为字节流用于本地存储或者网络传输，也可以将字节流重新还原为原始对象，整个过程不需要依赖任何第三方库，非常适合Go项目内部的数据交互场景。

encoding/gob基础概念

gob是Go语言特有的序列化格式，它的设计目标是为Go程序之间的数据交换提供高效、简单的解决方案。和JSON、XML等通用序列化格式不同，gob不需要额外的类型描述信息即可完成序列化，因为它会在序列化过程中自动记录类型定义，反序列化时自动匹配对应的类型结构。

gob的核心能力包括：支持所有Go原生数据类型、支持自定义结构体、支持接口类型的序列化、序列化后的字节流体积相对较小，适合对性能有一定要求的场景。

基础数据类型序列化示例

我们先从最简单的原生数据类型序列化开始，演示基本的编码和解码流程：

package main

import (
	"bytes"
	"encoding/gob"
	"fmt"
)

func main() {
	// 待序列化的基础数据
	var originStr string = "hello gob"
	var originNum int = 100
	var originBool bool = true

	// 创建缓冲区用于存放序列化后的字节流
	var buf bytes.Buffer
	// 创建gob编码器
	enc := gob.NewEncoder(&buf)

	// 编码数据
	err := enc.Encode(originStr)
	if err != nil {
		fmt.Println("编码字符串失败:", err)
		return
	}
	err = enc.Encode(originNum)
	if err != nil {
		fmt.Println("编码整数失败:", err)
		return
	}
	err = enc.Encode(originBool)
	if err != nil {
		fmt.Println("编码布尔值失败:", err)
		return
	}

	// 获取序列化后的字节流
	serializedData := buf.Bytes()
	fmt.Println("序列化后的字节长度:", len(serializedData))

	// 创建gob解码器
	dec := gob.NewDecoder(bytes.NewReader(serializedData))
	// 定义变量接收反序列化结果
	var decodedStr string
	var decodedNum int
	var decodedBool bool

	// 解码数据
	err = dec.Decode(&decodedStr)
	if err != nil {
		fmt.Println("解码字符串失败:", err)
		return
	}
	err = dec.Decode(&decodedNum)
	if err != nil {
		fmt.Println("解码整数失败:", err)
		return
	}
	err = dec.Decode(&decodedBool)
	if err != nil {
		fmt.Println("解码布尔值失败:", err)
		return
	}

	// 验证结果
	fmt.Println("解码后的字符串:", decodedStr)
	fmt.Println("解码后的整数:", decodedNum)
	fmt.Println("解码后的布尔值:", decodedBool)
}

自定义结构体序列化

实际开发中我们更多需要处理自定义结构体，gob也支持结构体的序列化，只需要保证结构体的字段是可导出的即可，因为gob只能访问导出字段：

package main

import (
	"bytes"
	"encoding/gob"
	"fmt"
)

// 定义自定义结构体，字段必须导出
type User struct {
	Name  string
	Age   int
	Email string
}

func main() {
	// 初始化结构体对象
	originUser := User{
		Name:  "张三",
		Age:   25,
		Email: "test@ipipp.com",
	}

	// 序列化结构体
	var buf bytes.Buffer
	enc := gob.NewEncoder(&buf)
	err := enc.Encode(originUser)
	if err != nil {
		fmt.Println("编码结构体失败:", err)
		return
	}

	// 反序列化结构体
	var decodedUser User
	dec := gob.NewDecoder(&buf)
	err = dec.Decode(&decodedUser)
	if err != nil {
		fmt.Println("解码结构体失败:", err)
		return
	}

	fmt.Printf("解码后的结构体: %+vn", decodedUser)
}

使用gob存储数据到本地文件

序列化后的数据可以写入本地文件实现持久化存储，以下是完整的存储和读取示例：

package main

import (
	"encoding/gob"
	"fmt"
	"os"
)

type Product struct {
	ID    int
	Name  string
	Price float64
}

func main() {
	// 待存储的产品数据
	products := []Product{
		{ID: 1, Name: "笔记本", Price: 4999.99},
		{ID: 2, Name: "鼠标", Price: 89.9},
	}

	// 创建本地文件
	file, err := os.Create("products.gob")
	if err != nil {
		fmt.Println("创建文件失败:", err)
		return
	}
	defer file.Close()

	// 创建编码器并写入文件
	enc := gob.NewEncoder(file)
	err = enc.Encode(products)
	if err != nil {
		fmt.Println("写入数据失败:", err)
		return
	}
	fmt.Println("数据已成功存储到本地文件")

	// 读取本地文件数据
	readFile, err := os.Open("products.gob")
	if err != nil {
		fmt.Println("打开文件失败:", err)
		return
	}
	defer readFile.Close()

	// 创建解码器并解码
	var decodedProducts []Product
	dec := gob.NewDecoder(readFile)
	err = dec.Decode(&decodedProducts)
	if err != nil {
		fmt.Println("读取数据失败:", err)
		return
	}

	fmt.Println("从文件读取的产品数据:")
	for _, p := range decodedProducts {
		fmt.Printf("ID:%d 名称:%s 价格:%.2fn", p.ID, p.Name, p.Price)
	}
}

使用gob进行网络数据传输

gob也常用于Go程序之间的网络传输，以下是一个简单的TCP服务端和客户端的示例，演示通过gob传输结构体数据：

服务端代码

package main

import (
	"encoding/gob"
	"fmt"
	"net"
)

type Message struct {
	From    string
	Content string
	Time    int64
}

func main() {
	// 监听本地8080端口
	listener, err := net.Listen("tcp", "127.0.0.1:8080")
	if err != nil {
		fmt.Println("监听端口失败:", err)
		return
	}
	defer listener.Close()
	fmt.Println("服务端已启动，等待连接...")

	// 接受客户端连接
	conn, err := listener.Accept()
	if err != nil {
		fmt.Println("接受连接失败:", err)
		return
	}
	defer conn.Close()

	// 创建解码器读取客户端发送的数据
	dec := gob.NewDecoder(conn)
	var msg Message
	err = dec.Decode(&msg)
	if err != nil {
		fmt.Println("解码数据失败:", err)
		return
	}

	fmt.Printf("收到客户端消息: 来自%s 内容:%s 时间戳:%dn", msg.From, msg.Content, msg.Time)

	// 给客户端返回响应
	response := Message{
		From:    "server",
		Content: "已收到你的消息",
		Time:    1234567890,
	}
	enc := gob.NewEncoder(conn)
	err = enc.Encode(response)
	if err != nil {
		fmt.Println("发送响应失败:", err)
		return
	}
}

客户端代码

package main

import (
	"encoding/gob"
	"fmt"
	"net"
	"time"
)

type Message struct {
	From    string
	Content string
	Time    int64
}

func main() {
	// 连接服务端
	conn, err := net.Dial("tcp", "127.0.0.1:8080")
	if err != nil {
		fmt.Println("连接服务端失败:", err)
		return
	}
	defer conn.Close()

	// 发送消息到服务端
	msg := Message{
		From:    "client",
		Content: "你好，服务端",
		Time:    time.Now().Unix(),
	}
	enc := gob.NewEncoder(conn)
	err = enc.Encode(msg)
	if err != nil {
		fmt.Println("发送消息失败:", err)
		return
	}

	// 接收服务端响应
	dec := gob.NewDecoder(conn)
	var response Message
	err = dec.Decode(&response)
	if err != nil {
		fmt.Println("接收响应失败:", err)
		return
	}

	fmt.Printf("收到服务端响应: 来自%s 内容:%s 时间戳:%dn", response.From, response.Content, response.Time)
}

注意事项和常见问题

• gob只能序列化可导出的字段，结构体中的小写字母开头的字段会被忽略，不会参与序列化过程。
• 反序列化时接收变量的类型必须和序列化时的类型完全匹配，否则会返回解码错误。
• 如果自定义结构体包含接口类型的字段，需要在序列化前调用gob.Register()注册接口的具体实现类型，否则会无法编码。
• gob是Go语言特有的格式，不能和其他语言编写的程序进行数据交互，如果需要跨语言传输数据，建议使用JSON等通用格式。
• 编码和解码的过程中要确保编码和解码的顺序一致，否则会导致数据解析错误。

总结

encoding/gob是Go语言中非常实用的原生序列化工具，适合Go程序内部的数据存储和传输场景，使用起来简单高效，不需要引入额外依赖。本文从基础用法到实战示例，覆盖了gob的核心使用场景，开发者可以根据实际需求调整代码逻辑，快速应用到自己的项目中。如果需要跨语言的数据交互，再考虑使用其他通用序列化方案即可。

encoding/gobGolang序列化数据存储数据传输修改时间：2026-06-25 00:51:42