← 课程目录 🚀 从零到一
📐 学习维度 阶段7 · 第28章 开源项目源码精读 🚀 从零到一 📚 课程目录 🏠 首页 🛤️ 学习路径

28.2.5 Dubbo 代理与 hessian2:对象是怎么过境的

审校 2026-09-26 · 素材来源:zcode会话#1《Dubbo+Zookeeper 学习Demo与教程》
📑 本篇章节导航 (共7节,点击直达)
代理诞生:ReferenceConfig.get() 到字段注入Javassist:不是 JDK 动态代理Stub:给真身套的本地外壳hessian2:对象复印机Feign 传影子,Dubbo 搬本体@DubboReference 注入的不是本地 Bean面试怎么问

userService.getUserById(1L) 明明是个本地调用写法,请求却飞到了另一台机器。中间发生了两件事:有人替你「伪装成本地方法」(代理),有人替你「把对象搬过网线」(序列化)。这篇讲透这两层,顺带对比 Feign 的 JSON 世界。

前置阅读:12.3 手写过简易 RPC 的代理与序列化。这篇看 Dubbo 的工业级实现强在哪。

代理诞生:ReferenceConfig.get() 到字段注入

你在 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 自己长出来的。

Javassist:不是 JDK 动态代理

看 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:给真身套的本地外壳

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:对象复印机

hessian2(Dubbo 默认的报文序列化框架,把 Java 对象压成紧凑二进制、对端原样还原)在报文结构里的位置:


┌───── 16 字节定长头 ─────┐┌──── body ────┐
│ 魔数0xdabb │ flag含序列化id ││ 接口名+方法名  │
└──────────────────────┘│ +参数DTO整棵树 │
                         └──────────────┘
                          ↑ 这坨就是 hessian2 编的

为什么不是 JSON 或 JDK 序列化?RPC 内部调用要的是快、小、Java 类型保真(BigDecimal、循环引用、复杂 DTO 原样往返)。序列化器本身也是个 SPI 插座,prefer.serialization 可换。

三种序列化摆在一起看:

JDK 序列化JSONhessian2
形态二进制文本二进制
体积/速度大且慢大且慢紧凑且快
Java 类型全弱(Long 精度、无循环引用)全
跨语言不行好好
可读性无好无

JSON 的优点(人类可读、谁都能调)在服务间高频调用里不值钱——那是给网关和浏览器准备的优点。

JDK 17 的「挤牙膏」报错

--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 传影子,Dubbo 搬本体

契约项Feign + JacksonDubbo + hessian2
implements Serializable不需要必须(最常忘)
serialVersionUID无此概念弱校验+工程惯例
字段只加不改同样成立(被静默吞掉)显性铁律(字段名=匹配键)
崩溃方式静默烂(线上才发现 null)响亮炸(启动/调用即报错)

Feign 传的是「数据的影子」(字段名和值),Dubbo 搬的是「带身份的对象」(类名和类型都编进字节流)。搬东西过境,自然要查身份证(Serializable)、登记版本(uid)、核对行李(字段表)。

@DubboReference 注入的不是本地 Bean

最容易忘的常识:@DubboReference 注入的字段是网络代理,每次调用走一次 RPC。把查询循环套在这个字段上——循环一百次就是一百次网络往返,性能事故的标准形态。

对照着记两个注解的分工:@DubboService 标在提供方实现类上,启动时立即导出,处理器是 BeanDefinition 后置;@DubboReference 标在消费方字段上,首次使用才创建引用(懒加载),处理器是 BeanPostProcessor。

一个容易忽略的细节:timeout/retries 写在 @DubboService 上只是「给消费者的建议值」——会写进注册到 ZK 的 URL,消费者不配时才采用;写在 @DubboReference 上才实际生效。「等结果的人定闹钟」,消费方优先。

双向服务也顺便看一眼:一个类可以同时是提供方和消费方——@DubboService 暴露通知接口、内部 @DubboReference 引用用户服务,双向回调就是两个注解反过来拼的。

面试怎么问

「Dubbo 为什么默认 Javassist 代理?」——答:JDK 动态代理每次调用走反射,Javassist 运行时生成真实方法字节码,热路径近乎原生调用;只留 SPI 后门可切回 JDK 代理。

一句话总结:代理管「装成本地方法」,Invoker 链管「真本事」,hessian2 管「对象原样过境」。