罗罗编程学习记录
本页内容 展开查看

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{} 的别名,最宽松的约束。
  • 适合场景:通用数据结构、通用工具函数、避免代码重复。

原理流程

  1. 写函数时,用 [T any] 声明类型参数 T。
  2. 函数里可以把 T 当成类型用,比如 T 是切片元素类型。
  3. 调用时,编译器自动推导 T 的具体类型,或者手动指定。
  4. 不用为 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 等。

原理流程

  1. 注册路由:http.HandleFunc("/users", userHandler)。
  2. 启动服务:http.ListenAndServe(":8080", nil)。
  3. 请求进来,ServeMux 匹配路径,调用对应的 Handler。
  4. 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:整个请求的最大时间(包括连接、发请求、读响应)。

原理流程

  1. 不配超时的话,如果客户端很慢,服务器的 goroutine 会一直挂着等。
  2. 高并发时,大量慢请求会占满 goroutine 和文件描述符,服务就不可用了。
  3. 配了超时,超过时间就主动断开,释放资源。

代码 / 示例

// 服务器超时配置
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 恢复)。

原理流程

  1. 写一个中间件函数,接收 next http.Handler。
  2. 返回一个新的 http.Handler,里面先做前置逻辑,然后调用 next.ServeHTTP,再做后置逻辑。
  3. 把多个中间件串起来,从外到里一层层包。

代码 / 示例

// 日志中间件
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:必须关闭,否则连接泄漏。

原理流程

  1. 调用 http.Get 发请求。
  2. 拿到 response,读 body。
  3. 读完 body,必须关闭 response.Body。
  4. 连接才能放回连接池复用。

代码 / 示例

// 简单 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 等参数。

原理流程

  1. 发请求时,先从连接池找有没有空闲连接。
  2. 有就直接用,没有就新建一个。
  3. 用完不关闭,放回连接池。
  4. 下次请求直接复用。

代码 / 示例

// 自定义 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 与超时控制