Skip to content

3.4-1 Dubbo 架构与服务暴露、引用流程 ​

所属:03 主流框架 / 3.4 Dubbo 分级:A 状态:◐ 初稿 关联:3.4-2、3.4-3、3.4-4、3.4-5、3.4-6、3.4-7、6.1-1、6.2-3

  • 题型:架构 / 流程 / 排障

  • 一句话结论:Dubbo 的一切都围绕 URL + Invoker + Protocol + SPI:Provider 启动时把接口实现包装成 Invoker,通过 Protocol.export 在本地开端口、在注册中心写 URL;Consumer 启动时从注册中心订阅 provider URL 列表,Cluster 把多个 Invoker 合成一个 Directory,再由 ProxyFactory 生成接口代理。调用链是 代理 → Cluster(路由/负载均衡/容错)→ Protocol/Exchange → Netty → Provider 的 Filter 链 → 真实实现;“暴露”= 建 Server + 注册,“引用”= 订阅 + 建客户端 + 生成代理。

  • 分层要点:

    1. 五个角色:Provider(暴露服务)、Consumer(引用服务)、Registry(注册与发现,ZK/Nacos)、Monitor(调用统计)、Container(Spring 容器)。Consumer 只依赖接口,不依赖实现;注册中心只存 URL 元数据,不在调用链路上。
    2. 十层架构(2.x 经典划分):Service(业务接口)、Config(ServiceConfig/ReferenceConfig)、Proxy(ProxyFactory)、Registry(注册中心)、Cluster(路由/负载均衡/容错)、Monitor、Protocol(dubbo/tri/rest)、Exchange(请求响应语义)、Transport(Netty/Mina)、Serialize(hessian2/fastjson2/protobuf)。每层都是 SPI 扩展点,这是 Dubbo 可插拔的根。
    3. URL 是统一模型:dubbo://192.168.1.10:20880/com.foo.UserService?interface=...&methods=...&timeout=3000&version=1.0.0&group=g1&side=provider。配置、注册中心数据、路由规则、调用参数全部落在 URL 参数里;Invoker、Exporter、Protocol、Directory 都围绕 URL 工作。面试里能说出“URL 驱动的统一模型”是加分项。
    4. 暴露(export)五步:ServiceConfig 校验并补全配置 → 为每个 protocol 构建 provider URL → ProxyFactory.getInvoker(ref, interface, url) 把实现包装成 Invoker → Protocol.export(invoker) → RegistryProtocol 先 doLocalExport(DubboProtocol.export → openServer → Netty Server),再 registry.register(url) 写注册中心。
    5. 引用(refer)五步:ReferenceConfig 构建 consumer URL → Protocol.refer(RegistryProtocol)→ registry.subscribe 拿到 provider URL 列表 → Cluster.join(Directory) 生成集群 Invoker → ProxyFactory.getProxy(invoker) 生成接口代理;provider 列表变化时 RegistryDirectory.notify 重建 Invoker 列表。
    6. Invoker 是调用模型的核心:Provider 侧 AbstractProxyInvoker 包住真实对象,Consumer 侧 InvokerInvocationHandler 包住代理;Invoker.invoke(Invocation) 是统一入口。Filter 链通过 ProtocolFilterWrapper 织到 Invoker 外面,所以“监控、超时、异常转换、限流”都是 Filter。
    7. 注册中心只做“地址簿”:ZK 上是 /dubbo/<interface>/providers|consumers|routers|configurators 的临时节点,URL 经过 encode;Nacos 用服务/实例模型。Consumer 本地有 registry 缓存文件,注册中心挂了仍能用旧地址调用(但看不到新 provider)。Dubbo 3 增加了应用级服务发现 + MetadataCenter,减少接口级节点数量。
    8. 生产上最常出问题的是“对不上”:group/version 不匹配、注册中心地址/命名空间错、check=false 掩盖启动期问题、端口冲突、provider 线程池打满、序列化不兼容、超时重试导致重复写。排查顺序是:注册中心有没有 provider URL → consumer 有没有订阅到 → 能不能连通 → 服务端有没有收到请求。
  • 图/流程:

text
整体架构:
  Provider 启动
    → ServiceConfig.export()
      → Invoker
      → Protocol.export
        → 本地开端口(Netty)
        → registry.register(URL)
  Consumer 启动
    → ReferenceConfig.get()
      → registry.subscribe(interface)
        → provider URL 列表
        → Cluster.join(Directory)
        → ProxyFactory.getProxy
  Consumer 调用
    → proxy → ClusterInvoker → Protocol → Netty → Provider
text
服务暴露(以 dubbo 协议为例):
  ServiceConfig.export()
    → checkAndUpdateSubConfigs()
    → doExportUrls()
      → 构建 URL(application/protocol/methods/timeout/...)
      → ProxyFactory.getInvoker(ref, interface, url)
        → JavassistProxyFactory / JdkProxyFactory
      → Protocol$Adaptive.export(invoker)   // 按 URL 的 protocol 参数选扩展
        → RegistryProtocol.export()
          → doLocalExport()
            → DubboProtocol.export()
              → openServer(url)
                → Exchangers.bind(url, requestHandler)
                  → Transporters.bind()
                    → NettyServer(监听 20880)
              → exporterMap.put(serviceKey, DubboExporter)
          → registry.register(registryUrl, providerUrl)
          → 订阅 override 规则
    → 状态 EXPORTED
text
服务引用:
  ReferenceConfig.get()
    → checkAndUpdateSubConfigs()
    → Protocol$Adaptive.refer()
      → RegistryProtocol.refer()
        → registry.subscribe(consumerUrl)
          → RegistryDirectory(provider URL 列表)
          → cluster.join(directory)
            → FailoverClusterInvoker(默认)
        → 返回 Invoker
    → ProxyFactory.getProxy(invoker)
      → JdkProxyFactory / JavassistProxyFactory
      → InvokerInvocationHandler
  运行期 provider 变化
    → RegistryDirectory.notify(urls)
      → 重建 Invoker 列表 + RouterChain
text
一次调用:
  consumer proxy
    → InvokerInvocationHandler
      → ClusterInvoker(路由 → 负载均衡 → 选 Invoker → 容错/重试)
        → Consumer Filter(ConsumerContextFilter / MonitorFilter)
          → DubboInvoker → ExchangeClient → NettyClient
            ========== 网络 ==========
              NettyServer
                → HeaderExchangeHandler
                  → DubboProtocol.requestHandler
                    → Provider Filter(Echo/ClassLoader/Generic/Context/Trace/Timeout/Monitor/Exception)
                      → AbstractProxyInvoker
                        → Wrapper.invokeMethod
                          → 真实实现
  • 版本/源码锚点:

    • Dubbo 2.7.x:ServiceConfig、ReferenceConfig、ServiceBean、ReferenceBean、DubboBootstrap(2.7.5+)、@DubboService/@DubboReference(2.7.7+,替代 @Service/@Reference)。
    • Dubbo 3.x:DubboBootstrap、ModuleModel/ApplicationModel/ScopeModel、Triple(tri 协议,HTTP/2 + protobuf,兼容 gRPC)、应用级服务发现与 MetadataCenter、MigrationRule。
    • 核心类:ProxyFactory、JavassistProxyFactory、JdkProxyFactory、Invoker、AbstractProxyInvoker、Exporter、Protocol、DubboProtocol、RegistryProtocol、InjvmProtocol、Exchangers、Transporters、NettyServer/NettyClient、HeaderExchangeHandler、ProtocolFilterWrapper、Cluster、Directory、RegistryDirectory、RouterChain、LoadBalance。
    • 注册中心:ZookeeperRegistry(/dubbo/{interface}/{providers|consumers|routers|configurators})、NacosRegistry、RegistryFactory、本地缓存 ~/.dubbo/dubbo-registry-*.cache。
    • 配置:dubbo.application.name、dubbo.registry.address、dubbo.protocol.name= dubbo|tri、dubbo.protocol.port=20880、dubbo.consumer.timeout、dubbo.provider.threads、check、retries、cluster、loadbalance;QOS 端口 22222。
    • Spring Boot:DubboAutoConfiguration、@EnableDubbo、DubboBootstrapApplicationListener(ContextRefreshedEvent 时启动 DubboBootstrap)。
  • 角色与职责:

角色职责关键行为
Provider暴露服务、处理请求建 Server、注册 URL、执行 Filter + 实现
Consumer引用服务、发起调用订阅、建客户端、生成代理、路由/容错
Registry地址簿存 provider/consumer URL,推送变更
Monitor调用统计上报次数/耗时/失败
Container生命周期Spring 容器管理 Bean 与导出/引用时机
  • 暴露 vs 引用对照:
维度暴露(export)引用(refer)
入口ServiceConfig.export()ReferenceConfig.get()
本地动作开端口、建 Netty Server建 Netty Client(懒连接)
注册中心动作register 写 provider URLsubscribe 拉 + 监听
核心对象Invoker → ExporterInvoker → 代理
默认扩展dubbo 协议FailoverClusterInvoker
Spring 集成ServiceBean(ContextRefreshedEvent 后导出)ReferenceBean(getObject 时引用)
  • 协议对比:
协议传输序列化特点场景
dubbo单一长连接 + Nettyhessian2(3.2 支持 fastjson2)默认、性能好、连接数少内部服务
tri(Triple)HTTP/2protobuf/JSON跨语言、gRPC 兼容、支持流式多语言/云原生
restHTTP/1.1JSON/XML对外 REST开放 API
injvm/本地调用无网络无同 JVM 直调单体/同进程
  • 注册中心对比:
维度ZookeeperNacos
数据模型树形节点 + 临时节点服务/实例
健康检查会话 + 临时节点心跳/主动探测
推送Watch长轮询/推送
额外能力无配置中心、命名空间
Dubbo 3接口级 + 应用级应用级为主
  • 关键 URL 参数:
参数含义常见问题
interface接口全限定名拼错导致找不到
version版本provider/consumer 不一致 → 无提供者
group分组同上
timeout超时(ms)默认 1000,过短误判
retries重试次数非幂等接口重复写
cluster容错策略failover/failfast/failsafe/forking/broadcast
loadbalance负载均衡random/roundrobin/leastactive/consistenthash
serialization序列化两端不一致 → 解码失败
sideprovider/consumer过滤用
methods方法列表方法级配置覆盖
  • 失效场景与定位:
现象根因处理
No provider availableprovider 未注册/group/version 不匹配/被禁用查注册中心节点、对齐 group/version
启动时 provider 未就绪check=true(默认)本地调试 check=false,生产慎用
端口冲突20880 被占改 dubbo.protocol.port
调用超时网络/GC/慢 SQL/线程池满看 provider 线程栈、调 timeout
Thread pool is EXHAUSTED业务线程池打满调 threads/隔离/异步化
序列化失败两端类不一致/字段变更统一版本、兼容性设计
注册中心挂了无法发现新节点本地缓存兜底、恢复注册中心
重复下单超时 + retries 重试幂等键、关闭非幂等重试
消费端启动报无提供者消费先于提供者启动check=false 或依赖顺序
大报文失败默认 payload 限制调 payload、改分页/压缩
反序列化漏洞hessian 黑名单绕过升级、开序列化白名单、鉴权
  • 深挖点(面试官常追的 6 个):

    1. 为什么 Dubbo 用 URL 做统一模型:URL 把“协议、地址、接口、方法、参数”收敛成一个可序列化字符串,注册中心只需要存/推 URL,Protocol/Invoker/Directory 都从 URL 取参数,配置可以逐层覆盖(方法级 > 接口级 > 全局),也便于日志与治理(路由规则、条件路由都是 URL)。代价是 URL 会很长、参数多了以后可读性差,Dubbo 3 用应用级发现 + 元数据中心缓解。
    2. 暴露时端口到底在哪一步打开:RegistryProtocol.doLocalExport 里对每个 protocol 调 Protocol.export;DubboProtocol.export 先 openServer(url),Exchangers.bind → Transporters.bind → NettyServer 绑定端口,之后才 exporterMap.put、再 registry.register。所以“端口起来但注册中心还没有”是正常的中间态;反过来注册中心有 URL 但端口没起来,说明 provider 异常退出、临时节点还没过期。
    3. 引用时为什么不是直接连一个地址:Consumer 拿到的是 provider URL 列表,RegistryDirectory 把它变成 Invoker 列表,Cluster 在外层做路由、负载均衡、容错。这样 provider 扩缩容、下线、权重调整都通过 notify 动态生效,不需要重启 consumer;ClusterInvoker 每次调用现选,才能实现 failover/leastactive。
    4. Invoker 和 Exporter 的区别:Invoker 是“可执行体”,invoke(Invocation) 返回 Result,provider 侧包真实对象、consumer 侧包远程调用;Exporter 是“已暴露服务的句柄”,持有 Invoker 和 URL,unexport() 时关闭 server/注销。Protocol.export 返回 Exporter,Protocol.refer 返回 Invoker——这个不对称是面试常问点。
    5. Filter 链怎么织进去的:ProtocolFilterWrapper 在 export/refer 时用 buildInvokerChain 把激活的 Filter 包在 Invoker 外层;Filter 通过 @Activate(group = PROVIDER/CONSUMER, order = ...) 自动激活,顺序由 order 决定。所以自定义 Filter 只要加 @Activate 并放 SPI 文件里就生效;ExceptionFilter 在链尾把异常转成字符串,避免 provider 异常类在 consumer 侧不存在导致反序列化失败。
    6. Dubbo 3 的应用级服务发现解决了什么:接口级发现下,一个应用有 N 个接口就在 ZK 上挂 N 份 provider 列表,规模大时注册中心压力大、推送风暴;应用级发现以“应用实例”为单位注册,接口 → 应用的映射放元数据中心,consumer 先拿实例再按接口过滤。代价是引入元数据中心依赖和迁移复杂度,所以有 MigrationRule 做接口级/应用级双注册过渡。
  • 追问链:

    1. Dubbo 的核心角色? → Provider/Consumer/Registry/Monitor/Container。
    2. Dubbo 分层? → Service/Config/Proxy/Registry/Cluster/Monitor/Protocol/Exchange/Transport/Serialize。
    3. 核心模型是什么? → URL + Invoker + Protocol + SPI。
    4. 服务怎么暴露? → ServiceConfig.export → Invoker → Protocol.export → 开端口 + 注册。
    5. 端口在哪一步开? → DubboProtocol.openServer → Transporters.bind → NettyServer。
    6. 注册中心写什么? → provider URL。
    7. 服务怎么引用? → ReferenceConfig.get → subscribe → Cluster.join → 代理。
    8. Consumer 拿到的是什么? → provider URL 列表 → Invoker 列表。
    9. 谁做负载均衡? → ClusterInvoker + LoadBalance。
    10. 默认集群容错? → failover。
    11. failover 重试几次? → 默认 2 次(共 3 次)。
    12. 重试有什么风险? → 非幂等重复执行。
    13. Invoker 是什么? → 统一调用抽象,invoke(Invocation)。
    14. Exporter 是什么? → 暴露后的句柄,持有 Invoker。
    15. Protocol 的职责? → export/refer。
    16. ProxyFactory 的作用? → 生成代理/包装 Invoker。
    17. 默认代理方式? → Javassist(可配 JDK)。
    18. 服务端线程模型? → IO 线程 + 业务线程池(见 3.4-4)。
    19. 默认业务线程数? → 200(fixed)。
    20. IO 线程数? → 默认 CPU+1(上限 32)。
    21. 默认协议端口? → 20880。
    22. 默认序列化? → hessian2。
    23. Triple 是什么? → HTTP/2 + protobuf,gRPC 兼容。
    24. Triple 优势? → 跨语言、流式、云原生。
    25. 注册中心挂了能调用吗? → 能,本地缓存 + 已有连接。
    26. 为什么有本地缓存? → 注册中心故障兜底。
    27. provider 下线怎么感知? → 临时节点消失 → notify → 重建 Invoker。
    28. group/version 作用? → 隔离与灰度。
    29. 不匹配会怎样? → No provider available。
    30. check 参数? → 启动时检查依赖服务是否存在。
    31. 生产能开 check=false 吗? → 谨慎,掩盖启动顺序问题。
    32. Filter 怎么生效? → @Activate + SPI + ProtocolFilterWrapper。
    33. ExceptionFilter 做什么? → 异常转字符串,防反序列化失败。
    34. 超时怎么配? → timeout,方法级优先。
    35. 超时后 provider 会停吗? → 不会,可能继续执行。
    36. 线程池满会怎样? → RejectedExecutionException/Thread pool is EXHAUSTED。
    37. 怎么隔离? → 独立线程池/分组/限流。
    38. 服务降级怎么做? → mock、failsafe、熔断(3.4-5)。
    39. 泛化调用是什么? → 无接口 jar,用 GenericService 调用(3.4-6)。
    40. Dubbo 3 服务发现变化? → 应用级 + 元数据中心。
    41. 为什么要应用级? → 减少注册中心节点和推送量。
    42. 迁移怎么做? → 双注册 + MigrationRule 灰度。
    43. Dubbo 和 Spring Cloud 区别? → RPC vs HTTP、协议/治理模型不同。
    44. Dubbo 和 gRPC 区别? → Dubbo 有注册中心/治理,gRPC 偏协议。
    45. Dubbo 支持 REST 吗? → rest 协议。
    46. 怎么排查调用不通? → 注册中心 → 订阅 → 连通性 → 服务端日志。
    47. QOS 有什么用? → 在线查看/操作服务(22222)。
    48. 服务预热怎么做? → warmup 权重。
    49. 多网卡/容器 IP 问题? → 指定 dubbo.protocol.host。
    50. 面试怎么总结? → 角色 → URL/Invoker/SPI → export 五步 → refer 五步 → 调用链 → 容错/治理 → Dubbo 3 变化。
  • 生产案例/取舍(示例,替换成你的项目):

    • provider 启动成功但 consumer 报 No provider available,实际是 group 写错;对齐 group/version 后恢复。
    • 消费方先于提供方启动,check=true 导致发布失败;改成依赖顺序 + 短暂 check=false。
    • 20880 与同机另一个服务冲突;容器化后统一用环境变量分配端口。
    • 超时 1s + 重试 2 次,支付回调重复扣款;关闭非幂等接口重试 + 幂等键。
    • provider 线程池 200 打满,大量超时;拆分慢接口到独立线程池/服务。
    • 大对象 6MB 超过 payload 限制;改分页/压缩/对象存储引用。
    • 注册中心故障,扩容的新 provider 不可见;本地缓存保证存量调用,恢复后验证。
    • 升级 Dubbo 3 后接口级/应用级双注册,注册中心节点翻倍;按迁移规则灰度下线接口级。
    • 自定义 Filter 没加 @Activate,一直不生效;补注解与 SPI 文件。
    • 两端 POJO 字段增删导致 hessian 反序列化异常;保持兼容字段、避免改类名。
    • 容器里注册了 Pod IP 但外部不可达;检查 host 与网络模式。
    • 取舍:接口级发现换精确路由,代价是注册中心压力;应用级发现换规模,代价是元数据依赖;failover 换可用性,代价是重复执行风险;长连接换性能,代价是连接治理与心跳。
  • 易错点:

    • 认为注册中心在调用链路上(它只做发现)。
    • 认为 consumer 直连某个 provider。
    • 认为 provider 列表变化要重启 consumer。
    • 认为 export 只做注册、不开端口。
    • 认为端口在 registry.register 之后才开。
    • 认为 Protocol.export 返回 Invoker(返回 Exporter)。
    • 认为 Protocol.refer 返回 Exporter(返回 Invoker)。
    • 认为 Invoker 就是代理对象。
    • 认为 Exporter 是网络连接。
    • 认为 Dubbo 默认用 JDK 动态代理。
    • 认为默认序列化是 JSON。
    • 认为默认协议端口是 8080。
    • 认为 tri 就是 gRPC(兼容但不等同)。
    • 认为超时后 provider 一定停止执行。
    • 认为 retries 对幂等没要求。
    • 认为 check=false 可以长期在生产使用。
    • 认为 group/version 只影响灰度不影响发现。
    • 认为 Filter 只要实现接口就生效。
    • 认为注册中心挂了服务立刻不可用。
    • 认为本地缓存能发现新节点。
    • 认为 Dubbo 3 仍只有接口级发现。
    • 认为 Triple 只能在 Dubbo 3 用(2.7 也有实验性支持)。
    • 认为线程池满只会变慢(会拒绝)。
    • 认为 Dubbo 自带分布式事务。
    • 认为泛化调用需要接口 jar。
    • 认为 QOS 只是监控端口。
    • 认为 Dubbo 只能用在 Spring 环境。
    • 认为 URL 只是日志信息。
  • 30 秒口述稿:

Dubbo 的核心是 URL、Invoker、Protocol 和 SPI。Provider 启动时 ServiceConfig.export 把实现包成 Invoker,RegistryProtocol 先调 DubboProtocol.export 开 Netty 端口,再把 provider URL 注册到注册中心。Consumer 启动时 ReferenceConfig.get 向注册中心订阅,拿到 URL 列表后交给 RegistryDirectory 和 Cluster,默认 FailoverClusterInvoker 做路由、负载均衡和重试,最后 ProxyFactory 生成接口代理。调用时走 代理 → Cluster → Filter → Netty → provider 的 Filter → 真实实现。注册中心只在启动和变更时参与,不在一调用链上;provider 变化通过 notify 动态更新,不用重启 consumer。

  • 3 分钟展开顺序:结论(URL/Invoker/Protocol/SPI)→ 五角色与十层 → URL 统一模型 → export 五步与端口打开时机 → refer 五步与动态 notify → 一次调用的完整链路 → Invoker/Exporter/Protocol 语义 → 注册中心数据模型与容错 → Dubbo 3 应用级发现与 Triple → 生产故障与取舍。