Skip to content
SuperJingggPublic

About

No description, website, or topics provided.

Resources

Stars

0 stars

Watchers

0 watching

Forks

Latest commit

 

History

2 Commits

Folders and files

NameName
Last commit message
Last commit date
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

my-rpc

一款使用 Go 从零手写的轻量级 RPC 框架,适合学习分布式系统通信的内部原理。

功能特性

  • 自定义 TCP 协议 — 带 Magic Number 的二进制协议,长度域解决粘包问题
  • 可插拔编解码器 — 基于工厂注册模式的 JSON / Protobuf 序列化
  • Gzip 压缩 — 透明的 Body 压缩,接口可扩展(Compressor 接口已导出)
  • 服务发现 — 基于 etcd 的注册中心,支持 Watch 实时同步服务实例列表
  • 负载均衡 — 随机、轮询,平滑加权轮询三种算法
  • 连接池 — 按地址独立管理连接池,自动清理失效连接
  • 熔断器 — 基于计数窗口的 Closed → Open → HalfOpen 状态机
  • 限流 — 客户端与服务端均采用令牌桶进行流量控制
  • 异步 / 同步调用 — InvokeAsync 返回 Future,Invoke 自动携带超时 Context
  • 优雅关闭 — 支持信号感知,逐个关闭连接后安全退出

架构图

┌──────────────────────────────────────────────────┐
│                      Client                       │
│  Invoke / InvokeAsync → Breaker → Limiter → LB   │
│           → ConnectionPool → TCPClient → Future   │
└───────────────────────┬──────────────────────────┘
                        │ TCP(自定义二进制协议)
┌───────────────────────┴──────────────────────────┐
│                      Server                       │
│  Accept → TCPConnection → Limiter → Handler      │
│         → 反射调用服务方法 → Encode Response       │
└──────────────────────────────────────────────────┘

协议格式

+--------+------------+----------+----------+------------+
| Magic  | HeaderLen  | BodyLen  |  Header  |    Body    |
| 2字节  |   4字节    |  4字节   |  N 字节   |  N 字节    |
+--------+------------+----------+----------+------------+
  • Magic:0x1234,用于识别合法数据包
  • HeaderLen / BodyLen:大端序 uint32,最大分别限制为 1MB / 16MB(防止恶意大包攻击)
  • Header:JSON 序列化的结构体,包含 RequestID、ServiceName、MethodName、Error、CodecType、Compression
  • Body:序列化后的请求/响应体,Header 中声明压缩方式时自动解压

目录结构

my-rpc/
├── cmd/
│   ├── server1/          # 服务实例,监听 :9090,注册 Arith 和 Arith2
│   ├── server2/          # 服务实例,监听 :9091,注册 Arith
│   ├── client/           # 异步调用示例,每 5 秒批量发送 3 个请求
│   ├── bench1/           # 固定总量压测工具(-n 总请求数 -c 并发数)
│   └── bench2/           # 固定时长压测工具(-d 秒数),输出 P50/P90/P99 延迟
├── internal/
│   ├── breaker/          # 熔断器(三态:Closed / Open / HalfOpen)
│   ├── client/           # RPC 客户端(Options 模式配置编解码器 / 超时 / 负载均衡器)
│   ├── codec/            # 编解码器工厂 + JSON / Protobuf 实现 + Gzip 压缩实现
│   ├── limiter/          # 令牌桶限流器(100ms 精度补充令牌,支持优雅停止)
│   ├── loadbalance/      # 负载均衡器(Random / RoundRobin / WeightedRR)
│   ├── protocol/         # 协议编解码(Encode / Decode),包大小限制
│   ├── registry/         # etcd 注册中心(本地缓存 + Watch 同步)
│   ├── server/           # RPC 服务器(注册服务 / 反射调用 / 优雅关闭)
│   └── transport/        # TCP 连接层(PacketBuffer 解决粘包 / Future 异步结果 / 连接池)
├── pkg/
│   └── api/              # 示例服务定义(Arith 算数服务)
├── go.mod
└── go.sum

