看 Spring 源码里的设计模式，很多时候你得绕好几层才能看到模式的全貌。Dubbo 不一样，它用模式用得很"明目张胆"——连类名都告诉你了。
Protocol、ProxyFactory、Cluster、LoadBalance……这些接口和实现之间的关系，就是设计模式教科书级别的案例。今天拆 4 个最典型的。
1. SPI + 工厂方法：扩展点加载机制
Dubbo 最核心的设计不是某个设计模式，而是它自己的 SPI 扩展机制。但这个机制的底层就是工厂方法模式。
java // ExtensionLoader 本质是一个工厂 public class ExtensionLoader<T> { // 根据名字创建扩展实例 — 典型工厂方法 public T getExtension(String name) { Holder<Object> holder = getOrCreateHolder(name); Object instance = holder.get(); if (instance == null) { synchronized (holder) { instance = holder.get(); if (instance == null) { instance = createExtension(name); // 创建具体实例 holder.set(instance); } } } return (T) instance; } }
调用方式：
java Protocol protocol = ExtensionLoader .getExtensionLoader(Protocol.class) .getExtension("dubbo"); // 按名字加载具体实现
ExtensionLoader是工厂，Protocol是产品接口，DubboProtocol、HttpProtocol、RedisProtocol是具体产品。你不需要new任何实现类，只要在META-INF/dubbo下配置好扩展点，工厂帮你创建。
这比 Spring 的BeanFactory更直白：你不需要注解、不需要容器启动，一行代码拿到扩展实例。
2. 装饰器模式：Protocol 的包装链
Dubbo 里的Protocol接口有一堆实现，有些是真正的协议，有些是装饰器。看源码：
```java // 真正的协议实现 public class DubboProtocol implements Protocol { ... } public class HttpProtocol implements Protocol { ... }
// 装饰器：给 Protocol 加功能 public class ProtocolFilterWrapper implements Protocol { private Protocol protocol; // 持有被装饰对象
public <T> Exporter<T> export(Invoker<T> invoker) { // 先构建 Filter 链，再委托给真正的 Protocol return protocol.export(buildInvokerChain(invoker, ...)); }}
public class ProtocolListenerWrapper implements Protocol { private Protocol protocol;
public <T> Exporter<T> export(Invoker<T> invoker) { // 加监听器逻辑，再委托 return protocol.export(invoker); }}
public class QosProtocolWrapper implements Protocol { private Protocol protocol; // 加 QoS 功能 } ```
加载顺序：先加载真正的 Protocol，然后用装饰器一层层包上去：
QosProtocolWrapper └─ ProtocolListenerWrapper └─ ProtocolFilterWrapper └─ DubboProtocol ← 真正干活的
这就是装饰器模式的精髓：不修改原始类，通过包装给它加功能。而且装饰器可以无限叠加，每层只管自己的事。
Dubbo 的 Filter 链也是装饰器模式的变体。你在配置文件里加的timeout、monitor、exceptionFilter，都是一个个装饰器，把Invoker包装后返回。
3. 策略模式：负载均衡
这是 Dubbo 里最容易看懂的策略模式——连接口名都叫LoadBalance：
java @SPI(RandomLoadBalance.NAME) public interface LoadBalance { <T> Invoker<T> select(List<Invoker<T>> invokers, URL url, Invocation invocation); }
四种策略实现：
java public class RandomLoadBalance extends AbstractLoadBalance { ... } // 随机 public class RoundRobinLoadBalance extends AbstractLoadBalance { ... } // 轮询 public class LeastActiveLoadBalance extends AbstractLoadBalance { ... } // 最少活跃 public class ConsistentHashLoadBalance extends AbstractLoadBalance { ... } // 一致性哈希
选择哪个策略？配置决定：
xml <dubbo:reference loadbalance="roundrobin" />
运行时通过 SPI 加载对应实现：
java LoadBalance lb = ExtensionLoader .getExtensionLoader(LoadBalance.class) .getExtension("roundrobin");
不写 if-else，不写 switch，策略的切换完全由配置驱动。新增负载均衡算法？写个实现类 + 配置文件就行，零侵入。
4. 模板方法模式：AbstractProtocol
Dubbo 的Protocol接口有两个核心方法：export（暴露服务）和refer（引用服务）。不同协议的实现逻辑差异很大，但有些公共步骤是固定的。
AbstractProtocol把这些公共步骤抽到模板方法里：
```java public abstract class AbstractProtocol implements Protocol {
// 模板方法：暴露服务的公共骨架 public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException { // 公共逻辑：校验 URL、记录 exporter 等 URL url = invoker.getUrl(); String key = serviceKey(url); Exporter<T> exporter = doExport(invoker, url, key); // 子类实现 exporterMap.put(key, exporter); return exporter; } // 子类必须实现的抽象方法 protected abstract <T> Exporter<T> doExport(Invoker<T> invoker, URL url, String key); // 引用服务同理 public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException { // 公共逻辑 Invoker<T> invoker = doRefer(type, url); // 子类实现 return invoker; } protected abstract <T> Invoker<T> doRefer(Class<T> type, URL url);} ```
DubboProtocol只需要关心自己的doExport和doRefer：
java public class DubboProtocol extends AbstractProtocol { @Override protected <T> Exporter<T> doExport(Invoker<T> invoker, URL url, String key) { // 打开 Server、注册到注册中心 等 Dubbo 特有逻辑 openServer(url); optimizeSerialization(url); return new DubboExporter<>(invoker, key, exporterMap); } }
公共逻辑不重复，协议特有逻辑各写各的。如果以后新增一个 gRPC 协议，继承AbstractProtocol实现两个方法就行。
跟 Spring 对比着看
| 模式 | Spring 怎么用 | Dubbo 怎么用 | |------|-------------|------------| | 工厂方法 | BeanFactory + 各种 FactoryBean | ExtensionLoader 直接按名加载 | | 装饰器 | BeanWrapper、各种 Proxy | ProtocolFilterWrapper 等包装链 | | 策略 | Resource 接口不同实现 | LoadBalance 接口不同实现 | | 模板方法 | AbstractApplicationContext | AbstractProtocol |
Dubbo 的特点是用得更"裸"：没有 IoC 容器帮你管理生命周期，模式就是模式，代码里一目了然。看 Spring 源码你得先搞懂容器机制才能看到模式，看 Dubbo 源码模式直接摊开在你面前。
对初学者来说，Dubbo 源码是比 Spring 更好的设计模式学习材料——不是因为它更高级，而是因为它更直白。
我在做的小程序「爪爪代码冒险记」也在尝试用更直白的方式讲设计模式，漫画+答题的形式，比啃源码轻松一点，感兴趣可以搜搜。
