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 |
|---|---|---|
| 传输 | 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 的所有设计都能对号入座。