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

05.6 阶段 5 Web 服务与 gRPC

所属:全栈开发面试题库 / 学习路径 / 05 Go 全栈

本页目录

一、阶段定位

前四个阶段都在解决"一个进程内怎么写好代码",本阶段开始解决"怎么把代码暴露成网络服务"。Go 的 net/http 标准库非常完整,但真实项目里几乎都要用框架(Gin/Chi/Echo);服务间调用则用 gRPC。本阶段的目标不是"学会 Gin 怎么写路由",而是理解 Handler、中间件、超时、优雅关闭这四件事——换任何框架都不变。

与前后阶段的衔接:

  • 往上接阶段 3 的 context:HTTP 服务每请求一个 goroutine,超时控制全靠 context;不打好 context 基础,本阶段的"读超时/写超时"会变成黑盒。
  • 往上接阶段 4 的 pprof:服务上线后延迟抖、内存涨,要靠本阶段的 pprof HTTP 接口抓 profile。
  • 往下接阶段 6(05.7):HTTP handler 后面要接数据库与 Redis,本阶段先把 HTTP 层做对。
  • 再往下接阶段 7(05.8):服务要容器化、上 K8s,本阶段的优雅关闭是 K8s 滚动更新不报错的前提。

原提纲里的"卡点"展开成可判断的现象依据:

  • 忽略读超时与写超时:服务起一个慢查询,连接一直挂着,并发上去后文件描述符打满。
  • 中间件顺序错:panic recovery 放在日志中间件后面,结果 panic 先打了一堆日志才被捕获。
  • gRPC 不传 deadline:请求挂死在下游,goroutine 泄漏,连接池被占满。

二、阶段目标与投入

能力目标(可验证的行为) 验证方式
能解释 http.Handler 接口与中间件链的执行顺序 手写一个"日志 + recovery"中间件,能画出请求从进入到响应的链路
能配置 ReadTimeout、WriteTimeout、IdleTimeout 一个服务起 1 秒读超时,用 curl --max-time 2 验证超时断开
能用 Gin 写路由分组与中间件,做参数校验 一个 POST 接口要求 JSON body 字段非空,校验失败返回 400
能实现优雅关闭:收到信号后处理完在途请求再退出 压测时发 SIGTERM,验证在途请求全部完成
能定义 proto 文件,生成 gRPC 服务端与客户端 一个一元 RPC 接口,客户端调用成功
能写 gRPC 拦截器做鉴权或日志 拦截器打印每个 RPC 的方法名与耗时

建议学时:

  • 全职:2 周,约 50–60 小时。net/http 与中间件 15 小时、Gin 与参数校验 15 小时、优雅关闭 5 小时、gRPC 15 小时、拦截器 10 小时。
  • 在职:4–5 周,约 60 小时。gRPC 单独占一周。

学时分配建议:net/http 原理 15%、中间件与超时 20%、Gin 与路由 15%、优雅关闭 10%、gRPC 与 proto 25%、拦截器 15%。

三、先修自检

先修项 合格标准 不合格时回到
HTTP 模型 知道方法、状态码、头部,会用 curl 05.1 的 5.5 节
context 能用 context.WithTimeout 让函数退出 05.4 的 5.3 节
错误包装 能用 %w 保留错误链 05.3 的 5.3 节
接口与依赖注入 能写小接口并注入实现 05.3 的 5.1 节
pprof 能抓 CPU/heap profile 05.5 的 5.5 节

经验判断:有 Node.js 经验的人容易把 Gin 当 Express 用,到处写回调;有 Java 经验的人容易过度设计分层,一个接口拆三个文件。本阶段以"能跑、能观测、能优雅关闭"为目标。

四、知识地图

模块 知识点 掌握程度 对应题库章节
net/http Handler、ServeMux、连接复用、超时 能讲清原理 06.6 Go 后端
中间件 中间件链、Recovery、日志、超时 会用 06.6 Go 后端
Web 框架 Gin/Echo/Chi/Fiber 取舍 会用 06.6 Go 后端
优雅关闭 信号监听、在途请求处理、资源释放 会用 06.6 Go 后端
gRPC proto、服务定义、生成代码、流式 会用 06.6 Go 后端
gRPC 拦截器 unary 拦截器、stream 拦截器、鉴权 会用 06.6 Go 后端
限流熔断 令牌桶、熔断、降级 了解 09.2 流量治理

