知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# Dubbo 概述与架构 > 导读:本文从"我已经会写 REST 接口了,为什么还要引入一个 RPC 框架"这个具体的痛点出发,把 Dubbo 是什么、它和 Spring Cloud 的定位差异、整体分层架构与核心组件、服务导出(export)与引用(refer)的完整流程、URL 统一模型、SPI 扩展机制,以及 Dubbo 3 的架构演进逐项讲透,最后给出生产用法与踩坑。适合已有 Java 与 Spring 基础、正在做服务化拆分或准备引入 Dubbo 的同学。 ## 一、先建立全局认知 ### Q:Dubbo 到底是什么?它到底解决什么痛点? A:结论先行——Dubbo 是一个高性能的 Java RPC(Remote Procedure Call,远程过程调用)框架,同时是一套服务治理框架:它把"跨进程的网络调用"伪装成"本地接口调用",并把地址发现、路由、负载均衡、容错、限流降级等治理能力做成可插拔的扩展点。 先说"为什么"。假设你把一个单体拆成订单服务和库存服务,订单服务要调用库存扣减。最朴素的写法是引入 HTTP 客户端: ```java // 解决什么问题:最原始的跨进程调用,写死在代码里 public class OrderService { public void createOrder(Long skuId, int count) { String url = "http://192.168.1.10:8080/stock/deduct?skuId=" + skuId + "&count=" + count; String result = HttpClientUtils.post(url); // 地址硬编码、没有重试、没有降级 if (!"OK".equals(result)) { throw new RuntimeException("扣减库存失败"); } } } ``` 这段代码能跑,但它把四类问题全部推给了业务开发者: 1. **地址问题**:`192.168.1.10` 写死在代码里。库存服务扩容到 10 台机器,你怎么把请求分到 10 台?机器下线了怎么办? 2. **协议与编解码问题**:HTTP + JSON 是文本协议,序列化体积大、解析慢;如果你要做二进制高效传输,还要自己设计协议头、粘包拆包。 3. **容错问题**:某台机器抖动导致超时,你不希望整个订单失败,而是重试到另一台——这需要"感知有多台机器 + 自动切换"的能力。 4. **治理问题**:上线灰度、按标签路由、突发流量限流、出问题降级,这些能力如果没有统一框架,每个业务都要重复实现一遍。 Dubbo 的价值就是把上面四件事从业务代码里"抽走"。业务侧只保留接口定义和方法调用: ```java // 解决什么问题:把远程调用伪装成本地方法调用,业务无感知 @DubboReference private StockService stockService; // 一个接口,看不到任何 HTTP、IP、序列化细节 public void createOrder(Long skuId, int count) { stockService.deduct(skuId, count); // 看起来像本地调用 } ``` 关键点在于:**`StockService` 是一个普通 Java 接口,调用方拿到的是一个动态代理对象**。代理对象内部完成了"从注册中心找到地址 → 选一台机器 → 序列化参数 → 走网络 → 反序列化结果 → 异常转换"的全过程。这就是 RPC 的本质:用代理(Proxy)+ 序列化(Serialize)+ 网络传输(Transport)三件套,抹平"本地调用"和"远程调用"的差异。 **适用边界**:Dubbo 是"接口 + 二进制协议"导向的,天然适合同一套技术栈(尤其是 Java 与 Java 之间)的内部服务调用。如果你要对外暴露给浏览器、给第三方合作方、给异构语言(Go、Python)调用,HTTP/JSON 或 Dubbo 3 的 Triple 协议(兼容 gRPC 语义)会更合适。 ### Q:Dubbo 和 Spring Cloud 是竞争关系吗?定位差异在哪? A:结论先行——两者不是同一层的东西:**Dubbo 的核心是一个 RPC 框架(负责"怎么调"),Spring Cloud 的核心是一整套微服务全家桶(负责"怎么组装一个微服务体系")**。用一句话概括:Dubbo 解决"远程调用与治理",Spring Cloud 解决"微服务所需的各类组件如何集成与标准化"。 对比表如下: | 维度 | Apache Dubbo | Spring Cloud(以 Netflix/Alibaba 体系为例) | | --- | --- | --- | | 核心定位 | RPC 框架 + 服务治理 | 微服务开发全家桶(集成式方案) | | 服务调用 | 接口级、二进制协议、动态代理 | 通常基于 HTTP + REST(RestTemplate/Feign,声明式 HTTP 客户端) | | 服务发现 | 内置抽象,适配 ZooKeeper/Nacos 等 | 通常依赖 Eureka/Nacos/Consul 等独立组件 | | 负载均衡 | 框架内置多种策略 | 通常由 Ribbon/LoadBalancer 承担 | | 熔断限流 | 早期偏薄弱,后接入 Sentinel | Hystrix/Resilience4j/Sentinel | | 配置中心 | 早期较弱,2.7 起支持动态配置中心 | Spring Cloud Config / Nacos Config | | 扩展方式 | 自研 SPI(ExtensionLoader,扩展点加载器) | Spring Boot 自动装配 + Spring 生态 | | 技术栈绑定 | 以 Java 为主(有 Go、Rust 等多语言实现) | 以 Spring 生态为主 | 需要纠正的两个常见误解: - **误解一:"Dubbo 只是 RPC,不能做微服务。"** 实际上 Dubbo 2.7 之后补齐了配置中心、元数据中心、动态路由、服务降级、并发控制、Sentinel 集成等能力;Dubbo 3 进一步引入应用级服务发现、Triple 协议与可观测性。它可以独立支撑一套完整的服务化体系。 - **误解二:"Spring Cloud 就等于 HTTP,Dubbo 就等于长连接。"** 这只是默认实现差异。Dubbo 也支持 `rest` 协议(基于 JAX-RS 的 HTTP/REST 风格),Spring Cloud 生态里也可以集成 gRPC。 **选型建议(结合实际约束,不是绝对结论)**: - 团队以 Java 为主、内部服务调用量大、对延迟与吞吐敏感 → 优先考虑 Dubbo,二进制协议 + 长连接 + 连接多路复用的收益更明显。 - 需要大量对外/异构语言接口、团队更熟悉 Spring 全家桶、希望组件自由拼装 → Spring Cloud 更顺手。 - 二者也可以混用:核心链路用 Dubbo,网关/前端/BFF(Backend For Frontend,面向前端的后端聚合层)层用 HTTP。 > 注意:上述"延迟与吞吐收益"是方向性判断,具体数值受协议、序列化方式、报文大小、网络环境影响。**不要拿某个博客上的压测数字当结论,要用自己业务报文做压测**。 ## 二、整体分层架构与核心组件 ### Q:Dubbo 的整体分层架构是怎样的? A:结论先行——Dubbo 采用经典的分层 + 扩展点架构,从上到下大致分为 Service、Config、Proxy、Registry、Cluster、Monitor、Protocol、Exchange、Transport、Serialize 共 10 层。上层依赖下层的抽象接口,每一层都可以通过 SPI 替换实现。  *图:Dubbo 十层架构:自上而下依赖抽象* ```text ┌──────────────────────────────────────────────┐ │ Service 业务层:接口 + 实现(你的代码) │ ├──────────────────────────────────────────────┤ │ Config 配置层:ServiceConfig / ReferenceConfig │ ├──────────────────────────────────────────────┤ │ Proxy 服务代理层:动态代理,生成 Invoker/Proxy │ ├──────────────────────────────────────────────┤ │ Registry 注册中心层:服务注册与发现、配置订阅 │ ├──────────────────────────────────────────────┤ │ Cluster 路由层:目录/路由/负载均衡/容错 合并成一路 │ ├──────────────────────────────────────────────┤ │ Monitor 监控层:RPC 调用次数与耗时统计 │ ├──────────────────────────────────────────────┤ │ Protocol 远程调用层:封装 Invocation 与 Result │ ├──────────────────────────────────────────────┤ │ Exchange 信息交换层:Request/Response 语义 │ ├──────────────────────────────────────────────┤ │ Transport 网络传输层:Netty/Mina 等抽象 │ ├──────────────────────────────────────────────┤ │ Serialize 数据序列化层:对象 ↔ 二进制 │ └──────────────────────────────────────────────┘ ▲ 自上而下依赖抽象,自下而上通过 SPI 扩展 ``` 各层职责再展开一点: - **Service 层**:业务代码。Dubbo 只要求你提供接口与实现,接口本身不应该带 RPC 语义(即不要出现 HttpClient、URL 之类的类型)。 - **Config 层**:对外配置入口。Provider 侧是 `ServiceConfig`,Consumer 侧是 `ReferenceConfig`(2.7 起还有 `ServiceConfigBase`、`ConfigCenterConfig` 等)。这一层负责把 `application.yml`、注解、XML、`-D` 参数、配置中心等多来源配置合并成最终的配置对象。 - **Proxy 层**:服务代理层。Provider 侧把实现类包装成 `Invoker`,Consumer 侧把 `Invoker` 包装成接口代理。默认使用 Javassist 字节码生成(`JavassistProxyFactory`),也可以用 JDK 动态代理。 - **Registry 层**:注册中心封装,负责服务注册、订阅、下线的通知。常见实现有 ZooKeeper、Nacos、Redis、Multicast 等。 - **Cluster 层**:把"多个可用的 Provider"聚合成一个逻辑 `Invoker`。它内部串联了 `Directory`(服务目录)、`Router`(路由)、`LoadBalance`(负载均衡)、`Cluster`(容错策略)。 - **Monitor 层**:统计 RPC 调用次数、成功率、耗时,并周期性上报到监控中心。 - **Protocol 层**:远程调用核心,负责导出(export)与引用(refer)服务。`dubbo`、`triple`、`rest`、`grpc` 等都属于这一层。 - **Exchange 层**:在传输层之上封装 Request/Response 模型,支持同步、异步、单向调用。 - **Transport 层**:网络抽象,默认基于 Netty 实现(`NettyTransporter`),也支持 Mina、Grizzly 等。 - **Serialize 层**:序列化抽象,Hessian2、Fastjson2、Protobuf、JDK 原生序列化等都在这层。 **这一层的价值**:分层不是为了好看,而是为了"可替换"。比如你想把 ZooKeeper 换成 Nacos,只需要替换 Registry 层实现;想把序列化从 Hessian2 换成 Protobuf,只需替换 Serialize 层实现,业务代码完全不动。 ### Q:Dubbo 的核心角色有哪些?一次调用的完整链路长什么样? A:结论先行——核心角色有 5 个:Provider(服务提供者)、Consumer(服务消费者)、Registry(注册中心)、Monitor(监控中心)、Container(服务运行容器)。调用链路是"启动时注册与订阅、运行时点对点调用、过程中异步上报"。  *图:Dubbo 角色协作:服务订阅、注册与通知流程* ```text ┌──────────┐ 1. subscribe(订阅) ┌──────────────┐ │ Consumer │ ──────────────────────▶ │ Registry │ │ 消费者 │ ◀────────────────────── │ 注册中心 │ └────┬─────┘ 4. notify(地址变更通知) └──────▲───────┘ │ │ │ 5. 直接发起 RPC 调用(点对点,不经注册中心) 2. register(注册) │ │ ▼ │ ┌──────────┐ 3. count(异步统计上报) ┌────┴─────┐ │ Provider │ ────────────────────────▶ │ Monitor │ │ 提供者 │ │ 监控中心 │ └────┬─────┘ └──────────┘ │ │ 0. start(容器启动,加载 Provider) ▼ ┌──────────┐ │Container │ └──────────┘ ``` 把链路拆成几个阶段: 1. **启动阶段**:Provider 在 Container(可以理解为 Spring 容器或 Dubbo 的 `Main` 启动类)中启动,把自身暴露的接口信息注册到 Registry。 2. **订阅阶段**:Consumer 启动时向 Registry 订阅自己需要的接口,拿到 Provider 地址列表并在本地缓存;此后地址变更由注册中心推送(notify)更新本地缓存。 3. **调用阶段**:真正的调用**不经过注册中心**,Consumer 从本地缓存的地址列表中按负载均衡策略选出一台 Provider,直接发起网络请求。注册中心只负责"地址簿"的角色,不承担数据面转发。 4. **监控阶段**:调用次数与耗时异步上报给 Monitor。 这带来一个重要特性:**注册中心短时间不可用,不会立刻导致调用失败**——因为 Consumer 本地已有地址缓存。这是设计上的容错考虑,但反过来也意味着"注册中心挂了,新扩容的 Provider 不会立刻被感知",属于**数据面与控制面分离**的经典权衡。 ### Q:为什么 Dubbo 到处都在传 URL?URL 统一模型是什么? A:结论先行——Dubbo 把"所有需要传递的信息"统一收敛成一个不可变的 `URL` 对象(配置信息、地址、参数全部编码在 URL 的协议、主机、端口、路径、参数里),让整个框架内部只有一种数据交换格式。 `URL` 不是一个网络地址,而是一个**配置总线**。它由 `protocol`、`username`、`password`、`host`、`port`、`path`、`parameters` 组成,形式上就是标准的 `protocol://host:port/path?k1=v1&k2=v2` 结构。 ```text dubbo://192.168.1.10:20880/com.example.StockService ?anyhost=true &application=order-service &interface=com.example.StockService &methods=deduct,query &timeout=3000 &retries=2 &side=provider &serialization=hessian2 ``` 这段 URL 表达的信息量很大,几个关键参数值得注意: | 参数 | 含义 | | --- | --- | | `protocol`(dubbo://) | 使用哪种协议导出/引用服务 | | `interface` | 服务接口全限定名,是服务发现的核心标识 | | `side` | provider 还是 consumer,决定参数合并方向 | | `timeout` | 调用超时(毫秒),会随请求从 consumer 传到 provider | | `methods` | 暴露的方法列表 | | `application` | 所属应用名,Dubbo 3 应用级服务发现的关键 | URL 统一模型带来的好处: 1. **可传递**:配置可以通过 URL 在进程间传递(例如 Consumer 的 `timeout` 参数会随请求带过去,Provider 端按 Consumer 的配置执行)。 2. **可缓存**:注册中心里存的就是 URL 字符串,从 ZooKeeper 节点下取出来的就是这个结构。 3. **可扩展**:任何扩展点需要新参数,只需加一个 URL 参数,不需要改接口签名。 4. **可覆盖**:动态配置、路由规则本质上就是"往 URL 上打补丁"(比如 override 规则覆盖某个参数)。 **适用边界与坑**:URL 的 `parameters` 是一个 `Map<String, String>`,参数同名冲突时需要靠"参数合并规则"决定谁生效(一般原则是"精确优先、Consumer 优先")。如果你在 Provider 和 Consumer 都配了 `timeout`,最终生效的值不一定是 Provider 上写的那个,排查问题时要打印完整 URL 才看得清。 ## 三、服务导出与引用的完整流程 ### Q:Provider 侧的"服务导出(export)"到底做了什么? A:结论先行——export 的核心是三步:**把实现类包装成 Invoker → 启动网络服务端(Server)→ 把 URL 注册到注册中心**。整个过程由 `ServiceConfig#export()` 驱动,最终落到 `RegistryProtocol#export()`。 ```java // 解决什么问题:最小可运行的 Provider 声明方式(以 API 方式为例,便于看清流程) public class ProviderBootstrap { public static void main(String[] args) throws Exception { ServiceConfig<StockService> service = new ServiceConfig<>(); service.setApplication(new ApplicationConfig("stock-service")); service.setRegistry(new RegistryConfig("zookeeper://127.0.0.1:2181")); service.setProtocol(new ProtocolConfig("dubbo", 20880)); // 协议 + 端口 service.setInterface(StockService.class); service.setRef(new StockServiceImpl()); // 真实实现对象 service.export(); // 触发导出 Thread.currentThread().join(); // 阻塞,保持进程存活 } } ``` 关键点:`setRef(new StockServiceImpl())` 里的对象是纯粹的 POJO,Dubbo 不会要求它实现任何框架接口;`export()` 之后,Dubbo 会一直持有它,并通过代理 Invoker 调用它。 导出流程的完整链路如下:  *图:ServiceConfig.export() 服务导出主流程* ```text ServiceConfig.export() ├─ 1. checkAndUpdateConfig():合并多来源配置、校验必填项、处理 delay 延迟导出 └─ doExport() └─ doExportUrls() ├─ loadRegistries(true):解析注册中心配置,得到注册中心 URL 列表 └─ 对每个 registry、每个 protocol 调用 doExportUrlsFor1Protocol() ├─ 组装服务 URL(protocol/host/port/interface/参数...) ├─ ProxyFactory#getInvoker(ref, interface, url) │ └─ 默认 JavassistProxyFactory:把 ref 包装成 AbstractProxyInvoker ├─ 用 Filter 链包装 Invoker(EchoFilter / ClassLoaderFilter / ... / MonitorFilter) └─ Protocol#export(invoker) └─ RegistryProtocol#export() ← 注意:因为配了注册中心,实际走这里 ├─ doLocalExport(originInvoker) │ └─ 按 URL 的 protocol 找到 DubboProtocol │ └─ DubboProtocol#export() │ ├─ 缓存 DubboExporter(key = 服务 key,用于请求分发) │ └─ openServer(url) │ └─ Exchanger#bind() │ └─ HeaderExchanger → Transporters#bind() │ └─ NettyTransporter → NettyServer 启动 ├─ registry.register(注册的 URL) ← 写入注册中心 └─ registry.subscribe(...) ← 订阅 override/动态配置 ``` 几个容易搞混的点: - **`export()` 里为什么是 `RegistryProtocol` 在干活?** 因为 `ServiceConfig` 在选择 Protocol 实现时,如果发现配置了注册中心,就会使用 `RegistryProtocol`(一个"代理型"协议实现)。它内部再按 URL 的 `protocol` 参数(这里是 `dubbo`)去 `doLocalExport`,真正的服务端还是 `DubboProtocol` 启动的 Netty Server。这也解释了为什么"注册中心挂了,已启动的服务端仍然能提供服务"。 - **"本地导出"和"注册"是两件事**:本地导出 = 端口起来了、能处理请求;注册 = 把自己的 URL 写到注册中心,让别人能找到你。顺序上先本地导出、再注册,这样可以保证"被发现时一定能被调用"。 - **`delay` 参数**:默认 `delay` 未配置时按 Spring 上下文刷新事件时机导出;如果设置 `delay=-1` 表示延迟到 Spring 初始化完成后再导出。**这在 Provider 依赖第三方资源(数据库、缓存)初始化时很关键,配错了会出现"服务已注册但依赖还没初始化完"**。 ### Q:Consumer 侧的"服务引用(refer)"又是怎么拿到可用代理的? A:结论先行——refer 核心是三步:**从注册中心订阅并拿到 Provider URL 列表 → 用 Cluster 把多个 Provider 聚合成一个逻辑 Invoker → 通过 ProxyFactory 生成接口代理对象**。 ```java // 解决什么问题:Consumer 侧最小引用示例(API 方式) ReferenceConfig<StockService> reference = new ReferenceConfig<>(); reference.setApplication(new ApplicationConfig("order-service")); reference.setRegistry(new RegistryConfig("zookeeper://127.0.0.1:2181")); reference.setInterface(StockService.class); reference.setTimeout(3000); // 3 秒超时,最终会随请求传给 Provider StockService stockService = reference.get(); // 触发引用,返回代理对象 stockService.deduct(1001L, 2); // 像本地调用一样使用 ``` `reference.get()` 内部流程:  *图:ReferenceConfig.get() 服务引用主流程* ```text ReferenceConfig.get() ├─ checkAndUpdateSubConfigs():合并配置、校验、判断是否需要服务端校验 └─ init() → createProxy(map) ├─ 情况 A:直连(URL 中直接写了 dubbo://host:port) │ └─ 构造一个只含单个 Provider 的 Invoker ├─ 情况 B:注册中心(最常见) │ └─ RegistryProtocol#refer() │ ├─ registryFactory.getRegistry(url) │ ├─ registry.subscribe(url, listener) ← 订阅,拿到 Provider URL 列表 │ ├─ 每个 Provider URL → protocol.refer() → 得到 Invoker │ │ └─ DubboProtocol#refer() → 复用或新建 Client(NettyClient) │ ├─ 用 Cluster(默认 FailoverCluster)把 N 个 Invoker 合并成 1 个 │ │ └─ Directory(服务目录)维护地址列表,Router 过滤,LoadBalance 选择 │ └─ 生成并缓存 ClusterInvoker └─ ProxyFactory#getProxy(invoker) └─ 默认 JavassistProxyFactory:生成实现 StockService 的代理类 ``` 值得注意的机制: - **订阅是"推"模型(大多数实现)**:Provider 上下线后,注册中心主动通知 Consumer,Consumer 更新 `Directory` 中的地址列表,无需重启即可感知,这是"服务动态扩缩容"的基础。 - **`invokers` 缓存与懒连接**:`DubboProtocol#refer()` 会为每个 Provider 建立或复用一个 Client。默认在 Consumer 启动时就会建立连接(`lazy=false`);也可以配 `lazy=true` 延迟到首次调用再连。 - **代理对象是"一次生成、长期使用"的**:代理类在首次 `get()` 时生成并缓存。因此"改了接口签名必须重新编译、并且 Provider/Consumer 必须同时升级"是 RPC 框架的硬约束——接口不兼容变更(删方法、改参数类型)会导致序列化失败或找不到方法。 - **"引用是否成功"由 `check` 决定**:`check` 默认 `true`,启动时如果订阅不到任何可用 Provider,会直接抛异常阻止启动。这就是很多团队第一次上 Dubbo 时"Consumer 起不来"的原因,详见生产实践篇。 ### Q:把"导出"和"引用"放在一起看,一条链路真正经过了哪些组件? A:结论先行——一次调用经过的组件是固定的一条链:**Consumer 代理 → Cluster(目录/路由/负载均衡/容错)→ Protocol(dubbo)→ Exchange(Request/Response)→ NettyClient → 网络 → NettyServer → Protocol 分发 → Invoker → Filter 链 → 真实实现**。  *图:Dubbo 调用链路:Consumer 侧与 Provider 侧的分层组件* ```text Consumer 侧 Provider 侧 ┌───────────────┐ ┌───────────────┐ │ StockService │ 动态代理 │ StockServiceImpl │ │ (Proxy) │ │ (业务实现) │ └──────┬────────┘ └───────▲───────┘ ▼ │ ┌───────────────┐ Route / LoadBalance ┌─────┴────────┐ │ ClusterInvoker│ / Failover(容错重试) │ Invoker 链 │ └──────┬────────┘ │ (Filter 包装) │ ▼ └─────▲────────┘ ┌───────────────┐ ┌─────┴────────┐ │ Invoker │ Protocol(dubbo) │ Exporter 分发 │ └──────┬────────┘ └─────▲────────┘ ▼ │ ┌───────────────┐ Exchange(Request/Response) ┌─────┴────────┐ │ ExchangeClient│ │ ExchangeServer│ └──────┬────────┘ └─────▲────────┘ ▼ │ ┌───────────────┐ TCP 长连接(多路复用) ┌─────┴────────┐ │ NettyClient │ ───────────────────────────────▶ │ NettyServer │ └───────────────┘ └──────────────┘ ``` 从排错角度看,这条链的每一段都可能出问题:代理层(接口不匹配)、Cluster 层(找不到 Provider、路由过滤空了)、Protocol 层(序列化不兼容)、Exchange 层(请求超时)、Transport 层(连接断裂)。知道这条链,是后面"线上排查"的前提。 ## 四、SPI 扩展机制 ### Q:Dubbo 为什么不直接用 JDK 自带的 SPI,而自己造了一个 ExtensionLoader? A:结论先行——因为 JDK SPI 有三大硬伤:**一次性实例化所有实现(不能按需加载)、不能按名字精确获取某个实现、不支持依赖注入与 AOP 包装**。Dubbo 的 SPI(Service Provider Interface,服务提供者接口,即扩展点规范)解决了这三件事,还额外增加了 `@Adaptive`(自适应)与 `@Activate`(自动激活)两个核心能力。 先看 JDK SPI 的问题: ```java // JDK SPI:ServiceLoader.load(Protocol.class) 会一次性把 META-INF/services 下所有实现都 new 出来 // 问题:1) 全部实例化,浪费资源;2) 无法"只拿 dubbo 这一个实现";3) 无法给扩展注入其他扩展 ServiceLoader<Protocol> loader = ServiceLoader.load(Protocol.class); for (Protocol p : loader) { /* 只能遍历,不能按名取 */ } ``` Dubbo SPI 的用法是"按名获取": ```java // 解决什么问题:按名称拿到某个扩展实现(dubbo 是扩展名,不是类名) Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class) .getExtension("dubbo"); // 获取"自适应扩展":调用时才根据 URL 参数决定用哪个实现 Protocol adaptive = ExtensionLoader.getExtensionLoader(Protocol.class) .getAdaptiveExtension(); // 获取某个分组下所有自动激活的扩展(如 Filter 链) List<Filter> filters = ExtensionLoader.getExtensionLoader(Filter.class) .getActivateExtension(url, "service.filter", "provider"); ``` Dubbo SPI 的配置文件位置(**2.7+ 与 3.x 的组织方式与命名有调整,需结合版本确认**): ```text META-INF/services/ JDK SPI 兼容目录 META-INF/dubbo/ 用户自定义扩展目录 META-INF/dubbo/internal/ Dubbo 框架内部扩展目录 ``` 每一行是 `扩展名=实现类全限定名` 的键值对: ```text # META-INF/dubbo/internal/org.apache.dubbo.rpc.Protocol dubbo=org.apache.dubbo.rpc.protocol.dubbo.DubboProtocol triple=org.apache.dubbo.rpc.protocol.tri.TripleProtocol rest=org.apache.dubbo.rpc.protocol.rest.RestProtocol ``` ### Q:@SPI、@Adaptive、@Activate 这三个注解分别在做什么? A:结论先行——`@SPI` 标记"这是一个扩展点接口"并给出默认实现名;`@Adaptive` 生成"运行时按 URL 参数动态选择实现"的代理;`@Activate` 声明"在满足分组/条件时自动加入"(典型用途是 Filter)。 三者的对比: | 注解 | 位置 | 作用 | 典型例子 | | --- | --- | --- | --- | | `@SPI` | 接口上 | 声明该接口是扩展点,value 为默认扩展名 | `@SPI("dubbo") public interface Protocol` | | `@Adaptive` | 类上或方法上 | 生成/指定自适应实现,运行时按 URL 参数选实现 | `Protocol#export`、`LoadBalance#select` | | `@Activate` | 实现类上 | 声明自动激活条件(group/value/order) | 各类 `Filter`、部分 `Cluster` 包装 | `@SPI` 示例: ```java // 解决什么问题:声明扩展点并给出默认实现,未显式配置时用它 @SPI("random") public interface LoadBalance { <T> Invoker<T> select(List<Invoker<T>> invokers, URL url, Invocation invocation); } ``` 这表示 `LoadBalance` 默认实现是 `random`(加权随机)。你可以通过 URL 参数 `loadbalance=leastactive` 换成最少活跃调用数。 `@Adaptive` 的两种用法: ```java // 用法一:标在方法上(最常见),Dubbo 运行期生成一个自适应代理类 @SPI("dubbo") public interface Protocol { @Adaptive // 会去 URL 里找 protocol 参数 <T> Exporter<T> export(Invoker<T> invoker) throws RpcException; @Adaptive <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException; } ``` ```java // 用法二:标在类上,表示这个类就是一个手写的自适应实现 // 例如 AdaptiveExtensionFactory / AdaptiveCompiler 就是手写的 Adaptive 类 @Adaptive public class AdaptiveCompiler implements Compiler { /* ... */ } ``` 关键点: - 运行期生成的 Adaptive 类,会去 `URL` 里取注解 `value()` 指定的参数(不写则默认取接口名转换为"点分隔小驼峰",如 `LoadBalance` → `loadbalance`),拿到扩展名后再去 `ExtensionLoader` 里查对应实现调用。**这就是"配置只改 URL、行为就变了"的底层机制。** - 如果 URL 里没配该参数,就回退到 `@SPI` 声明的默认扩展名。 - 一个扩展点接口上**最多只能有一个类标 `@Adaptive`**。 `@Activate` 示例: ```java // 解决什么问题:让 Filter 在满足条件时自动生效,无需手动在配置里列出来 @Activate(group = {CommonConstants.PROVIDER, CommonConstants.CONSUMER}, order = -9000) public class MonitorFilter implements Filter { /* ... */ } ``` - `group`:在 provider 侧还是 consumer 侧激活。 - `value`:URL 中必须存在的 key 才激活(可指定多个 key,配合 `before`/`after` 做顺序控制)。 - `order`:排序,越小越靠前。 ### Q:什么是 Wrapper 包装?它和 AOP 有什么关系? A:结论先行——如果某个扩展实现类**只有一个"以扩展接口为参数的构造函数"**,Dubbo 就认为它是一个 Wrapper(包装类),会用它去层层包裹真正的扩展实现,从而在不改动原实现的前提下增加功能——这就是 Dubbo 版的 AOP(Aspect Oriented Programming,面向切面编程)。 ```java // 解决什么问题:给所有 Protocol 实现统一加上"统计/日志"能力,而不修改任何具体实现 public class ProtocolFilterWrapper implements Protocol { private final Protocol protocol; // 关键:唯一构造函数,参数是扩展接口本身 → Dubbo 识别为 Wrapper public ProtocolFilterWrapper(Protocol protocol) { if (protocol == null) { throw new IllegalArgumentException("protocol == null"); } this.protocol = protocol; } @Override public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException { if (UrlUtils.isRegistry(invoker.getUrl())) { return protocol.export(invoker); // 注册中心协议不包 Filter } return protocol.export(buildFilterChain(invoker)); // 其他协议包一层 Filter 链 } } ``` 机制说明: 1. `ExtensionLoader` 在加载某个扩展实现前,会先扫描该扩展点下所有"符合 Wrapper 特征"的类。 2. 拿到目标实现后,按 Wrapper 被发现的顺序,从内到外依次包裹,形成一个装饰器链。 3. 因此**Wrapper 的执行顺序由加载顺序决定,不同版本可能不同,不要依赖固定顺序做业务逻辑**。 4. 常见的 Wrapper 包括:`ProtocolFilterWrapper`、`ProtocolListenerWrapper`、`RegistryProtocol`(注册中心场景下的自适应包装)等。 **与 Filter 的区别(很容易搞混)**: | 维度 | Wrapper | Filter | | --- | --- | --- | | 拦截对象 | 扩展点实现(如 Protocol、Cluster) | 每次 RPC 调用(Invocation) | | 声明方式 | 隐式(构造函数特征) | 显式 `@Activate` 或配置 | | 生效时机 | 扩展实例构建时包一次 | 每次调用都经过 | | 典型用途 | 框架内部织入能力 | 业务自定义:鉴权、限流、日志、埋点 | 写业务扩展时,绝大多数场景应该用 **Filter**,而不是 Wrapper。Wrapper 更偏框架内部使用,滥用容易造成"扩展被莫名包裹、行为不符合预期"。 ## 五、Dubbo 3 的演进 ### Q:Dubbo 3 引入的"应用级服务发现"是什么?和 2.x 的"接口级服务发现"有什么区别? A:结论先行——2.x 默认是**接口级服务发现**(Interface-level Service Discovery):一个接口注册一条数据;3.x 引入并逐步默认**应用级服务发现**(Application-level Service Discovery):一个应用实例注册一条数据,接口信息通过与实例关联的元数据获取。核心动机是大幅降低注册中心的存储与推送压力。 对比说明: | 维度 | 接口级服务发现(2.x 默认) | 应用级服务发现(3.x 引入) | | --- | --- | --- | | 注册数据粒度 | 每个"接口 × 实例"一条记录 | 每个"应用实例"一条记录 | | 数据量级 | 随接口数线性放大 | 与应用实例数同量级 | | 注册中心压力 | 大(接口多时节点爆炸) | 小(大幅收敛) | | 接口元数据来源 | 直接在注册数据中 | 通过元数据服务(MetadataService)获取 | | 与云原生/服务网格兼容 | 较弱 | 更好(贴近 Kubernetes Service 模型) | | 默认启用情况 | 2.x 唯一模型 | **3.0 引入,后续版本逐步切换为默认,需结合版本确认** | 为什么接口级会"数据爆炸"?举个例子:一个电商系统有 500 个接口、每个接口平均部署在 20 个实例上,接口级注册会产生约 1 万条注册数据;如果改成应用级,假设 30 个应用、每个应用 20 个实例,只有 600 条。差了一个数量级,注册中心(尤其 ZooKeeper 这类基于节点 watch 的实现)的推送成本差异会非常明显。 **两种模型的兼容性是 Dubbo 3 迁移时最需要注意的点**: - 3.x 应用级服务发现通过与具体注册中心(Nacos、ZooKeeper 等)的适配实现,**不同注册中心的支持程度与配置项不同,需结合版本确认**。 - 迁移时通常需要"接口级 + 应用级双注册/双订阅"过渡,混部期间会出现 Consumer 只认一种模型而发现不到 Provider 的情况。这是**升级 Dubbo 3 时最典型的"服务找不到"故障来源**。 ### Q:Triple 协议是什么?它解决了什么问题? A:结论先行——Triple(triple 协议)是 Dubbo 3 引入的新协议,**基于 HTTP/2 承载,兼容 gRPC 语义**,目标是同时满足"高性能内部调用"和"跨语言/跨框架互通"两个场景,并且支持流式(Streaming)通信。 它想解决三件事: 1. **协议互通**:传统 `dubbo` 协议是 Dubbo 私有二进制协议,跨语言成本高。Triple 基于 HTTP/2 + Protobuf 语义,可以与非 Java 的 gRPC 客户端/服务端互通。 2. **流式能力**:传统 RPC 是"一问一答",Triple 支持双向流、客户端流、服务端流,适合推送、大文件分片、实时交互场景。 3. **与网关/基础设施兼容**:HTTP/2 天然能被各类网关、Service Mesh(服务网格,如 Envoy)识别与治理。  *图:dubbo 与 Triple 协议:通信方式与优缺点* ```text 传统 dubbo 协议(私有二进制,单连接多路复用) Triple 协议(HTTP/2) ┌────────────┐ ┌────────────┐ ┌────────────┐ ┌────────────┐ │ Consumer │ │ Provider │ │ Consumer │ │ Provider │ └─────┬──────┘ └─────▲──────┘ └─────┬──────┘ └─────▲──────┘ │ 自定义协议头 + Hessian2 序列化 │ HTTP/2 帧 + Protobuf(默认) └─────────────────────┘ └─────────────────────┘ 优点:体积小、延迟低 优点:互通、流式、易被网关治理 缺点:跨语言、网关治理成本高 缺点:报文头开销相对更大 ``` **必须注意的版本差异**: - Triple 在 **Dubbo 3.0 引入**,后续版本在流式、序列化(是否支持 Hessian2 等非 Protobuf 序列化)、HTTP/3 支持上持续演进,**具体能力与默认值必须结合版本确认**。 - Dubbo 2.x **没有** Triple 协议(有实验性的 grpc 协议,但不等于 Triple)。看到"Triple"字样基本可以判定是 3.x。 - 是否把 Triple 作为默认协议,**不同 3.x 小版本策略不同,需结合版本确认**;迁移前务必在测试环境验证与现有注册中心、网关、序列化配置的兼容性。 ### Q:什么是"服务自省"?它和应用级服务发现是什么关系? A:结论先行——服务自省(Service Introspection)是 Dubbo 3 提出的一种架构模式:Provider 不再把"接口清单"直接塞进注册中心,而是**在注册中心只注册应用实例信息,接口与元数据通过内置的 MetadataService(元数据服务)对外提供,由 Consumer 按需拉取并缓存**。 它要解决的问题是:应用级服务发现让注册中心的注册数据变少了,但 Consumer 需要知道"这个应用实例到底暴露了哪些接口、方法签名是什么、参数怎么配"。这部分信息不能丢,于是把它从注册中心"搬"到了元数据服务:  *图:应用级注册:实例与接口元数据分开存放* ```text 注册中心(只存应用级实例) MetadataService(存接口元数据) ┌────────────────────────────┐ ┌──────────────────────────────┐ │ app=stock-service │ │ interface=StockService │ │ host=192.168.1.10 │ ◀──────│ methods=deduct,query │ │ port=20880 │ 关联 │ params=timeout/retries/... │ │ protocol=dubbo,tri │ │ version/group/... │ └────────────────────────────┘ └──────────────────────────────┘ ▲ ▲ │ 订阅实例 │ 按需拉取 + 本地缓存 └──────────────── Consumer ──────────────┘ ``` 关键要点: - 元数据同步方式在不同版本中有不同实现(有基于元数据中心、也有基于 Provider 内置 MetadataService 服务的方案),**需结合版本确认**。 - 服务自省带来的好处:注册中心数据量下降、元数据可独立治理、与云原生实例模型更贴近。 - 带来的新问题:多了一个"元数据获取"的链路,**首次调用前的元数据拉取失败会导致"服务能发现但调用不了"**,排查时要同时看注册中心和元数据链路。 > 这三个演进点(应用级服务发现、Triple 协议、服务自省)是 Dubbo 2 → 3 迁移的三大关键。它们**不是彼此独立的开关**:应用级服务发现依赖元数据能力,Triple 又与应用级服务发现的"应用实例"模型配合更好。升级前一定要先确认版本、做双注册/双订阅灰度,不要一次性全量切换。 ## 小结 - **定位**:Dubbo = RPC 框架 + 服务治理框架;核心是"代理 + 序列化 + 网络传输",把远程调用伪装成本地调用。它和 Spring Cloud(微服务全家桶)是不同层次的东西,可以互补而非互斥。 - **架构**:10 层分层(Service/Config/Proxy/Registry/Cluster/Monitor/Protocol/Exchange/Transport/Serialize),每层都能通过 SPI 替换实现。 - **角色与链路**:Provider、Consumer、Registry、Monitor、Container 五个角色;启动时"注册 + 订阅",运行时"点对点直连",监控"异步上报"。数据面与控制面分离,所以注册中心短期不可用不影响已有调用。 - **URL 统一模型**:URL 是 Dubbo 内部的"配置总线",承载协议、地址、接口、参数,是可传递、可缓存、可覆盖的载体。 - **导出/引用**:export = 包装成 Invoker → 启动 Server → 注册;refer = 订阅拿地址 → Cluster 聚合 → 生成代理。配了注册中心时走的是 `RegistryProtocol`。 - **SPI**:Dubbo 自研 `ExtensionLoader` 支持按需加载、按名获取、依赖注入、Wrapper AOP;`@SPI` 定默认实现、`@Adaptive` 定运行期自适应、`@Activate` 定自动激活。 - **Dubbo 3 演进**:应用级服务发现(降注册中心压力)、Triple 协议(HTTP/2 + 跨语言 + 流式)、服务自省(元数据服务解耦)。**这三者与 2.x 差异极大,版本相关性强,必须结合版本确认后再落地。** ## 思考题 1. 为什么 Consumer 拿到 Provider 地址列表后,真正的调用不经过注册中心?如果注册中心宕机 10 分钟,系统会出什么问题、不会出什么问题? 2. `@Adaptive` 生成的代理类是如何知道该用哪个扩展实现的?如果 URL 里既没有配 `protocol`、`@SPI` 也没写默认值,会发生什么? 3. 假设你要给"所有 Provider 的每次调用"统一加上"调用链埋点",应该实现 Filter 还是 Wrapper?为什么? 4. 从接口级服务发现迁移到应用级服务发现,你认为最容易出问题的环节是什么?如何做灰度? 5. 如果把 Dubbo 引入你的系统,你会优先用它替换哪一类调用(内部高频调用、还是对外/异构语言调用)?理由是什么?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入