Go on Snow

About Go Interview

Sat, 18 Apr 2026 15:36:08 +0800

前言

本指南基于 2025-2026 年腾讯、阿里、字节、华为等大厂 168 道真实 Go 后端面试真题整理，覆盖从基础语法到架构设计的全维度考点，帮助你系统性准备 Go 后端岗位面试。

一、面试考点整体分布

根据真实面试题统计，各模块考察占比如下：

模块	占比	核心考察方向
并发与并行控制	24.1%	协程管理、锁机制、资源竞争
性能优化与调试	18.9%	内存管理、查询优化、日志监控
系统设计	17.5%	高可用架构、业务系统设计
数据结构与 Go 特性	15.8%	切片、map、标准库特性
数据库与缓存	12.7%	Redis、MySQL、缓存设计
网络与安全	7.0%	协议、攻防、TCP 优化
工程实践	4.0%	CI/CD、依赖管理、监控

核心结论：前三个模块合计占比 60.5%，是决定面试成败的关键。

二、基础语法核心考点

1. new 和 make 的区别

问题： Go 中new和make有什么区别？ 解析：

new(T)：分配零值内存，返回*T指针，可用于所有类型，仅分配内存不初始化。
make(T, args)：仅用于slice、map、channel三种引用类型，返回初始化后的实例本身，而非指针。

示例：

1
2
3

// 正确用法
s := make([]int, 5) // 创建初始化后的切片
p := new(int) // 返回*int，指向零值

2. defer 关键字

问题： defer 的执行顺序是什么？对返回值有什么影响？ 解析：

执行顺序：多个 defer 按后进先出（LIFO） 栈结构执行，最后声明的最先执行。
参数求值：defer 语句的参数在声明时立即求值，而非执行时。
对返回值的影响：
- 命名返回值：defer 可以修改返回值，因为返回值是函数作用域的变量。
- 普通返回值：defer 修改的是局部变量，不影响返回值（return 会创建临时变量保存结果）。

示例：

// 假设 i=1，执行顺序：DeferFunc2 -> DeferFunc1

func DeferFunc1(i int) (t int) {
    t = i
    defer func() { t += 3 }()
    return t // 返回4，t是命名返回值
}

func DeferFunc2(i int) int {
    t := i
    defer func() { t += 3 }()
    return t // 返回1，return创建了临时变量
}

3. panic 和 recover

问题： panic 的执行流程是什么？recover 可以在什么地方使用？ 解析：

panic 触发后，会立即停止当前函数的执行，然后逆序执行当前已入栈的 defer 函数，直到所有 defer 执行完毕，最后程序崩溃。
如果 defer 中调用了 recover，会捕获 panic，程序恢复正常执行。
recover 必须在 defer 的函数中调用，否则无效，无法捕获其他 goroutine 的 panic。

补充：recover 是 Go 内置函数，用于捕获 panic，返回 panic 的值，如果没有 panic 则返回 nil。可以用来实现错误处理和资源清理，避免程序崩溃。

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("捕获到 panic:", r)
        }
    }()
    panic("发生错误")
}

4. 空结构体 `struct{}`

问题： 空结构体占用内存吗？有什么用途？ 解析：

空结构体不占用任何内存空间（unsafe.Sizeof(struct{}{}) = 0）。
常见用途：
1. 实现 Set 集合：用 map 的 key 存值，value 用空结构体节省内存。
2. 通道信号：仅需要通知，不需要传递数据时，发送空结构体。
3. 仅包含方法的结构体：不需要存储数据时。

5. rune 类型

问题： rune 和 byte 有什么区别？ 解析：

byte：等价于 uint8，占 1 个字节，代表 ASCII 码的一个字符。
rune：等价于 int32，占 4 个字节，代表一个 UTF-8 字符，用于处理中文、日文等多字节字符。但在下面的例子中为什么中文占3个字节呢？因为 UTF-8 编码中，中文字符通常占用 3 个字节，而 rune 是一个 Unicode 码点，占用 4 个字节的内存空间。

示例：

1
2
3

str := "hello 你好"
fmt.Println(len(str)) // 12，按字节计算（英文占1字节，中文占3字节）
fmt.Println(len([]rune(str))) // 8，按字符计算

6. 结构体 Tag

问题： Go 的结构体 Tag 有什么用？ 解析： Tag 是结构体字段的元数据，用于反射解析，常见用途：

json 序列化 / 反序列化：指定字段名、忽略空值等。
数据库映射：ORM 框架中指定数据库字段名。
参数绑定：Web 框架中指定表单参数、校验规则。

有关JSON参数绑定的详情可以参考Go语言中的JSON参数绑定。

示例：

type User struct {
 Name string `json:"name" db:"user_name" binding:"required"`
 Age int `json:"age,omitempty"`
}

7. init 函数

问题： init 函数什么时候执行？执行顺序是什么？ 解析：

init 函数在 main 函数之前执行，用于包的初始化。
执行顺序：import → const → var → init() → main()
同一个包、同一个文件可以有多个 init 函数，执行顺序由编译器决定，不保证顺序。

三、核心数据结构底层原理

1. 切片 Slice

问题 1：切片的底层结构是什么？数组和切片的区别？

解析： 切片的底层是一个结构体，包含三个字段：

type slice struct {
    array unsafe.Pointer // 底层数组指针
    len int // 长度，当前可访问元素个数
    cap int // 容量，底层数组最大容量
}

数组：固定长度，长度是类型的一部分（如 [5]int），值传递。
切片：动态长度，引用类型，对底层数组的封装。

问题 2：切片的扩容机制是什么？

解析： 当 append 元素时，如果容量不足，会触发扩容：

如果原容量小于 1024，新容量扩容为原来的 2 倍。
如果原容量大于等于 1024，新容量扩容为原来的 1.25 倍。
扩容时会分配新的底层数组，将原数组的元素拷贝过去，原数组如果没有引用会被 GC 回收。

注意：切片扩容会导致底层数组变更，所以如果要修改原切片的元素，需要注意引用关系。

问题 3：切片作为函数参数传递，会修改原切片吗？

解析： 切片本身是值传递，但是切片的底层数组是引用的：

如果修改元素，会修改原切片的元素，因为底层数组是同一个。
如果 append 导致扩容，新切片会指向新的底层数组，不会影响原切片。

2. 字典 Map

问题 1：Map 的底层实现原理是什么？

解析： Go 的 map 是哈希表实现，底层是数组 + 链表 + 溢出桶：

核心结构是bucket数组，每个 bucket 存放 8 个键值对。
哈希冲突时，新的键值对会放到溢出桶中。
哈希值的高 8 位用于找 bucket，低 8 位用于在 bucket 内比较 key。

举个例子：假设有一个 key 的哈希值是0x12345678，高 8 位0x12用于计算 bucket 索引，低 8 位0x78用于在 bucket 内比较 key 是否匹配。如果 bucket 已经有 8 个元素了，就会把新的键值对放到溢出桶中，溢出桶是一个链表结构，继续存储更多的键值对。否则，如果 bucket 内有空位，就直接放在 bucket 内。

溢出桶的存在是为了处理哈希冲突，避免性能下降。溢出桶中的元素数量过多时，会触发扩容，增加 bucket 数量，减少哈希冲突，提高性能。

问题 2：Map 的扩容机制是什么？

解析： 当 map 的负载因子（元素个数 /bucket 数量）超过 6.5 时，会触发扩容：

翻倍扩容：创建新的 bucket 数组，长度是原来的 2 倍。
增量扩容：不会一次性迁移所有数据，而是每次读写时迁移少量 bucket，避免阻塞。

问题 3：Map 是并发安全的吗？

解析： 原生 map 不是并发安全的，并发读写会 panic：concurrent map read and map write。

解决方案：
1. 加互斥锁sync.Mutex或读写锁sync.RWMutex。
2. 使用sync.Map，适用于读多写少的场景。

问题 4：Map 的遍历是有序的吗？

解析： 不是，Go 为了防止开发者依赖遍历顺序，故意在每次遍历时随机起始位置，所以不能依赖 map 的遍历顺序。如果需要有序遍历，需要把 key 取出来排序，再遍历。

3. 字符串 String

问题： 如何高效拼接字符串？

解析： 常见的拼接方式性能对比： strings.Join ≈ strings.Builder > bytes.Buffer > "+" > fmt.Sprintf

+：每次拼接都会创建新的字符串，性能差。
strings.Builder：底层是字节切片，可提前预分配容量，避免多次扩容，性能最高。

示例：

var sb strings.Builder
sb.Grow(100) // 提前预分配容量
sb.WriteString("hello")
sb.WriteString(" world")
result := sb.String()

四、并发编程与调度模型

1. Goroutine 与线程

问题： Goroutine 和 OS 线程（操作系统线程）有什么区别？为什么 Go 能支持百万级 Goroutine？

解析：

维度	OS 线程	Goroutine
栈大小	默认 MB 级，固定	初始 2KB，动态伸缩
调度	内核态调度，切换成本高	用户态调度，Runtime 调度，切换成本低
调度模型	1:1 映射（线程与 M 一对一）	M:N 映射，多个 G 映射到少量 M（内核线程）
上下文切换	需要陷入内核	仅用户态切换，无需内核参与

正是因为 Goroutine 轻量，初始栈小，调度成本低，所以 Go 可以轻松支持百万级 Goroutine 同时运行。

2. GMP 调度模型

问题： 什么是 GMP 模型？P 的作用是什么？

解析： GMP 是 Go 的调度模型，三个核心组件：

G（Goroutine）：协程实例，保存协程的栈、程序计数器等信息。
M（Machine）：内核线程，真正执行代码的实体。
P（Processor）：处理器，代表运行 G 的上下文，维护本地可运行 G 的队列。

P 的作用：

实现 M:N 调度，隔离调度上下文，避免全局锁竞争。
实现工作窃取（Work Stealing）：当 P 的本地队列为空时，从其他 P 的队列偷取 G，提高 CPU 利用率。
如果去掉 P，就会退化成 1:1 调度，全局锁竞争会非常严重，性能大幅下降。

3. Channel

问题 1：Channel 的底层实现是什么？

解析： Channel 的底层是一个环形队列，维护了发送者和接收者的等待队列：

有缓冲 Channel：带缓冲区的环形队列，当缓冲区满时发送者阻塞，空时接收者阻塞。
无缓冲 Channel：没有缓冲区，发送和接收必须同时准备好，否则阻塞，用于同步。

问题 2：不同状态的 Channel 操作会发生什么？

操作	nil Channel	未关闭非空 Channel	未关闭空 Channel	已关闭非空 Channel	已关闭空 Channel
读	永久阻塞	正常读数据	阻塞	正常读数据	读到零值，ok=false
写	永久阻塞	正常写数据（满时阻塞）	正常写数据	panic	panic
关闭	panic	正常关闭	正常关闭	panic	panic

问题 3：什么情况下会导致 Goroutine 泄漏？

解析： Goroutine 泄漏是指 Goroutine 永久阻塞，无法退出，占用内存：

Channel 发送 / 接收永久阻塞：比如无缓冲 Channel，没有接收者，发送者永久阻塞。
锁竞争导致永久阻塞。
循环中没有退出条件。

解决方案：

使用 Context 控制 Goroutine 的生命周期，超时取消。
带缓冲的 Channel，避免发送者阻塞。

4. Select

问题： Select 的执行机制是什么？多个 Case 同时就绪时怎么处理？

解析：

Select 会同时监听所有 Case 的 Channel 操作，哪个 Case 就绪就执行哪个。
如果多个 Case 同时就绪，Select 会伪随机选择一个执行，避免饥饿。为什么是伪随机？因为 Go 的 runtime 会在每次 Select 时随机打乱 Case 的顺序，保证公平性。
如果所有 Case 都没就绪，会执行 Default 分支（如果有），否则阻塞。

5. Sync 包工具

问题 1：Mutex 的模式是什么？

解析： Go 的 Mutex 有两种模式：

正常模式：锁被释放后，等待的 Goroutine 按 FIFO 顺序获取锁，性能高。
饥饿模式：当有 Goroutine 等待超过 1ms 时，会进入饥饿模式，锁直接移交等待的 Goroutine，避免长等待。

问题 2：sync.Once 的作用和原理？

解析： sync.Once 用于保证函数只执行一次，常用于单例初始化。

底层用原子操作uint32标记是否执行过，搭配 Mutex 保证并发安全。

问题 3：WaitGroup 的原理？

解析： WaitGroup 用于等待一组 Goroutine 完成：

Add (n)：增加计数。
Done ()：计数减 1。
Wait ()：阻塞直到计数为 0。
底层用信号量实现。

问题 4：sync.Map 的适用场景？

解析： sync.Map 是并发安全的 Map，适用于：

读多写少的场景。
key 一旦写入很少修改的场景。
底层用 read map 和 dirty map，读操作不加锁，写操作时合并数据，性能比加锁的原生 map 好。

6. Context

问题： Context 的作用是什么？底层原理？

解析： Context 用于在 Goroutine 之间传递取消信号、超时时间、请求元数据：

核心方法：Done()返回取消通道，Err()返回错误，Value()获取元数据。
实现了父子取消：父 Context 取消时，所有子 Context 都会取消。
常见用法：请求超时控制、Goroutine 退出控制、链路追踪传递 traceID。

五、内存管理与垃圾回收

1. 内存逃逸

问题： 什么是内存逃逸？什么情况下会发生？

解析： Go 的编译器会决定变量分配在栈上还是堆上，如果变量逃逸到堆上，就是内存逃逸。

栈上的变量函数返回后自动回收，不需要 GC。
堆上的变量需要 GC 回收，会增加 GC 压力。

常见逃逸场景：

变量太大，栈放不下。
变量的类型不确定，比如接口类型。
闭包引用变量（闭包就是一个函数值，它可以捕获并访问其外部作用域中的变量。当闭包引用了外部变量时，这些变量就会逃逸到堆上，因为闭包可能在函数返回后仍然存在）。例如：

func closure() func() {
    var x int // x 可能逃逸到堆上
    return func() {
    fmt.Println(x) // 闭包引用了 x
    }
}

变量被其他 Goroutine 引用。

可以用go build -gcflags="-m"查看逃逸分析结果。

2. 内存泄漏

问题： Go 有 GC，为什么还会内存泄漏？常见场景？

解析： GC 只会回收没有引用的内存，如果变量一直被引用，就不会被回收，导致内存泄漏。

常见场景：

Goroutine 泄漏：Goroutine 永久阻塞，一直占用栈内存。
全局 Map/Slice 一直增长，不清理过期数据。
没有关闭的资源，比如文件句柄、连接。
错误使用 sync.Pool，没有重置对象。

3. 垃圾回收 GC

问题 1：Go 的 GC 用的什么算法？三色标记法是什么？

解析： Go 的 GC 是并发三色标记清除算法：

白色：未被访问过的对象。
灰色：被访问过，但是它的引用对象还没处理。
黑色：被访问过，所有引用对象也处理过。

GC 流程：

初始所有对象都是白色。
从根对象出发，把根对象标记为灰色，加入队列。
取出灰色对象，把它的引用对象标记为灰色，自己标记为黑色。
直到没有灰色对象，剩下的白色对象（也是不可达的对象）就是垃圾，回收。

问题 2：什么是写屏障？混合写屏障？

解析： 并发 GC 时，用户程序可能并发修改对象引用，导致标记错误，所以需要写屏障：

写屏障是在修改引用时，记录操作，保证标记的正确性。
Go 1.8 之后用混合写屏障，取代了之前的插入写屏障和删除写屏障，大幅降低了 STW 的时间，现在 Go 的 STW 通常在微秒级。

问题 3：GC 的触发时机是什么？

解析：

内存分配达到阈值：当堆内存增长到上次 GC 后的 2 倍时触发。
手动触发：调用runtime.GC()。
定时触发：每 2 分钟强制触发一次 GC，防止长时间不分配内存导致垃圾无法回收。

六、接口、反射与泛型

1. 接口 Interface

问题 1：接口的底层结构是什么？

解析： Go 的接口是二元组结构：

iface：有方法的接口，包含tab（类型信息、方法表）和data（数据指针）。
eface：空接口interface{}，只有类型和数据指针。

问题 2：为什么 nil 接口不等于 nil？

解析： 接口的 nil 是指type和data都是 nil。如果把一个 nil 的具体类型指针赋值给接口，接口的type是具体类型，data是 nil，所以接口整体不是 nil。

示例：

func live() People {
    var stu *Student // stu是nil
    return stu // 接口的type是*Student，data是nil，所以接口不是nil
}

func main() {
    if live() == nil { // false
    fmt.Println("AAAAAAA")
    } else {
    fmt.Println("BBBBBBB") // 输出这个
    }
}

2. 反射

问题： 反射的作用是什么？有什么缺点？

解析： 反射可以在运行时获取变量的类型和值，动态调用方法，常用于序列化、ORM 等框架。

缺点：性能差，破坏类型安全，代码难维护。

3. 泛型

问题 1：Go 的泛型是怎么实现的？

解析： Go 的泛型用编译期单态化实现：

编译器会为每个具体的类型生成一份专用的代码。
运行时没有额外开销，性能和非泛型代码一致。
缺点是会增大二进制文件的体积。

问题 2：any 和 interface {} 有什么区别？

解析： 没有本质区别，any 是 interface {} 的别名，只是为了泛型的可读性引入的。

问题 3：泛型的约束是什么？

解析： 约束用于限制类型参数的范围，比如：

type Number interface {
 int | int64 | float64
}

func Sum[T Number](a, b T) T {
 return a + b
}

七、Web 开发与 ORM 框架

1. Gin 框架

问题 1：Gin 的中间件怎么实现的？

解析： Gin 的中间件是洋葱模型，中间件是HandlerFunc类型，通过Next()方法调用下一个处理函数：

func Logger() gin.HandlerFunc {
 return func(c *gin.Context) {
  // 处理前逻辑
  start := time.Now()
  c.Next() // 调用下一个处理函数
  // 处理后逻辑
  fmt.Println("耗时:", time.Since(start))
 }
}

问题 2：Gin 的路由原理是什么？

解析： Gin 用的是前缀树（Trie 树）实现路由，比正则匹配性能高，支持动态路由参数。

2. GORM ORM

问题 1：GORM 的 N+1 问题怎么解决？

解析： N+1 问题是指查询主表数据后，循环查询每个关联的从表数据，导致 N+1 次查询。

解决方案：用预加载Preload，一次查询把关联数据查出来：

`1`	`db.Preload("Orders").Find(&users)`

问题 2：GORM 怎么实现事务？

解析：

tx := db.Begin()
if err := tx.Create(&user).Error; err != nil {
 tx.Rollback()
 return err
}
tx.Commit()

八、微服务与分布式架构

1. gRPC

问题 1：gRPC 和 REST 的区别是什么？

解析：

维度	REST	gRPC
协议	HTTP/1.1，文本 / JSON	HTTP/2，二进制 / Protobuf
性能	序列化慢，头信息大，不支持多路复用	序列化快，体积小，支持多路复用、流处理
类型安全	无	有，Protobuf 强类型
适用场景	对外 API，浏览器兼容	微服务内部通信

问题 2：gRPC 的拦截器是什么？

解析： 拦截器类似中间件，用于在请求处理前后做统一处理，比如认证、日志、链路追踪。

2. 微服务核心组件

问题 1：服务发现是什么？

解析： 服务发现用于解决服务地址动态变化的问题，常用的有 Consul、Etcd、Nacos，服务启动时注册自己的地址，消费者从注册中心获取服务地址。

问题 2：熔断降级是什么？

解析：

熔断：当某个服务调用失败率过高，暂时停止调用，避免雪崩，等服务恢复后再恢复调用。
降级：当系统压力大时，暂时关闭非核心服务，保证核心服务可用。

问题 3：链路追踪是什么？

解析： 链路追踪用于追踪分布式请求的整个调用链，排查性能瓶颈，常用的有 OpenTelemetry、Jaeger。

九、工程化与性能调优

1. 依赖管理 Go Mod

问题： Go Mod 的作用是什么？

解析： Go Mod 是 Go 的依赖管理工具，解决了 GOPATH 的问题，支持版本管理，每个项目可以有自己的依赖版本，不会冲突。

2. 性能排查工具 pprof

问题： 怎么用 pprof 排查性能问题？

解析： pprof 是 Go 的性能排查工具，可以分析 CPU、内存、Goroutine、锁等问题：

排查 CPU 过高：查看哪些函数占用 CPU 最多。
排查内存泄漏：查看内存分配，有没有一直增长的对象。
排查 Goroutine 泄漏：查看 Goroutine 的数量，有没有阻塞的 Goroutine。
排查锁竞争：查看锁的等待时间。

示例：

package main

import (
    "log"
    "net/http"
    _ "net/http/pprof" // 导入 pprof，自动注册路由
)

func main() {
    go func() {
        log.Println(http.ListenAndServe("localhost:6060", nil)) // 6060 是 pprof 默认的端口
    }()

    select {} // 阻止主协程退出
}

上面的代码会启动一个 pprof 的 HTTP 服务器，可以通过http://localhost:6060/debug/pprof/访问性能数据。

3. 单元测试

问题： Go 的单元测试怎么写？

解析： Go 的测试文件以_test.go结尾，测试函数以Test开头，参数是*testing.T：

func TestAdd(t *testing.T) {
    res := Add(1,2)
    if res != 3 {
        t.Error("期望3，得到", res)
    }
}

十、业务实战与系统设计

1. 缓存常见问题

问题 1：缓存穿透、击穿、雪崩的区别和解决方案？

解析：

缓存穿透：查询不存在的数据，请求直接打到数据库。解决方案：布隆过滤器，空值缓存。
缓存击穿：热点 key 过期，大量请求打到数据库。解决方案：互斥锁，热点 key 永不过期。
缓存雪崩：大量 key 同时过期，或者 Redis 宕机，大量请求打到数据库。解决方案：过期时间加随机值，Redis 集群，熔断降级。

2. 高并发系统设计

问题： 秒杀系统的核心设计点是什么？ 解析：

限流：限制请求量，避免超过系统承载能力。
削峰：用消息队列把请求削峰，异步处理。
缓存：用 Redis 预存库存，避免直接查数据库。
原子操作：用 Redis 的原子操作扣减库存，避免超卖。
降级：秒杀时关闭非核心服务。

十一、常见易错点与踩坑指南

闭包陷阱：循环中的闭包捕获的是变量的地址，不是值，导致所有闭包都用了最后一个值。

// 错误写法
for i := 0; i < 10; i++ {
    go func() { fmt.Println(i) }() // 全部输出10
}
// 正确写法
for i := 0; i < 10; i++ {
    go func(i int) { fmt.Println(i) }(i) // 传值
}

Range 变量复用：Go1.22 之前，for range 的迭代变量是复用的，地址不变，取地址会导致都指向最后一个元素。
Map 并发写：原生 map 并发写会 panic，一定要加锁或者用 sync.Map。
Goroutine 泄漏：启动 Goroutine 一定要考虑退出条件，用 Context 控制生命周期。
Defer 参数求值：defer 的参数在声明时就求值了，不是执行时，所以如果要延迟求值，要用闭包。

十二、高频代码手写题

用 Channel 实现三个 Goroutine 交替打印 ABC

func main() {
    chA := make(chan struct{})
    chB := make(chan struct{})
    chC := make(chan struct{})

    go func() {
        for i := 0; i < 10; i++ {
            <-chA
            fmt.Print("A")
            chB <- struct{}{}
        }
    }()

    go func() {
        for i := 0; i < 10; i++ {
            <-chB
            fmt.Print("B")
            chC <- struct{}{}
        }
    }()

    go func() {
        for i := 0; i < 10; i++ {
            <-chC
            fmt.Print("C")
            chA <- struct{}{}
        }
    }()

    chA <- struct{}{} // 启动第一个 Goroutine
    time.Sleep(time.Second) // 等待 Goroutine 完成
}

实现一个限流器（令牌桶 / 漏桶）

type TokenBucket struct {
    capacity int
    tokens   chan struct{}
}

func NewTokenBucket(capacity int) *TokenBucket {
    tb := &TokenBucket{
        capacity: capacity,
        tokens:   make(chan struct{}, capacity),
    }
    for i := 0; i < capacity; i++ {
        tb.tokens <- struct{}{}
    }
    return tb
}

func (tb *TokenBucket) Acquire() {
    <-tb.tokens
}

func (tb *TokenBucket) Release() {
    select {
    case tb.tokens <- struct{}{}:
    default:
    }
}

实现生产者消费者模型

func main() {
    ch := make(chan int, 5)

    // 生产者
    go func() {
        for i := 0; i < 10; i++ {
            ch <- i
            fmt.Println("Produced:", i)
        }
        close(ch)
    }()

    // 消费者
    for item := range ch {
        fmt.Println("Consumed:", item)
    }
}

用 WaitGroup 实现并发控制

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            fmt.Println("Goroutine", i)
        }(i)
    }
    wg.Wait()
}

实现一个并发安全的 LRU 缓存

type LRUCache struct {
    capacity int
    cache    map[int]*list.Element
    list     *list.List
    mu       sync.Mutex
}

func NewLRUCache(capacity int) *LRUCache {
    return &LRUCache{
        capacity: capacity,
        cache:    make(map[int]*list.Element),
        list:     list.New(),
    }
}

func (c *LRUCache) Get(key int) (int, bool) {
    c.mu.Lock()
    defer c.mu.Unlock()
    if elem, ok := c.cache[key]; ok {
        c.list.MoveToFront(elem)
        return elem.Value.(pair).value, true
    }
    return 0, false
}

func (c *LRUCache) Put(key, value int) {
    c.mu.Lock()
    defer c.mu.Unlock()
    if elem, ok := c.cache[key]; ok {
        c.list.MoveToFront(elem)
        elem.Value = pair{key, value}
        return
    }
    if c.list.Len() == c.capacity {
        back := c.list.Back()
        delete(c.cache, back.Value.(pair).key)
        c.list.Remove(back)
    }
    elem := c.list.PushFront(pair{key, value})
    c.cache[key] = elem
}

type pair struct {
    key   int
    value int
}

手写一个简单的 Gin 中间件

func Logger() gin.HandlerFunc {
    return func(c *gin.Context) {
        start := time.Now()
        c.Next() // 调用下一个处理函数
        duration := time.Since(start)
        log.Printf("%s %s %d %s", c.Request.Method, c.Request.URL.Path, c.Writer.Status(), duration)
    }
}

面试准备建议

优先掌握并发、性能优化、系统设计这三个核心模块，占比超过 60%。
结合自己的项目，准备量化的优化结果，比如 QPS 提升了多少，延迟降低了多少。
熟悉 pprof 的使用，能讲清楚怎么排查线上的性能问题。
准备 1-2 个系统设计的案例，比如秒杀、短链服务，覆盖限流、缓存、一致性这些点。

Gin Tutorial

Sun, 12 Apr 2026 13:32:51 +0800

前言

欢迎来到 Gin 框架的零基础教程！无论你是刚接触 Go 语言的新手，还是想要快速上手 Web 开发的开发者，这篇教程都会带你从零开始，一步步掌握 Go 语言中最流行的轻量级 Web 框架 ——Gin。

什么是 Gin？

Gin 是一个用 Go (Golang) 编写的高性能 HTTP Web 框架。它提供了类似 Express.js 的简洁 API，同时凭借其基于 Radix 树的路由算法，实现了极致的性能，速度比标准的 net/http 库快了多达 40 倍。

为什么选择 Gin？

🚀 极致性能：零分配路由，内存占用极低，支持高并发
📦 轻量简洁：核心代码精简，无冗余依赖，上手成本低
🔌 丰富中间件：内置日志、恢复、CORS 等中间件，支持自定义扩展
✅ 参数校验：自动绑定并验证请求参数，减少重复代码
🎯 路由分组：灵活的路由组织方式，支持 API 版本管理
🛡️ panic 恢复：内置异常捕获，防止单个请求崩溃导致整个服务挂掉

前置知识

在开始之前，你只需要：

