← 课程目录 🚀 从零到一
📐 学习维度 阶段3 · 第12章 网络与 Netty 🚀 从零到一 📚 课程目录 🏠 首页 🛤️ 学习路径

12.3 手写一个简易 RPC:代理、网络与反射

审校 2026-09-25 · 素材来源:zhouyu-mini 系列(手写RPC框架改写)
📑 本篇章节导航 (共10节,点击直达)
调用链路总览第一步:定义请求与响应第二步:服务提供者,反射执行第三步:消费者,动态代理造幻觉同步外壳,异步内核序列化:字节流的三代演进与真实 Dubbo 对比踩坑清单面试怎么问一句话总结

Dubbo 里 @DubboReference 一标注,调远程服务跟调本地方法一模一样。这个「魔法」拆开其实一句话:RPC(远程过程调用,让调用远程服务像调用本地方法的技术)= 动态代理 + 网络传输 + 反射调用。这一篇动手把最小版写出来。

调用链路总览


消费者                                     提供者
service.hello("张三")                        │
  → 代理拦截,打包【接口名+方法名+参数类型+参数值】
  → 序列化成字节流 ── Socket 发送 ────────→ 反序列化还原请求
                                             → 反射调用真实实现
  ← 反序列化结果 ←── 序列化结果回传 ────── ←─┘

对调用方完全透明——「像调本地方法一样调远程」,这句 RPC 的定义就是全部设计目标。

第一步:定义请求与响应

网络那头要能「照着说明书」执行,请求对象得自带四要素:


class RpcRequest implements Serializable {
    String interfaceName;   // 接口全限定名:找哪个服务
    String methodName;      // 方法名:调哪个方法
    Class<?>[] paramTypes;  // 参数类型:重载区分全靠它
    Object[] args;          // 参数值
}
class RpcResponse implements Serializable {
    Object result;          // 正常返回值
    String error;           // 异常信息(null 代表成功)
}

第二步:服务提供者,反射执行


public class RpcProvider {
    private final Map<String, Object> services = new HashMap<>();

    public void register(Class<?> iface, Object instance) {
        services.put(iface.getName(), instance);   // 接口名→实现
    }

    public void start(int port) throws Exception {
        ServerSocket server = new ServerSocket(port);
        while (true) {
            Socket socket = server.accept();
            new Thread(() -> handle(socket)).start(); // 一连接一线程
        }
    }
}

private void handle(Socket socket) {
    try (ObjectInputStream in = new ObjectInputStream(socket.getInputStream());
         ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream())) {
        RpcRequest req = (RpcRequest) in.readObject();  // 收请求
        Object service = services.get(req.interfaceName);
        Method m = service.getClass().getMethod(req.methodName, req.paramTypes);
        RpcResponse resp = new RpcResponse();
        resp.result = m.invoke(service, req.args);      // 反射执行
        out.writeObject(resp);                          // 回结果
    } catch (Exception e) { e.printStackTrace(); }
}

核心就三行:按接口名找到实现、getMethod 拿到方法、invoke 执行——反射(程序运行期动态获取类信息并调用方法的能力)就是提供者的「机械臂」。

第三步:消费者,动态代理造幻觉


@SuppressWarnings("unchecked")
public <T> T getService(Class<T> iface) {
    return (T) Proxy.newProxyInstance(
        iface.getClassLoader(),
        new Class<?>[]{iface},
        (proxy, method, args) -> {              // 每次方法调用都进这里
            RpcRequest req = new RpcRequest();
            req.interfaceName = iface.getName();
            req.methodName = method.getName();
            req.paramTypes = method.getParameterTypes();
            req.args = args;
            return sendRequest(req);            // 网络往返
        });
}

Proxy.newProxyInstance 生成的代理对象实现了目标接口,任何方法调用都被拦进 InvocationHandler——动态代理(运行期生成代理对象拦截方法调用的机制)造出了「本地方法」的幻觉。这就是 @DubboReference 注入的那个对象的真身。