进度管理建议:net/http 与中间件是面试高频,必须到"能讲清原理";gRPC 要求"会用",能定义 proto 与拦截器即可。

五、分模块精讲

5.1 net/http 与 Handler 原理

为什么需要它:理解 net/http 才能理解为什么 Gin 能"包"在标准库上。每个请求一个 goroutine,Handler 是接口,这是 Go Web 服务的根基。

核心机制:

  • http.Handler 接口:ServeHTTP(ResponseWriter, *Request)。任何实现该接口的类型都能注册为 handler。
  • http.ServeMux:路由器,把请求路径映射到 handler;Go 1.22 起支持方法与路径参数(GET /users/{id})。
  • 连接模型:每个 TCP 连接一个读 goroutine,每个请求一个新 goroutine(server.go 里 go c.serve())。
  • http.Server 的超时参数:ReadTimeout(读完请求头+体的时间)、WriteTimeout(写完响应的时间)、IdleTimeout(keep-alive 空闲时间)。
  • 不设超时的后果:慢客户端让连接一直挂着,文件描述符打满。

最小可运行示例:

package main

import (
	"encoding/json"
	"log"
	"net/http"
	"time"
)

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("GET /users/{id}", func(w http.ResponseWriter, r *http.Request) {
		id := r.PathValue("id")
		w.Header().Set("Content-Type", "application/json")
		_ = json.NewEncoder(w).Encode(map[string]string{"id": id})
	})

	srv := &http.Server{
		Addr:         ":8080",
		Handler:      mux,
		ReadTimeout:  5 * time.Second,  // 读请求 5 秒
		WriteTimeout: 10 * time.Second, // 写响应 10 秒
		IdleTimeout:  120 * time.Second,
	}
	log.Fatal(srv.ListenAndServe())
}
curl -i http://127.0.0.1:8080/users/100
# HTTP/1.1 200 OK
# Content-Type: application/json
# {"id":"100"}

常见坑:

现象 原因 修法
连接一直挂着,并发上去 fd 打满 没设 ReadTimeout/WriteTimeout 设 http.Server 的三个超时
404 page not found 路径与注册不匹配 Go 1.22 前要区分尾斜杠;1.22 起用 GET /users/{id}
handler 里 panic 导致整个连接断开 没 recovery 中间件 加 recovery 中间件

面试考法:"net/http 每个请求一个 goroutine 吗""ServeMux 怎么路由""为什么要设超时"。要点:每请求一个 goroutine;ServeMux 按路径匹配;超时防慢客户端耗尽连接。

5.2 中间件链与超时控制

为什么需要它:日志、鉴权、recovery、超时这些横切逻辑不能写进每个 handler,要用中间件统一处理。中间件顺序错会导致 panic 没被捕获、日志漏记。

核心机制:

  • 中间件签名:func(next http.Handler) http.Handler,包一层 handler 返回新 handler。
  • 执行顺序:按注册顺序进入,按 LIFO 顺序返回(洋葱模型)。
  • 必须最先注册:Recovery(捕获 panic,否则进程崩)、RequestID(贯穿日志)。
  • 超时中间件:用 http.TimeoutHandler 或自己包一层 context.WithTimeout,超时后返回 504。
  • 鉴权中间件:从 Authorization 头解析 token,失败返回 401。

最小可运行示例:

package main

import (
	"context"
	"log"
	"net/http"
	"time"
)

// 中间件类型
type Middleware func(http.Handler) http.Handler

// 链多个中间件
func Chain(h http.Handler, mws ...Middleware) http.Handler {
	for i := len(mws) - 1; i >= 0; i-- {
		h = mws[i](h)
	}
	return h
}

func Recovery(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		defer func() {
			if rec := recover(); rec != nil {
				log.Printf("panic: %v", rec)
				http.Error(w, "internal server error", http.StatusInternalServerError)
			}
		}()
		next.ServeHTTP(w, r)
	})
}

func Logger(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		start := time.Now()
		next.ServeHTTP(w, r)
		log.Printf("%s %s %v", r.Method, r.URL.Path, time.Since(start))
	})
}