了解基本的计算机操作（会用终端 / 命令行）
了解 Go 语言的基础语法（变量、函数、结构体等）
了解基本的 HTTP 协议概念（请求、响应、GET/POST 方法等）

第一章：环境准备与安装

1.1 安装 Go 语言环境

Gin 框架依赖 Go 语言环境，首先我们需要安装 Go。

1.1.1 下载 Go 安装包

访问 Go 官方下载页面：https://go.dev/dl/

根据你的操作系统选择对应的安装包：

Windows：选择 go1.2X.X.windows-amd64.msi（推荐 64 位）
MacOS：选择 go1.2X.X.darwin-amd64.pkg（Intel 芯片）或 go1.2X.X.darwin-arm64.pkg（M1/M2 芯片）
Linux：选择 go1.2X.X.linux-amd64.tar.gz

💡 提示：Gin v1.10+ 要求 Go 版本至少为 1.25，建议安装最新的稳定版。

1.1.2 安装 Go

Windows 用户：

双击下载的 go.msi 文件，一路点击 Next 即可。安装程序会自动配置环境变量，无需手动设置。

MacOS 用户：

双击下载的 .pkg 文件，按照提示完成安装。同样会自动配置环境变量。

Linux 用户：

# 解压到 /usr/local 目录
sudo rm -rf /usr/local/go && sudo tar -C /usr/local -xzf go1.25.0.linux-amd64.tar.gz

# 配置环境变量，编辑 ~/.bashrc 或 ~/.zshrc
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc
source ~/.bashrc

1.1.3 验证安装

打开终端，输入以下命令验证是否安装成功：

`1`	`go version`

如果输出类似下面的内容，说明安装成功：

`1`	`go version go1.25.0 linux/amd64`

1.2 配置 Go 模块（Go Modules）

从 Go 1.11 开始，Go 引入了模块（Modules）来管理依赖，这是现在官方推荐的依赖管理方式，我们必须启用它。

💡 国内用户注意：由于网络原因，直接下载依赖可能会超时，我们先配置国内代理：

# 设置 GOPROXY 代理（七牛云镜像，国内访问速度快）
# Windows PowerShell
$env:GOPROXY = "https://goproxy.cn,direct"

# Windows CMD
set GOPROXY=https://goproxy.cn,direct

# Linux/Mac
export GOPROXY=https://goproxy.cn,direct

如果你想永久生效，可以把上面的命令添加到你的系统环境变量配置文件中。

1.3 安装 Gin 框架

现在我们来创建第一个 Gin 项目，并安装 Gin 框架。

1.3.1 创建项目目录

首先，创建一个项目文件夹，比如 my-gin-app：

# 创建项目目录
mkdir my-gin-app

# 进入项目目录
cd my-gin-app

1.3.2 初始化 Go 模块

在项目目录下，初始化 Go 模块：

`1`	`go mod init my-gin-app`

这个命令会创建一个 go.mod 文件，用来管理你的项目依赖。执行成功后，你会看到输出：

1
2
3

go: creating new go.mod: module my-gin-app
go: to add module requirements and sums:
	go mod tidy

1.3.3 安装 Gin

执行以下命令安装 Gin 框架:

`1`	`go get -u github.com/gin-gonic/gin`

这个命令会：

下载 Gin 框架的最新版本
自动把依赖信息添加到 go.mod 文件中
生成 go.sum 文件，用来校验依赖的版本

等待命令执行完成，没有报错的话，Gin 就安装好了！

第二章：你的第一个 Gin 应用

2.1 编写 Hello World

现在我们来写第一个最简单的 Gin 程序，实现一个 ping 接口。

在项目根目录下，创建一个 main.go 文件，写入以下代码：

package main

// 导入必要的包
import (
	"net/http" // 标准库，用于 HTTP 状态码
	"github.com/gin-gonic/gin" // 导入 Gin 框架
)

func main() {
	// 1. 创建 Gin 引擎
	// gin.Default() 会创建一个默认的引擎，自带两个中间件：
	// - Logger：打印请求日志
	// - Recovery：捕获 panic，防止服务崩溃
	r := gin.Default()

	// 2. 定义路由
	// 当客户端用 GET 方法访问 /ping 路径时，执行后面的处理函数
	r.GET("/ping", func(c *gin.Context) {
		// c *gin.Context 是 Gin 的核心，它包含了请求和响应的所有信息

		// 3. 返回 JSON 响应
		// 第一个参数是 HTTP 状态码，http.StatusOK 就是 200
		// 第二个参数是响应数据，gin.H 是 map[string]interface{} 的快捷方式
		c.JSON(http.StatusOK, gin.H{
			"message": "pong",
			"status":  "success",
		})
	})

	// 4. 启动服务器
	// 默认监听 0.0.0.0:8080，你也可以指定端口，比如 r.Run(":9090")
	r.Run() 
}

2.2 运行程序

在终端中，执行以下命令运行程序：

`1`	`go run main.go`

如果一切正常，你会看到类似下面的输出：

[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.
[GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
 - using env:	export GIN_MODE=release
 - using code:	gin.SetMode(gin.ReleaseMode)

[GIN-debug] GET    /ping                     --> main.main.func1 (3 handlers)
[GIN-debug] [WARNING] You trusted all proxies, this is NOT safe. We recommend you to set a value.
Please check https://pkg.go.dev/github.com/gin-gonic/gin#readme-don-t-trust-all-proxies for details.
[GIN-debug] Listening and serving HTTP on :8080

这说明你的 Gin 服务已经成功启动了，正在监听 8080 端口！

2.3 测试接口

现在打开你的浏览器，访问 http://localhost:8080/ping，或者用 curl.exe 命令测试：

`1`	`curl.exe http://localhost:8080/ping`

你会看到返回的 JSON 数据：

`1`	`{"message":"pong","status":"success"}`

🎉 恭喜！你已经成功运行了你的第一个 Gin 应用！

第三章：核心功能：路由管理

路由是 Web 框架的基础，它决定了如何响应客户端的请求。Gin 提供了非常强大灵活的路由功能。

3.1 基础路由

Gin 支持所有标准的 HTTP 方法：GET、POST、PUT、DELETE、PATCH、HEAD、OPTIONS 等。

package main

import (
	"net/http"

	"github.com/gin-gonic/gin"
)

func main() {
	r := gin.Default()

	// GET请求：获取资源
	r.GET("/users", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{"message": "获取用户列表"})
	})

	// POST请求：创建资源
	r.POST("/users", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{"message": "创建新用户"})
	})

	// PUT请求：更新资源（完整更新）
	r.PUT("/users/:id", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{"message": "更新用户信息"})
	})

	// DELETE请求：删除资源
	r.DELETE("/users/:id", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{"message": "删除用户"})
	})

	// Any：匹配所有请求方法
	r.Any("/test", func(c *gin.Context) {
		c.String(http.StatusOK, "支持所有请求方法：%s", c.Request.Method)
	})

	r.Run()
}

可以用 Postman 或者 curl.exe 来测试这些接口：

curl.exe -X GET http://localhost:8080/users
curl.exe -X POST http://localhost:8080/users
curl.exe -X PUT http://localhost:8080/users/123
curl.exe -X DELETE http://localhost:8080/users/123
curl.exe -X PATCH http://localhost:8080/users/123
curl.exe -X OPTIONS http://localhost:8080/test

3.2 路径参数（Route Parameters）

有时候我们需要从 URL 路径中获取动态参数，比如用户 ID、文章 ID 等。Gin 支持用 :param 的方式定义动态参数。

package main

import (
	"net/http"

	"github.com/gin-gonic/gin"
)

func main() {
	r := gin.Default()

	r.GET("/users/:id", func(c *gin.Context) {
		// 使用 c.Param() 获取路径参数
		userID := c.Param("id")

		c.JSON(http.StatusOK, gin.H{
			"user_id": userID,
		})
	})

	// 多个参数
	r.GET("/articles/:category/:article_id", func(c *gin.Context) {
		category := c.Param("category")
		articleID := c.Param("article_id")

		c.JSON(http.StatusOK, gin.H{
			"category":  category,
			"articleID": articleID,
		})
	})

	r.Run()
}

测试一下：

curl.exe http://localhost:8080/users/123
# 输出：{"user_id":"123"}

curl.exe http://localhost:8080/articles/tech/456
# 输出：{"article_id":"456","category":"tech"}

3.3 查询参数（Query Parameters）

查询参数是 URL 中 ? 后面的键值对，比如 /search?query=gin&page=1。

r.GET("/search", func(c *gin.Context) {
	// 获取查询参数，如果参数不存在，返回空字符串
	query := c.Query("query")
	
	// 获取查询参数，带默认值，如果参数不存在，返回默认值
	page := c.DefaultQuery("page", "1")
	limit := c.DefaultQuery("limit", "10")
	
	c.JSON(http.StatusOK, gin.H{
		"query": query,
		"page":  page,
		"limit": limit,
	})
})

测试一下：

1
2

curl.exe "http://localhost:8080/search?query=golang&page=2"
# 输出：{"limit":"10","page":"2","query":"golang"}

3.4 路由分组（Route Grouping）

当你的 API 越来越多的时候，你需要对路由进行分类管理。比如 API 版本、模块划分。Gin 的路由分组可以帮你轻松实现这一点。

package main

import (
	"net/http"

	"github.com/gin-gonic/gin"
)

func main() {
	r := gin.Default()

	// 创建 v1 版本的 API 分组
	v1 := r.Group("/api/v1")
	{
		// 实际路径是 /api/v1/users
		v1.GET("/users", func(c *gin.Context) {
			c.JSON(http.StatusOK, gin.H{"message": "v1 用户列表"})
		})

		// 实际路径是 /api/v1/users/:id
		v1.GET("users/:id", func(c *gin.Context) {
			c.JSON(http.StatusOK, gin.H{"message": "v1 用户详情"})
		})
	}

	// 创建 v2 版本的 API 分组
	v2 := r.Group("/api/v2")
	{
		// 实际路径是 /api/v2/users
		v2.GET("/users", func(c *gin.Context) {
			c.JSON(http.StatusOK, gin.H{"message": "v2 用户列表"})
		})

		// 实际路径是 /api/v2/users/:id
		v2.GET("users/:id", func(c *gin.Context) {
			c.JSON(http.StatusOK, gin.H{"message": "v2 用户详情"})
		})
	}

	// 嵌套分组：比如 /api/v1/admin
	admin := v1.Group("/admin")
	{
		admin.GET("/dashboard", func(c *gin.Context) {
			c.JSON(http.StatusOK, gin.H{"message": "管理员面板"})
		})
	}

	r.Run()
}

路由分组的好处是：

代码结构更清晰，便于维护
可以给整个分组统一应用中间件（后面会讲）
支持无限嵌套，满足复杂的路由组织需求

3.5 404 处理

当用户访问不存在的路由时，Gin 默认会返回 404 页面。我们可以自定义 404 的处理：

package main

import (
	"net/http"

	"github.com/gin-gonic/gin"
)

func main() {
	r := gin.Default()

	r.NoRoute(func(c *gin.Context) {
		c.JSON(http.StatusNotFound, gin.H{
			"code":    404,
			"message": "接口被陈导偷走了，去问问陈导吧",
		})
	})

	r.Run()
}

第四章：请求处理与参数绑定

处理客户端发来的请求数据是后端开发的核心任务。Gin 提供了非常便捷的参数绑定和验证功能。

4.1 获取表单数据

处理 HTML 表单提交（application/x-www-form-urlencoded）：

package main

import (
	"net/http"

	"github.com/gin-gonic/gin"
)

func main() {
	r := gin.Default()

	r.POST("/login", func(c *gin.Context) {
		// 获取表单数据
		username := c.PostForm("username")
		password := c.DefaultPostForm("password", "123456")

		c.JSON(http.StatusOK, gin.H{
			"username": username,
			"password": password,
		})
	})

	r.Run()
}

测试：

1
2

curl.exe -X POST http://localhost:8080/login -d "username=test&password=123"
# 输出：{"password":"123","username":"test"}

4.2 JSON 参数绑定

现代 API 开发最常用的就是 JSON 格式的请求体。Gin 可以自动把 JSON 请求体绑定到 Go 的结构体上，还能自动校验参数！

首先，我们定义一个结构体，用来接收请求参数：

package main

import (
	"net/http"

	"github.com/gin-gonic/gin"
)

// 定义注册请求的结构体
type RegisterRequest struct {
	// json:"username"	表示 JSON 中的字段名
	// binding:"required"	表示这个字段是必填的
	Username string `json:"username" binding:"required"`
	Password string `json:"password" binding:"required,min=6"` // 密码至少6位
	Email    string `json:"email" binding:"required,email"`    // 必须是邮箱格式
	Age      int    `json:"age" binding:"gte=18,lte=60"`       // 年龄必须在18-60之间
}

func main() {
	r := gin.Default()

	// 然后在处理函数中绑定参数：
	r.POST("/register", func(c *gin.Context) {
		var req RegisterRequest

		// ShouldBindJSON 会自动解析JSON请求体，绑定到结构体，并执行校验
		if err := c.ShouldBindJSON(&req); err != nil {
			// 如果绑定或校验失败，返回400错误
			c.JSON(http.StatusBadRequest, gin.H{
				"error": err.Error(),
			})
			return
		}

		// 绑定成功
		c.JSON(http.StatusOK, gin.H{
			"message": "注册成功",
			"data":    req,
		})
	})

	r.Run()
}

测试一下：

# 正确的请求
curl.exe -X POST http://localhost:8080/register -H "Content-Type: application/json" -d '{\"username\":\"test\",\"password\":\"123456\",\"email\":\"test@example.com\",\"age\":20}'

# 输出：{"data":{"username":"test","password":"123456","email":"test@example.com","age":20},"message":"注册成功"}

-X POST 表示使用 POST 方法
-H “Content-Type: application/json” 表示请求体是 JSON 格式
-d 后面是 JSON 数据。

# 错误的请求（年龄太小）
curl.exe -X POST http://localhost:8080/register -H "Content-Type: application/json" -d '{\"username\":\"test\",\"password\":\"123456\",\"email\":\"test@example.com\",\"age\":10}' 

# 输出：{"error":"Key: 'RegisterRequest.Age' Error:Field validation for 'Age' failed on the 'gte' tag"}

💡 常用的 binding 校验规则：

required：必填

email：邮箱格式

min=6：最小值（数字）/ 最小长度（字符串）

max=60：最大值

gte=18：大于等于

lte=60：小于等于

oneof=male female：必须是其中一个值

4.3 Query 参数绑定

除了 JSON，我们也可以把 URL 的查询参数绑定到结构体：

package main

import (
	"net/http"

	"github.com/gin-gonic/gin"
)

type UserQuery struct {
	Name string `form:"name" binding:"required"`
	Age  int    `form:"age" binding:"min=18"`
}

func main() {
	r := gin.Default()

	r.GET("/users", func(c *gin.Context) {
		var query UserQuery
		if err := c.ShouldBindQuery(&query); err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
			return
		}

		c.JSON(http.StatusOK, gin.H{"query": query})
	})

	r.Run()
}

测试：

1
2

curl.exe "http://localhost:8080/users?name=Alice&age=25"
# 输出：{"query":{"Name":"Alice","Age":25}}

4.4 文件上传

Gin 也支持文件上传，非常简单：

package main

import (
	"log"
	"net/http"
	"os"

	"github.com/gin-gonic/gin"
)

func main() {
	r := gin.Default()

	r.POST("/upload", func(c *gin.Context) {
		// 获取上传的文件，参数是表单的name
        // c.FormFile() 会返回一个 *multipart.FileHeader 类型的对象，包含了文件的基本信息,参数是表单的 name 属性值
		file, err := c.FormFile("file")
		if err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
			return
		}

		// 打印文件信息
		log.Printf("上传文件名: %s, 文件大小: %d KB", file.Filename, file.Size/1024)

		// 文件保存到本地
		dst := "./uploads/" + file.Filename
		// 确保 upload 目录存在。os.ModePerm 是 0777，表示所有用户都有读写执行权限，系统会根据 umask 自动调整权限。
		if err := os.MkdirAll("./uploads", os.ModePerm); err != nil {
			c.JSON(http.StatusInternalServerError, gin.H{"error": "目录创建失败"})
		}

		if err := c.SaveUploadedFile(file, dst); err != nil {
			c.JSON(http.StatusInternalServerError, gin.H{"error": "文件保存失败"})
			return
		}

		c.JSON(http.StatusOK, gin.H{
			"message":  "上传成功",
			"filename": file.Filename,
		})
	})

	r.Run()
}

测试：

`1`	`curl.exe -X POST http://localhost:8080/upload -F "file=@这是个测试文件.txt"`

第五章：响应处理

Gin 支持多种格式的响应，满足不同的场景需求。

5.1 JSON 响应（最常用）

这是 API 开发最常用的响应格式，我们之前已经用过很多次了：

c.JSON(http.StatusOK, gin.H{
	"code":    200,
	"message": "success",
	"data":    data,
})

5.2 字符串响应

简单的文本响应：

package main

import (
	"net/http"

	"github.com/gin-gonic/gin"
)

func main() {
	r := gin.Default()

	r.GET("/hello", func(c *gin.Context) {
		name := c.DefaultQuery("name", "Guest")
		c.String(http.StatusOK, "Hello, %s!", name)
	})

	r.Run()
}

测试：

`1`	`curl.exe "http://localhost:8080/hello"`

5.3 HTML 模板渲染

如果你需要服务端渲染 HTML 页面，Gin 也支持 HTML 模板：

首先，创建 templates 目录，然后创建 index.html 文件：

<!DOCTYPE html>
<html>
<head>
    {{.title}}
</head>
<body>
    <h1>{{.message}}</h1>
    <p>欢迎你，{{.name}}</p>
</body>
</html>

然后在 Gin 中加载模板：

package main

import (
	"net/http"

	"github.com/gin-gonic/gin"
)

func main() {
	r := gin.Default()

	// 加载 templates 目录下的所有 html 文件
	r.LoadHTMLGlob("templates/*")

	r.GET("/index", func(c *gin.Context) {
		// 渲染模板，传递参数
		c.HTML(http.StatusOK, "index.html", gin.H{
			"title":   "我的主页",
			"message": "欢迎来到 Gin 的世界！",
			"name":    "Gopher",
		})
	})

	r.Run()
}

测试：

`1`	`curl.exe http://localhost:8080/index`

也可以在浏览器中访问 http://localhost:8080/index，你会看到渲染后的 HTML 页面。

5.4 静态文件服务

当你有静态资源（比如 CSS、JS、图片，或者前端打包后的文件），可以用 Gin 快速托管：

// 把 /static 路径映射到本地的 ./static 目录
r.Static("/static", "./static")

// 比如你有 ./static/logo.png，就可以通过 http://localhost:8080/static/logo.png 访问

如果是前后端分离的项目，前端打包后的 dist 目录可以这样托管：

`1`	`r.Static("/", "./dist")`

5.5 文件下载

package main

import "github.com/gin-gonic/gin"

func main() {
	r := gin.Default()

	r.GET("/download", func(c *gin.Context) {
		// 直接返回文件给客户端下载
		c.File("./test.txt")
	})

	r.Run()
}

5.6 重定向

package main

import (
	"net/http"

	"github.com/gin-gonic/gin"
)

func main() {
	r := gin.Default()

	r.GET("/old", func(c *gin.Context) {
		// 301 永久重定向（不推荐）
		// c.Redirect(http.StatusMovedPermanently, "https://symphonyw.github.io/")

		// 302 临时重定向（默认）
		c.Redirect(http.StatusFound, "https://symphonyw.github.io/")

		// 307 临时重定向，保持请求方法不变（推荐）
		c.Redirect(http.StatusTemporaryRedirect, "https://symphonyw.github.io/")
	})

	r.Run()
}

测试：

`1`	`curl.exe -I http://localhost:8080/old`

或者直接在浏览器中访问 http://localhost:8080/old，你会被重定向到我的博客主页。

第六章：中间件（Middleware）

中间件是 Gin 中非常强大的特性，它可以在请求到达处理函数之前或之后执行一些通用的逻辑。比如日志记录、身份认证、跨域处理、权限校验等。

6.1 中间件的工作原理

中间件本质上就是一个拦截器，请求会先经过中间件，然后才到你的业务处理函数，处理完之后，响应还会再经过中间件。

你可以把它想象成安检：乘客（请求）先过安检（中间件），然后才能进去坐飞机（业务处理），出来的时候还要再过安检。

6.2 默认中间件

还记得我们之前用的 gin.Default() 吗？它默认就帮我们加了两个中间件：

gin.Logger()：打印请求日志，比如请求方法、路径、耗时、状态码等
gin.Recovery()：捕获 panic，防止因为一个请求的错误导致整个服务崩溃

如果你想要一个完全干净的引擎，没有任何中间件，可以用 gin.New()：

r := gin.New()
// 然后你可以手动添加你需要的中间件
r.Use(gin.Logger())
r.Use(gin.Recovery())

6.3 自定义中间件

我们来写一个自定义的日志中间件，看看中间件是怎么工作的：

// 自定义日志中间件
func LoggerMiddleware() gin.HandlerFunc {
	// 返回一个 gin.HandlerFunc 类型的函数
	return func(c *gin.Context) {
		// 请求处理之前执行的逻辑
		startTime := time.Now()

		// 调用下一个处理函数（可能是下一个中间件，也可能是最终的业务处理函数）
		c.Next()

		// 请求处理之后执行的逻辑
		endTime := time.Now()
		latency := endTime.Sub(startTime) // 计算耗时

		// 获取请求信息
		method := c.Request.Method
		path := c.Request.URL.Path
		statusCode := c.Writer.Status() // 响应状态码
		clientIP := c.ClientIP()       // 客户端 IP

		// 打印日志
		log.Printf("[%s] %s | %d | %s | %v", method, path, statusCode, clientIP, latency)
	}
}

然后我们就可以使用这个中间件了：

func main() {
	r := gin.Default()
	
	// 全局使用：对所有路由生效
	r.Use(LoggerMiddleware())

	// ... 定义路由 ...
}

6.4 中间件的作用范围

中间件可以作用在不同的范围：

全局中间件：对所有路由生效，用 r.Use()
分组中间件：只对某个路由分组生效，用 group.Use()
单个路由中间件：只对某个特定的路由生效，直接在路由定义时添加中间件参数

// 认证中间件示例
func AuthMiddleware() gin.HandlerFunc {
	return func(c *gin.Context) {
		// 从请求头获取 Token
		token := c.GetHeader("Authorization")
		
		// 简单的验证（实际项目中要验证 JWT）
		if token != "Bearer my-secret-token" {
			// 验证失败，终止请求链，返回 401
			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{
				"error": "未授权访问，请先登录",
			})
			return
		}

		// 验证通过，把用户信息存到 Context 中，供后续处理函数使用
		c.Set("userID", 123)
		c.Set("username", "test")

		// 继续处理请求
		c.Next()
	}
}

func main() {
	r := gin.Default()

	// 1. 全局中间件
	r.Use(LoggerMiddleware())

	// 公开路由，不需要认证
	r.POST("/login", loginHandler)

	// 2. 分组中间件：需要认证的接口
	authGroup := r.Group("/api")
	authGroup.Use(AuthMiddleware()) // 这个分组下的所有路由都需要认证
	{
		authGroup.GET("/profile", profileHandler)
		authGroup.POST("/update", updateHandler)
	}

	// 3. 单个路由中间件
	r.GET("/special", AuthMiddleware(), specialHandler)

	r.Run()
}

💡 关键方法说明：

c.Next()：调用下一个处理函数，继续执行链

c.Abort()：终止执行链，后面的处理函数不会再执行

c.Set(key, value) / c.Get(key)：在中间件和处理函数之间传递数据

6.5 常用社区中间件：解决跨域问题

开发前后端分离项目的时候，最常见的问题就是跨域（CORS）。

什么是跨域？当你的前端页面和后端 API 不在同一个域名、协议或端口下时，浏览器会出于安全考虑阻止前端访问后端接口，这就是跨域问题。

我们可以用 gin-contrib/cors 这个官方的中间件来解决。

首先安装：

`1`	`go get github.com/gin-contrib/cors`

然后使用：

import "github.com/gin-contrib/cors"

func main() {
	r := gin.Default()

	// 配置 CORS 中间件
	r.Use(cors.New(cors.Config{
		// 允许的来源，比如前端的域名
		AllowOrigins:     []string{"http://localhost:3000", "https://your-frontend.com"},
		// 允许的请求方法
		AllowMethods:     []string{"GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"},
		// 允许的请求头
		AllowHeaders:     []string{"Origin", "Content-Type", "Authorization"},
		// 是否允许携带 Cookie
		AllowCredentials: true,
		// 预检请求的缓存时间
		MaxAge:           12 * time.Hour,
	}))

	// 如果你是开发环境，想快速测试，可以用默认配置（允许所有来源，不推荐生产环境）
	// r.Use(cors.Default())

	// ... 路由 ...
}

这样就完美解决了跨域问题！

第七章：配置管理

在实际项目中，我们不会把配置（比如数据库地址、端口、密钥）硬编码在代码里，而是用配置文件来管理。最常用的就是 Viper 库。

7.1 安装 Viper

`1`	`go get github.com/spf13/viper`

7.2 编写配置文件

在项目根目录创建 config.yaml 文件：

# 服务配置
server:
  port: 8080
  mode: debug # debug/release

# 数据库配置
database:
  host: localhost
  port: 3306
  user: root
  password: 123456
  dbname: myapp

# JWT 配置
jwt:
  secret: my-secret-key
  expire: 24 # 过期时间，小时

7.3 读取配置

创建 config/config.go：

package config

import (
	"log"

	"github.com/spf13/viper"
)

// 定义配置结构体
type Config struct {
	Server   ServerConfig
	Database DatabaseConfig
	JWT      JWTConfig
}

type ServerConfig struct {
	Port int
	Mode string
}

type DatabaseConfig struct {
	Host     string
	Port     int
	User     string
	Password string
	DBName   string
}

type JWTConfig struct {
	Secret string
	Expire int
}

var GlobalConfig Config

// 加载配置
func InitConfig() {
	// 设置配置文件名（不带后缀）
	viper.SetConfigName("config")
	// 设置配置文件路径
	viper.AddConfigPath(".")
	// 设置配置文件类型
	viper.SetConfigType("yaml")

	// 读取配置文件
	if err := viper.ReadInConfig(); err != nil {
		log.Fatalf("读取配置文件失败: %v", err)
	}

	// 把配置反序列化到结构体
	if err := viper.Unmarshal(&GlobalConfig); err != nil {
		log.Fatalf("解析配置失败: %v", err)
	}

	log.Println("配置加载成功")
}

然后在 main.go 中初始化：

func main() {
	// 加载配置
	config.InitConfig()

	r := gin.Default()

	// 从配置中获取端口
	port := config.GlobalConfig.Server.Port
	r.Run(fmt.Sprintf(":%d", port))
}

这样，你就可以轻松管理不同环境的配置了，开发环境用 config.dev.yaml，生产环境用 config.prod.yaml。

第八章：身份认证：JWT

在 API 开发中，JWT（JSON Web Token）是最常用的身份认证方式。

JWT 是一种基于 Token 的认证机制，客户端登录成功后会获得一个 JWT Token，之后每次请求都携带这个 Token，服务器验证 Token 的合法性来判断用户是否有权限访问资源。

我们来看看怎么在 Gin 中使用 JWT。

8.1 安装依赖

`1`	`go get github.com/golang-jwt/jwt/v5`

8.2 实现 JWT 工具函数

创建 utils/jwt.go：

package utils

import (
	"errors"
	"time"

	"github.com/golang-jwt/jwt/v5"
	"my-gin-app/config"
)

// 定义 Claims，就是 Token 中存储的信息
type Claims struct {
	UserID   uint   `json:"user_id"`
	Username string `json:"username"`
	jwt.RegisteredClaims
}

