userService.getUserById(1L) 明明是个本地调用写法,请求却飞到了另一台机器。中间发生了两件事:有人替你「伪装成本地方法」(代理),有人替你「把对象搬过网线」(序列化)。这篇讲透这两层,顺带对比 Feign 的 JSON 世界。
前置阅读:12.3 手写过简易 RPC 的代理与序列化。这篇看 Dubbo 的工业级实现强在哪。
你在 consumer 里 @DubboReference UserService userService,注入的到底是什么?完整链路四步:
① ReferenceAnnotationBeanPostProcessor 拦截注入点(又是 BeanPostProcessor)
② ReferenceConfig.get()(双重检查锁,只初始化一次)
→ RegistryProtocol.refer():订阅 ZK 的 providers 节点
→ 组装 Invoker 套娃(从外到内):
MockClusterInvoker(mock 总开关)
→ FailoverClusterInvoker(容错循环)
→ DubboInvoker(真正持连接发请求)
③ proxyFactory.getProxy(invoker)(SPI 默认 javassist)→ 生成"真身"代理
④ 注入字段完成:业务调代理 → 代理调 Invoker 链 → 网络
代理只是皮,Invoker 链才是魂——所有 RPC 能力(容错、负载、mock)都在链上,代理只负责把「方法调用」翻译成「链的起点」。
套娃顺序读法也要会:从外往内依次是 Mock 总开关、Failover 容错循环、DubboInvoker 真身。断点翻对象结构就能看到这几层代理皮——它们是 Wrapper 机制套上去的,不是 DubboInvoker 自己长出来的。
看 JavassistProxyFactory 源码,Proxy.getProxy(interfaces).newInstance(handler) 里的 Proxy 不是 java.lang.reflect.Proxy,是 Dubbo 自己写的类:
import org.apache.dubbo.rpc.proxy.javassist.Proxy; // Dubbo 自研!
// 内部骨架:
ClassPool pool = ...;
CtClass ctcs = pool.makeClass("UserServiceDubboProxy0"); // 造空类
ctcs.addInterface(pool.get("UserService")); // implements 接口
// 为每个方法拼源码 → CtNewMethod.make 编译成字节码
Class<?> pc = ctcs.toClass(classLoader); // ★ 字节码真正诞生的一行
为什么不用 JDK 动态代理?JDK 靠反射 InvocationHandler 转发,每次调用有反射开销;Javassist 生成真实的方法字节码,调用近乎原生方法。RPC 热路径上,这点开销乘以每天亿次调用就是真金白银。
验证方法:断点停在代理方法里,remoteProxy.getClass().getName() 会是 UserServiceDubboProxy0——一个源码里查无此类、运行时凭空造出的类。加 -Ddubbo.proxy=jdk 重启,变成 $Proxy12。
把 getUserById(Long) 的生成结果反编译回等价 Java:
public class UserServiceDubboProxy0 implements UserService {
public static Method[] methods; // 静态 Method 表
private InvocationHandler handler; // JDK 同款协议
public UserDTO getUserById(Long arg0) {
Object[] args = new Object[1];
args[0] = arg0;
Object ret = handler.invoke(this, methods[0], args);
return (UserDTO) ret; // 生成代码里的强转
}
}
三个值得带走的设计点:
1. Javassist 生成 + JDK 协议的混合体:类是字节码直出(快),但 handler 用 java.lang.reflect.InvocationHandler(JDK 同款)——proxyFactory SPI 在 javassist/jdk 间切换时,InvokerInvocationHandler 一行不用改
2. 同包定义一石二鸟:生成类放在接口同包,既解决非 public 接口的可见性,又让异常栈一眼认出它属于谁
3. 静态 Method 注入是接缝技巧:生成代码要引用运行时对象,只能「静态字段加反射回填」——CGLIB 的 CGLIB$CALLBACK_0 是同款套路
还有一个隐蔽的收尾:造完类要 release() 归还 ClassPool 资源——Javassist 的 CtClass 不释放会内存泄漏,ClassPool 会缓存所有造过的类。
Stub(存根,构造器注入真身代理的本地拦截层)在调用发出去之前拦截:
public class UserServiceStub implements UserService {
private final UserService remoteProxy; // 真身,构造器注入
private final Cache<Long, User> cache = ...;
public User getUserById(Long id) {
if (id <= 0) throw new IllegalArgumentException(); // 预校验,省一次RPC
User u = cache.getIfPresent(id); // 本地缓存命中→零网络
if (u != null) return u;
return remoteProxy.getUserById(id); // 未命中→真出网
}
}
分工记忆:mock 是「调失败了之后」兜底,stub 是「调之前」拦截——一个善后一个前置。用途:本地缓存、参数预校验、日志埋点。远程代理由 Dubbo 构造好后从构造器塞进 Stub,业务代码拿到的永远是 Stub 这个「本地外壳」。
Stub 缓存一致性的代价别忽略:写死不过期就是永久脏读。生产姿势按成本选:TTL 兜底、写操作主动清、配置中心发版本号全清,或者干脆别缓存变化频繁的数据。
hessian2(Dubbo 默认的报文序列化框架,把 Java 对象压成紧凑二进制、对端原样还原)在报文结构里的位置:
┌───── 16 字节定长头 ─────┐┌──── body ────┐
│ 魔数0xdabb │ flag含序列化id ││ 接口名+方法名 │
└──────────────────────┘│ +参数DTO整棵树 │
└──────────────┘
↑ 这坨就是 hessian2 编的
为什么不是 JSON 或 JDK 序列化?RPC 内部调用要的是快、小、Java 类型保真(BigDecimal、循环引用、复杂 DTO 原样往返)。序列化器本身也是个 SPI 插座,prefer.serialization 可换。
三种序列化摆在一起看:
| JDK 序列化 | JSON | hessian2 | |
|---|---|---|---|
| 形态 | 二进制 | 文本 | 二进制 |
| 体积/速度 | 大且慢 | 大且慢 | 紧凑且快 |
| Java 类型 | 全 | 弱(Long 精度、无循环引用) | 全 |
| 跨语言 | 不行 | 好 | 好 |
| 可读性 | 无 | 好 | 无 |
JSON 的优点(人类可读、谁都能调)在服务间高频调用里不值钱——那是给网关和浏览器准备的优点。
--add-opens java.math 这类报错会一个包接一个包地蹦:JDK 强封装按包拦截,hessian2 运行到哪个功能才反射哪个包——序列化 String 碰 java.lang、金额碰 java.math、集合碰 java.util。所以要么一次贴全清单,要么学习阶段直接切回 JDK 8。
格式永远是 --add-opens 模块名/包名=ALL-UNNAMED,照报错原文填空。为什么 JSON 从不惹这事?因为 JSON 根本不碰对象内部,只做字符串拼接——代价是丢类型保真。
三个坑反推它的性格:
1. 自定义异常要提供 String 构造器、code 字段不能 final——hessian2 的规矩
2. Dubbo 3.2 序列化白名单(STRICT 检查)拦下不在名单里的类——它按「类型全名」实例化对象,这能力用于反序列化攻击也超好用
3. JDK 17 要 --add-opens java.math——还原 BigDecimal 要反射访问 BigInteger 私有字段,强封装把门关了
| 契约项 | Feign + Jackson | Dubbo + hessian2 |
|---|---|---|
| implements Serializable | 不需要 | 必须(最常忘) |
| serialVersionUID | 无此概念 | 弱校验+工程惯例 |
| 字段只加不改 | 同样成立(被静默吞掉) | 显性铁律(字段名=匹配键) |
| 崩溃方式 | 静默烂(线上才发现 null) | 响亮炸(启动/调用即报错) |
Feign 传的是「数据的影子」(字段名和值),Dubbo 搬的是「带身份的对象」(类名和类型都编进字节流)。搬东西过境,自然要查身份证(Serializable)、登记版本(uid)、核对行李(字段表)。
最容易忘的常识:@DubboReference 注入的字段是网络代理,每次调用走一次 RPC。把查询循环套在这个字段上——循环一百次就是一百次网络往返,性能事故的标准形态。
对照着记两个注解的分工:@DubboService 标在提供方实现类上,启动时立即导出,处理器是 BeanDefinition 后置;@DubboReference 标在消费方字段上,首次使用才创建引用(懒加载),处理器是 BeanPostProcessor。
一个容易忽略的细节:timeout/retries 写在 @DubboService 上只是「给消费者的建议值」——会写进注册到 ZK 的 URL,消费者不配时才采用;写在 @DubboReference 上才实际生效。「等结果的人定闹钟」,消费方优先。
双向服务也顺便看一眼:一个类可以同时是提供方和消费方——@DubboService 暴露通知接口、内部 @DubboReference 引用用户服务,双向回调就是两个注解反过来拼的。
「Dubbo 为什么默认 Javassist 代理?」——答:JDK 动态代理每次调用走反射,Javassist 运行时生成真实方法字节码,热路径近乎原生调用;只留 SPI 后门可切回 JDK 代理。
一句话总结:代理管「装成本地方法」,Invoker 链管「真本事」,hessian2 管「对象原样过境」。