func Timeout(timeout time.Duration) Middleware {
	return func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			ctx, cancel := context.WithTimeout(r.Context(), timeout)
			defer cancel()
			next.ServeHTTP(w, r.WithContext(ctx))
		})
	}
}

func main() {
	h := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		// handler 里读 ctx 判断超时
		select {
		case <-r.Context().Done():
			http.Error(w, "timeout", http.StatusGatewayTimeout)
		default:
			w.Write([]byte("ok"))
		}
	})
	// 顺序:Recovery 最外,然后 Logger,然后 Timeout
	wrapped := Chain(h, Recovery, Logger, Timeout(2*time.Second))
	_ = http.ListenAndServe(":8080", wrapped)
}

常见坑:

现象 原因 修法
panic 后整个进程崩了 Recovery 没放在最外层 Recovery 必须是第一个中间件
日志没记录请求路径 Logger 放在 Timeout 之后,超时没走到 next Logger 放 Timeout 外层
超时中间件设了但 handler 不响应 handler 没用 r.Context() 所有耗时操作接收 ctx

面试考法:"中间件执行顺序""为什么 Recovery 要放最外层""怎么实现超时"。要点:洋葱模型 LIFO;Recovery 最外防进程崩;超时用 context 传播。

5.3 Gin 与路由分组

为什么需要它:标准库路由功能弱(Go 1.22 前)、参数校验繁琐,Gin 是最常用的框架。它围绕 http.Handler 接口扩展,中间件模型与标准库一致。

核心机制:

  • Gin 的 *gin.Engine 实现了 http.Handler,可以直接传给 http.Server。
  • 路由分组:r.Group("/api/v1") 给一组路由加前缀与中间件。
  • gin.Context 封装了 http.ResponseWriter 与 *http.Request,提供 JSON、ShouldBindJSON 等便捷方法。
  • 参数校验:用 binding tag(validate:"required"),ShouldBindJSON 自动校验。
  • Gin 的中间件签名:gin.HandlerFunc,与标准库不同但模型一致。

最小可运行示例:

package main

import (
	"net/http"

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

type CreateUserReq struct {
	Name string `json:"name" binding:"required"`
	Age  int    `json:"age" binding:"gte=0,lte=150"`
}

func main() {
	r := gin.Default() // 自带 Logger 与 Recovery

	// 分组:/api/v1
	v1 := r.Group("/api/v1")
	{
		v1.POST("/users", func(c *gin.Context) {
			var req CreateUserReq
			if err := c.ShouldBindJSON(&req); err != nil {
				c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
				return
			}
			c.JSON(http.StatusCreated, gin.H{"name": req.Name, "age": req.Age})
		})
	}

	_ = r.Run(":8080")
}
curl -i -X POST http://127.0.0.1:8080/api/v1/users \
  -H "Content-Type: application/json" \
  -d '{"name":"ann","age":30}'
# 201 {"name":"ann","age":30}

curl -i -X POST http://127.0.0.1:8080/api/v1/users \
  -H "Content-Type: application/json" \
  -d '{"age":200}'
# 400 {"error":"Key: 'CreateUserReq.Name' Error:Field validation for 'Name' failed on the 'required' tag"}

常见坑:

现象 原因 修法
ShouldBindJSON 报 EOF body 没设 Content-Type 客户端设 Content-Type: application/json
校验失败返回的英文错误不好看 直接用 err.Error() 自定义校验错误映射
Gin 的 Recovery 把 panic 变成 500 但没日志 没接 zap 用 gin.LoggerWithConfig 或自定义 recovery

面试考法:"Gin 与标准库关系""路由分组怎么用""参数校验怎么做"。要点:Engine 实现 http.Handler;Group 加前缀与中间件;binding tag + ShouldBindJSON。

5.4 优雅关闭

为什么需要它:K8s 滚动更新时,旧 Pod 收到 SIGTERM 后如果立刻退出,在途请求会被切断;如果等太久,K8s 的 terminationGracePeriodSeconds(默认 30s)会强制杀进程。优雅关闭就是在两者间平衡。

核心机制:

  • 监听 syscall.SIGTERM 与 syscall.SIGINT。
  • 收到信号后调用 srv.Shutdown(ctx):停止接收新连接,等在途请求完成,关闭监听。
  • 同时关闭数据库连接池、消息队列消费者、Redis 连接。
  • 给 Shutdown 一个超时(如 10 秒),超时强制退出。

最小可运行示例:

package main

import (
	"context"
	"log"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"
)

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		time.Sleep(2 * time.Second) // 模拟慢请求
		w.Write([]byte("ok"))
	})

	srv := &http.Server{Addr: ":8080", Handler: mux}

	// 启动服务
	go func() {
		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			log.Fatal(err)
		}
	}()

	// 等待信号
	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
	<-quit
	log.Println("shutting down...")

	// 给 10 秒处理在途请求
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	if err := srv.Shutdown(ctx); err != nil {
		log.Fatal("forced shutdown:", err)
	}
	log.Println("server exited")
}
# 压测时另开一个终端发 SIGTERM
# kill -TERM <pid>
# 期望:在途请求(2 秒)完成后才退出,不返回 502