快速开始

前置依赖

  • Go 1.22+
  • etcd(本地运行于 localhost:2379)

启动服务

# 终端 1 — 监听 :9090,提供 Arith 和 Arith2 两个服务
go run ./cmd/server1/server1_example.go

# 终端 2 — 监听 :9091,提供 Arith 服务
go run ./cmd/server2/server2_example.go

启动客户端

# 终端 3 — 异步调用示例,每 5 秒向 Arith.Add 发送一轮 3 个请求
go run ./cmd/client/client_example.go

运行压测

# 固定总量压测(总请求数 -n,并发协程数 -c,批大小 -b)
# 内部使用 InvokeAsync,每批发送完再等结果
go run ./cmd/bench1 -n 10000 -c 100 -b 100

# 固定时长压测(-d 秒数,-c 并发协程数),输出 QPS 和 P50/P90/P99 延迟
# 内部使用 Invoke(同步调用)
go run ./cmd/bench2 -d 10 -c 50

使用示例

服务端

// 创建服务器,指定 JSON 编解码
srv, _ := server.NewServer(":9090", server.WithServerCodec(codec.JSON))

// 注册服务(遵循 net/rpc 风格)
srv.Register("Arith", &api.Arith{})

// 向 etcd 注册服务(TTL 10 秒,需配合 KeepAlive)
reg, _ := registry.NewRegistry([]string{"localhost:2379"})
reg.Register("Arith", registry.Instance{Addr: "localhost:9090"}, 10)

// 启动服务(在 goroutine 中运行以响应信号)
go srv.Start()

// 等待信号并优雅关闭
sigCh := make(chan os.Signal, 1)
signal.Notify(sigCh, os.Interrupt)
<-sigCh
srv.Shutdown()

客户端

reg, _ := registry.NewRegistry([]string{"localhost:2379"})
c, _ := client.NewClient(reg,
    client.WithClientCodec(codec.JSON),              // 指定编解码器
    client.WithClientTimeout(3*time.Second),         // 全局调用超时
    client.WithClientLoadBalancer(&loadbalance.RoundRobin{}), // 负载均衡器
)
defer c.Close()

// 同步调用(自动携带 3 秒超时)
reply := &api.Reply{}
err := c.Invoke(ctx, "Arith", "Add", &api.Args{A: 1, B: 2}, reply)

// 异步调用(返回 Future,可自行控制超时)
future, _ := c.InvokeAsync(ctx, "Arith", "Add", &api.Args{A: 1, B: 2})
result, err := future.WaitWithContext(ctx)

定义服务

服务方法签名必须为 func(req *Req, reply *Resp) error,与 Go 标准库 net/rpc 一致:

type Arith struct{}

func (a *Arith) Add(args *api.Args, reply *api.Reply) error {
    reply.Result = args.A + args.B
    return nil
}

func (a *Arith) Mul(args *api.Args, reply *api.Reply) error {
    reply.Result = args.A * args.B
    return nil
}

关键设计决策

模块 设计决策 理由
协议 自定义二进制协议 + JSON Header 调试友好,Header 结构灵活可扩展
粘包处理 PacketBuffer + Slice 压缩 每次读取后判断剩余容量,容量过半时复制压缩底层数组,防止内存泄漏
连接模型 单连接单协程串行处理 模型简单正确,连接可复用,类似 HTTP/1.1 风格
编解码 工厂注册 + init() 自动注册 对扩展开放,无需修改核心代码
服务发现 etcd Watch + 本地缓存 本地缓存降低延迟,Watch 保证最终一致性
熔断器 计数窗口 + 三态状态机 概念简单,阈值和熔断时长可配置

依赖

License

MIT

About

No description, website, or topics provided.

Resources

Stars

0 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages