620 lines
20 KiB
Markdown
620 lines
20 KiB
Markdown
---
|
||
tags: [后端, Go, Gin, 复习, 测试]
|
||
create time: 2026-04-28
|
||
---
|
||
|
||
# Gin 框架复习题库（Level 1→5）
|
||
|
||
## 使用说明
|
||
|
||
本题库覆盖 `[[GIN/1-gin-architecture]]` ~ `[[GIN/5-binding-validation]]` 全部核心知识点，共 **30 道题**：
|
||
|
||
| 题型 | 数量 | 每题分 | 合计 |
|
||
|------|------|--------|------|
|
||
| 选择题（单选） | 15 题 | 4 分 | 60 分 |
|
||
| 填空题 | 8 题 | 5 分 | 40 分 |
|
||
| 代码补全 | 7 题 | 约 6 分 | ~42 分 |
|
||
|
||
**总分：约 142 分。建议用时 60~90 分钟。**
|
||
|
||
---
|
||
|
||
## 一、选择题（每题 4 分，共 60 分）
|
||
|
||
### Q1 【架构】`gin.Default()` 默认挂载了哪两个中间件？
|
||
|
||
A. Logger + CORS
|
||
B. Logger + Recovery
|
||
C. Recovery + JWT Auth
|
||
D. Logger + RateLimit
|
||
|
||
> [!note]- Q1 答案
|
||
> **答案：B**。`gin.Default()` = `gin.New()` + `Use(Logger())` + `Use(Recovery())`。
|
||
>
|
||
> > 来源：`[[GIN/1-gin-architecture]]` §4
|
||
|
||
---
|
||
|
||
### Q2 【架构/Context】Gin 的 `*gin.Engine` 实现了标准库中哪个接口，从而可以无缝传给 `http.ListenAndServe`？
|
||
|
||
A. `http.RoundTripper`
|
||
B. `http.Handler`
|
||
C. `http.ResponseWriter`
|
||
D. `http.ServeMux`
|
||
|
||
> [!note]- Q2 答案
|
||
> **答案：B**。`ServeHTTP(ResponseWriter, *Request)` 签名匹配。
|
||
>
|
||
> > 来源：`[[GIN/1-gin-architecture/engine-handler]]` §1
|
||
|
||
---
|
||
|
||
### Q3 【路由】Gin 的路由匹配算法使用什么数据结构？
|
||
|
||
A. `map[string]Handler`
|
||
B. Radix Tree（基数树/压缩前缀树）
|
||
C. AVL Tree（平衡二叉树）
|
||
D. Trie（朴素前缀树，未压缩）
|
||
|
||
> [!note]- Q3 答案
|
||
> **答案：B**。Radix Tree 通过前缀共享实现 O(d) 匹配，d 为 URL 深度。
|
||
>
|
||
> > 来源：`[[GIN/2-routing]]` §3；`[[GIN/2-routing-complexity-comparison]]`
|
||
|
||
---
|
||
|
||
### Q4 【路由优先级】当同时注册 `/users/list`（静态）、`/users/:id`（动态）、`/users/*path`（通配符）时，请求 `/users/5` 会命中哪个路由？
|
||
|
||
A. `/users/list` — 因为它是第一个注册的
|
||
B. `/users/:id` — 静态优先于动态
|
||
C. `/users/*path` — 通配符是兜底规则
|
||
D. 取决于注册顺序
|
||
|
||
> [!note]- Q4 答案
|
||
> **答案：B**。优先级：静态 > 动态参数 > 通配符，与注册顺序无关。
|
||
>
|
||
> > 来源：`[[GIN/2-routing]]` §4
|
||
|
||
---
|
||
|
||
### Q5 【路由分组】以下代码输出的完整路径是什么？
|
||
|
||
```go
|
||
r := gin.Default()
|
||
api := r.Group("/api")
|
||
v1 := api.Group("/v1")
|
||
users := v1.Group("/users/:id")
|
||
users.GET("", handler)
|
||
```
|
||
|
||
A. `/api/v1/users/:id`
|
||
B. `/api/v1/users/` （`:id` 被忽略，因为放在 Group path 里）
|
||
C. `/api/v1/users/:id` — 正确
|
||
D. `/:id` — 只取最后一段
|
||
|
||
> [!note]- Q5 答案
|
||
> **答案：C**。`basePath` 逐层累加：`"" → "/api" → "/api/v1" → "/api/v1/users/:id"`。
|
||
>
|
||
> > 来源：`[[GIN/2-routing]]` §5
|
||
|
||
---
|
||
|
||
### Q6 【路由复杂度对比】如果有 10000 条路由，用 Gin 的 Radix Tree 和 `http.ServeMux` 分别匹配一个 URL，大致需要多少步？
|
||
|
||
A. Gin: 10000 步，ServeMux: 10000 步
|
||
B. Gin: ~4 步，ServeMux: ~10000 次比较
|
||
C. Gin: ~10000 步，ServeMux: ~4 步
|
||
D. Gin: ~4 步，ServeMux: ~4 步
|
||
|
||
> [!note]- Q6 答案
|
||
> **答案：B**。Gin 复杂度 O(d)，与路由总数 R 无关；ServeMux O(R×L)。
|
||
>
|
||
> > 来源：`[[GIN/2-routing-complexity-comparison]]` §3
|
||
|
||
---
|
||
|
||
### Q7 【中间件执行顺序】注册了两个全局中间件 A 和 B（A 先注册），一个 handler。完整的输出顺序是？
|
||
|
||
```go
|
||
// A: fmt.Println("A-before"); c.Next(); fmt.Println("A-after")
|
||
// B: fmt.Println("B-before"); c.Next(); fmt.Println("B-after")
|
||
// handler: fmt.Println("handler")
|
||
```
|
||
|
||
A. A-before → B-before → handler → B-after → A-after
|
||
B. A-before → B-before → handler → A-after → B-after
|
||
C. A-before → handler → A-after → B-before → B-after
|
||
D. handler → A-before → B-before → A-after → B-after
|
||
|
||
> [!note]- Q7 答案
|
||
> **答案：A**。前置按注册顺序，后置按逆序——栈式行为。
|
||
>
|
||
> > 来源：`[[GIN/3-middleware]]` §2
|
||
|
||
---
|
||
|
||
### Q8 【中间件 vs 标准库】Go 标准库 `net/http` 中间件的类型签名是？
|
||
|
||
A. `func(*gin.Context)`
|
||
B. `func(http.ResponseWriter, *http.Request)`
|
||
C. `func(http.Handler) http.Handler`
|
||
D. `func(*http.Server) http.Handler`
|
||
|
||
> [!note]- Q8 答案
|
||
> **答案：C**。这是装饰器模式，层层嵌套包装。
|
||
>
|
||
> > 来源：`[[GIN/gin-vs-std]]` §1
|
||
|
||
---
|
||
|
||
### Q9 【c.Abort()】中间件 A 中调用了 `c.Abort()`（紧接 `return`），以下说法正确的是？
|
||
|
||
A. 后续中间件和 handler 都跳过，但 A 的后置逻辑会执行
|
||
B. 后续中间件跳过，handler 执行
|
||
C. 整个链（包括后续中间件、handler、A 的所有剩余代码）都不再执行
|
||
D. 只有同一路由的中间件被跳过，其他路由不受影响
|
||
|
||
> [!note]- Q9 答案
|
||
> **答案：C**。`c.Abort()` 将 index 设为链长度，`c.Next()` 循环条件立即不满足。Abort 后必须紧跟 return。
|
||
>
|
||
> > 来源：`[[GIN/middleware-abort]]`
|
||
|
||
---
|
||
|
||
### Q10 【中间件 Goroutine】在中间件中启动 goroutine 异步处理日志，正确的做法是？
|
||
|
||
A. 直接在 goroutine 中使用 `c`
|
||
B. 先用 `c.Copy()` 创建副本，在 goroutine 中使用副本
|
||
C. 把 `c` 保存到全局变量，在 goroutine 中读取
|
||
D. 使用 `context.WithCancel` 取消原 context
|
||
|
||
> [!note]- Q10 答案
|
||
> **答案：B**。`c.Copy()` 创建独立副本，goroutine 中只能读不能写响应。
|
||
>
|
||
> > 来源：`[[GIN/3-middleware]]` §5
|
||
|
||
---
|
||
|
||
### Q11 【Context 池化】如果在 handler 中把 `*gin.Context` 保存到全局变量，下次请求时会发生什么？
|
||
|
||
A. 读到的是上一次请求的数据，完全安全
|
||
B. 可能读到任意并发请求正在使用的数据，造成数据错乱
|
||
C. Go 运行时会 panic，因为存在数据竞争
|
||
D. Context 会自动深拷贝，所以没问题
|
||
|
||
> [!note]- Q11 答案
|
||
> **答案：B**。sync.Pool 复用对象，字段被 reset 覆盖，全局引用指向的是被新请求改写后的同一个内存地址。
|
||
>
|
||
> > 来源：`[[GIN/context-pool]]` §2
|
||
|
||
---
|
||
|
||
### Q12 【Context reset】Context 从 pool 取出后，`reset()` 方法把 `index` 重置为多少？为什么？
|
||
|
||
A. `0` — 表示从头开始
|
||
B. `-1` — 表示还未开始执行，第一次 `c.Next()` 走到 index+1=0
|
||
C. `-1` — 表示无效值，需要用 -1 做判断
|
||
D. `nil` — 空表示未初始化
|
||
|
||
> [!note]- Q12 答案
|
||
> **答案：B**。`-1` 表示还未开始，`c.Next()` 先 `index++` 到 0，再执行 `handlers[0]`。
|
||
>
|
||
> > 来源：`[[GIN/4-context-lifecycle]]` §3
|
||
|
||
---
|
||
|
||
### Q13 【超时控制】Gin 默认是否有 HTTP 请求超时控制？如果需要超时，应该在哪里配置？
|
||
|
||
A. 有，默认 30 秒超时
|
||
B. 没有，应在 `http.Server` 层配置 `ReadTimeout`/`WriteTimeout`
|
||
C. 没有，但可用 `c.WithTimeout()` 设置
|
||
D. 有，在 `gin.Default()` 内部已经设置了
|
||
|
||
> [!note]- Q13 答案
|
||
> **答案：B**。Gin 本身不内置超时，需在 `http.Server{ReadTimeout: ...}` 配置。
|
||
>
|
||
> > 来源：`[[GIN/4-context-lifecycle]]` §7
|
||
|
||
---
|
||
|
||
### Q14 【绑定校验】`c.ShouldBind(&req)` 自动检测内容类型的顺序是？
|
||
|
||
A. form data → query string → JSON
|
||
B. query string → form data → JSON
|
||
C. JSON → form data → query string
|
||
D. 根据 Content-Type 头直接判定，不按顺序
|
||
|
||
> [!note]- Q14 答案
|
||
> **答案：C**。先试 JSON（检查 Content-Type），再试 form，最后试 query。
|
||
>
|
||
> > 来源：`[[GIN/5-binding-validation]]` §1
|
||
|
||
---
|
||
|
||
### Q15 【未知字段】`ShouldBindJSON` 对 JSON body 中的未知字段（struct 中没有对应 key）的默认行为是？
|
||
|
||
A. 返回 error，绑定失败
|
||
B. 静默忽略，值为零值
|
||
C. 抛出 panic
|
||
D. 打印警告日志但仍继续
|
||
|
||
> [!note]- Q15 答案
|
||
> **答案：B**。底层用 `encoding/json.Unmarshal`，对多余字段静默丢弃。
|
||
>
|
||
> > 来源：`[[GIN/unknown-fields]]` §1
|
||
|
||
---
|
||
|
||
## 二、填空题（每题 5 分，共 40 分）
|
||
|
||
### Q16 【路由优先级】Gin 路由匹配的优先级从高到低依次是：________ > ________ > ________。
|
||
|
||
> [!note]- Q16 答案
|
||
> **答案：静态字符串 > 动态参数 (`:param`) > 通配符 (`*rest`)**
|
||
>
|
||
> > 来源：`[[GIN/2-routing]]` §4
|
||
|
||
---
|
||
|
||
### Q17 【Engine 结构】`*gin.Engine` 嵌入了 `RouterGroup`，这意味着 Engine 本身就是一颗最大的 RouterGroup，可以直接调用 `.GET()`、`.Use()` 等方法。Engine 中还包含一个 `trees` 字段，其类型是 `methodTrees`（本质是 `[*tree]`），它的作用是：_________________________。
|
||
|
||
> [!note]- Q17 答案
|
||
> **答案：每种 HTTP 方法维护一棵独立的 Radix Tree（例如 GET 一棵、POST 一棵）**
|
||
>
|
||
> > 来源：`[[GIN/1-gin-architecture]]` §1
|
||
|
||
---
|
||
|
||
### Q18 【中间件作用域】Gin 中间件的三级作用域分别是：________、________、________。执行顺序为：________ → ________ → ________ → handler。
|
||
|
||
> [!note]- Q18 答案
|
||
> **答案：全局（Engine 级） / 分组（RouterGroup 级） / 路由（单条路由）；全局 → 分组 → 路由 → handler**
|
||
>
|
||
> > 来源：`[[GIN/3-middleware]]` §2
|
||
|
||
---
|
||
|
||
### Q19 【中间件设计模式】Go 标准库 `net/http` 中间件使用 ________ 模式，而 Gin 中间件使用 ________ 模式。
|
||
|
||
> [!note]- Q19 答案
|
||
> **答案：装饰器（Decorator）/ 责任链（Chain of Responsibility）**
|
||
>
|
||
> > 来源：`[[GIN/gin-vs-std]]` §1
|
||
|
||
---
|
||
|
||
### Q20 【c.Abort() 系列方法】Gin 提供了三种 Abort 相关方法：`c.Abort()`、`c.AbortWithStatus(code)`、`_______________`（Abort 同时写入 JSON 响应体）。
|
||
|
||
> [!note]- Q20 答案
|
||
> **答案：`c.AbortWithStatusJSON(code, json)`**
|
||
>
|
||
> > 来源：`[[GIN/middleware-abort]]` §4
|
||
|
||
---
|
||
|
||
### Q21 【c.Copy() 限制】在通过 `c.Copy()` 创建的 goroutine 副本中，________（能/不能）调用 `c.JSON()` 写入响应，但可以读取 `c.Request` 和 `c.Keys`。
|
||
|
||
> [!note]- Q21 答案
|
||
> **答案：不能**。`c.Writer` 无法复制，Copy 出的 goroutine 只能读不能写。
|
||
>
|
||
> > 来源：`[[GIN/3-middleware]]` §5
|
||
|
||
---
|
||
|
||
### Q22 【绑定方法速记】Gin 提供了多种绑定方法：`c.ShouldBindJSON` 绑定 JSON body，`_______________` 绑定 URL 查询参数，`c.ShouldBindUri` 绑定 URI 路径参数，`c.ShouldBindHeader` 绑定 HTTP 请求头。
|
||
|
||
> [!note]- Q22 答案
|
||
> **答案：`c.ShouldBindQuery`**
|
||
>
|
||
> > 来源：`[[GIN/5-binding-validation]]` §1
|
||
|
||
---
|
||
|
||
### Q23 【ShouldBindBodyWith】标准库的 `io.ReadCloser` 类型的 body 只能读取一次。当需要在同一个 handler 中对不同结构体多次解析 body 时，应使用 `_______________` 来缓存 body，避免二次读取报错。
|
||
|
||
> [!note]- Q23 答案
|
||
> **答案：`c.ShouldBindBodyWith(&obj, binding.JSON)`**
|
||
>
|
||
> > 来源：`[[GIN/5-binding-validation]]` §9
|
||
|
||
---
|
||
|
||
## 三、代码补全题（每题约 6 分，共 ~42 分）
|
||
|
||
### Q24 【CORS 中间件】补全以下 CORS 中间件，处理 OPTIONS 预检请求：
|
||
|
||
```go
|
||
func cors() gin.HandlerFunc {
|
||
return func(c *gin.Context) {
|
||
origin := c.Request.Header.Get("Origin")
|
||
if origin != "" {
|
||
c.Header("Access-Control-Allow-Origin", origin)
|
||
c.Header("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE,PATCH,OPTIONS")
|
||
c.Header("Access-Control-Allow-Headers", "Origin,Content-Type,Authorization")
|
||
}
|
||
|
||
// 处理 OPTIONS 预检请求
|
||
if c.Request.Method == "OPTIONS" {
|
||
c.AbortWithStatus(http.StatusNoContent)
|
||
_______ // ← 补全此行：立即返回，不再执行后续逻辑
|
||
}
|
||
|
||
c.Next() // 非 OPTIONS 请求，继续执行
|
||
}
|
||
}
|
||
```
|
||
|
||
> [!note]- Q24 答案
|
||
> **答案：`return`**
|
||
>
|
||
> CORS 中间件中 OPTIONS 预检请求处理后必须 `return`，否则会继续执行 `c.Next()` 并可能触发下游 handler。
|
||
>
|
||
> > 来源：`[[GIN/3-middleware]]` §4
|
||
|
||
---
|
||
|
||
### Q25 【JWT 认证中间件】补全 JWT 认证中间件中的认证失败处理和用户信息存储：
|
||
|
||
```go
|
||
func jwtAuth() gin.HandlerFunc {
|
||
return func(c *gin.Context) {
|
||
token := c.GetHeader("Authorization")
|
||
if token == "" {
|
||
c.JSON(http.StatusUnauthorized, gin.H{"error": "missing token"})
|
||
c.Abort()
|
||
_______ // ← 补全：阻止代码继续向下执行
|
||
}
|
||
|
||
claims, err := parseJWT(token)
|
||
if err != nil {
|
||
c.JSON(http.StatusUnauthorized, gin.H{"error": "invalid token"})
|
||
c.Abort()
|
||
_______ // ← 补全：同上
|
||
}
|
||
|
||
// 认证成功，将用户信息存入 Context
|
||
c.Set("userID", claims.UserID)
|
||
c.Set("role", claims.Role)
|
||
_______ // ← 补全：将控制权交给后续中间件/handler
|
||
}
|
||
}
|
||
```
|
||
|
||
> [!note]- Q25 答案
|
||
> **答案：两行 `return`，最后一行 `c.Next()`**
|
||
>
|
||
> 核心规则：`c.Abort()` 之后必须紧跟 `return`；认证成功后调用 `c.Next()` 推进链。
|
||
>
|
||
> > 来源：`[[GIN/3-middleware]]` §4
|
||
|
||
---
|
||
|
||
### Q26 【异步 Goroutine 安全修复】下面的代码有线程安全问题，请修复：
|
||
|
||
```go
|
||
func asyncProcessor() gin.HandlerFunc {
|
||
return func(c *gin.Context) {
|
||
c.Next()
|
||
|
||
// ❌ 危险：c 可能在 goroutine 运行时被回收并复用于其他请求
|
||
go func() {
|
||
log.Printf("处理完成: %s, 用户: %s", c.Request.URL.Path, c.GetString("userID"))
|
||
}()
|
||
}
|
||
}
|
||
```
|
||
|
||
**修正：**
|
||
|
||
```go
|
||
func safeAsyncProcessor() gin.HandlerFunc {
|
||
return func(c *gin.Context) {
|
||
c.Next()
|
||
|
||
// ✅ 修复：用 c.Copy() 创建独立副本
|
||
copy := c.Copy()
|
||
go func() {
|
||
log.Printf("处理完成: %s, 用户: %s",
|
||
copy.Request.URL.Path,
|
||
copy.GetString("userID")) // ← 补全：使用副本而不是 c
|
||
}()
|
||
}
|
||
}
|
||
```
|
||
|
||
> [!note]- Q26 答案要点
|
||
> **关键改动**：① `c.Copy()` 创建副本；② goroutine 中使用 `copy` 而非 `c`。
|
||
>
|
||
> > 来源：`[[GIN/3-middleware]]` §5
|
||
|
||
---
|
||
|
||
### Q27 【Context 生命周期 —— reset 清空项】补全 `reset` 方法中被清空的字段名（至少写出 4 个）：
|
||
|
||
```go
|
||
func (c *Context) reset(w http.ResponseWriter) {
|
||
c.Writer = w.(*responseWriter)
|
||
c.writerMem.Reset()
|
||
c.Params = c.Params[:0] // ← 清空路径参数
|
||
c.handlers = nil // ← 清空 handler 链
|
||
c.index = -1 // ← 重置执行位置
|
||
c.errors = c.errors[:0] // ← 清空错误列表
|
||
c.Keys = nil // ← 清空共享数据
|
||
c.QueryCache = nil // ← 清空查询缓存
|
||
c.FormCache = nil // ← 清空表单缓存
|
||
}
|
||
```
|
||
|
||
请从上方列出你记得住的所有被清空字段：
|
||
|
||
1. `c.Params = ______________`
|
||
2. `c.handlers = ______________`
|
||
3. `c.index = ______________`
|
||
4. `c.errors = ______________`
|
||
5. `c.Keys = ______________`
|
||
|
||
> [!note]- Q27 答案
|
||
> 1. `c.Params = c.Params[:0]`
|
||
> 2. `nil`
|
||
> 3. `-1`
|
||
> 4. `c.errors = c.errors[:0]`
|
||
> 5. `nil`
|
||
>
|
||
> > 来源：`[[GIN/4-context-lifecycle]]` §3
|
||
|
||
---
|
||
|
||
### Q28 【自定义 Validator】补全自定义校验器 `username` 的实现：用户名需满足字母数字下划线组合，长度 3~20 字符。
|
||
|
||
```go
|
||
func init() {
|
||
validator.Validator.RegisterValidation("username", func(v validator.FieldLevel) bool {
|
||
name := v.Field().String()
|
||
if len(name) < 3 || len(name) > 20 {
|
||
return false
|
||
}
|
||
return regexp.MustCompile(`_______________`).MatchString(name)
|
||
})
|
||
}
|
||
```
|
||
|
||
> [!note]- Q28 答案
|
||
> **答案：`^[a-zA-Z0-9_]+$`**
|
||
>
|
||
> 完整正则确保只允许字母、数字和下划线。
|
||
>
|
||
> > 来源：`[[GIN/5-binding-validation]]` §6
|
||
|
||
---
|
||
|
||
### Q29 【HTTP 启动方式】补全三种 Gin 启动方式的等价代码：
|
||
|
||
```go
|
||
r := gin.Default()
|
||
|
||
// 方式一：框架封装（最常用）
|
||
r.Run(":8080")
|
||
|
||
// 方式二：标准库直接启动（完全等价）
|
||
http.ListenAndServe(":8080", _______)
|
||
|
||
// 方式三：高级控制（推荐生产环境）
|
||
srv := &http.Server{
|
||
Addr: ":8080",
|
||
Handler: _______, // 传入 Gin Engine
|
||
ReadTimeout: 5 * time.Second,
|
||
WriteTimeout: 10 * time.Second,
|
||
}
|
||
_______ // ← 补全第三行的启动调用
|
||
```
|
||
|
||
> [!note]- Q29 答案
|
||
> **三个空依次为**：`r`、`r`、`srv.ListenAndServe()`
|
||
>
|
||
> > 来源：`[[GIN/engine-handler]]` §2
|
||
|
||
---
|
||
|
||
### Q30 【严格 JSON 模式】补全使用 `json.Decoder.DisallowUnknownFields()` 实现严格模式的方法：
|
||
|
||
```go
|
||
func strictJSONHandler(c *gin.Context) {
|
||
var req CreateUserRequest
|
||
|
||
decoder := json.NewDecoder(c.Request.Body)
|
||
decoder._______________ // ← 禁止未知字段
|
||
if err := decoder.Decode(&req); err != nil {
|
||
c.JSON(400, gin.H{
|
||
"code": 1003,
|
||
"message": "参数解析失败",
|
||
"error": err.Error(),
|
||
})
|
||
_______ // ← 补全：停止处理
|
||
}
|
||
// req 已包含所有已知字段，且无拼写错误
|
||
c.JSON(201, gin.H{"message": "ok"})
|
||
}
|
||
```
|
||
|
||
> [!note]- Q30 答案
|
||
> **两个空依次为**：`DisallowUnknownFields()`、`return`
|
||
>
|
||
> > 来源：`[[GIN/unknown-fields]]` §3
|
||
|
||
---
|
||
|
||
## 四、综合场景题（附加挑战，可选）
|
||
|
||
### Q31 【场景题】一个线上服务出现偶发的 "user not found" 错误。排查发现某个 handler 中有一段类似这样的代码：
|
||
|
||
```go
|
||
var savedUserID string
|
||
|
||
func myHandler(c *gin.Context) {
|
||
savedUserID = c.GetString("user_id") // 保存到一个全局变量
|
||
c.JSON(200, gin.H{"ok": true})
|
||
}
|
||
|
||
func backgroundWorker() {
|
||
_ = savedUserID // 在其他地方读取这个全局变量
|
||
}
|
||
```
|
||
|
||
请问这段代码可能引发什么问题？应该如何修复？
|
||
|
||
> [!note]- Q31 答案
|
||
> **问题：** `savedUserID = c.GetString("user_id")` 虽然是拷贝值，但如果改为 `globalC = c`（保存 Context 引用），则会导致数据错乱——因为 Context 被 sync.Pool 复用，另一个请求的 reset() 会清空该对象的 Keys。即使拷贝值，在全局变量中也会有并发写的竞态。
|
||
>
|
||
> **修复方案：**
|
||
> 1. 不要使用全局变量保存请求相关数据
|
||
> 2. 如果确实需要异步使用数据，用 `c.Copy()` 创建副本，或在 goroutine 中只传基本类型值
|
||
> 3. 参考：`[[GIN/context-pool]]` §2 和 `[[GIN/context-pool-safety]]`
|
||
|
||
---
|
||
|
||
### Q32 【场景题】你的 API 有以下路由注册顺序：
|
||
|
||
```go
|
||
r := gin.Default()
|
||
|
||
r.GET("/users/:id", getUser) // 先注册动态参数
|
||
r.GET("/users/list", listAll) // 后注册静态路由
|
||
```
|
||
|
||
当客户端请求 `GET /users/list` 时，会命中哪个 handler？为什么？注册顺序会影响结果吗？
|
||
|
||
> [!note]- Q32 答案
|
||
> 会命中 `listAll`（`/users/list`）。**注册顺序不影响匹配结果**。Gin 的 Radix Tree 按优先级决定匹配：静态路由优先级高于动态参数，无论谁先注册，`/users/list` 都是精确匹配静态字符串，必优于 `/users/:id` 的动态参数匹配。
|
||
>
|
||
> > 来源：`[[GIN/2-routing]]` §4 — "注意：如果有两条同类型的路由，Gin 注册时会 panic——不允许重复。" 不同类型的优先级由 Radix Tree 结构保证，与注册顺序无关。
|
||
|
||
---
|
||
|
||
## 五、速查表
|
||
|
||
### 中间件执行链路速记
|
||
|
||
```
|
||
请求进来 → Logger(前置) → Recovery(前置) → Auth(前置) → Handler →
|
||
Auth(后置) → Recovery(后置) → Logger(后置) → 归还 Context 到 pool
|
||
```
|
||
|
||
### ShouldBind 全家桶速记
|
||
|
||
| 数据源 | 方法 |
|
||
|--------|------|
|
||
| JSON body | `c.ShouldBindJSON(&v)` |
|
||
| Query string | `c.ShouldBindQuery(&v)` |
|
||
| 自动检测 | `c.ShouldBind(&v)` |
|
||
| URI 路径参数 | `c.ShouldBindUri(&v)` |
|
||
| HTTP 请求头 | `c.ShouldBindHeader(&v)` |
|
||
| Form + JSON 兼容 | `c.ShouldBindBodyWith(&v, binding.Form)` |
|
||
|
||
### binding 标签速记
|
||
|
||
`required` `email` `url` `min=N` `max=N` `numeric` `alphanum` `oneof=X Y Z`
|
||
|
||
---
|
||
|
||
*本题库基于 `[[GIN/README]]` 索引下的 Level 1→5 共 16 篇笔记整理。*
|