常见坑:

现象 原因 修法
K8s 滚动更新时偶发 502 没做优雅关闭,SIGTERM 立刻杀进程 用 srv.Shutdown(ctx)
优雅关闭等了 30 秒才退 Shutdown 超时设太长 按 K8s terminationGracePeriodSeconds 设(默认 30s,留 5s 余量)
数据库连接没关 Shutdown 只关 HTTP,没关 DB 同时 db.Close()、关 consumer

面试考法:"优雅关闭怎么做""为什么要监听 SIGTERM""K8s 滚动更新为什么不能直接杀进程"。要点:Shutdown 停新连接等在途;同时关资源;超时兜底。

5.5 gRPC 与 Protobuf 服务定义

为什么需要它:服务间内部调用,HTTP/JSON 有文本解析开销、契约不严格。gRPC 用 Protobuf 二进制序列化、HTTP/2 多路复用,契约由 .proto 文件定义,生成类型安全的代码。

核心机制:

  • .proto 文件定义服务(service)与消息(message):rpc SayHello (HelloRequest) returns (HelloReply)。
  • 用 protoc-gen-go 生成消息结构体,protoc-gen-go-grpc 生成服务端与客户端 stub。
  • 四种方法:一元(unary)、服务端流式、客户端流式、双向流式。
  • 默认用 HTTP/2,一个连接多路复用多个 RPC。
  • 错误码用 gRPC 标准码(codes.InvalidArgument、codes.NotFound 等),不要返回 HTTP 状态码。

最小可运行示例:

// hello.proto
syntax = "proto3";
option go_package = "example.com/hello/hellopb";

service HelloService {
  rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}
# 生成代码
protoc --go_out=. --go_opt=paths=source_relative \
       --go-grpc_out=. --go-grpc_opt=paths=source_relative \
       hello.proto
# 产出 hello.pb.go 与 hello_grpc.pb.go
// 服务端
package main

import (
	"context"
	"log"
	"net"

	"example.com/hello/hellopb"
	"google.golang.org/grpc"
)

type server struct {
	hellopb.UnimplementedHelloServiceServer
}

func (s *server) SayHello(ctx context.Context, req *hellopb.HelloRequest) (*hellopb.HelloReply, error) {
	return &hellopb.HelloReply{Message: "hello " + req.Name}, nil
}

func main() {
	lis, _ := net.Listen("tcp", ":50051")
	s := grpc.NewServer()
	hellopb.RegisterHelloServiceServer(s, &server{})
	log.Fatal(s.Serve(lis))
}
// 客户端
func main() {
	conn, _ := grpc.Dial("127.0.0.1:50051", grpc.WithInsecure())
	defer conn.Close()
	c := hellopb.NewHelloServiceClient(conn)
	resp, err := c.SayHello(context.Background(), &hellopb.HelloRequest{Name: "ann"})
	if err != nil {
		log.Fatal(err)
	}
	log.Println(resp.Message) // hello ann
}

常见坑:

现象 原因 修法
生成代码报 protoc-gen-go: program not found 没装 protoc 插件 go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
客户端 rpc error: code = Unavailable 服务端没起或端口错 确认 net.Listen 端口;客户端 grpc.Dial 地址对
不传 ctx 导致请求挂死 没设超时 客户端 c.SayHello(ctx, ...) 用 context.WithTimeout

面试考法:"gRPC 与 HTTP/JSON 区别""四种方法模式""为什么用 Protobuf"。要点:二进制序列化、HTTP/2 多路复用、契约由 proto 定义;一元/服务端流/客户端流/双向流。