// 生成 Token
func GenerateToken(userID uint, username string) (string, error) {
	// 设置过期时间
	expireTime := time.Now().Add(time.Duration(config.GlobalConfig.JWT.Expire) * time.Hour)

	// 创建 Claims
	claims := Claims{
		UserID:   userID,
		Username: username,
		RegisteredClaims: jwt.RegisteredClaims{
			ExpiresAt: jwt.NewNumericDate(expireTime),
			IssuedAt:  jwt.NewNumericDate(time.Now()),
			Issuer:    "my-gin-app",
		},
	}

	// 生成 Token
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	signedToken, err := token.SignedString([]byte(config.GlobalConfig.JWT.Secret))

	return signedToken, err
}

// 验证 Token
func ParseToken(tokenString string) (*Claims, error) {
	// 解析 Token
	token, err := jwt.ParseWithClaims(tokenString, &Claims{}, func(token *jwt.Token) (interface{}, error) {
		return []byte(config.GlobalConfig.JWT.Secret), nil
	})

	if err != nil {
		return nil, err
	}

	// 验证 Claims
	if claims, ok := token.Claims.(*Claims); ok && token.Valid {
		return claims, nil
	}

	return nil, errors.New("无效的 Token")
}

8.3 JWT 认证中间件

然后我们就可以写 JWT 认证中间件了：

func JWTAuthMiddleware() gin.HandlerFunc {
	return func(c *gin.Context) {
		// 获取 Token
		tokenString := c.GetHeader("Authorization")
		if tokenString == "" {
			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "请先登录"})
			return
		}

		// 去掉 Bearer 前缀
		tokenString = strings.TrimPrefix(tokenString, "Bearer ")

		// 验证 Token
		claims, err := utils.ParseToken(tokenString)
		if err != nil {
			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Token 无效或已过期"})
			return
		}

		// 把用户信息存到 Context 中
		c.Set("userID", claims.UserID)
		c.Set("username", claims.Username)

		c.Next()
	}
}

8.4 登录接口

func LoginHandler(c *gin.Context) {
	var req struct {
		Username string `json:"username" binding:"required"`
		Password string `json:"password" binding:"required"`
	}

	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	// 这里简化了，实际要去数据库查询用户，验证密码
	if req.Username == "admin" && req.Password == "123456" {
		// 生成 Token
		token, err := utils.GenerateToken(1, "admin")
		if err != nil {
			c.JSON(http.StatusInternalServerError, gin.H{"error": "生成 Token 失败"})
			return
		}

		c.JSON(http.StatusOK, gin.H{
			"token": token,
		})
		return
	}

	c.JSON(http.StatusUnauthorized, gin.H{"error": "用户名或密码错误"})
}

这样，你的 API 就有了完整的身份认证功能！

第九章：实战：用户管理 API

现在我们把前面学的所有知识整合起来，做一个完整的用户管理 API 项目。

9.1 项目结构

我们来规划一下项目的目录结构，这是一个标准的分层架构：

my-gin-app/
├── main.go              # 程序入口
├── go.mod               # 依赖管理
├── go.sum
├── config.yaml          # 配置文件
├── config/              # 配置相关
│   └── config.go
├── controllers/         # 控制器，处理请求
│   └── user_controller.go
├── middleware/          # 中间件
│   ├── auth.go
│   └── logger.go
├── models/              # 数据模型
│   └── user.go
├── utils/               # 工具函数
│   └── jwt.go
└── uploads/             # 上传文件目录

9.2 完整代码实现

我们来实现一个完整的用户管理 API，包含：

登录接口
获取用户列表
获取用户详情
创建用户
更新用户
删除用户

完整的代码就不全部贴在这里了，你可以参考前面的知识点，把它们组合起来。最终的效果是：

公开接口：登录
私有接口：需要 JWT 认证才能访问
统一的参数校验
统一的错误处理
日志记录

第十章：单元测试

写完代码之后，我们需要测试我们的接口。Gin 提供了很方便的测试方式。

创建 main_test.go：

package main

import (
	"net/http"
	"net/http/httptest"
	"testing"

	"github.com/gin-gonic/gin"
	"github.com/stretchr/testify/assert"
)

func TestPingRoute(t *testing.T) {
	// 设置为测试模式
	gin.SetMode(gin.TestMode)

	// 初始化路由
	r := gin.Default()
	r.GET("/ping", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{"message": "pong"})
	})

	// 创建测试请求
	req, _ := http.NewRequest("GET", "/ping", nil)
	w := httptest.NewRecorder()

	// 执行请求
	r.ServeHTTP(w, req)

	// 断言结果
	assert.Equal(t, 200, w.Code)
	assert.Equal(t, `{"message":"pong"}`, w.Body.String())
}

然后运行测试：

`1`	`go test -v`

第十一章：生产环境部署

当你的项目开发完成，就可以部署到生产环境了。

11.1 切换到 Release 模式

Gin 默认是 Debug 模式，会打印很多调试信息。生产环境要切换到 Release 模式：

1
2

// 在 main 函数最开始
gin.SetMode(gin.ReleaseMode)

或者通过环境变量：

`1`	`export GIN_MODE=release`

11.2 编译二进制文件

Go 可以编译成单个二进制文件，非常方便部署：

1
2

# 编译
go build -o myapp main.go

编译完成后，你会得到一个 myapp 文件，这就是你的整个应用，不需要任何依赖，直接运行就可以了。

11.3 后台运行

在 Linux 服务器上，你可以用 systemd 来管理你的服务，让它后台运行，开机自启。

创建 /etc/systemd/system/myapp.service：

[Unit]
Description=My Gin App
After=network.target

[Service]
Type=simple
User=root
WorkingDirectory=/root/my-gin-app
ExecStart=/root/my-gin-app/myapp
Restart=always
Environment=GIN_MODE=release

[Install]
WantedBy=multi-user.target

然后：

# 重载配置
systemctl daemon-reload

# 启动服务
systemctl start myapp

# 设置开机自启
systemctl enable myapp

第十二章：常见问题排查

1. go get 下载依赖超时

解决：设置 GOPROXY 代理，前面已经讲过了。

2. 端口被占用

错误：listen tcp :8080: bind: address already in use
解决：换个端口，或者杀掉占用端口的进程：lsof -i :8080 然后 kill -9 PID

3. 跨域问题

解决：使用 CORS 中间件，前面已经讲过。

4. 参数绑定失败

检查：JSON 格式是否正确，结构体的字段是否是大写（Go 的反射只能访问大写字段），tag 是否正确。

5. 静态文件访问不到

检查：静态文件的路径是否正确，r.Static 的第一个参数是 URL 路径，第二个是本地路径。

总结

恭喜你！读到这里，你已经掌握了 Gin 框架的核心用法：

✅ 环境搭建：Go 安装、Gin 安装、依赖管理
✅ 基础入门：第一个 Hello World 程序
✅ 路由管理：各种 HTTP 方法、参数、路由分组
✅ 请求处理：表单、JSON、文件上传、参数校验
✅ 响应处理：JSON、HTML、静态文件、重定向
✅ 中间件：自定义中间件、CORS、JWT 认证
✅ 配置管理：用 Viper 管理配置文件
✅ 项目实战：完整的用户管理 API
✅ 部署运维：生产环境配置、部署

Gin 是一个非常强大而简洁的框架，它把 Go 语言的高性能和 Web 开发的便捷性完美结合在了一起。希望这篇教程能帮助你快速入门，开启你的 Go Web 开发之旅！

接下来，你可以继续深入学习：

数据库集成（GORM）
限流、熔断等高级中间件
日志系统
监控与链路追踪
容器化部署（Docker）

祝你学习愉快！🚀

A Deep Dive into Go's Standard Library net Package and TChannel Package

Thu, 09 Apr 2026 11:26:03 +0800

net 包是 Go 语言标准库中网络编程的核心基石，它提供了跨平台的网络 I/O 抽象，支持 TCP/IP、UDP、域名解析、Unix 域套接字等几乎所有主流网络协议。无论是构建简单的客户端 / 服务端，还是开发复杂的分布式系统，net 包都是最底层的支撑工具。

本文档将从基础到高级，全面解析 net 包的核心功能，针对常用功能进行详细展开，并提供可直接运行的实战代码示例。

1. 包概述

net 包的设计理念是统一接口，分层抽象：

高层接口：Dial、Listen、Accept 等通用函数，屏蔽底层协议差异
中层接口：Conn、Listener、PacketConn 等接口，定义通用的读写、监听行为
底层实现：针对 TCP、UDP、IP、Unix 等不同协议的具体实现，提供协议特有的配置能力

大多数场景下，开发者只需要使用高层接口即可完成开发；而在需要精细控制网络行为的场景下，可以深入到底层实现进行调优。

2. 核心基础类型

网络编程的第一步是处理地址，net 包提供了多种地址类型来适配不同的协议。

2.1 IP 地址（`IP` 类型）

IP 类型是一个字节切片，用于表示 IPv4 或 IPv6 地址，它提供了一系列方法来判断地址的属性。

`1`	`type IP []byte`

核心方法与示例

package main

import (
	"fmt"
	"net"
)

func main() {
	// 1. 解析IP地址
	ip := net.ParseIP("192.168.1.100")
	if ip == nil {
		fmt.Println("无效的IP地址")
		return
	}

	// 2. 判断地址类型
	fmt.Println("是否为回环地址:", ip.IsLoopback()) // false
	fmt.Println("是否为私有地址:", ip.IsPrivate())   // true
	fmt.Println("是否为IPv4地址:", ip.To4() != nil)  // true
	// To4方法会返回IPv4地址的4字节表示，如果不是IPv4地址则返回nil；To16方法会返回IPv6地址的16字节表示，如果不是IPv6地址则返回nil。

	// 3. 构造IPv4地址
	ipv4 := net.IPv4(127, 0, 0, 1)
	fmt.Println("回环地址:", ipv4.String()) // 127.0.0.1

	// 4. 掩码计算
	ip2 := net.ParseIP("192.168.1.100")
	mask := net.IPv4Mask(255, 255, 255, 0)
	networkIP := ip2.Mask(mask)
	fmt.Println("网段地址:", networkIP.String()) // 192.168.1.0
}

2.2 IP 网段（`IPNet` 类型）

IPNet 用于表示一个 IP 网段，常用于判断某个 IP 是否属于某个子网，这在防火墙、路由匹配等场景中非常常用。

核心方法与示例

package main

import (
	"fmt"
	"log"
	"net"
)

func main() {
	// 1. 解析CIDR格式的网段
	ip, ipNet, err := net.ParseCIDR("192.168.1.50/24")
	if err != nil {
		log.Fatal(err)      // 解析失败，CIDR格式不正确，或者IP地址无效。
		// log.Fatal会导致程序崩溃，适合在示例代码中使用，但在生产环境中应该使用更优雅的错误处理方式，如log.Printf或返回错误给调用者。
	}

	fmt.Println("IP地址:", ip.String())       // 192.168.1.0
	fmt.Println("网段:", ipNet.String())        // 192.168.1.0/24

	// 2. 判断IP是否属于该网段
	testIP := net.ParseIP("192.168.1.100")
	fmt.Println(testIP.String(), "是否在网段内：", ipNet.Contains(testIP)) // true

	testIP2 := net.ParseIP("8.8.8.8")
	fmt.Println(testIP2.String(), "是否在网段内：", ipNet.Contains(testIP2)) // false
}

2.3 传输层地址（TCPAddr/UDPAddr）

TCP 和 UDP 地址都包含 IP 和端口两部分，用于标识网络中的一个端点。

地址解析示例

package main

import (
	"fmt"
	"log"
	"net"
)

func main() {
	// 解析TCP地址
	tcpAddr, err := net.ResolveTCPAddr("tcp", "localhost:8080")
	if err != nil {
		log.Println(err.Error())
		return
	}
	fmt.Println("TCP地址:", tcpAddr.String()) // 127.0.0.1:8080

	// 解析UDP地址
	udpAddr, err := net.ResolveUDPAddr("udp", "localhost:8080")
	if err != nil {
		log.Println(err.Error())
		return
	}
	fmt.Println("UDP地址:", udpAddr.String()) // 127.0.0.1:8080
}

2.4 地址处理工具函数

处理 host:port 格式的地址时，JoinHostPort 和 SplitHostPort 是最常用的工具，它们能正确处理 IPv6 地址的括号格式。

package main

import (
	"fmt"
	"log"
	"net"
)

func main() {
	// 拼接主机和端口
	host := "127.0.0.1"
	port := "8080"
	addr := net.JoinHostPort(host, port)
	fmt.Println("拼接后地址:", addr) // 127.0.0.1:8080

	// 拆分地址
	host2, port2, err := net.SplitHostPort(addr)
	if err != nil {
		log.Println(err.Error())
		return
	}
	fmt.Println("拆分后主机:", host2, "端口:", port2)

	// 正确处理IPv6地址
	ipv6Addr := "[::1]:8080"
	host3, port3, _ := net.SplitHostPort(ipv6Addr)
	fmt.Println("IPv6拆分后主机:", host3, "端口:", port3) // ::1 8080
}

3. TCP 网络编程（面向连接可靠传输）

TCP 是面向连接的可靠传输协议，是互联网中最常用的传输层协议。net 包通过 TCPListener 和 TCPConn 来实现 TCP 通信。

3.1 基础 TCP 服务端

TCP 服务端的工作流程是：监听端口 -> 接受连接 -> 处理连接。Go 中通过 goroutine 可以轻松实现高并发的服务端。

package main

import (
	"bufio"     // 提供了缓冲读取和写入功能，适用于网络连接的读写操作，可以按行读取数据。
	"fmt"
	"net"
	"log"
)

func handleConnection(conn *net.TCPConn) {
	// 确保连接关闭
	defer conn.Close()
	log.Printf("客户端 %s 已连接", conn.RemoteAddr())

	// 读取客户端数据
	reader := bufio.NewReader(conn)
	for {
		// 按行读取数据
		data, err := reader.ReadString('\n')
		if err != nil {
			log.Printf("客户端 %s 已断开", conn.RemoteAddr())
			return
		}

		log.Printf("收到来自 %s 的消息: %s", conn.RemoteAddr(), data)
		// 回显消息
		_, err = conn.Write([]byte("Echo: " + data))
		if err != nil {
			log.Printf("发送数据失败: %v", err)
			return
		}
	}
}

func main() {
	// 解析监听地址
	addr, err := net.ResolveTCPAddr("tcp", ":8080") // 监听8080端口
	if err != nil {
		log.Println(err.Error())
		return
	}

	// 监听端口
	listener, err := net.ListenTCP("tcp", addr)
	if err != nil {
		log.Println(err.Error())
		return
	}
	defer listener.Close()
	log.Println("TCP服务端已启动，监听 :8080")

	for {
		// 接受新连接
		conn, err := listener.AcceptTCP()
		if err != nil {
			log.Printf("接受连接失败: %v", err)
			continue
		}

		// 启动goroutine处理连接，实现并发
		go handleConnection(conn)
	}
}

3.2 基础 TCP 客户端

TCP 客户端通过主动连接服务端来建立连接，然后进行数据读写。

package main

import (
	"bufio"
	"fmt"
	"net"
	"os"
	"log"
)

func main() {
	// 连接服务端，中间这个nil表示本地地址，通常设置为nil让系统自动分配一个可用的端口。
	conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 8080})
	if err != nil {
		log.Println(err.Error())
		return
	}
	defer conn.Close()

	log.Println("已连接到服务端")

	// 从标准输入读取消息
	scanner := bufio.NewScanner(os.Stdin)   // 从标准输入读取用户输入，os.Stdin表示标准输入设备，通常是键盘。
	writer := bufio.NewWriter(conn)         
	// 创建一个缓冲写入器，用于向TCP连接写数据，它会将数据先写入内存缓冲区，只有在调用Flush方法时才会真正发送到网络上，这样可以提高效率，减少系统调用次数。
	// conn是之前建立的TCP连接，bufio.NewWriter(conn)创建了一个新的缓冲写入器，将TCP连接作为底层的写入目标。

	for scanner.Scan() {
		text := scanner.Text()
		// 发送消息
		_, err = writer.WriteString(text + "\n")
		if err != nil {
			log.Println(err.Error())
		return
		}
		writer.Flush()

		// 读取响应
		resp, err := bufio.NewReader(conn).ReadString('\n') // 以换行符为分隔符读取服务端响应，直到遇到换行符为止。
		if err != nil {
			log.Println(err.Error())
		return
		}
		fmt.Println("服务端响应:", resp)
	}
}

如此即可实现一个简单的 TCP 客户端，能够向服务端发送消息并接收响应。

3.3 TCP 连接高级配置

TCPConn 提供了一系列方法来调整 TCP 协议的参数，以适配不同的业务场景。

3.3.1 禁用 Nagle 算法（`SetNoDelay`）

Nagle 算法是 TCP 协议中的一个优化机制，它会将小数据包合并成一个大数据包发送，以减少网络开销。但在某些实时性要求高的场景下（如在线游戏、即时通信），这种合并会引入不必要的延迟，因此需要禁用 Nagle 算法。

Nagle 算法默认会合并小数据包以减少网络开销，但会引入延迟。对于实时性要求高的场景（如游戏、即时通信），需要禁用它。

// 建立连接后
conn, err := net.DialTCP("tcp", nil, serverAddr)
if err != nil {
	log.Println(err.Error())
		return
}

// 禁用Nagle算法，小数据包立即发送
err = conn.SetNoDelay(true)
if err != nil {
	log.Printf("设置NoDelay失败: %v", err)
}

3.3.2 TCP 保活机制（`SetKeepAlive`）

TCP 保活机制可以自动检测死连接，避免长时间占用资源。Go 1.13+ 还支持更精细的保活配置。

// 启用保活机制
err = conn.SetKeepAlive(true)
if err != nil {
	log.Printf("启用保活失败: %v", err)
}

// 方式1：简单设置保活间隔（旧API）
err = conn.SetKeepAlivePeriod(30 * time.Second)
if err != nil {
	log.Printf("设置保活间隔失败: %v", err)
}

// 方式2：精细配置保活参数（Go 1.13+ 新API）
err = conn.SetKeepAliveConfig(net.KeepAliveConfig{
	Enable:   true,
	Idle:     30 * time.Second,  // 空闲30秒后开始发送探针
	Interval: 10 * time.Second,  // 探针间隔10秒
	Count:    3,                 // 连续3次失败则断开连接
})
if err != nil {
	log.Printf("设置保活配置失败: %v", err)
}

3.3.3 连接半关闭

TCP 支持半关闭，即可以单独关闭读或写通道，这在某些场景下非常有用（比如发送完数据后告诉服务端不再发送，但还能接收响应）。

// 发送完所有数据后，关闭写通道
err = conn.CloseWrite()
if err != nil {
	log.Printf("关闭写通道失败: %v", err)
}

// 此时还可以继续读取服务端的响应
data, err := conn.Read(buf)

// 读取完后，关闭读通道
err = conn.CloseRead()

4. UDP 网络编程（无连接数据报传输）

UDP 是无连接的传输协议，不需要建立连接，直接发送数据包，适用于对实时性要求高、可容忍少量丢包的场景（如音视频、心跳检测）。

4.1 基础 UDP 服务端

package main

import (
	"fmt"
	"net"
	"log"
)

func main() {
	// 解析UDP地址
	addr, err := net.ResolveUDPAddr("udp", ":8080")
	if err != nil {
		log.Println(err.Error())
		return
	}

	// 监听UDP端口
	conn, err := net.ListenUDP("udp", addr)
	if err != nil {
		log.Println(err.Error())
		return
	}
	defer conn.Close()
	log.Println("UDP服务端已启动，监听 :8080")

	buf := make([]byte, 1024)
	for {
		// 读取UDP数据包，同时获取客户端地址
		n, clientAddr, err := conn.ReadFromUDP(buf)
		if err != nil {
			log.Printf("读取数据失败: %v", err)
			continue
		}

		data := string(buf[:n])
		log.Printf("收到来自 %s 的消息: %s", clientAddr, data)

		// 向客户端发送响应
		resp := []byte("UDP Ack: " + data)
		_, err = conn.WriteToUDP(resp, clientAddr)
		if err != nil {
			log.Printf("发送响应失败: %v", err)
		}
	}
}

4.2 基础 UDP 客户端

package main

import (
	"fmt"
	"net"
	"log"
)

func main() {
	// 服务端地址
	serverAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:8080")
	if err != nil {
		log.Println(err.Error())
		return
	}

	// 建立UDP连接（UDP的连接只是逻辑绑定，不发送网络包）,中间这个nil表示本地地址，通常设置为nil让系统自动分配一个可用的端口。
	conn, err := net.DialUDP("udp", nil, serverAddr)
	if err != nil {
		log.Println(err.Error())
		return
	}
	defer conn.Close()

	// 发送数据
	_, err = conn.Write([]byte("Hello UDP Server!"))
	if err != nil {
		log.Println(err.Error())
		return
	}

	// 读取响应
	buf := make([]byte, 1024)
	n, err := conn.Read(buf)
	if err != nil {
		log.Println(err.Error())
		return
	}

	fmt.Println("服务端响应:", string(buf[:n]))
}

如此即可实现一个简单的 UDP 客户端，能够向服务端发送消息并接收响应。

4.3 实战：UDP 心跳检测

UDP 非常适合做心跳检测，因为它轻量、无连接开销。

package main

import (
	"net"
	"time"
	"log"
)

func main() {
	serverAddr, _ := net.ResolveUDPAddr("udp", "127.0.0.1:8080")
	conn, _ := net.DialUDP("udp", nil, serverAddr)
	defer conn.Close()

	// 定时器，每秒发送一次心跳
	ticker := time.NewTicker(1 * time.Second)
	defer ticker.Stop()

	for range ticker.C {
		// 发送心跳包
		_, err := conn.Write([]byte("HEARTBEAT"))
		if err != nil {
			log.Printf("发送心跳失败: %v", err)
			continue
		}

		// 设置读取超时，检测服务端是否存活
		conn.SetReadDeadline(time.Now().Add(2 * time.Second))
		buf := make([]byte, 1024)
		n, err := conn.Read(buf)
		if err != nil {
			log.Printf("心跳检测失败，服务端可能已下线: %v", err)
			continue
		}

		log.Printf("心跳正常，服务端响应: %s", string(buf[:n]))
	}
}

如图所示，UDP 心跳检测可以快速判断服务端的存活状态，适用于分布式系统中的健康检查和服务发现。

5. DNS 域名解析

net 包提供了完整的 DNS 解析能力，从基础的域名转 IP，到高级的 MX、SRV、TXT 记录查询。

5.1 基础域名解析

package main

import (
	"fmt"
	"net"
	"log"
)

func main() {
	// 解析域名对应的IP列表（同时返回IPv4和IPv6）
	ips, err := net.LookupIP("google.com")
	if err != nil {
		log.Println(err.Error())
		return
	}

	for _, ip := range ips {
		fmt.Println("IP地址:", ip.String())
	}

	// 反向解析：根据IP查找域名
	names, err := net.LookupAddr("8.8.8.8")
	if err != nil {
		log.Println(err.Error())
		return
	}
	for _, name := range names {
		fmt.Println("8.8.8.8对应的域名:", name)
	}
}

解析结果如下图所示：

5.2 高级 DNS 记录查询

package main

import (
	"fmt"
	"net"
	"log"
)

func main() {
	// 1. 查询MX记录（邮件服务器记录）。MX记录是Mail Exchanger Record的缩写，邮件交换记录，用于指定处理该域邮件的服务器地址和优先级。
	mxs, err := net.LookupMX("gmail.com")
	if err != nil {
		log.Println(err.Error())
		return
	}
	fmt.Println("Gmail的邮件服务器:")
	for _, mx := range mxs {
		fmt.Printf("  优先级: %d, 服务器: %s\n", mx.Pref, mx.Host)
	}

	// 2. 查询SRV记录（服务发现记录，常用于微服务）。SRV记录是Service Record的缩写，用于指定提供特定服务的服务器地址、端口和优先级，常用于微服务架构中的服务发现。
	cname, srvs, err := net.LookupSRV("xmpp-server", "tcp", "gmail.com")
	if err != nil {
		log.Println(err.Error())
		return
	}
	fmt.Println("\nXMPP服务的SRV记录:")
	fmt.Println("CNAME:", cname)
	for _, srv := range srvs {
		fmt.Printf("  目标: %s:%d, 优先级: %d, 权重: %d\n", srv.Target, srv.Port, srv.Priority, srv.Weight)
	}

	// 3. 查询TXT记录（常用于验证域名、SPF、DKIM等）。TXT记录是Text Record的缩写，用于存储任意文本信息，常用于域名验证、SPF（Sender Policy Framework）和DKIM（DomainKeys Identified Mail）等邮件安全机制。
	txts, err := net.LookupTXT("gmail.com")
	if err != nil {
		log.Println(err.Error())
		return
	}
	fmt.Println("\nTXT记录:")
	for _, txt := range txts {
		fmt.Println("  ", txt)
	}
}

查询结果如下图所示：

5.3 自定义 DNS 解析器

默认情况下，net 包使用系统的 DNS 配置，但我们可以自定义 DNS 服务器，比如使用 Google DNS 或 Cloudflare DNS。

package main

import (
	"context"
	"fmt"
	"net"
	"time"
)

func main() {
	// 自定义DNS解析器，使用Google的8.8.8.8
	resolver := &net.Resolver{
		// 强制使用Go原生的DNS解析器，不使用系统的cgo解析
		PreferGo: true,
		// 自定义DNS服务器的连接
		Dial: func(ctx context.Context, network, address string) (net.Conn, error) {
			d := net.Dialer{
				Timeout: 3 * time.Second,
			}
			// 连接到自定义的DNS服务器
			return d.DialContext(ctx, "udp", "8.8.8.8:53")
		},
	}

	// 使用自定义解析器解析域名
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	ips, err := resolver.LookupIP(ctx, "ip4", "google.com")
	if err != nil {
		log.Println(err.Error())
		return
	}

	for _, ip := range ips {
		fmt.Println("通过8.8.8.8解析到的IP:", ip.String())
	}
}

解析结果如下图所示：

6. 错误处理与超时控制

网络编程中，错误处理和超时控制是保证服务稳定性的关键。

6.1 网络错误类型（`net.Error`）

net 包的所有网络错误都实现了 net.Error 接口，它提供了 Timeout() 和 Temporary() 方法来区分错误类型。

package main

import (
	"fmt"
	"net"
	"time"
)

func main() {
    // 这里用google.com:80作为测试地址，设置一个非常短的超时时间来触发错误
	conn, err := net.DialTimeout("tcp", "google.com:80", 1*time.Second)
	if err != nil {
		// 判断错误是否为网络错误
		if ne, ok := err.(net.Error); ok {
			fmt.Println("是否为超时错误:", ne.Timeout())
			fmt.Println("是否为临时错误:", ne.Temporary())
		}
		fmt.Println("错误信息:", err)
		return
	}
	defer conn.Close()
	fmt.Println("连接成功")
}

之所以 Timeout() 和 Temporary() 都返回 true，是因为在这个场景下，连接超时被认为是一个临时错误，可能是网络状况不佳导致的，重试可能会成功。

6.2 超时控制详解

net 包提供了多层级的超时控制：

1. 连接超时

在建立连接时设置超时，避免长时间卡在连接阶段。

// 方式1：使用DialTimeout
conn, err := net.DialTimeout("tcp", "google.com:80", 5*time.Second)

// 方式2：使用Dialer+Context
d := net.Dialer{Timeout: 5*time.Second}
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
conn, err := d.DialContext(ctx, "tcp", "google.com:80")

2. 读写超时

连接建立后，为读写操作设置超时，避免单个读写操作阻塞。

// 统一设置读写超时
conn.SetDeadline(time.Now().Add(30 * time.Second))

// 单独设置读超时
conn.SetReadDeadline(time.Now().Add(10 * time.Second))

// 单独设置写超时
conn.SetWriteDeadline(time.Now().Add(10 * time.Second))

7. 高级连接配置：`Dialer`

Dialer 是 net 包中用于配置连接的核心结构体，它可以统一配置连接的超时、保活、DNS 解析器等参数。