跑起来验证:先 register(HelloService.class, new HelloServiceImpl()) 再 start(8080),消费端 getService(HelloService.class).hello("张三"),控制台打出 Hello, 张三! (来自RPC服务器)——第一次跑通时,魔法就祛魅了。

跑通的下一步是压它:for 循环打一万次调用,会发现耗时大头在网络往返和每次新建 Socket 上——把 sendRequest 里的 new Socket 换成缓存的复用连接,吞吐立刻翻几倍。这个小实验比读十篇优化文章更能建立「连接复用值多少钱」的直觉。

同步外壳,异步内核

消费端 getService().hello() 看起来是同步的,里面却是异步戏法。真实实现(Dubbo 同款)分三步:调用前生成一个 requestId,把 Future 存进待答 Map;发起网络发送后,当前线程挂起等待;响应回来时按 requestId 找到 Future,填结果并唤醒线程。调用方一觉醒来拿到返回值,全程无感知。

这套「异步变同步」的机关,把 12.2 的 NIO 非阻塞和业务代码的同步习惯焊在了一起。CompletableFuture 只是它的现代外衣——原理还是那对 requestId 和 Future。也解释了为什么 RPC 框架的异步调用零成本:底层本来就是异步,同步反而是「做出来」的那个。顺带也解释了超时为什么必须设在等待上——挂起的线程要有醒来的保证,否则就是永久等待。

序列化:字节流的三代演进

Java 原生序列化(ObjectOutputStream)胜在零配置,败在三处:体积大(类全限定名和校验信息全带上)、性能平(反射密集)、安全雷(历史上的反序列化漏洞一箩筐)。生产标配换二进制协议:Hessian2(Dubbo 默认,自描述)、Kryo(Java 生态里速度第一梯队)、Protobuf(跨语言王者,gRPC 御用,代价是先写 IDL)。选型口径一句话:内部 Java 对 Java 用 Kryo/Hessian2,多语言互通用 Protobuf。

与真实 Dubbo 对比

特性手写版Dubbo
传输Socket 同步阻塞Netty 异步 NIO
序列化Java 原生Hessian2/Protobuf/Kryo
服务发现直连 IP注册中心(Nacos/ZooKeeper)
负载均衡无轮询/随机/一致性哈希
容错重试无Failover 等多种策略

升级路线也顺着这张表读:换 Netty 解决性能、上注册中心解决「找谁调」、加负载均衡解决「调哪个」、配容错解决「调挂了怎么办」。框架没有黑魔法,全是顺着问题长出来的。

表里最值得展开的是注册中心一行。最小实现用 ZooKeeper 三步走:提供者启动时在 /rpc/接口名/providers 下建临时节点(写入自己的 IP:port);消费者启动读该目录拿地址列表,并注册 watch;提供者宕机,临时节点自动消失,消费者收到通知刷新列表——「断线即删」天然充当心跳,和 10.5 的 ZooKeeper 分布式锁是同一机制的两面。

超时与容错也是手写版欠的账。Dubbo 的 Failover(失败自动切换:超时或报错就换下一台重试,默认两次)三行就能落地:地址列表按序尝试、单次调用设超时、全败才抛异常。但重试的前提是幂等——查询随便重试,扣款重试就是重复扣款:这类操作要么带唯一请求 ID 去重,要么老老实实 Failfast 不重试。

再进一步是异步:sendRequest 返回 CompletableFuture,调用方需要结果时再 join——Dubbo 的异步调用、gRPC 的 Future 形态都是它。异步的意义一句话:RPC 耗时的大头在网络往返,异步是把这段等待藏进并行度里的唯一办法。

踩坑清单

面试怎么问

一句话总结

RPC 的魔法拆开是三样老朋友——动态代理拦调用、Socket 传字节、反射跑方法;亲手写过一遍,Dubbo 的所有设计都能对号入座。