5.6 gRPC 拦截器与超时重试

为什么需要它:鉴权、日志、超时、限流这些横切逻辑不能写进每个 RPC,要用拦截器统一处理。

核心机制:

  • 一元拦截器:grpc.UnaryServerInterceptor,签名 func(ctx, req, info, handler) (resp, error)。
  • 流式拦截器:grpc.StreamServerInterceptor,处理流式 RPC。
  • 注册:grpc.NewServer(grpc.UnaryInterceptor(myInterceptor))。
  • 超时:客户端用 context.WithTimeout,服务端用 grpc.WithUnaryServerTimeout 或拦截器统一设。
  • 重试:用 grpc-go 的 grpc.WithDefaultCallOptions 或插件 grpc-go-middleware;不要随便重试非幂等接口。

最小可运行示例:

package main

import (
	"context"
	"log"
	"time"

	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
)

// 日志拦截器
func LoggingInterceptor(ctx context.Context, req any, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (any, error) {
	start := time.Now()
	resp, err := handler(ctx, req)
	log.Printf("method=%s duration=%v err=%v", info.FullMethod, time.Since(start), err)
	return resp, err
}

// 鉴权拦截器
func AuthInterceptor(ctx context.Context, req any, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (any, error) {
	// 从 ctx 取 token(客户端用 metadata 传)
	if err := checkAuth(ctx); err != nil {
		return nil, status.Errorf(codes.Unauthenticated, "invalid token: %v", err)
	}
	return handler(ctx, req)
}

func checkAuth(ctx context.Context) error {
	// 简化:从 metadata 取 authorization
	return nil
}

func main() {
	s := grpc.NewServer(
		grpc.ChainUnaryInterceptor(LoggingInterceptor, AuthInterceptor),
	)
	_ = s
}
// 客户端超时
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
resp, err := c.SayHello(ctx, &hellopb.HelloRequest{Name: "ann"})
// 超时后 err == codes.DeadlineExceeded

常见坑:

现象 原因 修法
拦截器没生效 用了 grpc.UnaryInterceptor 只注册一个,多个要 ChainUnaryInterceptor 用 Chain
客户端不传超时,请求挂死 忘了 context.WithTimeout 所有 RPC 客户端调用都包超时
鉴权拦截器放在日志后面,401 没日志 顺序错 日志放最外,鉴权在里面

面试考法:"gRPC 拦截器怎么写""为什么要传 deadline""拦截器顺序"。要点:UnaryServerInterceptor;Chain 注册多个;客户端必须设超时;日志最外。

5.7 限流与熔断(了解)

为什么需要它:下游服务挂了,不能让请求全部打过去把自己也拖垮。限流保护自己,熔断保护下游。

核心机制:

  • 令牌桶:固定速率往桶里放令牌,请求取令牌,取不到就拒绝。
  • 漏桶:请求先进桶,按固定速率流出。
  • 熔断:下游错误率超过阈值时,暂时停止调用(打开状态),过一段时间半开试探。
  • Go 生态:golang.org/x/time/rate(令牌桶)、sony/gobreaker(熔断)。

最小可运行示例:

package main

import (
	"context"
	"net/http"

	"golang.org/x/time/rate"
)

var limiter = rate.NewLimiter(100, 200) // 100 QPS,桶容量 200

func LimitMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if !limiter.Allow() {
			http.Error(w, "too many requests", http.StatusTooManyRequests)
			return
		}
		next.ServeHTTP(w, r)
	})
}

func main() {
	_ = http.ListenAndServe(":8080", LimitMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("ok"))
	})))
}

常见坑:

现象 原因 修法
限流太严,正常请求被拒 QPS 设太低 按压测结果调;用 429 而不是 500
熔断后一直不放行 半开状态没设 设熔断恢复时间

面试考法:"限流算法""熔断状态机"。要点:令牌桶允许突发;漏桶平滑;熔断三态(关闭/打开/半开)。

六、分层练习

6.1 复现型

练习 要求 验收标准 预计耗时
手写 Handler 用标准库写 GET /users/{id} 返回 JSON curl 能拿到正确响应 1 小时
中间件链 写 Recovery + Logger 两个中间件 故意 panic 返回 500,进程不崩 1 小时
超时配置 设 ReadTimeout=2s,起一个 5 秒的 handler 客户端 curl --max-time 3 看到连接断开 1 小时
Gin 参数校验 写 POST /users,name 必填 缺 name 返回 400 1 小时
优雅关闭 起服务,压测时发 SIGTERM 在途请求完成后退出 1 小时

6.2 改造型

练习 要求 验收标准 预计耗时
加 RequestID 在中间件生成 request id,注入 context 与响应头 每个请求响应头有 X-Request-Id 1 小时
错误响应规范 统一错误返回 {"error":"...","code":400} 所有错误格式一致 1 小时
gRPC 拦截器 给 gRPC 服务加日志拦截器 每个 RPC 打印方法名与耗时 2 小时
gRPC 客户端超时 客户端调用加 2 秒超时 下游慢时返回 codes.DeadlineExceeded 1 小时
限流中间件 给 HTTP 服务加令牌桶限流 超过 QPS 返回 429 1 小时

6.3 设计型

练习 要求 验收标准 预计耗时
分层 HTTP 服务 handler / service / repository 三层,Gin 路由 + 优雅关闭 依赖注入清晰;压测时 SIGTERM 不丢请求 6 小时
gRPC 用户服务 定义 proto,实现 GetUser 与 CreateUser,带鉴权拦截器 客户端调用成功;无 token 返回 401 6 小时
限流 + 熔断组合 入口限流 + 下游调用熔断 下游故障时快速失败,不拖垮 4 小时

七、排障表

现象 可能原因 排查步骤 解决办法
请求挂死不返回 没设超时;下游慢 curl -v 看连接;pprof goroutine 看阻塞 设 ReadTimeout/WriteTimeout;客户端设 ctx 超时
panic 后进程崩了 Recovery 没放最外 看中间件注册顺序 Recovery 必须是第一个
K8s 滚动更新偶发 502 没优雅关闭 看 Pod 日志退出时机 用 srv.Shutdown(ctx)
gRPC 客户端 code = Unavailable 服务端没起、端口错、TLS 配置 grpcurl 或 nc -zv host port 确认服务与端口
gRPC 请求挂死 没传 deadline 客户端 ctx 加超时 context.WithTimeout
限流后正常请求被拒 QPS 设太低 看 429 日志 按压测调;用 429
Gin 的 ShouldBindJSON 报 EOF Content-Type 没设 客户端 curl 加 -H "Content-Type: application/json"
连接数持续上涨 没设 IdleTimeout,keep-alive 不释放 netstat 看 TIME_WAIT 设 IdleTimeout

八、出口条件

全部勾选后再进入 05.7 阶段 6 数据层、缓存与消息。

  • [ ] 能解释 http.Handler 接口与每请求一个 goroutine 的模型
  • [ ] 能配置 ReadTimeout/WriteTimeout/IdleTimeout
  • [ ] 能写 Recovery + Logger 中间件,顺序正确
  • [ ] 能用 Gin 写路由分组与参数校验
  • [ ] 能实现优雅关闭,K8s 滚动更新不丢请求
  • [ ] 能定义 proto 并生成 gRPC 服务端与客户端
  • [ ] 能写 gRPC 拦截器做日志或鉴权
  • [ ] 客户端 RPC 调用都带超时

自测题:

  1. net/http 每个请求是一个 goroutine 吗?为什么?
    • 要点:是;每个 TCP 连接一个读 goroutine,每个请求 go c.serve() 起新 goroutine。
  2. 中间件执行顺序是什么?为什么 Recovery 要放最外?
    • 要点:洋葱模型,LIFO;Recovery 放最外才能捕获所有内层 panic。
  3. 优雅关闭的步骤是什么?
    • 要点:监听信号 → srv.Shutdown(ctx) 停新连接等在途 → 关 DB/consumer → 超时退出。
  4. gRPC 四种方法模式?
    • 要点:一元、服务端流式、客户端流式、双向流式。
  5. gRPC 拦截器怎么注册多个?
    • 要点:grpc.ChainUnaryInterceptor 按顺序注册。
  6. 为什么 gRPC 客户端必须传 deadline?
    • 要点:不传则请求挂死时 goroutine 泄漏、连接池被占满;超时返回 codes.DeadlineExceeded。