7.1 Dialer 核心配置

package main

import (
	"context"
	"fmt"
	"log"
	"net"
	"time"
)

func main() {
	// 配置Dialer
	dialer := &net.Dialer{
		// 连接超时：如果在指定时间内无法建立连接，则返回错误
		Timeout:   5 * time.Second,
		// 保活间隔：每隔30秒发送一次TCP保活探针
		KeepAlive: 30 * time.Second,
		// 本地地址，用于指定出站网卡
		LocalAddr: nil,
		// 自定义DNS解析器
		Resolver: &net.Resolver{
            // 强制使用Go原生的DNS解析器，不使用系统的cgo解析
			PreferGo: true,
            // 自定义DNS服务器的连接
			Dial: func(ctx context.Context, network, address string) (net.Conn, error) {
				return net.Dial("udp", "8.8.8.8:53")
			},
		},
	}

	// 使用Dialer建立连接
	conn, err := dialer.DialContext(context.Background(), "tcp", "google.com:80")
	if err != nil {
		log.Println(err.Error())
		return
	}
	defer conn.Close()

	fmt.Println("连接成功")
}

如果连不上会得到以下输出：

如果连接成功会得到以下输出：

8. Unix 域套接字（本地进程间通信）

Unix 域套接字是用于同一主机上进程间通信的机制，比 TCP 更快，不需要经过网络协议栈，延迟更低。

8.1 流式 Unix 域套接字（类似 TCP）

// 服务端
package main

import (
	"net"
	"os"
	"log"
)

func main() {
	sockPath := "/tmp/test.sock"
	// 清理旧的sock文件
	os.Remove(sockPath)

	// 监听Unix域套接字
	listener, err := net.Listen("unix", sockPath)
	if err != nil {
		log.Println(err.Error())
		return
	}
	defer listener.Close()
	defer os.Remove(sockPath)

	log.Println("Unix服务端已启动")

	for {
		conn, err := listener.Accept()
		if err != nil {
			continue
		}
		go func(c net.Conn) {
			defer c.Close()
			// 处理连接，和TCP完全一样
			buf := make([]byte, 1024)
			n, _ := c.Read(buf)
			c.Write([]byte("Echo: " + string(buf[:n])))
		}(conn)
	}
}

// 客户端
package main

import (
	"fmt"
	"net"
)

func main() {
	// 连接Unix域套接字
	conn, err := net.Dial("unix", "/tmp/test.sock")
	if err != nil {
		log.Println(err.Error())
		return
	}
	defer conn.Close()

	conn.Write([]byte("Hello IPC!"))
	buf := make([]byte, 1024)
	n, _ := conn.Read(buf)
	fmt.Println(string(buf[:n]))
}

9. 原始 IP 与 ICMP：实现 Ping 工具

通过 net 包的原始 IP 连接，我们可以实现 ICMP 协议，也就是常用的 ping 工具。

注意：ICMP 原始套接字在部分系统上需要 root 权限。

package main

import (
	"fmt"
	"net"
	"time"
)

// 计算ICMP校验和
func checkSum(msg []byte) uint16 {
	sum := 0
	for i := 0; i < len(msg)-1; i += 2 {
		sum += int(msg[i])*256 + int(msg[i+1])
	}
	sum = (sum >> 16) + (sum & 0xffff)
	sum += sum >> 16
	return uint16(^sum)
}

func ping(host string) error {
	// 建立ICMP连接
	conn, err := net.Dial("ip4:icmp", host)
	if err != nil {
		return err
	}
	defer conn.Close()

	// 构造ICMP Echo请求包
	msg := make([]byte, 64)
	msg[0] = 8 // Type: Echo Request
	msg[1] = 0 // Code: 0
	// Checksum占位
	msg[2] = 0
	msg[3] = 0
	// Identifier
	id := uint16(1234)
	msg[4] = byte(id >> 8)
	msg[5] = byte(id & 0xff)
	// Sequence
	seq := uint16(1)
	msg[6] = byte(seq >> 8)
	msg[7] = byte(seq & 0xff)

	// 计算校验和
	sum := checkSum(msg)
	msg[2] = byte(sum >> 8)
	msg[3] = byte(sum & 0xff)

	start := time.Now()
	// 发送ICMP包
	_, err = conn.Write(msg)
	if err != nil {
		return err
	}

	// 设置超时
	conn.SetReadDeadline(time.Now().Add(2 * time.Second))
	recv := make([]byte, 1024)
	n, err := conn.Read(recv)
	if err != nil {
		return err
	}

	duration := time.Since(start)
	// 解析响应，ICMP响应的Type为0
	if recv[20] == 0 { // 跳过20字节IP头
		fmt.Printf("%s is up, 延迟: %v\n", host, duration)
		return nil
	}
	return fmt.Errorf("收到非预期的响应")
}

func main() {
	err := ping("8.8.8.8")
	if err != nil {
		fmt.Println("Ping失败:", err)
	}
}

10. 网络接口与本机信息获取

net 包还提供了获取本机网卡、IP 信息的能力。

获取本机所有非回环 IP

package main

import (
	"fmt"
	"net"
)

func main() {
	// 获取所有网络接口的地址
	addrs, err := net.InterfaceAddrs()
	if err != nil {
		log.Println(err.Error())
		return
	}

	for _, addr := range addrs {
		// 转换为IPNet
		if ipNet, ok := addr.(*net.IPNet); ok {
			// 排除回环地址
			if !ipNet.IP.IsLoopback() {
				// 只打印IPv4地址
				if ipNet.IP.To4() != nil {
					fmt.Println("本机IP:", ipNet.IP.String())
				}
			}
		}
	}
}

11. 其他常用工具示例

11.1 简单端口扫描

通过 DialTimeout 我们可以快速实现一个简单的端口扫描工具，检测目标主机的端口是否开放。

package main

import (
	"fmt"
	"net"
	"sync"
	"time"
)

func main() {
	target := "localhost"
	var wg sync.WaitGroup

	// 扫描1-1024端口
	for port := 1; port <= 1024; port++ {
		wg.Add(1)
		go func(p int) {
			defer wg.Done()
			address := fmt.Sprintf("%s:%d", target, p)
			// 用500ms超时检测端口
			conn, err := net.DialTimeout("tcp", address, 500*time.Millisecond)
			if err == nil {
				fmt.Printf("端口 %d 开放\n", p)
				conn.Close()
			}
		}(port)
	}
	wg.Wait()
	fmt.Println("扫描完成")
}

11.2 内存管道 Pipe

Pipe 函数可以创建一对内存中的连接，用于进程内的通信，它实现了 net.Conn 接口，所以可以像网络连接一样进行读写。

package main

import (
	"fmt"
	"net"
)

func main() {
	// 创建内存管道
	r, w := net.Pipe()

	// 写入端goroutine
	go func() {
		defer w.Close()
		// 写入数据
		_, err := w.Write([]byte("Hello from Pipe!"))
		if err != nil {
			log.Println(err.Error())
		return
		}
	}()

	// 读取端
	buf := make([]byte, 1024)
	n, err := r.Read(buf)
	if err != nil {
		log.Println(err.Error())
		return
	}

	fmt.Println("读取到的数据:", string(buf[:n]))
}

11.3 Go 1.26 新特性：Dialer 新方法

Go 1.26 为 Dialer 新增了针对特定协议的方法，比如 DialTCP、DialUDP，这些方法支持预解析的地址，兼顾了预解析的效率和 context 的可取消性。

package main

import (
	"context"
	"fmt"
	"net"
	"net/netip"
	"time"
)

func main() {
	// 预解析地址，避免每次连接都解析
	raddr := netip.MustParseAddrPort("127.0.0.1:8080")

	dialer := &net.Dialer{
		Timeout: 5 * time.Second,
	}

	// 使用新的DialTCP方法，支持context
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	conn, err := dialer.DialTCP(ctx, "tcp", netip.AddrPort{}, raddr)
	if err != nil {
		log.Println(err.Error())
		return
	}
	defer conn.Close()

	fmt.Println("连接成功")
}

11.4 自定义 DNS 在 HTTP 客户端中的应用

我们可以将自定义的 DNS 解析器和 HTTP 客户端结合，让 HTTP 请求也使用自定义的 DNS 服务器。

package main

import (
	"context"
	"fmt"
	"net"
	"net/http"
	"io/ioutil"
	"time"
)

func main() {
	// 自定义DNS解析器，使用Cloudflare的1.1.1.1
	resolver := &net.Resolver{
		PreferGo: true,
		Dial: func(ctx context.Context, network, address string) (net.Conn, error) {
			d := net.Dialer{Timeout: 3 * time.Second}
			return d.DialContext(ctx, "udp", "1.1.1.1:53")
		},
	}

	// 自定义Transport的DialContext
	transport := &http.Transport{
		DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
			// 拆分主机和端口
			host, port, err := net.SplitHostPort(addr)
			if err != nil {
				return nil, err
			}

			// 用自定义解析器解析主机
			ips, err := resolver.LookupHost(ctx, host)
			if err != nil {
				return nil, err
			}

			// 逐个尝试连接解析到的IP
			for _, ip := range ips {
				dialer := &net.Dialer{Timeout: 5 * time.Second}
				conn, err := dialer.DialContext(ctx, network, net.JoinHostPort(ip, port))
				if err == nil {
					return conn, nil
				}
			}
			return nil, fmt.Errorf("所有IP连接失败")
		},
	}

	// 创建使用自定义DNS的HTTP客户端
	client := &http.Client{
		Transport: transport,
		Timeout:   10 * time.Second,
	}

	// 发送请求
	resp, err := client.Get("https://example.com")
	if err != nil {
		log.Println(err.Error())
		return
	}
	defer resp.Body.Close()

	body, _ := ioutil.ReadAll(resp.Body)
	fmt.Println("响应状态:", resp.Status)
	fmt.Println("响应长度:", len(body))
}

12. 避坑指南

始终处理错误：网络操作的错误必须处理，不能忽略，尤其是 Accept、Read、Write 这些核心操作。
资源释放：使用 defer conn.Close() 确保连接关闭，避免文件描述符泄漏。
超时控制：所有网络操作都要设置超时，避免阻塞导致服务不可用。
并发处理：TCP 服务端必须用 goroutine 处理每个连接，才能实现高并发。
参数调优：
- 实时场景：禁用 Nagle 算法（SetNoDelay(true)）
- 长连接场景：启用 TCP 保活，快速检测死连接
- 批量传输：保持 Nagle 算法，增大读写缓冲区，提升吞吐量
DNS 缓存：默认的 DNS 解析没有缓存，高并发场景下建议自己实现 DNS 缓存，避免频繁解析。
Unix 域套接字：本地进程间通信优先使用 Unix 域套接字，比 TCP 性能更好。

通过以上内容，你已经基本掌握了 Go net 包的核心用法，从基础的 TCP/UDP 通信，到高级的 DNS 解析、ICMP 实现，都可以基于此进行开发。无论是构建简单的网络工具，还是开发复杂的分布式系统，net 包都是你不可或缺的利器。希望这份文档能帮助你更好地理解和使用 Go 的网络编程能力！

RabbitMQ Tutorial for Beginners (Go)

Mon, 30 Mar 2026 19:45:57 +0800

前言

RabbitMQ 是目前最流行的开源消息中间件之一，它基于 AMQP 协议（Advanced Message Queuing Protocol），能够帮我们实现系统解耦、异步通信、流量削峰等功能，是微服务架构中必不可少的组件。

读完这份教程，你将学会：

RabbitMQ 的核心概念，再也不怕听不懂术语
如何在各种系统上快速安装部署 RabbitMQ
如何用 Go 语言连接和操作 RabbitMQ
RabbitMQ 的 6 种核心工作模式，以及它们的适用场景
生产环境必备的高级特性：消息确认、持久化、死信队列等

一、RabbitMQ 核心概念：用快递站帮你搞懂

很多新手刚接触 RabbitMQ 时，会被一堆术语搞晕：生产者、消费者、交换机、队列… 别担心，我们用生活中最常见的快递站来类比，保证你一看就懂。

1.1 核心组件类比

想象一下，你开了一家淘宝店，每天要给全国各地的用户发快递。你不会自己一个个送快递，而是把包裹交给快递站，由快递站来帮你完成后续的配送。

RabbitMQ 就相当于这个 快递站，它的各个组件对应快递站的不同角色：

`RabbitMQ` 术语	快递站类比	作用说明
生产者 (Producer)	发快递的你（淘宝卖家）	负责生产消息，把消息发送给 `RabbitMQ`
消费者 (Consumer)	收快递的买家	负责从 `RabbitMQ` 接收并处理消息
交换机 (Exchange)	快递分拣中心	接收你发来的包裹，根据地址把包裹分到不同的快递柜
队列 (Queue)	小区的快递柜	用来暂存包裹，买家什么时候有空什么时候来取
绑定 (Binding)	分拣中心到快递柜的路线	告诉分拣中心：XX 地址的包裹，要放到 XX 快递柜里
路由键 (Routing Key)	包裹上的收货地址	你发包裹时写的地址，用来告诉分拣中心这个包裹要送到哪（也就是目的地）
虚拟主机 (VHost)	独立的快递园区	用来隔离不同的业务，比如淘宝的快递和京东的快递各用一个园区，互不干扰

1.2 消息流转的完整流程

搞懂了这些角色，整个消息流转的过程就非常清晰了：

你（生产者）打包好商品，写好收货地址（路由键），把包裹交给快递站（RabbitMQ）
包裹先送到分拣中心（交换机）
分拣中心根据你写的地址，按照之前定好的路线（绑定），把包裹放到对应的快递柜（队列）里
买家（消费者）下班后来到小区，从对应的快递柜里取出包裹，完成签收

整个过程中：

你不需要等买家签收，交完包裹就可以去忙别的了（异步处理）
就算买家今天没空取，包裹也会一直存在快递柜里，等他明天来取（消息存储）
双 11 包裹爆仓时，快递柜能帮你暂存所有包裹，不会因为突然的流量把系统冲垮（流量削峰）

1.3 架构图直观理解

下面这张架构图，能帮你更直观地理解这些组件之间的关系：

二、环境搭建：5 分钟搞定 RabbitMQ 服务

接下来我们要把 RabbitMQ 服务跑起来，这里我最推荐你用 Docker 来安装，因为它最简单，一行命令就能搞定，不用管什么依赖、版本问题。当然，我也会给你提供其他系统的安装方式。

2.1 推荐方式：Docker 一键安装

如果你已经装了 Docker，只需要执行下面这一条命令：

`1`	`docker run -d --name rabbitmq -p 5672:5672 -p 15672:15672 rabbitmq:3-management`

第一次运行会自动下载镜像，等它下载完了，容器就会启动成功了。我这里已经是下载好了，所以直接就启动了。

解释一下这几个参数：

-p 5672:5672：这是 RabbitMQ 的通信端口，我们的 Go 程序就是通过这个端口连接 RabbitMQ 的
-p 15672:15672：这是 Web 管理界面的端口，装完之后我们可以通过浏览器来可视化管理 RabbitMQ
rabbitmq:3-management：这个镜像已经内置了管理插件，不用我们手动装了

执行完之后，等个几十秒，容器启动成功就好了。

2.2 其他系统的安装方式

如果你不想用 Docker，也可以用系统包管理器安装：

Ubuntu/Debian

# 安装 Erlang 环境（RabbitMQ 是用 Erlang 写的）
sudo apt-get update
sudo apt-get install erlang

# 安装 RabbitMQ
sudo apt-get install rabbitmq-server

# 启动服务
sudo systemctl start rabbitmq-server

# 启用管理插件
sudo rabbitmq-plugins enable rabbitmq_management

CentOS/RHEL

# 添加 yum 源
sudo vim /etc/yum.repos.d/rabbitmq.repo

# 写入以下内容
[rabbitmq_server]
name=rabbitmq_server
baseurl=https://packagecloud.io/rabbitmq/rabbitmq-server/el/7/$basearch
repo_gpgcheck=1
gpgcheck=1
enabled=1
gpgkey=https://packagecloud.io/rabbitmq/rabbitmq-server/gpgkey

# 安装
sudo yum install -y rabbitmq-server

# 启动服务
sudo systemctl start rabbitmq-server

# 启用管理插件
sudo rabbitmq-plugins enable rabbitmq_management

Windows

直接去官网下载安装包：https://www.rabbitmq.com/download.html 下载完之后一路下一步安装就行，安装完成后服务会自动启动。

2.3 访问 Web 管理界面

不管你用哪种方式安装，装完之后，打开浏览器，访问：

`1`	`http://localhost:15672`

你会看到这样的登录界面：

默认用户名：guest
默认密码：guest

登录进去之后，你就能看到 RabbitMQ 的管理后台了，长这样：

这个后台非常有用，你可以在这里查看队列、交换机、连接数，还能手动发消息、查看消息堆积情况，后面我们跑代码的时候，也可以在这里实时看到消息的流转。

注意：默认的 guest 用户只能从 localhost 访问，如果你的 RabbitMQ 是部署在远程服务器上，需要新建一个管理员用户，我会在后面的最佳实践部分讲。

2.4 Go 客户端安装

RabbitMQ 服务装好了，接下来我们要准备 Go 语言的客户端，用来连接和操作 RabbitMQ。

官方推荐的 Go 客户端是 amqp091-go，这是原来的 streadway/amqp 的官方维护版本，现在已经完全替代了旧的库。

创建一个新的 Go 项目（空项目即可），然后执行下面的命令安装依赖：

# 初始化项目（如果是新项目）
go mod init rabbitmq-demo

# 安装 RabbitMQ 客户端
go get github.com/rabbitmq/amqp091-go

好了，到这里，我们的环境就全部准备好了！接下来我们就可以开始写代码，一个个体验 RabbitMQ 的工作模式了。

三、入门实战：Hello World 简单队列

我们从最简单的 简单队列 模式开始，这是 RabbitMQ 最基础的用法，就像我们平时发消息给一个人，一对一的通信。

3.1 模式说明

简单队列的结构非常简单：

`1`	`生产者 -> 队列 -> 消费者`

生产者把消息发送到一个队列
消费者从这个队列里读取消息
一条消息只能被一个消费者消费一次

这个模式非常适合简单的点对点通信，比如：下单成功后，通知库存服务扣库存。

3.2 编写生产者代码

首先，我们写一个生产者，用来发送消息：

// producer.go
package main

import (
    "log"

    amqp "github.com/rabbitmq/amqp091-go"
)

// 错误处理的辅助函数
func failOnError(err error, msg string) {
    if err != nil {
        log.Panicf("%s: %s", msg, err)
    }
}

func main() {
    // 1. 连接到 RabbitMQ 服务器
    conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
    failOnError(err, "无法连接到 RabbitMQ")
    defer conn.Close() // 函数结束时关闭连接

    // 2. 创建一个通道（Channel），所有的操作都是通过通道完成的
    ch, err := conn.Channel()
    failOnError(err, "无法创建通道")
    defer ch.Close()

    // 3. 声明一个队列，队列的名字叫 "hello"
    q, err := ch.QueueDeclare(
        "hello", // 队列名称
        false,   // 是否持久化（重启后队列是否保留）
        false,   // 是否自动删除（没有消费者时自动删除队列）
        false,   // 是否排他（只有当前连接能访问）
        false,   // 是否不等待
        nil,     // 额外参数
    )
    failOnError(err, "无法声明队列")

    // 4. 要发送的消息
    body := "Hello World! 这是我的第一条 RabbitMQ 消息"

    // 5. 发送消息
    err = ch.Publish(
        "",     // 交换机名称，这里用默认的交换机
        q.Name, // 路由键，这里就是队列的名字
        false,  // 是否强制
        false,  // 是否立即
        amqp.Publishing{
            // ContentType 是消息的内容类型，这里我们用 text/plain 表示纯文本
            ContentType: "text/plain", // 消息的内容类型
            Body:        []byte(body), // 消息的内容，转成字节数组
        })
    failOnError(err, "无法发送消息")

    log.Printf(" [x] 已发送消息: %s", body)
}

3.3 编写消费者代码

然后，我们写一个消费者，用来接收消息：

// consumer.go
package main

import (
	"log"

	amqp "github.com/rabbitmq/amqp091-go"
)

func failOnError(err error, msg string) {
	if err != nil {
		log.Panicf("%s: %s", msg, err)
	}
}

func main() {
	// 1. 同样的，先连接 RabbitMQ，创建通道
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	failOnError(err, "无法连接到 RabbitMQ")
	defer conn.Close()

	// 2. 创建一个通道（Channel），所有的操作都是通过通道完成的
	ch, err := conn.Channel()
	failOnError(err, "无法创建通道")
	defer ch.Close()

	// 3. 同样声明队列，这里要和生产者的队列名一致
	// 为什么要两边都声明？因为我们不知道生产者和消费者谁先启动
	// 如果队列已经存在，声明操作不会做任何事，只会返回队列的信息；如果队列不存在，声明操作会创建一个新的队列，所以很安全
	q, err := ch.QueueDeclare(
		"hello", // 队列名称
		false,   // 是否持久化（重启后队列是否保留）
		false,   // 是否自动删除（没有消费者时自动删除队列）
		false,   // 是否排他（只有当前连接能访问）
		false,   // 是否不等待
		nil,     // 额外参数
	)
	failOnError(err, "无法声明队列")

	// 4. 注册消费者，监听这个队列的消息
	msgs, err := ch.Consume(
		q.Name, // 要监听的队列名称
		"",     // 消费者名称，空的话服务器会自动生成
		true,   // 是否自动确认（后面会详细讲）
		false,  // 是否排他（只有当前连接能访问）
		false,  // 是否本地
		false,  // 是否不等待
		nil,    // 额外参数
	)
	failOnError(err, "无法注册消费者")

	// 5. 启动一个协程来处理消息
	// 因为接收消息是阻塞的，所以我们要放到协程里，不阻塞主程序
	go func() {
		for d := range msgs {
			// 收到消息了！
			log.Printf(" [x] 收到消息: %s", d.Body)
		}
	}()

	log.Printf(" [*] 等待消息中... 按 CTRL+C 退出")
	// 阻塞主程序，不让它退出
	<-make(chan bool)
}

3.4 运行测试

现在我们来运行一下：

首先打开另一个终端，运行生产者：

`1`	`go run producer.go`

生产者这边会输出： [x] 已发送消息: Hello World! 这是我的第一条 RabbitMQ 消息

在生产者终端看到这个输出，说明消息已经成功发送到 RabbitMQ 了。

同时我们可以在 Web 管理后台的 Queues 标签页里看到 hello 队列，点击进去可以看到消息数量是 1，说明消息已经进入队列了。

在下方的 Get messages 标签页里，我们也能看到这条消息的内容：

再先打开一个终端，运行消费者：

`1`	`go run consumer.go`

你会看到输出： [*] 等待消息中... 按 CTRL+C 退出，说明消费者已经启动，在等消息了。然后会再输出： [x] 收到消息: Hello World! 这是我的第一条 RabbitMQ 消息，说明消费者成功接收到了消息。

我们也可以在 Web 管理后台看到，hello 队列里的消息数量从 1 变成了 0，说明消息已经被消费者取走了。

完美！我们的第一个 RabbitMQ 程序就跑通了！

四、工作队列：任务分发与负载均衡

接下来我们看第二个模式：工作队列（Work Queue）。

4.1 模式说明

工作队列的结构是这样的：

`1`	`生产者 -> 队列 -> 多个消费者`

它的作用是什么呢？当我们有很多耗时的任务要处理时，我们可以启动多个消费者，让它们一起分担这些任务，实现负载均衡。

比如，我们有 10 个图片压缩的任务，启动两个消费者，每个消费者处理 5 个，这样处理速度就快了一倍。

4.2 轮询分发 vs 公平分发

RabbitMQ 默认的分发方式是轮询分发：它会把任务按顺序一个一个分给消费者，不管这个消费者有没有处理完上一个任务。

这就会有个问题：如果有一个任务特别耗时，另一个很快，就会导致一个消费者忙死，另一个闲死。

所以我们一般会用公平分发：告诉 RabbitMQ，一次只给一个消费者发一个任务，等这个消费者处理完了，再给它发下一个。这样就能保证任务会均匀地分给空闲的消费者。

4.3 代码实现

我们来写个例子，模拟任务处理：

生产者：发送任务

// task_producer.go
package main

import (
	"log"
	"strconv"
	"strings"
	"time"

	amqp "github.com/rabbitmq/amqp091-go"
)

func failOnError(err error, msg string) {
	if err != nil {
		log.Panicf("%s: %s", msg, err)
	}
}

func main() {
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	failOnError(err, "无法连接到 RabbitMQ")
	defer conn.Close()

	ch, err := conn.Channel()
	failOnError(err, "无法创建通道")
	defer ch.Close()

	// 声明队列，这次我们把队列设为持久化
	q, err := ch.QueueDeclare(
		"task_queue", // 队列名
		true,         // 持久化，RabbitMQ 重启后队列不丢
		false,        // 不自动删除
		false,        // 不排他
		false,        // 不等待
		nil,
	)
	failOnError(err, "无法声明队列")

	// 发送10个任务
	for i := 0; i < 10; i++ {
		// 任务内容，我们用点来表示任务的耗时，一个点代表1秒
		// 比如 "task3 ..." 表示这个任务要处理3秒
		// strconv.Itoa(i)：把整数 i 转换成字符串，这样我们就能看到每个任务的编号了
		// strings.Repeat(".", i/2)：重复 i/2 次点号，这样任务的耗时就会随着 i 的增加而增加
		task := "task" + strconv.Itoa(i) + " " + strings.Repeat(".", i/2)
		err = ch.Publish(
			"",     // 默认交换机
			q.Name, // 路由键
			false,
			false,
			amqp.Publishing{
				// 消息也设为持久化，这样重启后消息不丢
				DeliveryMode: amqp.Persistent,
				ContentType:  "text/plain",
				Body:         []byte(task),
			})
		failOnError(err, "无法发送消息")
		log.Printf(" [x] 发送任务: %s", task)

		time.Sleep(100 * time.Millisecond)
	}
}

消费者：处理任务

// worker.go
package main

import (
	"bytes"
	"log"
	"time"

	amqp "github.com/rabbitmq/amqp091-go"
)

func failOnError(err error, msg string) {
	if err != nil {
		log.Panicf("%s: %s", msg, err)
	}
}

func main() {
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	failOnError(err, "无法连接到 RabbitMQ")
	defer conn.Close()

	ch, err := conn.Channel()
	failOnError(err, "无法创建通道")
	defer ch.Close()

	q, err := ch.QueueDeclare(
		"task_queue", true, false, false, false, nil,
	)
	failOnError(err, "无法声明队列")

	// 关键！设置预取计数，开启公平分发
	// Qos 是 Quality of Service 的缩写，意思是服务质量，这个设置告诉 RabbitMQ 在同一时间只给一个消费者分发一个消息，直到这个消费者处理完了并确认了这个消息，RabbitMQ 才会给它分发下一个消息。这样就能实现公平分发了，不会让某个消费者因为处理慢而积压大量消息。
	// 告诉 RabbitMQ，一次只给我一个任务，我处理完了你再给我下一个
	err = ch.Qos(
		1,     // 预取数量
		0,     // 预取大小
		false, // 是否全局
	)
	failOnError(err, "无法设置 Qos")

	// 注册消费者，注意这里我们把自动确认关了，这样我们就可以在处理完消息后手动确认。
	msgs, err := ch.Consume(
		q.Name, "",
		false, // 自动确认设为 false，我们要手动确认
		false, false, false, nil,
	)
	failOnError(err, "无法注册消费者")

	go func() {
		for d := range msgs {
			log.Printf(" [x] 开始处理任务: %s", d.Body)

			// 模拟任务处理，点的数量就是耗时
			t := time.Duration(bytes.Count(d.Body, []byte("."))) * time.Second
			time.Sleep(t)

			log.Printf(" [x] 任务处理完成: %s", d.Body)

			// 手动确认消息，告诉 RabbitMQ：这个消息我处理完了，你可以删了
			d.Ack(false)
		}
	}()

	log.Printf(" [*] 工作进程已启动，等待任务...")
	<-make(chan bool)
}

4.4 运行测试

现在我们来测试一下：

1个工作进程 : 1个生产者先启动工作进程：

`1`	`go run worker.go`

你会看到输出： [*] 工作进程已启动，等待任务...，说明消费者已经启动了。

然后启动生产者：

`1`	`go run task_producer.go`

你会看到，生产者发送了 10 个任务，工作进程一个人吃了 10 个任务，处理完一个才处理下一个。

2个工作进程 : 1个生产者启动两个工作进程，打开两个终端，都运行：

`1`	`go run worker.go`

然后运行生产者：

`1`	`go run task_producer.go`

你会看到，两个工作进程会自动分担这 10 个任务，快的消费者会处理更多的任务，慢的也不会被拖累，这就是公平分发的效果。

这里要重点注意：我们把自动确认关了，用了手动确认。这非常重要！如果消费者处理到一半崩溃了，手动确认的话，RabbitMQ 会把这个任务重新放回队列，交给另一个消费者处理，不会丢消息。

五、发布订阅：广播消息给所有消费者

接下来是 发布 / 订阅（Publish/Subscribe） 模式，这个模式下，一条消息会被发送给所有的消费者，也就是广播。

5.1 模式说明

发布订阅的结构是这样的：

`1`	`生产者 -> 交换机(Fanout) -> 多个队列 -> 多个消费者`

这里我们用到了 Fanout 类型的交换机，这种交换机的作用很简单：它会把收到的所有消息，广播给所有绑定到它的队列，完全不管路由键是什么。

比如，我们做一个日志系统，所有服务的日志都发给这个交换机，然后：

一个消费者把日志存到磁盘
一个消费者把日志打印到屏幕
一个消费者把日志发到监控系统所有消费者都能收到同一条日志消息，互不干扰。

5.2 代码实现

生产者：发送日志

// log_producer.go
package main

import (
	"context"
	"log"
	"strconv"
	"time"

	amqp "github.com/rabbitmq/amqp091-go"
)

func failOnError(err error, msg string) {
	if err != nil {
		log.Panicf("%s: %s", msg, err)
	}
}

func main() {
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	failOnError(err, "无法连接到 RabbitMQ")
	defer conn.Close()

	ch, err := conn.Channel()
	failOnError(err, "无法创建通道")
	defer ch.Close()

	// 声明一个 Fanout 类型的交换机
	err = ch.ExchangeDeclare(
		"logs",   // 交换机名称
		"fanout", // 类型：fanout 就是广播
		true,     // 持久化
		false,    // 自动删除
		false,    // 内部
		false,    // 不等待
		nil,
	)
	failOnError(err, "无法声明交换机")

	// 每隔1秒发一条日志
	for i := 0; ; i++ {
		logMsg := "这是一条日志消息，序号: " + strconv.Itoa(i)

		// 发送消息到交换机
		err = ch.PublishWithContext(
			context.Background(),
			"logs", // 交换机名称
			"",     // 路由键，fanout 模式下这个参数会被忽略，随便写什么都行
			false, false,
			amqp.Publishing{
				ContentType: "text/plain",
				Body:        []byte(logMsg),
			})
		failOnError(err, "无法发送消息")
		log.Printf(" [x] 发送日志: %s", logMsg)

		time.Sleep(1 * time.Second)
	}
}

消费者 1：打印日志到屏幕

// log_console.go
package main

import (
	"log"

	amqp "github.com/rabbitmq/amqp091-go"
)

func failOnError(err error, msg string) {
	if err != nil {
		log.Panicf("%s: %s", msg, err)
	}
}

func main() {
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	failOnError(err, "无法连接到 RabbitMQ")
	defer conn.Close()

	ch, err := conn.Channel()
	failOnError(err, "无法创建通道")
	defer ch.Close()

	// 同样声明交换机，要和生产者的一致，否则消费者无法接收到消息
	err = ch.ExchangeDeclare("logs", "fanout", true, false, false, false, nil)
	failOnError(err, "无法声明交换机")

	// 而且我们把 exclusive 设为 true，这样消费者断开连接后，队列会自动删除
	q, err := ch.QueueDeclare(
		"log_console_queue", // 队列名
		false,               // 不持久化
		false,               // 不自动删除
		true,                // 排他，连接断了就删
		false,               // 不等待
		nil,
	)
	failOnError(err, "无法声明队列")

	// 把队列绑定到交换机上
	err = ch.QueueBind(
		q.Name, // 队列名
		"",     // 路由键，fanout 模式下忽略
		"logs", // 交换机名
		false,
		nil,
	)
	failOnError(err, "无法绑定队列")

	// 消费消息
	msgs, err := ch.Consume(q.Name, "", true, false, false, false, nil)
	failOnError(err, "无法注册消费者")

	go func() {
		for d := range msgs {
			log.Printf(" [控制台消费者] 收到日志: %s", d.Body)
		}
	}()

	log.Println(" [*] 控制台日志消费者已启动")
	<-make(chan bool)
}

消费者 2：把日志存到文件

// log_file.go
package main

import (
	"log"
	"os"

	amqp "github.com/rabbitmq/amqp091-go"
)

func failOnError(err error, msg string) {
	if err != nil {
		log.Panicf("%s: %s", msg, err)
	}
}

func main() {
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	failOnError(err, "无法连接到 RabbitMQ")
	defer conn.Close()

	ch, err := conn.Channel()
	failOnError(err, "无法创建通道")
	defer ch.Close()

	err = ch.ExchangeDeclare("logs", "fanout", true, false, false, false, nil)
	failOnError(err, "无法声明交换机")

	q, err := ch.QueueDeclare("log_file_queue", false, false, true, false, nil)
	failOnError(err, "无法声明队列")

	err = ch.QueueBind(q.Name, "", "logs", false, nil)
	failOnError(err, "无法绑定队列")

	// 打开文件，准备写日志
	f, err := os.OpenFile("app.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()

	msgs, err := ch.Consume(q.Name, "", true, false, false, false, nil)
	failOnError(err, "无法注册消费者")

	go func() {
		for d := range msgs {
			logMsg := string(d.Body)
			log.Printf(" [文件消费者] 保存日志到文件: %s", logMsg)
			// 写入文件
			f.WriteString(logMsg + "\n")
			f.Sync()
		}
	}()

	log.Println(" [*] 文件日志消费者已启动")
	<-make(chan bool)
}

5.3 运行测试

现在运行一下:

先启动控制台消费者：

`1`	`go run log_console.go`

再启动文件消费者：

`1`	`go run log_file.go`

最后启动生产者：

`1`	`go run log_producer.go`

你会发现，两个消费者都能收到所有的日志消息！生产者发一条，两个消费者各收到一条，完美实现了广播的效果。

六、路由模式：精准定向分发消息

接下来是路由模式（Routing），这个模式下，我们可以根据消息的类型，把消息发给指定的消费者。

6.1 模式说明

路由模式用的是 Direct 类型的交换机，这种交换机会根据路由键的精确匹配来转发消息。

比如，我们还是做日志系统，这次我们想：

error 级别的日志，存到磁盘，用来排查问题
info、warning 级别的日志，只打印到屏幕

那我们就可以：

生产者发消息时，给 error 日志的路由键设为 error，info 的设为 info，warning 的设为 warning
存磁盘的消费者，只绑定 error 这个路由键
打印屏幕的消费者，绑定 info 和 warning 两个路由键

这样，error 日志两个消费者都能收到，info 日志只有屏幕消费者能收到，非常灵活。

6.2 代码实现

生产者：按级别发日志

// routing_producer.go
package main

import (
    "context"
    "log"
    "time"

    amqp "github.com/rabbitmq/amqp091-go"
)

func failOnError(err error, msg string) {
    if err != nil {
        log.Panicf("%s: %s", msg, err)
    }
}

func main() {
    conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
    failOnError(err, "无法连接到 RabbitMQ")
    defer conn.Close()

    ch, err := conn.Channel()
    failOnError(err, "无法创建通道")
    defer ch.Close()

    // 声明 Direct 类型的交换机
    err = ch.ExchangeDeclare(
        "logs_direct", // 交换机名
        "direct",      // 类型：direct
        true, false, false, false, nil,
    )
    failOnError(err, "无法声明交换机")

    // 模拟发不同级别的日志
    logs := []struct {
        level   string
        message string
    }{
        {"info", "这是一条普通的信息日志"},
        {"warning", "这是一条警告日志"},
        {"error", "这是一条错误日志！系统出问题了"},
    }

    for _, l := range logs {
        err = ch.PublishWithContext(
            context.Background(),
            "logs_direct", // 交换机
            l.level,       // 路由键，就是日志级别
            false, false,
            amqp.Publishing{
                ContentType: "text/plain",
                Body:        []byte(l.message),
            })
        failOnError(err, "无法发送消息")
        log.Printf(" [x] 发送[%s]日志: %s", l.level, l.message)

        time.Sleep(500 * time.Millisecond)
    }
}

消费者 1：只接收 error 日志，存到磁盘

// error_consumer.go
package main

import (
    "log"
    "os"

    amqp "github.com/rabbitmq/amqp091-go"
)

func failOnError(err error, msg string) {
    if err != nil {
        log.Panicf("%s: %s", msg, err)
    }
}

func main() {
    conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
    failOnError(err, "无法连接到 RabbitMQ")
    defer conn.Close()

    ch, err := conn.Channel()
    failOnError(err, "无法创建通道")
    defer ch.Close()

    err = ch.ExchangeDeclare("logs_direct", "direct", true, false, false, false, nil)
    failOnError(err, "无法声明交换机")

    q, err := ch.QueueDeclare("", false, false, true, false, nil)
    failOnError(err, "无法声明队列")

    // 只绑定 error 路由键
    err = ch.QueueBind(q.Name, "error", "logs_direct", false, nil)
    failOnError(err, "无法绑定队列")

    f, err := os.OpenFile("error.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
    if err != nil {
        log.Fatal(err)
    }
    defer f.Close()

    msgs, err := ch.Consume(q.Name, "", true, false, false, false, nil)
    failOnError(err, "无法注册消费者")

    go func() {
        for d := range msgs {
            logMsg := string(d.Body)
            log.Printf(" [Error消费者] 保存错误日志: %s", logMsg)
            f.WriteString(logMsg + "\n")
            f.Sync()
        }
    }()

    log.Println(" [*] Error 消费者已启动，只处理 error 日志")
    <-make(chan bool)
}

消费者 2：接收所有日志，打印到屏幕

// all_log_consumer.go
package main

import (
    "log"

    amqp "github.com/rabbitmq/amqp091-go"
)

func failOnError(err error, msg string) {
    if err != nil {
        log.Panicf("%s: %s", msg, err)
    }
}

func main() {
    conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
    failOnError(err, "无法连接到 RabbitMQ")
    defer conn.Close()

    ch, err := conn.Channel()
    failOnError(err, "无法创建通道")
    defer ch.Close()

    err = ch.ExchangeDeclare("logs_direct", "direct", true, false, false, false, nil)
    failOnError(err, "无法声明交换机")

    q, err := ch.QueueDeclare("", false, false, true, false, nil)
    failOnError(err, "无法声明队列")

    // 绑定 info 路由键
    err = ch.QueueBind(q.Name, "info", "logs_direct", false, nil)
    failOnError(err, "无法绑定队列")
    // 绑定 warning 路由键
    err = ch.QueueBind(q.Name, "warning", "logs_direct", false, nil)
    failOnError(err, "无法绑定队列")
    // 绑定 error 路由键
    err = ch.QueueBind(q.Name, "error", "logs_direct", false, nil)
    failOnError(err, "无法绑定队列")

    msgs, err := ch.Consume(q.Name, "", true, false, false, false, nil)
    failOnError(err, "无法注册消费者")

    go func() {
        for d := range msgs {
            log.Printf(" [控制台消费者] 收到日志: %s", d.Body)
        }
    }()

    log.Println(" [*] 控制台消费者已启动，处理所有级别日志")
    <-make(chan bool)
}

6.3 运行测试

运行一下：

启动 error 消费者：

`1`	`go run error_consumer.go`

启动控制台消费者：

`1`	`go run all_log_consumer.go`

启动生产者：

`1`	`go run routing_producer.go`

你会看到：

error 日志，两个消费者都收到了
info 和 warning 日志，只有控制台消费者收到了

完美！这就是精准路由的效果。

七、主题模式：通配符灵活路由

接下来是最灵活的主题模式（Topic），这个模式下，路由键支持通配符，我们可以做更复杂的消息过滤。

7.1 模式说明

主题模式用的是 Topic 类型的交换机，它和 Direct 很像，但是它的路由键匹配支持通配符：

*：匹配一个单词
#：匹配零个或多个单词

这里的单词，是用点 . 分隔的。

比如，我们的路由键可以是 order.create、order.update、user.register 这种格式，然后：

order.*：可以匹配 order.create、order.update，但是匹配不了 user.register
#：可以匹配所有的路由键
*.create：可以匹配 order.create、user.create

这个模式非常适合多层级的消息路由，比如我们要按模块、按操作类型来过滤消息。

7.2 代码实现

我们来做一个订单和用户的消息通知系统：

生产者：发送不同类型的消息

// topic_producer.go
package main

import (
	"context"
	"log"
	"time"

	amqp "github.com/rabbitmq/amqp091-go"
)

func failOnError(err error, msg string) {
	if err != nil {
		log.Panicf("%s: %s", msg, err)
	}
}

func main() {
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	failOnError(err, "无法连接到 RabbitMQ")
	defer conn.Close()

	ch, err := conn.Channel()
	failOnError(err, "无法创建通道")
	defer ch.Close()

	// 声明 Topic 类型的交换机
	err = ch.ExchangeDeclare(
		"events_topic", // 交换机名
		"topic",        // 类型：topic
		true, false, false, false, nil,
	)
	failOnError(err, "无法声明交换机")

	// 模拟发送不同的事件
	events := []struct {
		routingKey string
		message    string
	}{
		{"order.create", "用户创建了新订单"},
		{"order.update", "订单状态更新了"},
		{"user.register", "新用户注册了"},
		{"user.login", "用户登录了"},
	}

	for _, e := range events {
		// Publish只能发送消息到交换机，路由键由我们指定，消费者根据路由键来决定是否接收消息
		// 而PublishWithContext可以指定上下文，支持超时等功能
		err = ch.PublishWithContext(
			context.Background(), // 上下文：这里使用背景上下文，表示没有特定的超时或取消条件
			"events_topic",       // 交换机名
			e.routingKey,         // 路由键，消费者根据这个键来决定是否接收消息
			false, false,
			amqp.Publishing{
				ContentType: "text/plain",
				Body:        []byte(e.message),
			})
		failOnError(err, "无法发送消息")
		log.Printf(" [x] 发送事件[%s]: %s", e.routingKey, e.message)

		time.Sleep(500 * time.Millisecond)
	}
}

消费者 1：只关心订单相关的事件

// order_consumer.go
package main

import (
    "log"

    amqp "github.com/rabbitmq/amqp091-go"
)

func failOnError(err error, msg string) {
    if err != nil {
        log.Panicf("%s: %s", msg, err)
    }
}

func main() {
    conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
    failOnError(err, "无法连接到 RabbitMQ")
    defer conn.Close()

    ch, err := conn.Channel()
    failOnError(err, "无法创建通道")
    defer ch.Close()

    err = ch.ExchangeDeclare("events_topic", "topic", true, false, false, false, nil)
    failOnError(err, "无法声明交换机")

    q, err := ch.QueueDeclare("", false, false, true, false, nil)
    failOnError(err, "无法声明队列")

    // 绑定 order.*，匹配所有 order 开头的事件
    err = ch.QueueBind(q.Name, "order.*", "events_topic", false, nil)
    failOnError(err, "无法绑定队列")

    msgs, err := ch.Consume(q.Name, "", true, false, false, false, nil)
    failOnError(err, "无法注册消费者")

    go func() {
        for d := range msgs {
            log.Printf(" [订单服务] 收到事件: %s", d.Body)
        }
    }()

    log.Println(" [*] 订单服务消费者已启动，只处理订单相关事件")
    <-make(chan bool)
}

消费者 2：关心所有的事件

// all_event_consumer.go
package main

import (
    "log"

    amqp "github.com/rabbitmq/amqp091-go"
)

func failOnError(err error, msg string) {
    if err != nil {
        log.Panicf("%s: %s", msg, err)
    }
}

func main() {
    conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
    failOnError(err, "无法连接到 RabbitMQ")
    defer conn.Close()

    ch, err := conn.Channel()
    failOnError(err, "无法创建通道")
    defer ch.Close()

    err = ch.ExchangeDeclare("events_topic", "topic", true, false, false, false, nil)
    failOnError(err, "无法声明交换机")

    q, err := ch.QueueDeclare("", false, false, true, false, nil)
    failOnError(err, "无法声明队列")

    // 绑定 #，匹配所有的事件
    err = ch.QueueBind(q.Name, "#", "events_topic", false, nil)
    failOnError(err, "无法绑定队列")

    msgs, err := ch.Consume(q.Name, "", true, false, false, false, nil)
    failOnError(err, "无法注册消费者")

    go func() {
        for d := range msgs {
            log.Printf(" [监控服务] 收到所有事件: %s", d.Body)
        }
    }()

    log.Println(" [*] 监控服务消费者已启动，处理所有事件")
    <-make(chan bool)
}

7.3 运行测试

运行一下：

启动订单消费者：

`1`	`go run order_consumer.go`

启动监控消费者：

`1`	`go run all_event_consumer.go`

启动生产者：

`1`	`go run topic_producer.go`

你会看到：

订单相关的两个事件，两个消费者都收到了
用户相关的两个事件，只有监控消费者收到了

这就是主题模式的灵活之处，你可以用通配符很方便地做各种消息过滤。

八、RPC 模式：同步远程调用

前面的模式都是异步的，但是有时候我们需要同步的调用：我发一个请求，然后等你给我返回结果，这就是 RPC（远程过程调用）模式。

8.1 模式说明

RPC 模式的流程是这样的：

客户端发送一个请求消息，同时指定两个东西：
- reply_to：告诉服务端，处理完结果要把响应发到哪个队列
- correlation_id：请求的唯一 ID，用来区分不同的请求
服务端收到请求，处理，然后把响应发到 reply_to 指定的队列，并且带上 correlation_id
客户端监听响应队列，根据 correlation_id 找到对应的响应

这样就实现了同步的远程调用。

8.2 代码实现

我们来实现一个计算斐波那契数的 RPC 服务：

RPC 服务端

// rpc_server.go
package main

import (
    "log"
    "strconv"

    amqp "github.com/rabbitmq/amqp091-go"
)

func failOnError(err error, msg string) {
    if err != nil {
        log.Panicf("%s: %s", msg, err)
    }
}

// 计算斐波那契数
func fib(n int) int {
    if n == 0 {
        return 0
    }
    if n == 1 {
        return 1
    }
    return fib(n-1) + fib(n-2)
}

func main() {
    conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
    failOnError(err, "无法连接到 RabbitMQ")
    defer conn.Close()

    ch, err := conn.Channel()
    failOnError(err, "无法创建通道")
    defer ch.Close()

    // 声明 RPC 请求队列
    q, err := ch.QueueDeclare(
        "rpc_queue", // 请求队列名
        false, false, false, false, nil,
    )
    failOnError(err, "无法声明队列")

    // 设置 Qos，保证公平分发
    err = ch.Qos(1, 0, false)
    failOnError(err, "无法设置 Qos")

    msgs, err := ch.Consume(
        q.Name, "", false, false, false, false, nil,
    )
    failOnError(err, "无法注册消费者")

    log.Println(" [*] RPC 服务已启动，等待请求...")

    for d := range msgs {
        // 解析请求参数
        n, err := strconv.Atoi(string(d.Body))
        if err != nil {
            log.Printf("无效的参数: %s", d.Body)
            d.Ack(false)
            continue
        }

        log.Printf(" [.] 计算 fib(%d)", n)
        // 计算结果
        response := fib(n)

        // 把响应发回给客户端
        err = ch.Publish(
            "", // 默认交换机
            d.ReplyTo, // 客户端指定的响应队列
            false, false,
            amqp.Publishing{
                ContentType:   "text/plain",
                CorrelationId: d.CorrelationId, // 带上请求的ID
                Body:          []byte(strconv.Itoa(response)),
            })
        failOnError(err, "无法发送响应")

        // 确认请求消息
        d.Ack(false)
    }
}

RPC 客户端

// rpc_client.go
package main

import (
    "log"
    "math/rand"
    "strconv"
    "time"

    amqp "github.com/rabbitmq/amqp091-go"
)

func failOnError(err error, msg string) {
    if err != nil {
        log.Panicf("%s: %s", msg, err)
    }
}

type RPCClient struct {
    conn         *amqp.Connection
    channel      *amqp.Channel
    callbackQueue amqp.Queue
    corrID       string
    responses    map[string]chan string
}

func NewRPCClient() *RPCClient {
    conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
    failOnError(err, "无法连接到 RabbitMQ")

    ch, err := conn.Channel()
    failOnError(err, "无法创建通道")

    // 声明回调队列，用来接收响应
    callbackQueue, err := ch.QueueDeclare(
        "", false, false, true, false, nil,
    )
    failOnError(err, "无法声明回调队列")

    // 监听回调队列
    msgs, err := ch.Consume(
        callbackQueue.Name, "", true, false, false, false, nil,
    )
    failOnError(err, "无法注册消费者")

    client := &RPCClient{
        conn:         conn,
        channel:      ch,
        callbackQueue: callbackQueue,
        responses:    make(map[string]chan string),
    }

    // 后台协程处理响应
    go client.handleResponses(msgs)

    return client
}

func (c *RPCClient) handleResponses(msgs <-chan amqp.Delivery) {
    for d := range msgs {
        // 根据 correlationId 找到对应的响应通道
        corrId := d.CorrelationId
        if ch, ok := c.responses[corrId]; ok {
            ch <- string(d.Body)
        }
    }
}

func (c *RPCClient) Call(n int) (string, error) {
    // 生成唯一的 correlationId
    c.corrID = strconv.Itoa(rand.Intn(999999))
    ch := make(chan string)
    c.responses[c.corrID] = ch

    // 发送请求
    err := c.channel.Publish(
        "", "rpc_queue", false, false,
        amqp.Publishing{
            ContentType:   "text/plain",
            CorrelationId: c.corrID,
            ReplyTo:       c.callbackQueue.Name, // 告诉服务端响应发到哪
            Body:          []byte(strconv.Itoa(n)),
        })
    failOnError(err, "无法发送请求")

    // 等待响应
    response := <-ch
    delete(c.responses, c.corrID)
    return response, nil
}

func (c *RPCClient) Close() {
    c.conn.Close()
}

func main() {
    client := NewRPCClient()
    defer client.Close()

    // 调用 RPC，计算 fib(30)
    log.Println(" [x] 请求 fib(30)")
    res, err := client.Call(30)
    failOnError(err, "RPC 调用失败")

    log.Printf(" [.] 结果: %s", res)
}

8.3 运行测试

运行一下：

先启动服务端：

`1`	`go run rpc_server.go`

然后启动客户端：

`1`	`go run rpc_client.go`

客户端会输出：

1
2

[x] 请求 fib(30)
[.] 结果: 832040

我们就实现了一个基于 RabbitMQ 的 RPC 调用。

可以单独运行 rpc_client.go ，然后去 Web 管理界面查看 rpc_queue 队列，你会看到客户端发出的请求消息，服务端处理完后，消息就会从队列里消失。

九、生产环境必备：高级特性

到这里，RabbitMQ 的核心工作模式我们就都讲完了，接下来我们讲几个生产环境必须要掌握的高级特性。

9.1 消息确认机制（ACK）

前面我们已经提到过，消息确认机制是保证消息不丢失的关键。

当你把 autoAck 设为 true 时，RabbitMQ 把消息发出去之后，就立刻把消息删了，不管消费者有没有处理完。如果消费者刚收到消息，还没处理就崩溃了，那这个消息就丢了。

而当你把 autoAck 设为 false 时，RabbitMQ 会等消费者手动调用 d.Ack() 之后，才会把消息删掉。如果消费者崩溃了，RabbitMQ 会把这个消息重新放回队列，发给其他消费者，保证消息不会丢。

除了 Ack，还有两个方法：

d.Nack(false, true)：拒绝这个消息，并且让它重新入队，用来重试
d.Nack(false, false)：拒绝这个消息，并且直接丢弃，用来处理坏消息

9.2 消息持久化

持久化是为了保证 RabbitMQ 重启之后，消息不会丢。要实现完整的持久化，你需要同时设置三个地方：

队列的 durable 参数设为 true：这样 RabbitMQ 重启后，队列不会丢
消息的 DeliveryMode 设为 amqp.Persistent：这样消息会被存到磁盘，重启后不会丢
交换机的 durable 参数设为 true：这样交换机重启后不会丢

注意：这三个要同时设置，缺一不可！不然还是会丢消息。

9.3 发布确认（Publisher Confirm）

前面的 ACK 是消费者给 RabbitMQ 的确认，那生产者怎么知道消息真的被 RabbitMQ 收到了呢？这就需要发布确认机制。

开启发布确认后，RabbitMQ 收到消息后，会给生产者发一个确认，告诉生产者：我收到了。如果没收到，生产者就可以重试。

代码示例：

// 开启发布确认
err = ch.Confirm(false)
failOnError(err, "无法开启确认")

// 创建一个通道来接收确认
confirms := ch.NotifyPublish(make(chan amqp.Confirmation, 1))

go func() {
    for confirm := range confirms {
        if confirm.Ack {
            log.Printf("消息 %d 已被服务器确认", confirm.DeliveryTag)
        } else {
            log.Printf("消息 %d 被服务器拒绝了", confirm.DeliveryTag)
            // 重试发送
        }
    }
}()

9.4 死信队列（DLQ）

死信队列，就是用来存放那些死掉的消息的队列。什么是死信？就是：

消息被消费者拒绝了，并且没有重新入队
消息过期了（TTL 到了）
队列满了，消息放不下了

这些消息不会直接被扔掉，而是会被转发到死信交换机，然后存到死信队列里，我们可以后续排查问题，或者重试处理。

最常见的用法就是用死信队列实现延迟消息：比如我们要做订单超时关闭，下单后 30 分钟没支付，就自动关闭订单。

我们可以这样做：

声明一个普通队列，设置它的 TTL 是 30 分钟，并且设置死信交换机
下单的时候，把消息发到这个队列
30 分钟后，消息过期了，就会被转发到死信队列
我们的消费者监听死信队列，收到消息后，就去检查订单状态，如果没支付就关闭

代码示例：

// 声明死信交换机
err = ch.ExchangeDeclare("dlx_exchange", "direct", true, false, false, false, nil)
failOnError(err, "无法声明死信交换机")

// 声明死信队列
dlq, err := ch.QueueDeclare("dlq_queue", true, false, false, false, nil)
failOnError(err, "无法声明死信队列")

// 绑定死信队列到死信交换机
err = ch.QueueBind(dlq.Name, "order_timeout", "dlx_exchange", false, nil)
failOnError(err, "无法绑定死信队列")

// 声明延迟队列，设置 TTL 和死信交换机
args := amqp.Table{
    "x-message-ttl":             30 * 60 * 1000, // 30分钟，单位毫秒
    "x-dead-letter-exchange":    "dlx_exchange",  // 死信交换机
    "x-dead-letter-routing-key": "order_timeout", // 死信路由键
}
delayQueue, err := ch.QueueDeclare("delay_queue", true, false, false, false, args)
failOnError(err, "无法声明延迟队列")

这样，我们把订单消息发到 delay_queue，30 分钟后，它就会自动跑到 dlq_queue 里，我们的消费者就可以处理了。

十、最佳实践与常见问题

最后，给你一些生产环境的最佳实践：

10.1 用户权限管理

默认的 guest 用户只能本地访问，生产环境一定要新建用户，不要用默认的：

# 添加用户
rabbitmqctl add_user myuser mypassword

# 设置用户为管理员
rabbitmqctl set_user_tags myuser administrator

# 给用户授权
rabbitmqctl set_permissions -p / myuser ".*" ".*" ".*"

10.2 连接与重连

RabbitMQ 的连接是会断的，网络抖动、服务重启都会导致连接断开，所以实际开发时，你的客户端一定要有重连机制，不要断了就直接挂了。

可以把连接的代码放在一个循环里，连接失败了就等几秒钟再重试：

for {
    conn, err := amqp.Dial("amqp://myuser:mypassword@localhost:5672/")
    if err != nil {
        log.Printf("连接失败，5秒后重试: %s", err)
        time.Sleep(5 * time.Second)
        continue
    }
    // 连接成功，继续后续操作
    break
}

如果连接后发生网络抖动，导致连接断开了，也要监听连接的 NotifyClose 通道，及时重连：

conn, err := amqp.Dial("amqp://myuser:mypassword@localhost:5672/")
failOnError(err, "无法连接到 RabbitMQ")

// 监听连接关闭事件
notifyClose := conn.NotifyClose(make(chan *amqp.Error, 1))

go func() {
    err := <-notifyClose
    log.Printf("连接关闭: %s", err)
    // 重连逻辑
    for {
        conn, err = amqp.Dial("amqp://myuser:mypassword@localhost:5672/")
        if err != nil {
            log.Printf("重连失败，5秒后重试: %s", err)
            time.Sleep(5 * time.Second)
            continue
        }
        log.Println("重连成功")
        break
    }
}()

10.3 幂等性消费

网络问题可能会导致消息重复投递，所以你的消费端一定要保证幂等性：就是同一个消息，消费多少次，结果都是一样的。

常见的做法：

用消息的唯一 ID，存到 Redis，消费之前先查一下有没有处理过
数据库的唯一索引，防止重复插入
业务状态机，比如订单状态，只有待支付的才能处理超时，已经支付的就忽略

10.4 监控

一定要开启监控，监控队列的堆积情况、连接数、消息速率，有问题及时报警。RabbitMQ 的管理后台已经提供了很多指标，你也可以用 Prometheus 来采集。

总结

恭喜你！看完这份教程，你已经掌握了 RabbitMQ 的核心用法了！

我们从最基础的概念开始，一步步学会了：

RabbitMQ 的核心组件和消息流转
6 种核心工作模式：简单队列、工作队列、发布订阅、路由、主题、RPC
生产环境必备的高级特性：ACK、持久化、死信队列
各种场景下的 Go 代码实现

RabbitMQ 是一个非常强大的工具，掌握了它，你就能在分布式系统中轻松实现异步通信、解耦、削峰这些功能。

接下来，你可以自己动手把这些代码跑一遍，加深理解，然后就可以在你的项目中使用它了！

Go gRPC Tutorial

Thu, 26 Mar 2026 17:29:38 +0800

前言

gRPC 是一个高性能、开源的远程过程调用（RPC）框架，由 Google 开发。它基于 HTTP/2 协议设计，默认使用 Protocol Buffers 作为序列化工具，支持跨语言、跨平台的服务调用。对于 Go 语言开发者来说，gRPC 是构建微服务架构的首选工具之一，它能够极大地简化服务间的通信开发，同时提供极高的性能。

本文章将从最基础的概念开始，带你一步步完成从环境搭建到实战开发，再到容器化部署的全流程，覆盖 Windows、Linux、Mac 三大主流系统，以及 Docker 容器化部署方案，让你从零开始，快速掌握 Go 语言下的 gRPC 开发。

一、核心概念入门

1.1 什么是 gRPC？

gRPC 是一个现代化的 RPC 框架，它允许客户端应用直接调用不同机器上的服务端方法，就像调用本地方法一样。它基于 HTTP/2 协议，带来了以下优势：

多路复用：在同一个 TCP 连接上并行处理多个请求，减少连接开销
流处理：支持客户端、服务端的双向流处理
强类型接口：基于 Protobuf 定义服务接口，天然支持跨语言
高性能：二进制序列化，比 JSON 等文本格式更快、更小

1.2 什么是 Protocol Buffers？

Protocol Buffers（简称 Protobuf）是 Google 推出的一种轻量级、高效的结构化数据序列化格式，它比 XML、JSON 更小、更快、更简单。在 gRPC 中，我们使用 Protobuf 来定义服务的接口和消息结构，然后通过编译器生成不同语言的代码。

1.3 gRPC 的四种服务类型

gRPC 支持四种不同类型的服务调用模式，以满足不同的业务场景：

简单 RPC（Unary RPC）：最基础的调用模式，客户端发送一个请求，服务端返回一个响应，就像普通的函数调用一样。
客户端流 RPC（Client-side Streaming RPC）：客户端发送多个请求给服务端，服务端处理完后返回一个响应。
服务端流 RPC（Server-side Streaming RPC）：客户端发送一个请求，服务端返回多个响应流。
双向流 RPC（Bidirectional Streaming RPC）：客户端和服务端都可以通过读写流来发送多个消息，双方可以独立地读写。

1.4 gRPC 工作架构

下图展示了 gRPC 客户端与服务端的基础交互架构：

客户端侧：业务代码调用本地的 gRPC Stub（客户端桩），Stub 会把调用参数通过 Protobuf 序列化为二进制数据，再通过 HTTP/2 客户端把请求发送出去。
网络传输：基于 TCP 连接的 HTTP/2 协议，支持多路复用，同一个连接可以并行处理多个请求。
服务端侧：HTTP/2 服务端收到请求后，先通过 Protobuf 反序列化出请求参数，交给 gRPC 服务端，再转发到你的业务服务实现，处理完成后把结果原路返回给客户端。

二、Protobuf 基础语法

在开始开发之前，我们需要先掌握 Protobuf 的基础语法，因为我们所有的服务定义都需要写在 .proto 文件中。我们这里使用最新的 proto3 语法，这也是目前 gRPC 推荐的版本。

2.1 基础文件结构

一个标准的 .proto 文件的基础结构如下：

// 1. 声明语法版本，必须放在文件第一行（注释除外）
syntax = "proto3";

// 2. 包声明，用于防止命名冲突，相当于命名空间
package helloworld;

// 3. Go语言专属选项，指定生成代码的包路径和包名
// 格式为: 生成文件的输出路径; 包名
option go_package = "./;pb";

2.2 消息（Message）定义

消息是 Protobuf 中数据的载体，你可以把它理解为 Go 语言中的结构体，用来定义传输的数据结构。

// 定义请求消息
message HelloRequest {
  // 字段格式: 类型 字段名 = 字段编号;
  string name = 1;
}

// 定义响应消息
message HelloReply {
  string message = 1;
}

关键字段说明

字段类型：支持基础类型（int32、int64、float、bool、string 等），也支持嵌套的消息类型。
字段编号：每个字段都必须有一个唯一的数字编号，范围是 1~536870911，其中 1~15 占用 1 个字节，16~2047 占用 2 个字节，所以高频使用的字段尽量用小编号。

重复字段：如果需要定义数组 / 列表，使用 repeated 关键字：

message Person {
  string name = 1;
  // repeated 表示这是一个列表
  repeated string hobbies = 2;
}

2.3 服务（Service）定义

服务定义了 gRPC 接口的方法，用来声明客户端可以调用的远程方法：

// 定义 Greeter 服务
service Greeter {
  // 定义一个简单的 RPC 方法
  // 格式: rpc 方法名(请求消息) returns (响应消息);
  rpc SayHello (HelloRequest) returns (HelloReply);
}

三、开发环境搭建

接下来我们分别介绍在 Windows、Linux、Mac 三大系统下的 gRPC Go 开发环境搭建步骤，你可以根据自己的系统选择对应的部分。

3.1 前置条件：安装 Go 语言

首先你需要安装 Go 语言环境，gRPC 要求 Go 版本 >= 1.19，推荐使用最新的稳定版本。

下载地址：Go 官方下载页
安装完成后，打开终端 / 命令行，执行 go version 验证是否安装成功：
1 2

go version # 输出类似: go version go1.22.0 linux/amd64

3.2 安装 Protobuf 编译器（protoc）

protoc 是 Protobuf 的编译器，用来把我们的 .proto 文件编译成不同语言的代码。

Linux 系统（Ubuntu/Debian）

使用 apt 包管理器直接安装：

sudo apt update
sudo apt install -y protobuf-compiler
# 验证安装
protoc --version
# 输出: libprotoc 3.xx.x，确保版本 >= 3.0

Mac 系统

使用 Homebrew 安装：

1
2
3

brew install protobuf
# 验证安装
protoc --version

Windows 系统

前往 Protobuf 发布页，下载对应 Windows 版本的压缩包，比如 protoc-xx.x-x-win64.zip
解压压缩包，把解压后的 bin 目录下的 protoc.exe 所在的路径添加到系统的 Path 环境变量中：
- 右键此电脑 -> 属性 -> 高级系统设置 -> 环境变量
- 在系统变量中找到 Path，点击编辑，添加 protoc.exe 所在的文件夹路径
打开新的命令行，执行 protoc --version 验证是否安装成功。

3.3 安装 Go 语言的 Protobuf 插件

protoc 本身只支持基础的 C++ 等语言，要生成 Go 语言的代码，我们需要安装两个 Go 专属的插件：

protoc-gen-go：用来生成基础的 Protobuf 消息结构代码
protoc-gen-go-grpc：用来生成 gRPC 的服务端和客户端代码

执行以下命令安装这两个插件：

# 安装基础的 Protobuf 插件
go install google.golang.org/protobuf/cmd/protoc-gen-go@latest

# 安装 gRPC 插件
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

安装完成后，需要把 Go 的二进制目录添加到系统的 PATH 环境变量中，这样系统才能找到这两个插件：

1
2
3

# 查看 Go 的 GOPATH 路径
go env GOPATH
# 输出类似: /home/user/go 或者 C:\Users\YourName\go

Linux/Mac：在终端中执行以下命令，或者把它添加到 ~/.bashrc 或 ~/.zshrc 中永久生效：
1

export PATH="$PATH:$(go env GOPATH)/bin"
Windows：把 %GOPATH%\bin（通常是 C:\Users\你的用户名\go\bin）添加到系统的 Path 环境变量中。

验证插件是否安装成功：

1
2
3

# 执行这两个命令，如果没有提示命令不存在，就说明安装成功了
protoc-gen-go --version
protoc-gen-go-grpc --version

四、实战入门：Hello World 示例

现在我们来完成一个最基础的 Hello World 示例，带你完整走一遍 gRPC 开发的全流程。

4.1 创建项目结构

首先创建我们的项目目录，结构如下：

grpc-hello/
├── go.mod
├── go.sum
├── proto/
│   └── helloworld.proto  # 我们的 proto 定义文件
├── server/
│   └── main.go           # 服务端代码
└── client/
    └── main.go           # 客户端代码

执行以下命令初始化项目：

# 创建项目文件夹
mkdir grpc-hello && cd grpc-hello

# 初始化 Go mod
go mod init github.com/yourname/grpc-hello

4.2 编写 Protobuf 定义文件

创建 proto/helloworld.proto 文件，写入以下内容：

syntax = "proto3";

package helloworld;

option go_package = "../pb;pb";

// 定义请求消息
message HelloRequest {
  string name = 1;
}

// 定义响应消息
message HelloReply {
  string message = 1;
}

// 定义 Greeter 服务
service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}

4.3 生成 Go 代码

现在我们使用 protoc 编译器，把上面的 .proto 文件编译成 Go 语言的代码。在项目根目录执行以下命令：

`1`	`protoc --go_out=. --go-grpc_out=. proto/helloworld.proto`

执行完成后，你会发现项目根目录下多了一个 pb 文件夹，里面有两个文件：

helloworld_grpc.pb.go：gRPC 相关的服务端、客户端代码
helloworld.pb.go：Protobuf 消息结构的代码

4.4 编写服务端代码

创建 server/main.go 文件，这是我们的 gRPC 服务端代码，用来处理客户端的请求：

package main

import (
	"context"
	"log"
	"net"

	"google.golang.org/grpc"
	pb "github.com/yourname/grpc-hello/pb" // 替换成你自己的模块路径
)

// 定义服务结构体，必须嵌入 pb.UnimplementedGreeterServer
// 这是为了兼容未来的接口扩展，保证向前兼容
type server struct {
	pb.UnimplementedGreeterServer
}

// 实现 SayHello 方法，这是我们在 proto 中定义的服务方法
func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
	// 打印收到的请求信息
	log.Printf("Received request from: %v", in.GetName())
	// 返回响应
	return &pb.HelloReply{Message: "Hello " + in.GetName()}, nil
}

