阶段2(上):后端专题 Go/Gin/PostgreSQL/MySQL/Redis/MQ/gRPC 的课程、企业场景、面试题和可运行示例

This commit is contained in:
Shikui Wang committed 2026-10-23 15:24:57 +08:00
1 parent 0bae9916a9
commit 5eb67c5d08
65 files changed
+6457 -77

No files matched your search

@@ -0,0 +1,81 @@
# requires: grpc, grpc_tools
"""gRPC 演示:从 user.proto 生成代码 → 启动服务端 → 客户端调用(一元、服务端流、超时、错误码)。
运行:pip install grpcio grpcio-tools && python demo.py
生成的代码放在临时目录,不污染仓库。
"""
import importlib
import sys
import tempfile
import time
from concurrent import futures
from pathlib import Path
import grpc
from grpc_tools import protoc
HERE = Path(__file__).resolve().parent
def generate(out: Path):
rc = protoc.main(["protoc", f"-I{HERE}", f"--python_out={out}", f"--grpc_python_out={out}", str(HERE / "user.proto")])
assert rc == 0, "protoc 生成失败"
sys.path.insert(0, str(out))
return importlib.import_module("user_pb2"), importlib.import_module("user_pb2_grpc")
def main() -> None:
with tempfile.TemporaryDirectory() as tmp:
pb, pb_grpc = generate(Path(tmp))
users = {i: pb.User(id=i, name=f"用户{i}", email=f"u{i}@example.com") for i in range(1, 6)}
class UserService(pb_grpc.UserServiceServicer):
def GetUser(self, request, context):
if request.id == 99:
time.sleep(0.5) # 模拟慢请求
user = users.get(request.id)
if user is None:
context.abort(grpc.StatusCode.NOT_FOUND, f"用户 {request.id} 不存在")
return user
def ListUsers(self, request, context):
for i, u in enumerate(users.values()):
if i >= request.page_size:
break
yield u
server = grpc.server(futures.ThreadPoolExecutor(max_workers=4))
pb_grpc.add_UserServiceServicer_to_server(UserService(), server)
port = server.add_insecure_port("127.0.0.1:0") # 0 = 随机可用端口
server.start()
try:
with grpc.insecure_channel(f"127.0.0.1:{port}") as ch:
stub = pb_grpc.UserServiceStub(ch)
u = stub.GetUser(pb.GetUserRequest(id=1), timeout=1.0) # 每次调用都带超时
print("一元调用:", u.id, u.name)
assert u.name == "用户1"
names = [x.name for x in stub.ListUsers(pb.ListUsersRequest(page_size=3), timeout=1.0)]
print("服务端流:", names)
assert len(names) == 3
try:
stub.GetUser(pb.GetUserRequest(id=42), timeout=1.0)
raise AssertionError("应该返回 NOT_FOUND")
except grpc.RpcError as e:
print("错误码:", e.code().name, e.details())
assert e.code() == grpc.StatusCode.NOT_FOUND
try:
stub.GetUser(pb.GetUserRequest(id=99), timeout=0.1)
raise AssertionError("应该超时")
except grpc.RpcError as e:
print("超时:", e.code().name)
assert e.code() == grpc.StatusCode.DEADLINE_EXCEEDED
finally:
server.stop(grace=None)
print("gRPC 演示通过")
if __name__ == "__main__":
main()
@@ -0,0 +1,26 @@
syntax = "proto3";
package user.v1;
// 用户服务:一个一元调用 + 一个服务端流
service UserService {
rpc GetUser(GetUserRequest) returns (User);
rpc ListUsers(ListUsersRequest) returns (stream User);
}
message GetUserRequest {
int64 id = 1;
}
message ListUsersRequest {
int32 page_size = 1;
}
message User {
int64 id = 1;
string name = 2;
string email = 3;
// 字段编号一旦发布就不能修改或复用;删除字段时用 reserved
reserved 4;
reserved "phone";
}
@@ -0,0 +1,3 @@
module example/resilience
go 1.22
@@ -0,0 +1,119 @@
// Package resilience 服务调用的三件套:超时(由调用方的 context 控制)、带退避的重试、熔断器。只用标准库。
package resilience
import (
"context"
"errors"
"math/rand/v2"
"sync"
"time"
)
// ErrOpen 熔断器打开时直接返回,不再调用下游
var ErrOpen = errors.New("熔断中:下游暂时不可用")
// Permanent 包装不应该重试的错误(参数错误、没有权限、资源不存在等)
type Permanent struct{ Err error }
func (p Permanent) Error() string { return p.Err.Error() }
func (p Permanent) Unwrap() error { return p.Err }
// Retry 最多尝试 attempts 次,间隔指数增长并加随机抖动;context 取消或超时立即停止
func Retry(ctx context.Context, attempts int, base time.Duration, fn func(context.Context) error) error {
var err error
for i := range attempts {
if err = fn(ctx); err == nil {
return nil
}
var p Permanent
if errors.As(err, &p) || errors.Is(err, ErrOpen) || i == attempts-1 {
return err
}
backoff := base << i // base, 2*base, 4*base ...
backoff += time.Duration(rand.Int64N(int64(backoff)/2 + 1)) // 抖动,避免所有客户端同时重试
select {
case <-ctx.Done():
return errors.Join(err, ctx.Err())
case <-time.After(backoff):
}
}
return err
}
type state int
const (
closed state = iota // 正常放行
open // 熔断:直接拒绝
halfOpen // 试探:放一个请求过去
)
// Breaker 连续失败 threshold 次后打开,cooldown 之后进入半开,试探成功则关闭、失败则重新打开
type Breaker struct {
mu sync.Mutex
state state
failures int
threshold int
cooldown time.Duration
openedAt time.Time
probing bool
now func() time.Time // 测试时可以替换
}
func NewBreaker(threshold int, cooldown time.Duration) *Breaker {
return &Breaker{threshold: threshold, cooldown: cooldown, now: time.Now}
}
func (b *Breaker) allow() bool {
b.mu.Lock()
defer b.mu.Unlock()
switch b.state {
case open:
if b.now().Sub(b.openedAt) < b.cooldown {
return false
}
b.state = halfOpen
fallthrough
case halfOpen:
if b.probing {
return false // 半开状态只放一个试探请求
}
b.probing = true
return true
}
return true
}
func (b *Breaker) record(err error) {
b.mu.Lock()
defer b.mu.Unlock()
var p Permanent
failed := err != nil && !errors.As(err, &p) // 业务错误不算下游故障
if b.state == halfOpen {
b.probing = false
if failed {
b.state, b.openedAt = open, b.now()
} else {
b.state, b.failures = closed, 0
}
return
}
if !failed {
b.failures = 0
return
}
b.failures++
if b.failures >= b.threshold {
b.state, b.openedAt = open, b.now()
}
}
// Do 通过熔断器调用 fn
func (b *Breaker) Do(ctx context.Context, fn func(context.Context) error) error {
if !b.allow() {
return ErrOpen
}
err := fn(ctx)
b.record(err)
return err
}
@@ -0,0 +1,82 @@
package resilience
import (
"context"
"errors"
"sync/atomic"
"testing"
"time"
)
var errDown = errors.New("下游 503")
func TestRetrySucceedsAfterTransientErrors(t *testing.T) {
var calls atomic.Int32
err := Retry(context.Background(), 5, time.Millisecond, func(context.Context) error {
if calls.Add(1) < 3 {
return errDown
}
return nil
})
if err != nil || calls.Load() != 3 {
t.Fatalf("err=%v calls=%d", err, calls.Load())
}
}
func TestRetryStopsOnPermanent(t *testing.T) {
var calls int
err := Retry(context.Background(), 5, time.Millisecond, func(context.Context) error {
calls++
return Permanent{errors.New("参数错误")}
})
if calls != 1 || err == nil {
t.Fatalf("不可重试的错误只应调用一次,calls=%d", calls)
}
}
func TestRetryRespectsDeadline(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Millisecond)
defer cancel()
start := time.Now()
err := Retry(ctx, 10, 20*time.Millisecond, func(context.Context) error { return errDown })
if !errors.Is(err, context.DeadlineExceeded) || time.Since(start) > 200*time.Millisecond {
t.Fatalf("应该在截止时间后停止:%v,耗时 %v", err, time.Since(start))
}
}
func TestBreaker(t *testing.T) {
now := time.Unix(0, 0)
b := NewBreaker(3, 10*time.Second)
b.now = func() time.Time { return now }
ctx := context.Background()
fail := func(context.Context) error { return errDown }
ok := func(context.Context) error { return nil }
for range 3 {
_ = b.Do(ctx, fail)
}
if err := b.Do(ctx, ok); !errors.Is(err, ErrOpen) {
t.Fatalf("连续失败 3 次后应该熔断,得到 %v", err)
}
now = now.Add(11 * time.Second) // 冷却结束 → 半开,试探失败 → 重新打开
if err := b.Do(ctx, fail); !errors.Is(err, errDown) {
t.Fatalf("半开时应放行试探请求:%v", err)
}
if err := b.Do(ctx, ok); !errors.Is(err, ErrOpen) {
t.Fatal("试探失败后应该重新熔断")
}
now = now.Add(11 * time.Second) // 再次半开,试探成功 → 关闭
if err := b.Do(ctx, ok); err != nil {
t.Fatal(err)
}
if err := b.Do(ctx, ok); err != nil {
t.Fatal("恢复后应该正常放行")
}
// 业务错误不计入熔断
for range 5 {
_ = b.Do(ctx, func(context.Context) error { return Permanent{errors.New("用户不存在")} })
}
if err := b.Do(ctx, ok); err != nil {
t.Fatal("业务错误不应该触发熔断")
}
}