纲要
- 阅读源码的方法论
- 明确目标
- 先构思、后验证
- 以问题驱动源码阅读
- RPC 调度需要解决的核心问题
- 请求与响应的数据格式
- 多种编码方式的集成
- 从请求到具体方法的映射与调度
- 注册流程分析
- 利用
reflect获取服务名和方法集 - 以
sync.Map存储服务与方法映射
- 利用
- 请求调度流程分析
- 从连接读取请求信息
- 通过编解码器(
codec)反序列化请求 - 根据服务名与方法名查找并调用对应方法
- 源码验证(
net/rpc标准库)Server.Register的反射与注册逻辑Server.serveRequest的读取与调度路径- 编解码器的解耦设计
- 总结
在微服务与分布式系统中,RPC(远程过程调用)是基石之一。Go 语言标准库自带的 net/rpc 包虽然功能有限,但它的设计与调度思路极具代表性,读透它对构建自己的 RPC 框架会很有帮助。本文将结合源码阅读的一般方法,逐步拆解 net/rpc 在服务注册与请求调度背后的实现原理。
阅读源码的方法论
很多开发者在初次接触标准库或框架源码时,容易陷入“看不懂、绕来绕去、无从下手”的局面。其实症结通常有三个:
- 目标模糊——不清楚自己想从源码中得到什么;
- 直接硬读——没有基于自己的理解先构思一个大致实现,导致思维被牵着走;
- 畏惧复杂调度——面对跨模块调用、并发处理时难以理清脉络。
一种更高效的方式是:先确定要解决的问题,然后闭上眼睛想一想如果自己来实现会怎么做,最后再带着这个“假想实现”去对比源码,验证或修正自己的设计。这样每一次源码阅读都变成了一次“设计讨论”,收获会大不相同。
下面我们就用这套思路,来分析 net/rpc 的调度原理。
RPC 调度要解决的核心问题
要实现一个基本的 RPC 框架,至少需要回答下面三个问题:
| 核心问题 | 说明 |
|---|---|
| 消息编码与传输格式 | 请求和响应在网络上以什么格式传输?如何定义结构体? |
| 多编码方式集成 | 怎么支持 JSON、Gob 甚至自定义编码,而不与核心调度耦合? |
| 请求到方法的映射 | 客户端传来一个字符串“服务名.方法名”,怎样精准地调用到对应的实际方法? |
在 net/rpc 标准库中,请求和响应的数据结构已经定义好(Request 和 Response)。编码方式则通过 ServerCodec 接口抽象,默认提供了 Gob 编码,也允许替换为 JSON。最关键的是第三点:如何从字符串映射到方法调用,这就衍生出了注册与调度两套机制。
我们可以构思一个简化的实现方案:
- 注册时,利用反射拿到服务的类型名称,并遍历其所有导出方法,将它们存入一个
map,键为“ServiceName.MethodName”,值为方法的反射调用信息。 - 调度时,从请求中解析出服务名和方法名,到
map里查找,找到后通过反射调用。
带着这样的想象,我们再去源码中寻找证据和差异。
注册流程分析
服务的注册入口是 rpc.Register 或 rpc.RegisterName。内部会创建一个默认的 Server 实例,并调用其 Register 方法。
简化后的注册过程可以抽象为以下代码意图:
func (server *Server) Register(rcvr interface{}) error {
// 使用反射获取 rcvr 的类型与值
typ := reflect.TypeOf(rcvr)
val := reflect.ValueOf(rcvr)
// 获取服务名称:优先使用自定义名称,否则取类型的字符串表示
sname := reflect.Indirect(val).Type().Name()
// 遍历方法,筛选出符合 RPC 签名的方法
methods := suitableMethods(typ)
// 以服务名为 key,将 (服务名, 方法集) 存入 sync.Map
server.serviceMap.Store(sname, &service{
name: sname,
rcvr: val,
method: methods,
})
return nil
}
在真正的源码中,你会看到:
- 当没有显式指定服务名时,通过
reflect.Indirect(reflect.ValueOf(rcvr)).Type().Name()获取结构体的名称作为服务名。 - 之后遍历所有方法,按照约定的签名(方法必须有两个参数:一个指针类型的请求参数,一个指针类型的响应参数,并返回一个
error)进行筛选。 - 筛选后的方法集和接收者一起被组装成一个内部
service对象,并存入一个sync.Map。使用同步 map 是为了在并发注册和调度时避免锁竞争。
这一设计与我们之前的构想几乎一致:以字符串为键存储服务与方法,为后续的快速查找做准备。
下图展示了注册流程:
请求调度流程分析
当客户端通过网络将请求发送到服务端后,Server 会在 Accept 循环中为每个连接启动一个 goroutine,核心调度发生在 serveRequest 方法中。
简化的调度流程可表示为:
func (server *Server) serveRequest(codec ServerCodec) error {
// 1. 从 codec 中读取请求
req, err := server.readRequest(codec)
// 2. 根据服务名查找 service
svc, mtype, err := server.lookupMethod(req.ServiceMethod)
// 3. 准备调用参数并执行方法
argv := ... // 根据 mtype 反射构造请求参数
replyv := ... // 构造响应参数
returnValue := mtype.method.Func.Call([]reflect.Value{svc.rcvr, argv, replyv})
// 4. 将响应写回
server.sendResponse(codec, replyv, ...)
}
在真实源码中,readRequest 会与 codec 交互,完成头部和包体的读取及反序列化。编解码器 ServerCodec 是一个接口,定义了 ReadRequestHeader、ReadRequestBody、WriteResponse 等方法,这正是实现多编码方式集成的关键:你只需实现该接口,就可以将 net/rpc 的传输层与任何序列化协议搭配使用。
而 lookupMethod 的内部逻辑正是利用字符串切割将 "Service.Method" 拆分为服务名和方法名,然后从 sync.Map 中取出对应的 service 和 method 反射对象。这与我们最初构思的“基于 map + 字符串查找”完全吻合。
调度的序列图如下:
源码验证与深入
在 net/rpc 中,server.go 是核心文件。你可以清晰地看到:
serviceMap是一个sync.Map,用于存储所有已注册的服务。Register中确实使用了反射来推导名称和方法列表。serveRequest中创建了一个gobServerCodec(默认),然后调用readRequest进行请求读取,其中包含了对codec的调用。- 调度发生在
call相关逻辑中,通过method.Func.Call完成真正的反射调用。
整个调度代码并不复杂,但它奠定了标准库 RPC 模块的基石,也为我们构建自定义 RPC 框架提供了极佳的参考范本。
附:一个可运行的简易 RPC Demo
下面我们基于前面分析的核心机制,实现一个最小化的 RPC 库。它仅依赖标准库的 net、reflect 和 encoding/json,完整演示服务注册、请求解码、方法调度和响应返回的全过程。
整体设计
- 通信协议:使用 TCP,请求与响应均编码为 JSON 行(以
\n分隔)。 - 请求结构:包含
ServiceMethod、Args和Seq(请求序号)。 - 响应结构:包含
Seq、Reply和Error。 - 注册表:用
map[string]*service存储,通过读写锁保护。 - 调度:从请求中解析出服务名和方法名,查找注册表,利用反射调用目标方法。
完整代码
将以下代码保存为 main.go,然后使用 go run main.go 启动服务端,再通过另一个终端以客户端模式运行即可。
package main
import (
"bufio"
"encoding/json"
"errors"
"fmt"
"io"
"log"
"net"
"os"
"reflect"
"strings"
"sync"
)
// 请求与响应结构
type Request struct {
ServiceMethod string `json:"method"` // "Service.Method"
Args json.RawMessage `json:"args"` // 客户端传来的参数 JSON
Seq uint64 `json:"seq"` // 请求序号,用于匹配响应
}
type Response struct {
Seq uint64 `json:"seq"`
Reply json.RawMessage `json:"reply,omitempty"`
Error string `json:"error,omitempty"`
}
// 服务端内部结构
type methodType struct {
method reflect.Method
argType reflect.Type // 请求参数的类型
}
type service struct {
name string
rcvr reflect.Value
typ reflect.Type
methods map[string]*methodType
}
type Server struct {
mu sync.RWMutex
services map[string]*service
}
func NewServer() *Server {
return &Server{services: make(map[string]*service)}
}
// 注册一个服务对象,要求其所有导出方法符合 func(req *T, resp *U) error 签名
func (s *Server) Register(rcvr interface{}) error {
s.mu.Lock()
defer s.mu.Unlock()
val := reflect.ValueOf(rcvr)
typ := reflect.Indirect(val).Type()
sname := typ.Name()
if _, ok := s.services[sname]; ok {
return errors.New("rpc: service already defined: " + sname)
}
svc := &service{
name: sname,
rcvr: val,
typ: typ,
methods: make(map[string]*methodType),
}
for i := 0; i < typ.NumMethod(); i++ {
method := typ.Method(i)
mtype := method.Type
// 检查签名:3 个输入参数(receiver, 指针参数, 指针参数),1 个输出 error
if mtype.NumIn() != 3 || mtype.NumOut() != 1 {
continue
}
argType := mtype.In(1)
if argType.Kind() != reflect.Ptr {
continue
}
replyType := mtype.In(2)
if replyType.Kind() != reflect.Ptr {
continue
}
if returnType := mtype.Out(0); returnType != reflect.TypeOf((*error)(nil)).Elem() {
continue
}
svc.methods[method.Name] = &methodType{
method: method,
argType: argType.Elem(),
}
}
if len(svc.methods) == 0 {
return errors.New("rpc: no exported methods with correct signature for: " + sname)
}
s.services[sname] = svc
return nil
}
// 处理单个连接
func (s *Server) ServeConn(conn net.Conn) {
defer conn.Close()
reader := bufio.NewReader(conn)
writer := bufio.NewWriter(conn)
for {
line, err := reader.ReadBytes('\n')
if err != nil {
if err != io.EOF {
log.Println("rpc: read error:", err)
}
break
}
var req Request
if err := json.Unmarshal(line, &req); err != nil {
s.sendError(writer, req.Seq, "invalid request: "+err.Error())
continue
}
go s.handleRequest(writer, &req)
}
}
func (s *Server) handleRequest(writer *bufio.Writer, req *Request) {
parts := strings.SplitN(req.ServiceMethod, ".", 2)
if len(parts) != 2 {
s.sendError(writer, req.Seq, "invalid service method format")
return
}
serviceName, methodName := parts[0], parts[1]
s.mu.RLock()
svc, ok := s.services[serviceName]
s.mu.RUnlock()
if !ok {
s.sendError(writer, req.Seq, "service not found: "+serviceName)
return
}
mtype, ok := svc.methods[methodName]
if !ok {
s.sendError(writer, req.Seq, "method not found: "+methodName)
return
}
// 构造参数实例
argv := reflect.New(mtype.argType)
if err := json.Unmarshal(req.Args, argv.Interface()); err != nil {
s.sendError(writer, req.Seq, "unmarshal args: "+err.Error())
return
}
replyv := reflect.New(mtype.method.Type.In(2).Elem())
// 调用方法
returnValues := mtype.method.Func.Call([]reflect.Value{svc.rcvr, argv, replyv})
if errInter := returnValues[0].Interface(); errInter != nil {
s.sendError(writer, req.Seq, errInter.(error).Error())
return
}
replyBytes, _ := json.Marshal(replyv.Interface())
resp := Response{
Seq: req.Seq,
Reply: replyBytes,
}
respBytes, _ := json.Marshal(resp)
writer.Write(append(respBytes, '\n'))
writer.Flush()
}
func (s *Server) sendError(writer *bufio.Writer, seq uint64, msg string) {
resp := Response{Seq: seq, Error: msg}
respBytes, _ := json.Marshal(resp)
writer.Write(append(respBytes, '\n'))
writer.Flush()
}
// 启动服务监听
func (s *Server) ListenAndServe(addr string) error {
ln, err := net.Listen("tcp", addr)
if err != nil {
return err
}
log.Println("rpc server listening on", addr)
for {
conn, err := ln.Accept()
if err != nil {
log.Println("accept error:", err)
continue
}
go s.ServeConn(conn)
}
}
// ---------- 客户端辅助 ----------
type Client struct {
conn net.Conn
writer *bufio.Writer
reader *bufio.Reader
mu sync.Mutex
seq uint64
}
func Dial(addr string) (*Client, error) {
conn, err := net.Dial("tcp", addr)
if err != nil {
return nil, err
}
return &Client{
conn: conn,
writer: bufio.NewWriter(conn),
reader: bufio.NewReader(conn),
}, nil
}
func (c *Client) Call(serviceMethod string, args interface{}, reply interface{}) error {
c.mu.Lock()
defer c.mu.Unlock()
c.seq++
seq := c.seq
argsBytes, err := json.Marshal(args)
if err != nil {
return err
}
req := Request{
ServiceMethod: serviceMethod,
Args: argsBytes,
Seq: seq,
}
reqBytes, _ := json.Marshal(req)
_, err = c.writer.Write(append(reqBytes, '\n'))
if err != nil {
return err
}
c.writer.Flush()
line, err := c.reader.ReadBytes('\n')
if err != nil {
return err
}
var resp Response
if err := json.Unmarshal(line, &resp); err != nil {
return err
}
if resp.Error != "" {
return errors.New(resp.Error)
}
if reply != nil {
return json.Unmarshal(resp.Reply, reply)
}
return nil
}
func (c *Client) Close() error {
return c.conn.Close()
}
// ---------- 示例服务 ----------
type Arith struct{}
type Args struct {
A, B int
}
type Reply struct {
C int
}
func (a *Arith) Add(args *Args, reply *Reply) error {
reply.C = args.A + args.B
return nil
}
func (a *Arith) Sub(args *Args, reply *Reply) error {
reply.C = args.A - args.B
return nil
}
// ---------- main ----------
func main() {
if len(os.Args) < 2 {
fmt.Println("Usage: go run main.go server|client")
return
}
switch os.Args[1] {
case "server":
srv := NewServer()
if err := srv.Register(new(Arith)); err != nil {
log.Fatal("register error:", err)
}
log.Fatal(srv.ListenAndServe(":12345"))
case "client":
client, err := Dial(":12345")
if err != nil {
log.Fatal("dial error:", err)
}
defer client.Close()
args := &Args{A: 10, B: 3}
var reply Reply
if err := client.Call("Arith.Add", args, &reply); err != nil {
log.Fatal("call Add error:", err)
}
fmt.Printf("Add: %d + %d = %d\n", args.A, args.B, reply.C)
if err := client.Call("Arith.Sub", args, &reply); err != nil {
log.Fatal("call Sub error:", err)
}
fmt.Printf("Sub: %d - %d = %d\n", args.A, args.B, reply.C)
}
}
运行方式
1 ) 启动服务端:
go run main.go server
2 ) 在另一个终端启动客户端:
go run main.go client
3 ) 你将看到类似输出:
Add: 10 + 3 = 13
Sub: 10 - 3 = 7
关键点解析
- 注册:
Server.Register遍历结构体的所有方法,筛选出签名正确的方法并存入map。 - 调度:
handleRequest解析请求中的Service.Method,从map中查找对应服务和方法,通过反射创建参数并调用。 - 编码:使用
json.RawMessage延迟解码,在方法调用前才将Args反序列化为具体参数类型。 - 并发:每个连接独立处理,每个请求在单独的
goroutine中执行,读写锁保证服务注册表安全。
这个 Demo 虽然精简,却完整覆盖了 net/rpc 的核心调度思路。你可以在此基础上添加超时控制、连接池、更多编码支持,甚至与 go-zero 的设计理念进行对比,进一步加深对 RPC 框架的理解。
总结
本文我们从“自己先构思”出发,然后对照 net/rpc 源码,验证了服务注册与请求调度两大部分的设计。核心思路可以概括为:
- 注册:反射提取服务名和方法集,存入线程安全的
sync.Map。 - 调度:从编解码器读取请求,解析出服务名和方法名,从
sync.Map查找反射信息,最终通过反射发起调用。 - 编码解耦:通过
ServerCodec接口将序列化逻辑与调度逻辑分离,使得扩展新协议变得简单。
理解这些机制后,再去阅读其它 RPC 框架(如 gRPC、rpcx、go-zero)的内部实现,你会发现很多异曲同工之处。更重要的是,这种“先构思后验证”的源码阅读方式,值得在每一次深入技术内核时反复运用。
3万+



被折叠的 条评论
为什么被折叠?