func main() {
	// 监听 50051 端口，这是 gRPC 的默认端口
	lis, err := net.Listen("tcp", ":50051")
	if err != nil {
		log.Fatalf("failed to listen: %v", err)
	}

	// 创建 gRPC 服务端实例
	s := grpc.NewServer()
	// 把我们的服务注册到 gRPC 服务端中
	pb.RegisterGreeterServer(s, &server{})

	log.Printf("server listening at %v", lis.Addr())
	// 启动服务，开始处理请求
	if err := s.Serve(lis); err != nil {
		log.Fatalf("failed to serve: %v", err)
	}
}

4.5 编写客户端代码

创建 client/main.go 文件，这是我们的客户端代码，用来调用服务端的远程方法：

package main

import (
	"context"
	"log"
	"time"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
	pb "github.com/yourname/grpc-hello/pb" // 替换成你自己的模块路径
)

func main() {
	// 连接到 gRPC 服务端，这里我们连接本地的 50051 端口
	// 使用 insecure  credentials，因为我们的示例没有开启 TLS
	conn, err := grpc.Dial("localhost:50051", grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	// 函数结束时关闭连接
	defer conn.Close()

	// 创建 Greeter 客户端
	c := pb.NewGreeterClient(conn)

	// 设置超时时间，防止请求阻塞
	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()

	// 调用远程的 SayHello 方法
	r, err := c.SayHello(ctx, &pb.HelloRequest{Name: "World"})
	if err != nil {
		log.Fatalf("could not greet: %v", err)
	}

	// 打印响应结果
	log.Printf("Greeting: %s", r.GetMessage())
}

4.6 运行测试

现在我们来启动服务端，然后运行客户端，测试我们的 gRPC 服务。

首先启动服务端：
1

go run server/main.go
你会看到输出：server listening at [::]:50051，说明服务端已经启动成功了。
打开一个新的终端，运行客户端：
1

go run client/main.go
客户端会输出：Greeting: Hello World，说明调用成功了！
回到服务端的终端，你会看到服务端输出：Received request from: World，说明服务端成功收到了客户端的请求。

恭喜你！你已经成功运行了你的第一个 gRPC 应用！

五、Docker 容器化部署

当我们开发完成后，我们可以把我们的 gRPC 服务打包成 Docker 镜像，方便部署和分发。这里我们使用多阶段构建的方式，来最小化镜像的体积。

5.1 编写 Dockerfile

在项目的根目录创建 Dockerfile 文件，内容如下：

# 第一阶段：构建阶段，使用完整的 Go 环境来编译代码
FROM golang:1.22-alpine AS builder

# 设置工作目录
WORKDIR /app

# 复制 go.mod 和 go.sum，先下载依赖，利用 Docker 缓存
COPY go.mod go.sum ./
RUN go mod download

# 复制所有代码
COPY . .

# 编译代码，CGO_ENABLED=0 表示静态编译，不依赖动态库
# GOOS=linux 指定目标系统是 Linux
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o grpc-server ./server/main.go

# 第二阶段：运行阶段，使用极小的 alpine 镜像，只保留编译后的二进制文件
FROM alpine:latest

# 安装 ca-certificates，用于 TLS 证书验证
RUN apk --no-cache add ca-certificates

WORKDIR /root/

# 从构建阶段复制编译好的二进制文件
COPY --from=builder /app/grpc-server .

# 暴露服务端口
EXPOSE 50051

# 启动服务
CMD ["./grpc-server"]

5.2 构建 Docker 镜像

在项目根目录执行以下命令，构建 Docker 镜像：

`1`	`docker build -t grpc-hello-server:latest .`

这个命令会自动完成多阶段构建，最终生成的镜像体积非常小，通常只有十几 MB，比直接用 Go 基础镜像小了几十倍。

5.3 运行 Docker 容器

构建完成后，我们可以运行这个镜像，启动我们的 gRPC 服务：

`1`	`docker run -p 50051:50051 grpc-hello-server:latest`

这个命令会把容器的 50051 端口映射到主机的 50051 端口，这样我们就可以像之前一样，用本地的客户端来连接这个服务了。

5.4 测试容器化服务

现在你可以运行之前的客户端代码，来测试容器中的服务：

`1`	`go run client/main.go`

你会看到和之前一样的输出，说明容器化的服务已经正常工作了！

六、常见问题与排错

6.1 protoc: command not found

这说明系统找不到 protoc 命令，你需要检查：

是否已经正确安装了 protoc
是否把 protoc 的路径添加到了系统的 PATH 环境变量中

6.2 Plugin protoc-gen-go not found

这说明系统找不到 protoc-gen-go 插件，检查：

是否已经正确安装了插件
是否把 $GOPATH/bin 添加到了 PATH 环境变量中

6.3 模块路径错误

在导入 pb 包的时候，一定要替换成你自己的 go mod 初始化的模块路径，否则会出现导入错误。

6.4 连接超时

如果客户端连接服务端超时，检查：

服务端是否已经正常启动
端口是否正确，防火墙是否开放了对应的端口
如果是 Docker 部署，检查端口映射是否正确

总结

通过本指南，你已经完成了从 0 开始的 gRPC 学习，掌握了：

gRPC 和 Protobuf 的核心概念
三大系统下的开发环境搭建
完整的 gRPC 服务开发流程
Docker 容器化部署方案

接下来你可以继续深入学习 gRPC 的高级特性，比如 TLS 加密、认证拦截、流处理、负载均衡等，来构建生产级的微服务应用。

Instant Messaging System base Golang

Wed, 21 Jan 2026 15:10:42 +0800

即时通讯系统

系统架构

v0.1 基础server构建

此版本只有如下两个文件：

server.go

package main

import (
	"fmt"
	"net"
)

type Server struct {
	Ip   string
	Port int
}

// 创建一个server的接口
func NewServer(ip string, port int) *Server {
	server := &Server{ip, port}

	return server
}

func (this *Server) Handle(conn net.Conn) {
	// ...当前链接的业务
	fmt.Println("链接建立成功")
}

// 启动服务器的接口
func (this *Server) Start() {
	// socket listen，net.Listen用于创建套接字，参数为(network, address string)，返回值为(Listener, error)
	listener, err := net.Listen("tcp", fmt.Sprintf("%s:%d", this.Ip, this.Port))
	if err != nil {
		fmt.Println("net.Listen err:", err)
		return
	}
	// close listen socket
	defer fmt.Println("关闭链接")
	defer listener.Close()

	for {
		// accept，会返回一个连接Conn，和err
		conn, err := listener.Accept()
		if err != nil {
			fmt.Println("listener.Accept err:", err)
			continue
		}

		// do handler
		go this.Handle(conn)
	}

}

main.go

package main

func main() {
	server := NewServer("127.0.0.1", 8888)
	server.Start()
}

编译运行：

Linux系统：

1
2

go build -o server main.go server.go
server

Windows系统

1
2

go build -o server.exe main.go server.go
.\server.exe

最后运行测试的时候，根据系统输入如下指令进行测试：

Linux系统可以执行nc 127.0.0.1 8888
Windows系统可以执行curl 127.0.0.1:8888

若得到如下输出，则表示构建成功。

v0.2 用户上线及广播功能

user.go(新增)

user类型

type User struct {
	Name string
	Addr string
	C    chan string // 与用户通信的管道
	conn net.Conn    // 用户的网络连接
}

方法

创建一个用户的API

func NewUser(conn net.Conn) *User {
	userAddr := conn.RemoteAddr().String() // 获取用户的网络地址并转为字符串，作为用户名

	user := &User{
		Name: userAddr,
		Addr: userAddr,
		C:    make(chan string), // 创建一个用户消息管道
		conn: conn,              // 保存用户的网络连接
	}

	// 创建完用户对象后，就启动监听当前 User 的消息管道的 goroutine
	go user.ListenMessage()

	return user
}

监听当前User的channel的方法，一旦有消息，就发送给对端客户端

func (this *User) ListenMessage() {
	for {
		/*
			从 channel C 接收消息字符串 msg
			在消息末尾加换行符
			转换为字节切片
			通过网络连接发送给客户端
		*/

		msg := <-this.C

		this.conn.Write([]byte(msg + "\n")) // 将消息发送给客户端
		// 将字符串转换为字节切片（因为 Write() 方法需要接收字节切片）
	}
}

server.go

server类型：新增OnlineMap和Message属性

type Server struct {
	Ip   string
	Port int

	// 在线用户列表
	OnlineMap map[string]*User // map[key]value，key是用户名，value是User对象指针
	mapLock   sync.RWMutex     // 保护在线用户列表的锁

	// 消息广播的channel
	Message chan string
}

// 创建一个server的接口
func NewServer(ip string, port int) *Server {
	server := &Server{
		Ip:        ip,
		Port:      port,
		OnlineMap: make(map[string]*User),
		Message:   make(chan string),
	}

	return server
}

修改Handler方法

在处理客户端上线的Handler创建并添加⽤用户

func (this *Server) Handle(conn net.Conn) {
	// ...当前链接的业务
	fmt.Println("链接建立成功！")

	user := NewUser(conn)

	// 用户上线，将用户加入到OnlineMap中
	this.mapLock.Lock()
	this.OnlineMap[user.Name] = user
	this.mapLock.Unlock()

	// 广播当前用户上线消息
	this.BroadCast(user, "已上线\n")

	// 当前handler阻塞：若当前handler结束，则所有子go程也都会结束
	select {}
}

新增广播消息方法

// 广播消息的方法
func (this *Server) BroadCast(user *User, msg string) {
	sendMsg := "[" + user.Addr + "]" + user.Name + ":" + msg

	this.Message <- sendMsg
}

新增监听广播消息channel方法

// 监听Message广播消息channel的goroutine，一旦有消息就发送给全部的在线User
func (this *Server) ListenMessager() {
	for {
		msg := <-this.Message // 不断地从this.Message中读数据

		// 将msg发送给全部的在线User
		this.mapLock.Lock()
		for _, cli := range this.OnlineMap { // key:_  value:cli
			cli.C <- msg
		}
		this.mapLock.Unlock()
	}
}

修改Start方法

用一个goroutine单独监听Message

// 启动服务器的接口
func (this *Server) Start() {
	// socket listen，net.Listen用于创建套接字，参数为(network, address string)，返回值为(Listener, error)
	listener, err := net.Listen("tcp", fmt.Sprintf("%s:%d", this.Ip, this.Port))
	if err != nil {
		fmt.Println("net.Listen err:", err)
		return
	}
	// close listen socket
	defer fmt.Println("关闭连接")
	defer listener.Close()

	//--------------在此修改--------------
	// 启动监听Message的goroutine
	go this.ListenMessager()
	//------------------------------------

	for {
		// accept，会返回一个连接Conn，和err
		conn, err := listener.Accept()
		if err != nil {
			fmt.Println("listener.Accept err:", err)
			continue
		}

		// do handler
		go this.Handle(conn)
	}
}

测试

测试结果如下图所示，可以实现用户上线消息的广播。

v0.3 用户消息广播功能

此版本只需完善server.go中的handler方法即可。

func (this *Server) Handle(conn net.Conn) {
	// ...当前链接的业务
	fmt.Println("链接建立成功！")

	user := NewUser(conn)

	// 用户上线，将用户加入到OnlineMap中
	this.mapLock.Lock()
	this.OnlineMap[user.Name] = user
	this.mapLock.Unlock()

	// 广播当前用户上线消息
	this.BroadCast(user, "上线了\n")

	//--------------新增部分--------------
	// 接收客户端发送的消息：对socket进行基本的read操作
	go func() {
		buf := make([]byte, 4096)
		for {
			n, err := conn.Read(buf) // 从当前conn套接字中读取数据到buf中，返回值是读取的字节数n和错误信息err
			if n == 0 {
				this.BroadCast(user, "下线了\n")
				return
			}

			if err != nil && err != io.EOF {
				fmt.Println("Conn Read err:", err)
				return
			}

			// 提取用户的消息并去除结尾的'\n'
			msg := string(buf[:n-1])

			// 将得到的消息进行广播
			this.BroadCast(user, msg)
		}
	}()
	//---------------------------------

	// 当前handler阻塞：若当前handler结束，则所有子go程也都会结束
	select {}
}

测试 测试结果如下图所示，可以实现广播用户的信息，以及用户下线消息。

v0.4 用户业务封装

与v0.3的功能相同，主要是将用户上线下线以及发送消息的方法封装到user.go中。

user类添加新成员变量server

type User struct {
	Name string
	Addr string
	C    chan string // 与用户通信的管道
	conn net.Conn    // 用户的网络连接

	server *Server   // 所属服务器
}

新增Online方法

// 用户上线的业务
func (this *User) Online() {
	// 用户上线，将用户加入到OnlineMap中
	this.server.mapLock.Lock()
	this.server.OnlineMap[this.Name] = this
	this.server.mapLock.Unlock()

	// 广播当前用户上线消息
	this.server.BroadCast(this, "上线了\n")
}

新增Offline方法

// 用户下线的业务
func (this *User) Offline() {
	// 用户下线，将用户从OnlineMap中删除
	this.server.mapLock.Lock()
	delete(this.server.OnlineMap, this.Name)
	this.server.mapLock.Unlock()

	// 广播当前用户下线消息
	this.server.BroadCast(this, "下线了\n")
}

新增DoMessage方法

// 用户处理消息的业务
func (this *User) DoMessage(msg string) {
	this.server.BroadCast(this, msg)
}

替换

v0.5 在线用户查询

提供SendMsg向对象客户端发送消息API

// 给当前user对应的客户端发送消息
func (this *User) SendMsg(msg string) {
	this.conn.Write([]byte(msg))
}

在DoMessage方法中，加上对“who”指令的处理

// 用户处理消息的业务
func (this *User) DoMessage(msg string) {
	if msg == "who" {
		// 查询当前在线用户都有哪些
		this.server.mapLock.Lock()
		for _, user := range this.server.OnlineMap {
			onlineMesg := "[" + user.Addr + "]" + user.Name + ":" + "在线\n"
			this.SendMsg(onlineMesg)
		}
		this.server.mapLock.Unlock()

	} else {
		this.server.BroadCast(this, msg)
	}
}

一个小bug

需要注意的是，前面对用户输入的消息仅去掉了最末尾的’\n’，但这是不够的，因为Windows下默认的换行标识符是’\r\n’，因此需要去掉末尾的两个元素。

另外，不同操作系统的默认换行标识符也是不同的，若下图所示：

测试

**用户输入"who"即可查看当前在线用户。如此，即可实现查询在线用户的操作

v0.6 修改用户名

修改代码

// 用户处理消息的业务
func (this *User) DoMessage(msg string) {
	if msg == "who" {
		// 查询当前在线用户都有哪些
		this.server.mapLock.Lock()
		for _, user := range this.server.OnlineMap {
			onlineMesg := "[" + user.Addr + "]" + user.Name + ":" + "在线\n"
			this.SendMsg(onlineMesg)
		}
		this.server.mapLock.Unlock()
	} else if len(msg) > 7 && msg[:7] == "rename|" {
		// 消息格式：rename|张三
		// string.Split(msg, "sign")可以将字符串msg以sign为断点来切分，返回的是一个字符串数组
		newName := strings.Split(msg, "|")[1]

		// 判断name是否存在
		_, ok := this.server.OnlineMap[newName]
		if ok {
			this.SendMsg("当前用户名已被使用!\n")
		} else {
			this.server.mapLock.Lock()
			delete(this.server.OnlineMap, this.Name)
			this.server.OnlineMap[newName] = this
			this.server.mapLock.Unlock()

			this.Name = newName
			this.SendMsg("您已成功更新用户名:" + this.Name + "!\n")
		}
	} else {
		this.server.BroadCast(this, msg)
	}
}

测试

测试结果如下，成功实现修改用户名及Online Map操作：

v0.7 超时强踢功能

修改Handler方法

func (this *Server) Handler(conn net.Conn) {
	// ...当前链接的业务
	fmt.Println("链接建立成功！")

	user := NewUser(conn, this)

	user.Online()

	// -----------修改位置-----------
	// 监听用户是否活跃的channel
	isLive := make(chan bool)
	// -----------------------------

	// 接收客户端发送的消息：对socket进行基本的read操作
	go func() {
		buf := make([]byte, 4096)
		for {
			// 从当前conn套接字中读取数据到buf中，返回值是读取的字节数n和错误信息err
			n, err := conn.Read(buf)

			if n == 0 {
				user.Offline()
				return
			}

			if err != nil && err != io.EOF {
				fmt.Println("Conn Read err:", err)
				return
			}

			// 提取用户的消息并去除结尾的'\r\n'
			msg := string(buf[:n-2])

			// 用户针对msg进行消息处理
			user.DoMessage(msg)

			// 用户的任意消息，都能代表用户当前是活跃的
			isLive <- true
		}
	}()

	// -----------修改位置-----------
	// 当前handler阻塞：若当前handler结束，则所有子go程也都会结束
	for {
		select {
		case <-isLive:
			// 当前用户是活跃的，应该充值定时器
			// 不用做任何事情，只是为了结束本次的select，循环进入新的一个select，以重置下面的定时器，妙妙妙

		case <-time.After(time.Minute * 30): // time.After也是一个channel，作为计时器使用，这里计时30分钟，超时后channel中就会有一个数据
			// 已经超时
			// 将当前的user强制关闭

			user.SendMsg("由于长时间未操作，你被踢了。\n")

			// 销毁用户资源
			close(user.C)

			// 关闭连接
			conn.Close()

			// 退出当前handler
			// runtime.Goexit()
			return
		}
	}
	// -----------------------------
}

select在这个地方起到了非常妙的效果，具体详见注释。

测试

v0.8 用户私聊功能

修改DoMessage

此版本只需在DoMessage方法中新增一个分支即可：

// 用户处理消息的业务
func (this *User) DoMessage(msg string) {
	if msg == "who" {
		// 查询当前在线用户都有哪些
		this.server.mapLock.Lock()
		for _, user := range this.server.OnlineMap {
			onlineMesg := "[" + user.Addr + "]" + user.Name + ":" + "在线\n"
			this.SendMsg(onlineMesg)
		}
		this.server.mapLock.Unlock()
	} else if len(msg) > 4 && msg[:3] == "to|" {
		// 私聊消息格式：to|张三|消息内容

		// 1.获取对方用户名
		remoteName := strings.Split(msg, "|")[1]
		if remoteName == "" {
			this.SendMsg("消息格式不正确，请使用 \"to|张三|你好啊\"的格式.\n")
			return
		}
		// 2.根据用户名得到对方的User对象
		remoteUser, ok := this.server.OnlineMap[remoteName]
		if !ok {
			this.SendMsg(remoteName + "当前不在线!\n")
		}

		// 3.获取消息内容，通过对方的User对象将消息内容发送过去
		content := strings.Split(msg, "|")[2]
		if content == "" {
			this.SendMsg("无消息内容，请重发。\n")
			return
		}
		remoteUser.SendMsg(this.Name + "对您说：" + content + "\n")
	} else if len(msg) > 7 && msg[:7] == "rename|" {
		// 修改用户名消息格式：rename|张三
		// string.Split(msg, "sign")可以将字符串msg以sign为断点来切分，返回的是一个字符串数组
		newName := strings.Split(msg, "|")[1]

		// 判断name是否存在
		_, ok := this.server.OnlineMap[newName]
		if ok {
			this.SendMsg("当前用户名已被使用!\n")
		} else {
			this.server.mapLock.Lock()
			delete(this.server.OnlineMap, this.Name)
			this.server.OnlineMap[newName] = this
			this.server.mapLock.Unlock()

			this.Name = newName
			this.SendMsg("您已成功更新用户名:" + this.Name + "!\n")
		}
	} else {
		if msg == "" {
			this.SendMsg("无消息内容，请重发。\n")
			return
		}
		this.server.BroadCast(this, msg)
	}
}

测试

实现预期功能：

v0.9 客户端实现

v0.9.1 建立连接

在这个版本中，要新创建一个client.go。但当前服务器的ip和端口是写死的，在后续版本中会实现在客户端指定服务器的ip和端口。

定义client类型

type Client struct {
	ServerIp   string
	ServerPort int
	Name       string   // 重命名后在赋值
	conn       net.Conn // 连成功后再赋值
}

创建client对象，同时连接服务器

func NewClient(serverIp string, serverPort int) *Client {
	// 创建客户端对象
	client := &Client{
		ServerIp:   serverIp,
		ServerPort: serverPort,
	}

	// 连接server，net.Dial是 Go 语言 net 标准库中最核心的函数之一，用于从客户端发起一个网络连接。参数是协议和地址(network, address)，升级版本加了超时控制参数
	// conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", serverIp, serverPort))
	conn, err := net.DialTimeout("tcp", fmt.Sprintf("%s:%d", serverIp, serverPort), 5*time.Second)

	// 如果连接失败
	if err != nil {
		fmt.Println("net.DialTimeout error:", err)
		return nil
	}

	client.conn = conn

	// 返回对象
	return client
}

主业务创建client对象

func main() {
	client := NewClient("127.0.0.1", 8888)
	if client == nil {
		fmt.Println(">>>>> 连接服务器失败...")
		return
	}

	fmt.Println(">>>>> 连接服务器成功！")

	// 启动客户端的业务
	for {
	}
}

测试

v0.9.2 命令行解析

修改client.go

**NewClient方法无需修改，只需将NewClient方法之后的代码替换成如下代码即可。

// 定义了两个全局变量，用来存储最终要连接的 IP 和端口。
var serverIp string
var serverPort int

// init() 函数会在 main() 函数执行之前自动被调用。这确保了程序一开始就配置好了这些参数规则。
// flag包，用于实现命令行参数解析的功能，允许在运行程序（.exe）时，通过命令行动态地指定服务器的IP和端口，而不是把IP写死在代码里。
// .\client -ip 127.0.0.1 -port 8888
func init() {
	flag.StringVar(&serverIp, "ip", "127.0.0.1", "设置服务器IP地址(默认为127.0.0.1)")
	flag.IntVar(&serverPort, "port", 8888, "设置服务器IP地址(默认为8888)")
}

func main() {
	// 用于读取并解析用户输入的命令
	flag.Parse()

	// client := NewClient("127.0.0.1", 8888)
	client := NewClient(serverIp, serverPort)

	if client == nil {
		fmt.Println(">>>>> 连接服务器失败...")
		return
	}

	fmt.Println(">>>>> 连接服务器成功！")

	// 启动客户端的业务
	for {
	}
}

测试

v0.9.3 菜单显示

Client新增flag属性

type Client struct {
	ServerIp   string
	ServerPort int
	Name       string   // 重命名后在赋值
	conn       net.Conn // 连成功后再赋值
	flag       int      // 表示当前client的模式
}

func (client *Client) menu() bool {
	var flag int

	fmt.Println("1.公聊模式")
	fmt.Println("2.私聊模式")
	fmt.Println("3.更新用户名")
	fmt.Println("0.退出")

	fmt.Scanln(&flag)

	if flag >= 0 && flag <= 3 {
		client.flag = flag // flag合法，赋值给用户的状态
		return true
	} else {
		fmt.Println(">>>>>请输入合法范围内的谁<<<<<")
		return false
	}
}

新增Run主业务循环

func (client *Client) Run() {
	// 应该根据用户menu的提示结果来选择不同的模式

	for client.flag != 0 {
		for client.menu() != true {
		}

		// 根据不同的模式处理不同的业务
		// 在 Go 语言中的 switch 是默认不穿透的，每个 case 执行完后会自动退出，因此不需要显式地写 break。
		// 如果希望执行完 case 1 后，继续执行 case 2（就像 C 语言那样），就需要显式使用 fallthrough 关键字
		switch client.flag {
		case 1:
			// 公聊模式
			fmt.Println("公聊模式选择...")
			// fallthrough		// case穿透
		case 2:
			// 私聊模式
			fmt.Println("私聊模式选择...")
		case 3:
			// 更新用户名
			fmt.Println("更新用户名选择...")
		}
	}
}

测试

v0.9.4 更新用户名(封装版)

新增UpdateName()更新用户名

func (client *Client) UpdateName() bool {
	// 提示输入用户名->用户输入->发给服务器
	var name string
	fmt.Println(">>>>>请输入用户名,exit退出:")
	fmt.Scanln(&name)

	if name == "exit" {
		return false
	}

	client.Name = name

	sendMsg := "rename|" + client.Name + "\r\n"
	_, err := client.conn.Write([]byte(sendMsg))
	if err != nil {
		fmt.Println("conn.Write err:", err)
		return false
	}

	return true
}

把UpdateName加入到Run业务分支中

func (client *Client) Run() {
	// 应该根据用户menu的提示结果来选择不同的模式

	for client.flag != 0 {
		for client.menu() != true {
		}

		// 根据不同的模式处理不同的业务
		// 在 Go 语言中的 switch 是默认不穿透的，每个 case 执行完后会自动退出，因此不需要显式地写 break。
		// 如果希望执行完 case 1 后，继续执行 case 2（就像 C 语言那样），就需要显式使用 fallthrough 关键字
		switch client.flag {
		case 1:
			// 公聊模式
			fmt.Println("公聊模式选择...")
			// fallthrough		// case穿透
		case 2:
			// 私聊模式
			fmt.Println("私聊模式选择...")
		case 3:
			// 更新用户名
			// fmt.Println("更新用户名选择...")
			client.UpdateName()
		}
	}
}

添加处理server回执消息的DealResponse()方法

// 处理server回应的消息，直接显示到标准输出即可
func (client *Client) DealResponse() {
	// 建立一条直通管道，把服务器发来的所有原始数据，原封不动地直接打印到屏幕上
	// 一旦client.conn有数据，就直接copy到stdout标准输出上，io.Copy内部自带了一个死循环，永久阻塞监听
	io.Copy(os.Stdout, client.conn) // 不断阻塞等待client.conn中的数据，如果有数据就直接反倒os.Stdout中，而且是永久阻塞
}

在main方法中开启一个go，去承载DealResponse()流程

func main() {
	// 用于读取并解析用户输入的命令
	flag.Parse()

	// client := NewClient("127.0.0.1", 8888)
	client := NewClient(serverIp, serverPort)

	if client == nil {
		fmt.Println(">>>>> 连接服务器失败...")
		return
	}

	// 单独开启一个goroutine去从处理server的回执消息
	go client.DealResponse()

	fmt.Println(">>>>> 连接服务器成功！")

	// 启动客户端的业务
	client.Run()
}

测试

v0.9.5 封装版公聊、私聊、查询在线用户

公聊：新增PublicChat方法

func (client *Client) PublicChat() {
	// 提示输入消息内容->用户输入->发给服务器

	var chatMsg string
	fmt.Println(">>>>>请输入聊天内容,exit退出:")
	fmt.Scanln(&chatMsg)

	for chatMsg != "exit" {
		// 发送给服务器

		// 消息不为空则发送
		if len(chatMsg) != 0 {
			sendMsg := chatMsg + "\r\n"
			_, err := client.conn.Write([]byte(sendMsg))
			if err != nil {
				fmt.Println("conn.Write err:", err)
				break
			}
		}

		chatMsg = ""
		fmt.Println(">>>>>请输入聊天内容,exit退出:")
		fmt.Scanln(&chatMsg)
	}
}

私聊：新增PrivateChat方法

func (client *Client) PrivateChat() {
	// 提示输入消息内容->用户输入->发给服务器

	var chatName string
	var chatMsg string

	client.QueryOnline()
	fmt.Println(">>>>>请输入要私聊的用户名:")
	fmt.Scanln(&chatName)

	fmt.Println(">>>>>请输入与", chatName, "的聊天内容,exit退出:")
	fmt.Scanln(&chatMsg)

	for chatMsg != "exit" {
		// 发送给服务器

		// 消息不为空则发送
		if len(chatMsg) != 0 {
			sendMsg := "to" + "|" + chatName + "|" + chatMsg + "\r\n"
			_, err := client.conn.Write([]byte(sendMsg))
			if err != nil {
				fmt.Println("conn.Write err:", err)
				break
			}
		}

		chatMsg = ""
		fmt.Println(">>>>>请输入与", chatName, "的聊天内容,exit退出:")
		fmt.Scanln(&chatMsg)
	}
}

查询在线用户：新增QueryOnline方法

func (client *Client) QueryOnline() {
	// 查询当前在线用户
	sendMsg := "who\r\n"
	_, err := client.conn.Write([]byte(sendMsg))
	if err != nil {
		fmt.Println("conn.Write err:", err)
		return
	}
}

调用这些方法：修改Run中的分支

func (client *Client) Run() {
	// 应该根据用户menu的提示结果来选择不同的模式

	for client.flag != 0 {
		for client.menu() != true {
		}

		// 根据不同的模式处理不同的业务
		// 在 Go 语言中的 switch 是默认不穿透的，每个 case 执行完后会自动退出，因此不需要显式地写 break。
		// 如果希望执行完 case 1 后，继续执行 case 2（就像 C 语言那样），就需要显式使用 fallthrough 关键字
		switch client.flag {
		case 1:
			// 公聊模式
			// fmt.Println("公聊模式选择...")
			client.PublicChat()
			// fallthrough		// case穿透
		case 2:
			// 私聊模式
			// fmt.Println("私聊模式选择...")
			client.PrivateChat()
		case 3:
			// 更新用户名
			// fmt.Println("更新用户名选择...")
			client.UpdateName()
		case 4:
			// 查询在线用户
			fmt.Println("当前在线的用户有...")
			client.QueryOnline()
		}
	}
}

此外，优化了菜单的显示方式

func (client *Client) menu() bool {
	var flag int

	menuContent := []string{
		"1.公聊模式",
		"2.私聊模式",
		"3.更新用户名",
		"4.查询在线用户",
		"0.退出",
	}
	menuSize := len(menuContent)

	for _, line := range menuContent {
		fmt.Println(line)
	}

	// fmt.Println("1.公聊模式")
	// fmt.Println("2.私聊模式")
	// fmt.Println("3.更新用户名")
	// fmt.Println("4.查询在线用户")
	// fmt.Println("0.退出")

	fmt.Scanln(&flag)

	if flag >= 0 && flag < menuSize {
		client.flag = flag // flag合法，赋值给用户的状态
		return true
	} else {
		fmt.Println(">>>>>请输入合法范围内的数字<<<<<")
		return false
	}
}

测试

完结撒花

此文档根据B站刘丹冰老师的《8小时转职Golang工程师(如果你想低成本学习Go语言)》教程构建了一个即时通讯系统，但目前只有命令行的操作方式，未来或许会新增GUI版本，敬请期待。

源码地址：

Github：https://github.com/SymphonyW/IM-System.git
可运行git clone https://github.com/SymphonyW/IM-System.git直接拉去
百度网盘：https://pan.baidu.com/s/1j_cU9qtjDnDy_fmVYBX1Mw?pwd=3v17 提取码: 3v17

Golang Learning Note

Wed, 21 Jan 2026 13:54:12 +0800

This blog is used to record notes while learning Golang. Video URL: https://www.bilibili.com/video/BV1gf4y1r79E?spm_id_from=333.788.videopod.episodes&vd_source=a28b0a61baf52e2de1f7120e1c9d88e1 Video Author: Liu Danbing

Go学习笔记

第一部分

基本结构

main函数不能有形参和返回值

// 程序入口
package main

// fmt 常用标准库
import "fmt"

func main() {
    fmt.Println("Hello World!")

    return 0
}

变量声明方式、赋值方式

默认0

1
2
3

    var a int
    fmt.Println("a =", a)
    fmt.Printf("type of a: %T\n", a)

赋初值

1
2
3

    var b int = 100
    fmt.Println("b =", b)
    fmt.Printf("type of b: %T\n", b)

省去类型名，类似python

1
2
3

    var c = 200
    fmt.Println("c =", c)
    fmt.Printf("type of c: %T\n", c)

省去var（最常用方法），直接自动匹配

1
2
3

    d := 300
    fmt.Println("d =", d)
    fmt.Printf("type of d: %T\n", d)

注：此方式不可用于声明全局变量

常量声明方式、iota的用法

// const和iota
// const就是定义变量时把var换成const
const PI = 3.1415926

// iota初值为0，往下每行自增1，用于给多个常量赋值
const (
    BEIJING = 10 * iota
    SHANGHAI
    SHENZHEN
)
const (
    a, b = iota + 1, iota + 2 // iota = 0,a = 1,b = 2
    c, d                      // iota = 1,c = 2,d = 3
    e, f                      // iota = 2,e = 3,f = 4

    g, h = iota * 2, iota * 3 // iota = 3,g = 6,h = 9
    i, j                      // iota = 4,i = 8,j = 12
)

函数、返回值

单返回值函数

go中的函数参数关键字func在前，类型名与返回值皆在后

func foo1(a string, b int) int {
    fmt.Println("====foo1====")
    fmt.Println("a =", a, ", b=", b)
    c := 100

    return c
}

多返回值函数(1)

多返回值就用括号包起来

func foo2(a string, b int) (int, int) {
    fmt.Println("====foo2====")
    fmt.Println("a =", a, ", b=", b)
    c := 100

    return c, c + 10
}

多返回值函数(2)

go中的函数参数关键字func在前，类型名与返回值皆在后

func foo3(a string, b int) (r1 int, r2 int) {
    fmt.Println("====foo3====")
    fmt.Println("a =", a, ", b=", b)

    //c := 100
    //return c, c + 10

    // 或者给有名称的返回值赋值
    fmt.Println("r1 =", r1, ", r2 =", r2) // r1,r2属于foo3的形参，初始化默认为0
    r1 = 100
    r2 = 200

    return
}

多返回值函数(3)

go中的函数参数关键字func在前，类型名与返回值皆在后

func foo4(a string, b int) (r1, r2 int) {
    fmt.Println("====foo4====")
    fmt.Println("a =", a, ", b =", b)

    //c := 100
    //return c, c + 10

    // 或者给有名称的返回值赋值
    r1 = 100
    r2 = 200

    return
}

import时init方法调用流程

import匿名及别名导包形式

匿名导包

匿名导包用 _ 表示，可以导入某个包但不使用

import _ "fmt"

func main() {
	// 不会报未使用的错
}

别名导包

匿名导包用 . 表示，使用包中的方法时无需指明是哪个包的方法

import . "fmt"

func main() {
	Println("hello world")
    // fmt.Println("hello world")
}

defer语句

defer是在某个函数要结束时执行的语句，多个defer会用过压栈再出栈的顺序执行. 最终的执行顺序应该是func3 -> func2 -> func1。

值得注意的是，当defer和return同时存在时，也是先执行return再执行defer。

func returnFunc() int {
	fmt.Println("this is returnFunc")
	return 0
}
func deferFunc() {
	fmt.Println("this is deferFunc")
}
func test() int {
	defer deferFunc()
	return returnFunc()
}

执行函数test后，输出的结果是：

1
2

this is returnFunc
this is deferFunc

第二部分

数组的定义

// 固定长度数组在函数中的参数类型必须一致，且传参是以复制的形式
func test1(myArray [5]int) {
	fmt.Printf("myArray = %v\n", myArray) // %v 表示输出：详细信息
}

func main() {
	//定长数组
	var myArray [5]int

	fmt.Println("myArray =", myArray) // 默认全0：[0 0 0 0 0]

	myArray1 := [10]int{1, 2, 3, 4, 5}
	fmt.Println("myArray1 =", myArray1) // 未赋值的位置全0：[1 2 3 4 5 0 0 0 0 0]

	// for循环写法
	for i := 0; i < len(myArray); i++ {
		fmt.Printf("myArray[%d]=%d", i, myArray[i])
	}
	fmt.Printf("\n")
	for index, value := range myArray1 {
		fmt.Printf("myArray[%d]=%d", index, value)
	}
	fmt.Printf("\n")
	// _ 用于表示匿名变量，不会被使用
	for _, value := range myArray1 {
		fmt.Printf("myArray1[%d]=%d", value, value)
	}
	fmt.Printf("\n")

	// 变长数组
	arr := make([]int, 10) // 默认全0
	fmt.Printf("arr=%v\n", arr)

	// 查看数组的数据类型
	fmt.Printf("myArray types = %T\n", myArray)   // 数据类型为[5]int
	fmt.Printf("myArray1 types = %T\n", myArray1) // 数据类型为[10]int\

	test1(myArray)
}

输出：

myArray = [0 0 0 0 0]
myArray1 = [1 2 3 4 5 0 0 0 0 0]
myArray[0]=0myArray[1]=0myArray[2]=0myArray[3]=0myArray[4]=0
myArray[0]=1myArray[1]=2myArray[2]=3myArray[3]=4myArray[4]=5myArray[5]=0myArray[6]=0myArray[7]=0myArray[8]=0myArray[9]=0
myArray1[1]=1myArray1[2]=2myArray1[3]=3myArray1[4]=4myArray1[5]=5myArray1[0]=0myArray1[0]=0myArray1[0]=0myArray1[0]=0myArray1[0]=0
arr=[0 0 0 0 0 0 0 0 0 0]
myArray types = [5]int
myArray1 types = [10]int
myArray = [0 0 0 0 0]

数组的复制

浅拷贝

    arr1 := []int{1, 2, 3, 4}
    fmt.Printf("arr1=%v\n", arr1)

    arr2 := arr1
    fmt.Printf("arr2=%v\n", arr2)

    arr1[0] = 999
    fmt.Printf("arr1=%v\n", arr1)
    fmt.Printf("arr2=%v\n", arr2)

    fmt.Printf("%p\n", arr1)
    fmt.Printf("%p\n", arr2)

输出：

arr1=[1 2 3 4]
arr2=[1 2 3 4]
arr1=[999 2 3 4]
arr2=[999 2 3 4]
0xc0000141e0
0xc0000141e0

深拷贝(copy)

    arr1 := []int{1, 2, 3, 4}
    fmt.Printf("arr1=%v\n", arr1)

    arr2 := make([]int, 3)
    copy(arr2, arr1)
    fmt.Printf("arr2=%v\n", arr2)
    arr3 := make([]int, 10)
    copy(arr3, arr1)
    fmt.Printf("arr3=%v\n", arr3)

    arr1[0] = 999
    fmt.Printf("arr1=%v\n", arr1)
    fmt.Printf("arr2=%v\n", arr2)
    fmt.Printf("arr3=%v\n", arr3)

    fmt.Printf("%p\n", arr1)
    fmt.Printf("%p\n", arr2)
    fmt.Printf("%p\n", arr3)

输出：

arr1=[1 2 3 4]
arr2=[1 2 3]
arr3=[1 2 3 4 0 0 0 0 0 0]
arr1=[999 2 3 4]
arr2=[1 2 3]
arr3=[1 2 3 4 0 0 0 0 0 0]
0xc0000141e0
0xc000010150
0xc0000121e0

参数为数组的函数写法及修改的情况

func test1(arr1 []int) {
    arr1 = append(arr1, 10)    // 无法得到append后的数组
}
func test2(arr1 []int) []int {
    arr1 = append(arr1, 10)    // 通过返回值接收，可以得到append后的数组
    return arr1
}
func test3(arr1 []int) {
    arr1[0] = 1                   // 可以得到修改后的数组，因此是通过引用传递的参数
}
func main() {
    arr1 := make([]int, 6)

    test1(arr1)
    fmt.Printf("arr1 = %d\n", arr1)

    arr1 = test2(arr1)
    fmt.Printf("arr1 = %d\n", arr1)

    test3(arr1)
    fmt.Printf("arr1 = %d\n", arr1)
}

输出：

1
2
3

arr1 = [0 0 0 0 0 0]
arr1 = [0 0 0 0 0 0 10]
arr1 = [1 0 0 0 0 0 10]

切片slice的尺寸和容量，以及判空

func main() {
    slice1 := []int{1, 2, 3, 4, 5}
    fmt.Printf("slice1=%v, size=%d, cap=%d\n", slice1, len(slice1), cap(slice1))

    slice2 := make([]int, 4)
    fmt.Printf("slice2=%v, size=%d, cap=%d\n", slice2, len(slice2), cap(slice2)) // 默认状态下cap等于size

    slice3 := make([]int, 3, 5) // make(dataType,size,cap)
    fmt.Printf("slice3=%v, size=%d, cap=%d\n", slice3, len(slice3), cap(slice3)) // 指定状态下cap大于等于size

    slice1 = append(slice1, 9)
    fmt.Printf("slice1=%v, size=%d, cap=%d\n", slice1, len(slice1), cap(slice1)) // cap不足时，cap翻倍，与cpp的vector类似

    // 判断一个slice是否为0
    var slice []int
    if slice == nil {
       fmt.Printf("slice is nil\n")
    } else {
       fmt.Printf("slice is %v\n", slice)
    }
}

输出：

slice1=[1 2 3 4 5], size=5, cap=5
slice2=[0 0 0 0], size=4, cap=4
slice3=[0 0 0], size=3, cap=5
slice1=[1 2 3 4 5 9], size=6, cap=10
slice is nil

切片截取（设置上下限）

func main() {
    slice1 := []int{1, 2, 3, 4, 5}

    fmt.Printf("slice1[0:3] = %d\n", slice1[0:3]) // 左闭右开的区间
    fmt.Printf("slice1[:3] = %d\n", slice1[:3])   // 左边不填默认为0
    fmt.Printf("slice1[1:] = %d\n", slice1[1:])   // 右边不填默认为len(slice)

    slice2 := slice1[0:3]
    fmt.Printf("slice2 = %d\n", slice2)
}

输出：

slice1[0:3] = [1 2 3]
slice1[:3] = [1 2 3]
slice1[1:] = [2 3 4 5]
slice2 = [1 2 3]

map的声明、赋值和遍历

第一种声明方式：先声明，再make

    // 声明myMap1是一种map类型，key是int，value是string
    var myMap1 map[int]string
    if myMap1 == nil {
       fmt.Printf("mymap1 is nil\n")
       myMap1 = make(map[int]string, 10)
    }

    myMap1[1] = "Beijing"
    myMap1[2] = "Shanghai"
    myMap1[3] = "Guangzhou"
    myMap1[4] = "Shenzhen"
    myMap1[5] = "Iceland"

    fmt.Println(myMap1)

    for k, v := range myMap1 {
       fmt.Println(k, v)
    }

输出：

mymap1 is nil
map[1:Beijing 2:Shanghai 3:Guangzhou 4:Shenzhen 5:Iceland]
3 Guangzhou
1 Beijing
2 Shanghai
4 Shenzhen
5 Iceland

第二种声明方式：直接make

    myMap2 := make(map[int]string)
    myMap2[1] = "Beijing"
    myMap2[2] = "Shanghai"
    myMap2[3] = "Guangzhou"
    myMap2[4] = "Shenzhen"
    myMap2[5] = "Iceland"

    fmt.Println(myMap2)

输出：

`1`	`map[1:Beijing 2:Shanghai 3:Guangzhou 4:Shenzhen 5:Iceland]`

第三种声明方式：声明、赋值同时进行

	myMap3 := map[int]string{
		1: "Beijing",
		2: "Shanghai",
		3: "Guangzhou",
		4: "Shenzhen",
		5: "Iceland",
	}

	fmt.Println(myMap3)

输出：

`1`	`map[1:Beijing 2:Shanghai 3:Guangzhou 4:Shenzhen 5:Iceland]`

map的增删改查

        myMap := map[int]string{
           1: "Beijing",
           2: "Shanghai",
           3: "Guangzhou",
           4: "Shenzhen",
           5: "Iceland",
        }
        fmt.Println(myMap)
    
        // 添加
        myMap[6] = "NewYork"
        fmt.Println(myMap)
    
        // 删除
        delete(myMap, 3)
        fmt.Println(myMap)
    
        // 修改
        myMap[2] = "Tokyo"
        fmt.Println(myMap)
    
        // 遍历
        for key, value := range myMap {
           fmt.Println(key, value)
        }

输出

map[1:Beijing 2:Shanghai 3:Guangzhou 4:Shenzhen 5:Iceland]
map[1:Beijing 2:Shanghai 3:Guangzhou 4:Shenzhen 5:Iceland 6:NewYork]
map[1:Beijing 2:Shanghai 4:Shenzhen 5:Iceland 6:NewYork]
map[1:Beijing 2:Tokyo 4:Shenzhen 5:Iceland 6:NewYork]
4 Shenzhen
5 Iceland
6 NewYork
1 Beijing
2 Tokyo

第三部分

struct基本定义与使用

// 声明一种新的数据类型
type myInt int

// 定义一个结构体
type Book struct {
    title  string
    author string
}

func main() {
    var a myInt = 66
    fmt.Println(a)

    var book1 Book
    book1.title = "Go Programming Language"
    book1.author = "www.golang.com"
    fmt.Printf("%v\n", book1)
    fmt.Printf("book1.title:%s, book1.author:%s\n", book1.title, book1.author)
}

输出

1
2
3

66
{Go Programming Language www.golang.com}
book1.title:Go Programming Language, book1.author:www.golang.com

类的表示与封装

值得注意的是，Go与cpp不同，cpp是显式定义类的成员类型(public、private)，而Go是通过首字母是否大写来表示是否是public。

// 如果类名首字母大写，表示其他包也能够访问
type Hero struct {
    // 如果说类的属性首字母大写，表示该属性是对外能够访问的(public)，否则只能在类的内部使用(private)
    Name  string
    Ad    int
    Level int
}

// hero Hero表示当前函数绑定在调用这个函数的Hero对象中，其实也就是一个参数，所以最好传指针进去
// 相当于cpp中类里的成员函数
func (hero *Hero) GetName() string {
    fmt.Println("Name:", hero.Name)
    return hero.Name
}

func (hero *Hero) Show() {
    fmt.Println("Hero:", hero.Name)
    fmt.Println("Ad:", hero.Ad)
    fmt.Println("Level:", hero.Level)
}

//  func (hero Hero) SetName(newName string) {
//     //hero 是调用该方法的对象的一个副本(浅拷贝)
//     hero.Name = newName
//  }

// 最好是使用hero *Hero来绑定
func (hero *Hero) SetName(newName string) {
    //this 是调用该方法的对象的一个副本(浅拷贝)
    hero.Name = newName
}

func main() {
    // 创建一个对象
    hero := Hero{Name: "Spider-Man", Ad: 5, Level: 1}

    hero.Show()

    fmt.Println(hero.GetName())
    hero.SetName("wxz")
    fmt.Println(hero.GetName())
}

输出

Hero: Spider-Man
Ad: 5
Level: 1
Name: Spider-Man
Spider-Man
Name: wxz
wxz

继承的语法

type Human struct {
    name string
    sex  string
}

func (h *Human) Eat() {
    fmt.Printf("Human.Eat()...\n")
}

func (h *Human) Walk() {
    fmt.Printf("Human.Walk()...\n")
}

// ================================
// 子类
type Superman struct {
    Human // Superman类继承了Human类的属性和方法
    level int
}

// 重写父类的方法
func (s *Superman) Walk() {
    fmt.Printf("Superman.Walk()...\n")
}

//func (s *Superman) Eat() {
//  fmt.Printf("Superman.Eat()...\n")
//}

func (s *Superman) Show() {
    fmt.Println(s.name)
    fmt.Println(s.sex)
    fmt.Println(s.level)
}

func main() {
    h := Human{"zhang3", "male"}
    h.Eat()
    h.Walk()

    //s := Superman{Human{"lisi", "male"}, 5}
    var s Superman
    s.name = "lisi"
    s.sex = "male"
    s.level = 5

    s.Show() // 子类的方法
    s.Eat()  // 父类的方法
    s.Walk() // 子类的方法
}

输出

Human.Eat()...
Human.Walk()...
lisi
male
5
Human.Eat()...
Superman.Walk()...

面向对象多态的实现与基本要素

先定义一下接口和具体的类，接口的本质是一个指针。

type Animal interface {
    Sleep()
    GetColor() string
    GetType() string
}

具体的类必须要重写接口中所有的方法，如果没有重写完全的话，接口的指针就无法指向具体的类。

cat类：

type Cat struct {
    Color string
}

func (cat *Cat) Sleep() {
    fmt.Printf("Cat is sleeping...\n")
}
func (cat *Cat) GetColor() string {
    return cat.Color
}
func (cat *Cat) GetType() string {
    return "Cat"
}

dog类：

type Dog struct {
    Color string
}

func (dog *Dog) Sleep() {
    fmt.Printf("Dog is sleeping...\n")
}
func (dog *Dog) GetColor() string {
    return dog.Color
}
func (dog *Dog) GetType() string {
    return "Dog"
}

具体用法

func main() {
    // 父类对象指针指向子类指针，调用的方法是子类的方法
    var animal Animal
    animal = &Cat{"red"}
    animal.Sleep()

    animal = &Dog{"yellow"}
    animal.Sleep()
}

输出：

1
2

Cat is sleeping...
Dog is sleeping...

// 注意，这边的Animal接口类本质是一个指针，所有传参时应该穿指针进去
func ShowAnimal(animal Animal) {
    animal.Sleep()
    fmt.Println(animal.GetColor())
    fmt.Println(animal.GetType())
}

func main() {
    // 可以定义具体的类然后取地址
    cat := Cat{"red"}
    dog := Dog{"yellow"}
    ShowAnimal(&cat)
    fmt.Printf("==============\n")
    ShowAnimal(&dog)
    fmt.Printf("==============\n")

    // 也可以直接定义类的指针然后传指针
    catP := &Cat{"red"}
    dogP := &Dog{"yellow"}
    ShowAnimal(catP)
    fmt.Printf("==============\n")
    ShowAnimal(dogP)
}

输出：

Cat is sleeping...
red
Cat
==============
Dog is sleeping...
yellow
Dog
==============
Cat is sleeping...
red
Cat
==============
Dog is sleeping...
yellow
Dog

interface空接口万能类型与类型断言机制

interface空接口

interface{}是万能数据类型

// interface{}是万能数据类型
func myFunc(arg interface{}) {
	fmt.Println("myFunc is called...")
	fmt.Println(arg)
	fmt.Println("type of arg: ", reflect.TypeOf(arg))
	// 或者是
	// fmt.Printf("type of d: %T\n", arg)
}
func main() {
	myFunc(1)
	myFunc("Hello World")
	myFunc(true)
}

输出：

myFunc is called...
1
type of arg:  int
myFunc is called...
Hello World
type of arg:  string
myFunc is called...
true
type of arg:  bool

类型断言机制

interface{}提供“类型断言”的机制，用于区分此时引用的底层数据类型到底是什么

// interface{}是万能数据类型
func myFunc(arg interface{}) {
	value, ok := arg.(int)
	if !ok {
		fmt.Println("arg is not int type")
	} else {
		fmt.Println("arg is int type, value is: ", value)
	}
}

func main() {
	myFunc(1)
	myFunc("Hello World")
	myFunc(true)
}

输出：

1
2
3

arg is int type, value is:  1
arg is not int type
arg is not int type

变量内置的pair结构详细说明

在 Go 中，一个接口变量（interface variable）在运行时内部可以看作是一个pair：(Type, Value)

Type(动态类型)：这是接口实际持有的具体类型（例如 *Book）。
Value (动态值)：这是持有具体数据的指针或值的副本。

定义接口与结构体

type Reader interface { ReadBook() }
type Writer interface { WriteBook() }
type Book struct {}

// *Book 实现了 Reader 接口
func (b *Book) ReadBook() { fmt.Println("Read a book.") }
// *Book 实现了 Writer 接口
func (b *Book) WriteBook() { fmt.Println("Write a book.") }

这里 *Book（Book 的指针类型）同时实现了 Reader 和 Writer 两个接口的全部方法。这意味着 *Book 类型的变量既可以赋值给 Reader，也可以赋值给 Writer。

func main() {
	// b: pair<type:Book, value:book{}地址>
	b := &Book{"To Live"}

	// r: pair<type: , value: >
	var r Reader
	fmt.Println(reflect.TypeOf(r), r)
	// r: pair<type:Book, value:book{}地址>
	r = b
	fmt.Println(reflect.TypeOf(r), r)
	r.ReadBook()

	// w: pair<type: , value: >
	var w Writer
	fmt.Println(reflect.TypeOf(w), w)
	// w: pair<type:Book, value:book{}地址>
	w = r.(Writer)
	fmt.Println(reflect.TypeOf(w), w)
	w.WriteBook()
}

输出：

<nil> <nil>
*main.Book &{To Live}
Read a book.
<nil> <nil>
*main.Book &{To Live}
Write a book.

从上面的输出可以看出，接口类在未赋值时的pair为(nil,nil)。我们可以把 r 和 w 想象成两个不同的“窗口”，它们看着同一个“房间”（具体的 Book 对象）：

b (具体指针):

指向内存中的 Book{}。

r (Reader 接口):

动态类型: *Book
动态值: 指向 b
能力: 只能看见 ReadBook()

w (Writer 接口):

(通过 r.(Writer) 转换而来)
动态类型: *Book (和 r 一样！)
动态值: 指向 b (和 r 一样！)
能力: 只能看见 WriteBook()

反射reflect机制用法

反射基本类型

reflect.TypeOf() 用于获取变量的类型
reflect.ValueOf() 用于获取变量的值

// interface{}作为万能类型，类似模板
func reflectNum(arg interface{}) {
	fmt.Println("type : ", reflect.TypeOf(arg))
	fmt.Println("value : ", reflect.ValueOf(arg))
}
func main() {
	var num float64 = 3.1415926

	reflectNum(num)
}

输出：

1
2

type :  float64
value :  3.1415926

反射复杂类型

type User struct {
	Id   int
	Name string
	Age  int
}

func (u *User) Call() {
	fmt.Println("user is called ..")
	fmt.Printf("%v\n", u)
}
func (u User) Display() {
	fmt.Println("user is displayed ..")
	fmt.Printf("%v\n", u)
}

func DoFiledAndMethod(input interface{}) {
	//获取input的type
	inputType := reflect.TypeOf(input)
	fmt.Println("inputType : ", inputType)

	//获取input的value
	inputValue := reflect.ValueOf(input)
	fmt.Println("inputValue : ", inputValue)

	//通过type获取里面的字段
	//1. 获取interface的reflect.Type，通过Type得到NumField，进行遍历
	//2. 得到每个field，数据类型
	//3. 通过field有一个Interface()方法得到对应的value
	for i := 0; i < inputType.NumField(); i++ {
		field := inputType.Field(i)
		value := inputValue.Field(i).Interface()

		// 变量名 变量类型：变量的值
		fmt.Printf("%s %s: %v\n", field.Name, field.Type, value)
	}

	//通过type获取里面的方法，调用
	fmt.Println(inputType.NumMethod())
 	// 这里得到的是1，因为Call方法是绑定在*User类型上的，而本方法中reflect.TypeOf()传的是User类型，所以不会计算Call方法
	
 	for i := 0; i < inputType.NumMethod(); i++ {
		method := inputType.Method(i)
		fmt.Printf("%s %s: %v\n", method.Name, method.Type, method.Func)
	}
    
}
func main() {
	user := User{1, "wxz", 22}

	DoFiledAndMethod(user)
}

输出：

inputType :  main.User
inputValue :  {1 wxz 22}
Id int: 1
Name string: wxz
Age int: 22
1
Display func(main.User): 0x7ff7b08a24e0

结构体标签

相当于注释

type Resume struct {
	Name string `info:"name" doc:"我的名字"`
	Sex  string `info:"sex"`
}

func findTag(str interface{}) {
	//t := reflect.TypeOf(str).Elem() // Elem()表示当前结构体的所有元素，其作用是获取指针指向的元素，或者容器（如 Map、Slice、Array、Chan）里的元素类型。
	t := reflect.TypeOf(str)

	for i := 0; i < t.NumField(); i++ {
		taginfo := t.Field(i).Tag.Get("info")
		tagdoc := t.Field(i).Tag.Get("doc")
		fmt.Println("info:", taginfo, " doc:", tagdoc)
	}
}
func main() {
	var re Resume
	re = Resume{"wxz", "male"}

	findTag(re)
}

输出：

1
2

info: name  doc: 我的名字
info: sex  doc:

结构体标签在json中的应用

前置准备（导包，创建结构体）：

import (
	"encoding/json"
	"fmt"
)

type Movie struct {
	Title  string   `json:"title"`
	Year   int      `json:"year"`
	Price  int      `json:"rmb"`
	Actors []string `json:"actors"`
}

编码的过程结构体—> json

movie := Movie{"喜剧之王", 2000, 10, []string{"xingye", "zhangbozhi"}}

	// 编码的过程  结构体---> json
	jsonStr, err := json.Marshal(movie)

	if err != nil {
		fmt.Println("json marshal error:", err)
		return
	}

	// 这边输出的字段的名称就是上面在结构体中写的标签
	fmt.Println("jsonStr =", string(jsonStr))
	// 或者 fmt.Printf("jsonStr = %s\n", string(jsonStr))

输出如下，可以复制到json在线解析的网站中验证：

`1`	`jsonStr = {"title":"喜剧之王","year":2000,"rmb":10,"actors":["xingye","zhangbozhi"]}`

解码的过程 jsonstr—> 结构体

	//jsonStr = {"title":"喜剧之王","year":2000,"rmb":10,"actors":["xingye","zhangbozhi"]}
	my_movie := Movie{}
	err = json.Unmarshal(jsonStr, &my_movie)
	if err != nil {
		fmt.Println("json unmarshal error:", err)
		return
	}
	fmt.Printf("%#v\n", my_movie)
	fmt.Printf("%v\n", my_movie)

输出：

1
2

main.Movie{Title:"喜剧之王", Year:2000, Price:10, Actors:[]string{"xingye", "zhangbozhi"}}
{喜剧之王 2000 10 [xingye zhangbozhi]}

第四部分

goroutine基本模型和调度设计策略

在go中把协程co-routine做了一些修改，包括内存占用和名字（goroutine）。

最大支持GOMAXPROCS个goroutine并行

创建goroutine

// 子goroutine
func newTask() {
	i := 0
	for { // 死循环
		i++
		fmt.Printf("new Goroutine : i = %d\n", i)
		time.Sleep(1 * time.Second)
	}
}

// 主goroutine
func main() {
	// go关键字：创建一个go程，去执行newTask() 流程
	go newTask()

	i := 0
	for { // 死循环
		i++
		fmt.Printf("main Goroutine : i = %d\n", i)
		time.Sleep(1 * time.Second)
	}
}

输出：

main Goroutine : i = 1
new Goroutine : i = 1
new Goroutine : i = 2
main Goroutine : i = 2
new Goroutine : i = 3
main Goroutine : i = 3
...
...

也可以用匿名函数创建goroutine

// 主goroutine
func main() {

	// 用go创建承载一个形参为空，返回值为空的一个函数
	go func() {
		defer fmt.Println("A.defer")

		func() {
			defer fmt.Println("B.defer")
			// 退出当前goroutine
			runtime.Goexit()
			fmt.Println("B")
		}()

		fmt.Println("A")
		//// 退出当前goroutine
		//runtime.Goexit()

	}() // 最后这对括号用于传参

	go func(a int, b int) bool {
		fmt.Println("a = ", a, "b = ", b)
		return true
	}(10, 20)

	for {
		time.Sleep(1 * time.Second)
	}
}

输出：

B
B.defer
A
A.defer
a =  10 b =  20

其中，下面这条语句用于退出当前goroutine

`1`	`runtime.Goexit()`

channel的基本定义和使用

无缓冲channel

无缓冲的channel若只有写没有读，则写go程会阻塞；如果只有读没有写，则读go程会阻塞。

	// 定义一个无缓冲区的channel，channel就是一个数据结构，且能够保证goroutine间的同步和互斥
	c := make(chan int)

	go func() {
		defer fmt.Println("goroutine结束")

		fmt.Println("goroutine 正在运行...")

		c <- 666 // 将666发送给c
	}()

	num := <-c // 从c中接收数据，并赋值给num

	fmt.Println("num =", num)
	fmt.Println("main goroutine 结束...")

输出：

goroutine 正在运行...
goroutine结束
num = 666
main goroutine 结束...

有缓冲channel

有缓冲的channel只有当缓冲区满且还在写入时，写go程才会阻塞；只有当缓冲区空且还在读取时，读go程才会阻塞。

c := make(chan int, 3) // 带有3个缓冲区的channel

	fmt.Println("len(c) =", len(c), "cap(c) =", cap(c))

	go func() {
		defer fmt.Println("子go程结束")

		for i := 0; i < 4; i++ {
			c <- i
			fmt.Println("子go程正在运行，发送的元素 =", i, " len(c) =", len(c), ", cap(c) =", cap(c))
		}
	}()

	time.Sleep(2 * time.Second)

	for i := 0; i < 4; i++ {
		num := <-c // 从c中接收数据，并赋值给num
		fmt.Println("num =", num)
	}

	fmt.Println("main 结束")

当channel满，若继续写数据，则会阻塞。
当channel空，若继续读数据，也会阻塞。
输出：

len(c) = 0 cap(c) = 3
子go程正在运行，发送的元素 = 0  len(c) = 1 , cap(c) = 3
子go程正在运行，发送的元素 = 1  len(c) = 2 , cap(c) = 3
子go程正在运行，发送的元素 = 2  len(c) = 3 , cap(c) = 3
num = 0
num = 1
num = 2
num = 3
main 结束
子go程正在运行，发送的元素 = 3  len(c) = 2 , cap(c) = 3
子go程结束

channel的关闭特点

close关键字可以关闭一个channel，channel关闭后只能读不能写，且向未make的channel（nil channel）收发数据都会被阻塞

	c := make(chan int)

	go func() {
		for i := 0; i < 5; i++ {
			c <- i
		}

		// close关键字可以关闭一个channel，channel关闭后只能读不能写，且向未make的channel（nil channel）收发数据都会被阻塞
		close(c)
	}()

	for {
		// ok 如果为true表示channel没有关闭，如果为false表示channel已经关闭
		if data, ok := <-c; ok { // if的条件是 ok
			fmt.Println(data)
		} else {
			break
		}
	}

	fmt.Println("Main finished...")

输出：

0
1
2
3
4
Main finished...

channel与range

类似C++中的for(auto i:arr)

	c := make(chan int)

	go func() {
		for i := 0; i < 5; i++ {
			c <- i
		}

		// close关键字可以关闭一个channel，channel关闭后只能读不能写，且向未make的channel（nil channel）收发数据都会被阻塞
		close(c)
	}()

	/*  
	for {
		// ok 如果为true表示channel没有关闭，如果为false表示channel已经关闭
		if data, ok := <-c; ok { // if的条件是 ok
			fmt.Println(data)
		} else {
			break
		}
	}
	*/
    // 上面这段代码可以替换为下面这段代码

	// 可以使用range来迭代不断操作channel
	for data := range c {
		fmt.Println(data)
	}

	fmt.Println("Main finished...")

输出相同：

0
1
2
3
4
Main finished...

channel与select

单流程下的一个go只能监控一个channel的状态，通过select可以监控多个channel的状态

func fibonacci(c chan int, quit chan int) {
	x, y := 1, 1

	for {
		select {
		case c <- x: // 如果c可写，则此case就会进来
			x, y = y, x+y
		case <-quit: // 如果quit可读，则此case就会进来
			fmt.Println("quit")
			return
		}
	}
}

func main() {
	c := make(chan int)
	quit := make(chan int)

	// sub go
	go func() {
		for i := 0; i < 6; i++ {
			fmt.Println(<-c)
		}

		quit <- 0
	}()

	// main go，channel传参传的都是引用
	fibonacci(c, quit)
}

输出：

1
1
2
3
5
8
quit

第五部分

什么是Go Modules？

Go modules是Go语言的依赖解决方案，发布于Go1.11，成长于Go1.12，丰富于Go1.13，正式于Go1.14，推荐在生产上使用。

Go modules目前集成在Go的工具链中，只要安装了Go，自然而然也就可以使用Go modules了，而Go modules的出现也解决了在Go1.11前的几个常见争议问题：

Go语言长久以来的依赖管理问题。
“淘汰”现有的GOPATH的使用模式。
同意社区中的其他的依赖管理工具（提供迁移功能）。

GOPATH的弊端

在 GOPATH 的 $GOPATH/src 下进行 .go 文件或源代码的存储，我们可以称其为 GOPATH 的模式，这个模式拥有一些弊端。

A. 无版本控制概念。 在执行go get的时候，你无法传达任何的版本信息的期望，也就是说你也无法知道自己当前更新的是哪一个版本，也无法通过指定来拉取自己所期望的具体版本。
B.无法同步一致第三方版本号。在运行 Go 应用程序的时候，你无法保证其它人与你所期望依赖的第三方库是相同的版本，也就是说在项目依赖库的管理上，你无法保证所有人的依赖版本都一致。
C.无法指定当前项目引用的第三方版本号。没办法处理 v1、v2、v3 等等不同版本的引用问题，因为 GOPATH 模式下的导入路径都是一样的，都是github.com/foo/bar。

Go Modules模式

go mod命令
go mod环境变量可以通过 go env 命令来进行查看

GO111MODULE

Go语言提供了 GO111MODULE这个环境变量来作为 Go modules 的开关，其允许设置以下参数：

auto：只要项目包含了 go.mod 文件的话启用 Go modules，目前在 Go1.11 至 Go1.14 中仍然是默认值。
on：启用 Go modules，推荐设置，将会是未来版本中的默认值。
off：禁用 Go modules，不推荐设置。

可以在终端执行：go env -w GO111MODULE=on 来设置。

GOPROXY

这个环境变量主要是用于设置 Go 模块代理（Go module proxy）,其作用是用于使 Go 在后续拉取模块版本时直接通过镜像站点来快速拉取。

GOPROXY 的默认值是：https://proxy.golang.org,direct

实际上 “direct” 是一个特殊指示符，用于指示 Go 回源到模块版本的源地址去抓取（比如 GitHub 等），场景如下：当值列表中上一个 Go 模块代理返回 404 或 410 错误时，Go 自动尝试列表中的下一个，遇见 “direct” 时回源，也就是回到源地址去抓取，而遇见 EOF 时终止并抛出类似 “invalid version: unknown revision…” 的错误。

GOSUMDB

它的值是一个 Go checksum database，用于在拉取模块版本时（无论是从源站拉取还是通过 Go module proxy 拉取）保证拉取到的模块版本数据未经过篡改，若发现不一致，也就是可能存在篡改，将会立即中止。

GOSUMDB 的默认值为：sum.golang.org，在国内也是无法访问的，但是 GOSUMDB 可以被 Go 模块代理所代理（详见：Proxying a Checksum Database）。

因此我们可以通过设置 GOPROXY 来解决，而先前我们所设置的模块代理 goproxy.cn 就能支持代理 sum.golang.org，所以这一个问题在设置 GOPROXY 后，你可以不需要过度关心。

另外若对 GOSUMDB 的值有自定义需求，其支持如下格式：

格式 1：<SUMDB_NAME>+<PUBLIC_KEY>。
格式 2：<SUMDB_NAME>+<PUBLIC_KEY> <SUMDB_URL>。

也可以将其设置为“off”，也就是禁止 Go 在后续操作中校验模块版本。

GONOPROXY/GONOSUMDB/GOPRIVATE

这三个环境变量都是用在当前项目依赖了私有模块，例如像是你公司的私有 git 仓库，又或是 github 中的私有库，都是属于私有模块，都是要进行设置的，否则会拉取失败。

更细致来讲，就是依赖了由 GOPROXY 指定的 Go 模块代理或由 GOSUMDB 指定 Go checksum database 都无法访问到的模块时的场景。

而一般建议直接设置 GOPRIVATE，它的值将作为 GONOPROXY 和 GONOSUMDB 的默认值，所以建议的最佳姿势是直接使用 GOPRIVATE。

并且它们的值都是一个以英文逗号 “,” 分割的模块路径前缀，也就是可以设置多个，例如：

`1`	`$ go env -w GOPRIVATE="git.example.com,github.com/eddycjy/mquote"`

设置后，前缀为 git.xxx.com 和 github.com/eddycjy/mquote 的模块都会被认为是私有模块。

如果不想每次都重新设置，我们也可以利用通配符，例如：

`1`	`$ go env -w GOPRIVATE="*.example.com"`

这样子设置的话，所有模块路径为 example.com 的子域名（例如：git.example.com）都将不经过 Go module proxy 和 Go checksum database，需要注意的是不包括 example.com 本身。

Go on Snow

About Go Interview

前言

一、面试考点整体分布

二、基础语法核心考点

1. new 和 make 的区别

2. defer 关键字

3. panic 和 recover

4. 空结构体 struct{}

5. rune 类型

6. 结构体 Tag

7. init 函数

三、核心数据结构底层原理

1. 切片 Slice

问题 1：切片的底层结构是什么？数组和切片的区别？

问题 2：切片的扩容机制是什么？

问题 3：切片作为函数参数传递，会修改原切片吗？

2. 字典 Map

问题 1：Map 的底层实现原理是什么？

问题 2：Map 的扩容机制是什么？

问题 3：Map 是并发安全的吗？

问题 4：Map 的遍历是有序的吗？

3. 字符串 String

四、并发编程与调度模型

1. Goroutine 与线程

2. GMP 调度模型

3. Channel

问题 1：Channel 的底层实现是什么？

问题 2：不同状态的 Channel 操作会发生什么？

问题 3：什么情况下会导致 Goroutine 泄漏？

4. Select

5. Sync 包工具

问题 1：Mutex 的模式是什么？

问题 2：sync.Once 的作用和原理？

问题 3：WaitGroup 的原理？

问题 4：sync.Map 的适用场景？

6. Context

五、内存管理与垃圾回收

1. 内存逃逸

2. 内存泄漏

3. 垃圾回收 GC

问题 1：Go 的 GC 用的什么算法？三色标记法是什么？

问题 2：什么是写屏障？混合写屏障？

问题 3：GC 的触发时机是什么？

六、接口、反射与泛型

1. 接口 Interface

问题 1：接口的底层结构是什么？

问题 2：为什么 nil 接口不等于 nil？

2. 反射

3. 泛型

问题 1：Go 的泛型是怎么实现的？

问题 2：any 和 interface {} 有什么区别？

问题 3：泛型的约束是什么？

七、Web 开发与 ORM 框架

1. Gin 框架

问题 1：Gin 的中间件怎么实现的？

问题 2：Gin 的路由原理是什么？

2. GORM ORM

问题 1：GORM 的 N+1 问题怎么解决？

问题 2：GORM 怎么实现事务？

八、微服务与分布式架构

1. gRPC

问题 1：gRPC 和 REST 的区别是什么？

问题 2：gRPC 的拦截器是什么？

2. 微服务核心组件

问题 1：服务发现是什么？

问题 2：熔断降级是什么？

问题 3：链路追踪是什么？

九、工程化与性能调优

1. 依赖管理 Go Mod

2. 性能排查工具 pprof

3. 单元测试

十、业务实战与系统设计

1. 缓存常见问题

问题 1：缓存穿透、击穿、雪崩的区别和解决方案？

2. 高并发系统设计

十一、常见易错点与踩坑指南

十二、高频代码手写题

面试准备建议

Gin Tutorial

4. 空结构体 `struct{}`

2.1 IP 地址（`IP` 类型）