04.3.3.1 泛型与 net/http
所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.3 Go / 04.3.3 泛型与标准库
覆盖范围
- Go 泛型:类型参数、类型约束、comparable
- net/http:标准库 HTTP 服务、Handler、ServeMux
- HTTP 客户端:Get/Post、超时、连接池
- 中间件模式
高频题速览
| 编号 | 题目 | 难度 | 频率 |
|---|---|---|---|
| 04.3.3.1-001 | Go 泛型是什么,什么时候用 | 进阶 | ★★★★☆ |
| 04.3.3.1-002 | Go 泛型的类型约束 | 进阶 | ★★★☆☆ |
| 04.3.3.1-003 | net/http 怎么写服务 | 基础 | ★★★★★ |
| 04.3.3.1-004 | Handler 和 ServeMux 区别 | 进阶 | ★★★★☆ |
| 04.3.3.1-005 | net/http 超时怎么配 | 进阶 | ★★★★☆ |
| 04.3.3.1-006 | 怎么写 HTTP 中间件 | 进阶 | ★★★★☆ |
| 04.3.3.1-007 | HTTP 客户端怎么用 | 基础 | ★★★★☆ |
| 04.3.3.1-008 | 连接池是怎么回事 | 进阶 | ★★★☆☆ |
04.3.3.1-001 Go 泛型是什么?什么时候用?
频率 ★★★★☆ | 难度 进阶
一句话结论
Go 1.18 引入泛型,用类型参数(type parameter)让函数或结构体支持多种类型,不用为每种类型写一份代码;适合写通用数据结构(切片、Map、链表)和通用工具函数。
概念解释
- 类型参数:函数名后面用 [T any] 声明类型参数。
- 类型约束:限制 T 必须满足什么条件,比如 comparable 表示可以用 == 比较。
- any:interface{} 的别名,最宽松的约束。
- 适合场景:通用数据结构、通用工具函数、避免代码重复。
原理流程
- 写函数时,用 [T any] 声明类型参数 T。
- 函数里可以把 T 当成类型用,比如 T 是切片元素类型。
- 调用时,编译器自动推导 T 的具体类型,或者手动指定。
- 不用为 int、string 等每种类型写一份函数。
代码 / 示例
// 泛型函数:求切片里所有元素的和
func Sum[T int | float64](nums []T) T {
var sum T
for _, n := range nums {
sum += n
}
return sum
}
// 泛型结构体:栈
type Stack[T any] struct {
items []T
}
func (s *Stack[T]) Push(item T) {
s.items = append(s.items, item)
}
func (s *Stack[T]) Pop() T {
item := s.items[len(s.items)-1]
s.items = s.items[:len(s.items)-1]
return item
}
// 使用
func main() {
intSum := Sum([]int{1, 2, 3}) // 6
floatSum := Sum([]float64{1.5, 2.5}) // 4.0
s := Stack[string]{}
s.Push("hello")
s.Push("world")
}
常见误区
- 误区:Go 泛型和 Java 泛型一样?正解:Go 泛型是编译期实例化,不是类型擦除;Go 的类型约束是接口,更灵活。
- 误区:所有函数都应该用泛型?正解:泛型增加复杂度,只在需要复用多种类型时才用,不要过度使用。
追问 / 延伸
- 什么是 comparable?答:内置约束,表示这个类型可以用 == 和 != 比较。
- 什么是类型约束?答:用 interface 定义约束,T 必须实现这个接口的所有方法。
04.3.3.1-003 net/http 怎么写 HTTP 服务?
频率 ★★★★★ | 难度 基础
一句话结论
net/http 是 Go 标准库的 HTTP 包,用 http.HandleFunc 注册路由,http.ListenAndServe 启动服务;一个函数就是一个 Handler,签名是 func(w http.ResponseWriter, r *http.Request)。
概念解释
- Handler:处理 HTTP 请求的函数,签名 func(w http.ResponseWriter, r *http.Request)。
- ServeMux:路由路由器,根据 URL 路径分发到不同的 Handler。
- ResponseWriter:写响应的接口。
- Request:请求对象,包含 URL、Header、Body 等。
原理流程
- 注册路由:http.HandleFunc("/users", userHandler)。
- 启动服务:http.ListenAndServe(":8080", nil)。
- 请求进来,ServeMux 匹配路径,调用对应的 Handler。
- Handler 处理请求,把响应写到 ResponseWriter。
代码 / 示例
package main
import (
"encoding/json"
"net/http"
)
type User struct {
ID int `json:"id"`
Name string `json:"name"`
}
func getUserHandler(w http.ResponseWriter, r *http.Request) {
user := User{ID: 1, Name: "Alice"}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(user)
}
func main() {
// 注册路由
http.HandleFunc("/users", getUserHandler)
// 启动服务
http.ListenAndServe(":8080", nil)
}
常见误区
- 误区:net/http 性能很差?正解:net/http 性能很好,Go 的 HTTP 服务器是生产级的,很多公司直接用标准库。
- 误区:必须用框架才能写 HTTP 服务?正解:标准库 net/http 就够了,框架只是加了路由、中间件等便利功能。
追问 / 延伸
- 什么是 http.Handler 接口?答:type Handler interface { ServeHTTP(ResponseWriter, *Request) },只要实现这个接口就是一个 Handler。
- 什么是 DefaultServeMux?答:默认的路由路由器,http.HandleFunc 就是注册到 DefaultServeMux。
04.3.3.1-005 net/http 超时怎么配?为什么重要?
频率 ★★★★☆ | 难度 进阶
一句话结论
net/http 服务器要配 ReadTimeout、WriteTimeout、IdleTimeout,防止慢请求拖垮服务;客户端要配 Timeout,防止请求hang住;不配超时是生产事故的常见原因。
概念解释
服务器超时:
- ReadTimeout:读请求的最大时间(从连接到读完 body)。
- WriteTimeout:写响应的最大时间。
- IdleTimeout:keep-alive 连接空闲的最大时间。 客户端超时:
- Timeout:整个请求的最大时间(包括连接、发请求、读响应)。
原理流程
- 不配超时的话,如果客户端很慢,服务器的 goroutine 会一直挂着等。
- 高并发时,大量慢请求会占满 goroutine 和文件描述符,服务就不可用了。
- 配了超时,超过时间就主动断开,释放资源。
代码 / 示例
// 服务器超时配置
srv := &http.Server{
Addr: ":8080",
Handler: mux,
ReadTimeout: 5 * time.Second, // 读请求最多 5 秒
WriteTimeout: 10 * time.Second, // 写响应最多 10 秒
IdleTimeout: 120 * time.Second, // 空闲连接最多 120 秒
}
srv.ListenAndServe()
// 客户端超时配置
client := &http.Client{
Timeout: 10 * time.Second, // 整个请求最多 10 秒
}
resp, err := client.Get("http://api.example.com/users")
常见误区
- 误区:net/http 默认有超时?正解:默认没有超时!必须手动配,否则慢请求会拖垮服务。
- 误区:客户端超时配越长越好?正解:超时太长会让用户等很久,太短会误杀慢请求,要根据业务定。
追问 / 延伸
- 什么是慢客户端攻击?答:客户端故意发很慢的请求,占满服务器资源,导致正常用户无法访问。
- 什么是 context 超时?答:用 context.Context 控制请求超时,更灵活,可以在请求中途取消。
04.3.3.1-006 怎么写 HTTP 中间件?
频率 ★★★★☆ | 难度 进阶
一句话结论
Go 的 HTTP 中间件是一个函数,接收 http.Handler,返回 http.Handler;在调用 next.ServeHTTP 前后加逻辑,实现日志、鉴权、CORS 等功能。
概念解释
- 中间件模式:包装 Handler,在前后加逻辑。
- 写法:func Middleware(next http.Handler) http.Handler。
- 常见中间件:日志、鉴权、CORS、Recovery(panic 恢复)。
原理流程
- 写一个中间件函数,接收 next http.Handler。
- 返回一个新的 http.Handler,里面先做前置逻辑,然后调用 next.ServeHTTP,再做后置逻辑。
- 把多个中间件串起来,从外到里一层层包。
代码 / 示例
// 日志中间件
func LoggingMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
log.Printf("%s %s", r.Method, r.URL.Path)
next.ServeHTTP(w, r) // 调用下一个 handler
duration := time.Since(start)
log.Printf("%s %s 耗时 %v", r.Method, r.URL.Path, duration)
})
}
// 鉴权中间件
func AuthMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
token := r.Header.Get("Authorization")
if token == "" {
http.Error(w, "未登录", http.StatusUnauthorized)
return
}
// 验证 token...
next.ServeHTTP(w, r)
})
}
// 串起来
mux := http.NewServeMux()
mux.HandleFunc("/users", getUserHandler)
handler := LoggingMiddleware(AuthMiddleware(mux))
http.ListenAndServe(":8080", handler)
常见误区
- 误区:中间件只能写一个?正解:可以串很多个,从外到里一层层包。
- 误区:中间件执行顺序不重要?正解:顺序很重要,比如日志要在最外面,鉴权要在业务前面。
追问 / 延伸
- 什么是 Recovery 中间件?答:捕获 panic,返回 500 错误,不让整个服务崩掉。
- 什么是 CORS 中间件?答:处理跨域请求,加 Access-Control-Allow-Origin 等 Header。
04.3.3.1-007 HTTP 客户端怎么用?
频率 ★★★★☆ | 难度 基础
一句话结论
net/http 包的 http.Get、http.Post 发请求,自定义 client 配超时和连接池;请求完要关闭 response.Body,否则连接泄漏。
概念解释
- http.Get:简单 GET 请求。
- http.Post:简单 POST 请求。
- http.Client:自定义客户端,配超时、连接池。
- response.Body:必须关闭,否则连接泄漏。
原理流程
- 调用 http.Get 发请求。
- 拿到 response,读 body。
- 读完 body,必须关闭 response.Body。
- 连接才能放回连接池复用。
代码 / 示例
// 简单 GET
resp, err := http.Get("https://api.example.com/users")
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close() // 必须关闭
body, err := io.ReadAll(resp.Body)
fmt.Println(string(body))
// 自定义 client
client := &http.Client{
Timeout: 10 * time.Second, // 整个请求超时
}
resp, err := client.Get("https://api.example.com/users")
defer resp.Body.Close()
常见误区
- 误区:response.Body 不用关?正解:必须关,否则连接泄漏,文件描述符会用完。
- 误区:http.Get 很慢?正解:默认 client 没有超时,会一直等;要自定义 client 配超时。
追问 / 延伸
- 什么是连接池?答:http.Client 内部维护连接池,复用 TCP 连接,不用每次都重新建。
- 怎么发带 JSON 的 POST?答:用 http.NewRequest,设置 Content-Type: application/json。
04.3.3.1-008 连接池是怎么回事?
频率 ★★★☆☆ | 难度 进阶
一句话结论
http.Client 内部有连接池,发完请求不关闭 TCP 连接,放回池子里,下次请求复用同一个连接,减少 TCP 握手开销。
概念解释
- 为什么需要连接池:每次新建 TCP 连接要三次握手,开销大。
- 连接池:发完请求不关闭连接,放着,下次请求复用。
- 好处:减少 TCP 握手,性能更高。
- 默认配置:默认连接池是无限的,要自己控制 MaxIdleConns 等参数。
原理流程
- 发请求时,先从连接池找有没有空闲连接。
- 有就直接用,没有就新建一个。
- 用完不关闭,放回连接池。
- 下次请求直接复用。
代码 / 示例
// 自定义 Transport 配置连接池
transport := &http.Transport{
MaxIdleConns: 100, // 整个连接池最大空闲连接
MaxIdleConnsPerHost: 10, // 每个 host 最大空闲连接
IdleConnTimeout: 90 * time.Second, // 空闲连接 90 秒后关闭
}
client := &http.Client{
Transport: transport,
Timeout: 10 * time.Second,
}
常见误区
- 误区:http.Client 是连接池?正解:http.Client 里的 Transport 才是连接池,Client 只是封装。
- 误区:连接池越大越好?正解:连接太多会把服务器打满,要根据服务器能力配置。
追问 / 延伸
- 什么是 keep-alive?答:TCP 连接保持打开,不关闭,下次请求复用。
- 为什么 response.Body 要读完?答:读完 body 连接才能放回连接池复用;没读完连接会被关闭,不能复用。
待整理清单
- [ ] Go 泛型实战案例
- [ ] net/http 底层原理
- [ ] Go 标准库常用包
- [ ] context 与超时控制