欢迎光临
我们一直在努力

【1】23个设计模式精讲全集_上册

23个设计模式精讲全集:从入门到精通 –上

一本涵盖GoF全部23个经典设计模式的完整教程

包含:Java / C# / Python 三语标准实现 | 生活真实故事 | 文科类比 | 架构级应用 | 工业级中间件案例 | 实战优化避坑

📖 姊妹篇:《设计模式公理化推演体系——从经验归纳到数理演绎》
本书采用自下而上的归纳路径:从代码实践 → 提炼思维 → 跨学科原理;续集采用自上而下的演绎路径:从公理 → 范式 → 模式推导 → 衍生实例推演,两书互补形成完整闭环。


目录

第一篇:创建型模式(5个)

  • 第1章 单例模式(Singleton)
  • 第2章 工厂方法模式(Factory Method)
  • 第3章 抽象工厂模式(Abstract Factory)
  • 第4章 建造者模式(Builder)
  • 第5章 原型模式(Prototype)

第二篇:结构型模式(7个)

  • 第6章 代理模式(Proxy)
  • 第7章 外观模式(Facade)
  • 第8章 适配器模式(Adapter)
  • 第9章 桥接模式(Bridge)
  • 第10章 组合模式(Composite)
  • 第11章 装饰器模式(Decorator)
  • 第12章 享元模式(Flyweight)

第三篇:行为型模式(11个)

  • 第13章 策略模式(Strategy)
  • 第14章 观察者模式(Observer)
  • 第15章 模板方法模式(Template Method)
  • 第16章 迭代器模式(Iterator)
  • 第17章 责任链模式(Chain of Responsibility)
  • 第18章 命令模式(Command)
  • 第19章 状态模式(State)
  • 第20章 中介者模式(Mediator)
  • 第21章 访问者模式(Visitor)
  • 第22章 备忘录模式(Memento)
  • 第23章 解释器模式(Interpreter)

思维体系(详见续集《设计模式公理化推演体系》)

  • 导读一:23个设计模式的6大思维分组
  • 导读二:设计模式的跨学科底层原理拆解
  • 导读三:设计模式公理化推演体系
  • 附录A:23个设计模式完整速查表
  • 附录B:学习路线与建议

📖 以上思维体系内容已迁移至续集《设计模式公理化推演体系》中系统讲解。原书专注于23个设计模式的代码实现与案例分析。


📖 阅读建议

本书采用自下而上的归纳路径:从代码实践 → 提炼思维 → 跨学科原理。
若希望系统学习设计模式的思维体系、跨学科原理与公理化推演,请参阅续集《设计模式公理化推演体系》。

续集采用自上而下的演绎路径:从公理 → 范式 → 模式推导 → 衍生实例推演,与本书记忆-理解-应用的学习路径形成完整闭环。


第1章 单例模式(Singleton)- 创建型

核心一句话:保证一个类在全局范围内有且仅有一个实例,并提供一个全局统一的访问入口

🏠 生活真实故事

你公司只有一台公共打印机,全公司所有人打印文件都必须使用这一台。

  • 不能每人配一台(资源严重浪费)

  • 不能私自在工位装打印机(管理混乱,无法统一管控耗材和故障)

  • 无论多少人同时发起打印请求,最终都指向同一个物理设备

  • 打印机只会在第一次有人使用时开机初始化,之后一直处于待机状态

核心一句话:保证一个类在全局范围内有且仅有一个实例,并提供一个全局统一的访问入口

🏠 生活真实故事

你公司只有一台公共打印机,全公司所有人打印文件都必须使用这一台。

  • 不能每人配一台(资源严重浪费)

  • 不能私自在工位装打印机(管理混乱,无法统一管控耗材和故障)

  • 无论多少人同时发起打印请求,最终都指向同一个物理设备

  • 打印机只会在第一次有人使用时开机初始化,之后一直处于待机状态

📚 文科类比

  • 单位法定公章:所有对外公文、合同、证明只能盖这一枚章,私刻公章违法

  • 国家唯一新闻发言人:官方对外发声只有一个出口,避免信息混乱

  • 学校唯一校长:最高决策岗位全局唯一,不会同时有两个校长

  • 城市总供水阀门:整个城市的供水系统只有一个总开关

💻 代码级:GoF 经典实现(三语标准)

Java 经典实现

// ============== 模式类:纯单例核心逻辑 ==============
public class Printer {
// 【核心1】静态私有实例:类级别的唯一实例引用,延迟初始化
// 使用static确保全局唯一,使用private防止外部直接访问
private static Printer instance;

// 【核心2】私有构造函数:防止外部通过new创建实例
// 这是单例模式的根本保障,将实例化控制权收归类自身
private Printer() {
System.out.println("🖨️ 初始化打印机(仅执行一次)");
}

// 【核心3】静态工厂方法:全局唯一的访问入口
// 延迟初始化(Lazy Initialization):第一次调用时才创建实例,节省资源
public static Printer getInstance() {
// 判断实例是否已存在,避免重复创建
if (instance == null) {
instance = new Printer(); // 唯一的一次实例化
}
return instance;
}

// 业务方法:单例对象提供的具体功能
public void print(String content) {
System.out.println("打印内容:" + content);
}
}

// ============== 独立测试类 ==============
public class SingletonTest {
public static void main(String[] args) {
// 通过统一入口获取实例,而非直接new
Printer p1 = Printer.getInstance();
Printer p2 = Printer.getInstance();

// 验证:两个引用指向同一内存地址(==比较的是引用地址)
System.out.println("p1和p2是同一个对象:" + (p1 == p2)); // true

// 无论通过哪个引用调用,操作的都是同一个对象
p1.print("员工考勤表");
p2.print("部门周报");
}
}

C# 经典实现

// ============== 模式类:纯单例核心逻辑 ==============
public class Printer
{
// 【核心1】静态私有实例:类级别的唯一实例引用
// static确保全局唯一,private防止外部直接访问
private static Printer instance;

// 【核心2】私有构造函数:阻止外部通过new创建实例
// 将实例化控制权严格限制在类内部
private Printer()
{
Console.WriteLine("🖨️ 初始化打印机(仅执行一次)");
}

// 【核心3】静态工厂方法:全局统一访问入口
// 采用PascalCase命名规范(C#命名习惯)
public static Printer GetInstance()
{
// 延迟初始化:首次调用时才创建,避免资源浪费
if (instance == null)
{
instance = new Printer(); // 唯一实例化点
}
return instance;
}

// 业务方法:单例对外提供的功能
public void Print(string content)
{
Console.WriteLine("打印内容:" + content);
}
}

// ============== 独立测试类 ==============
public class SingletonTest
{
public static void Main()
{
// 通过统一入口获取实例
Printer p1 = Printer.GetInstance();
Printer p2 = Printer.GetInstance();

// 验证单例:引用相等性判断(C#中==对引用类型比较地址)
Console.WriteLine("p1和p2是同一个对象:" + (p1 == p2)); // True

// 两个变量操作同一对象
p1.Print("员工考勤表");
p2.Print("部门周报");
}
}

Python 经典实现

# ============== 模式类:纯单例核心逻辑 ==============
class Printer:
# 【核心1】类变量:存储唯一实例的引用
# Python中类变量相当于其他语言的静态变量,所有实例共享
_instance = None

# 构造函数:每次调用都会执行(即使单例已存在也会打印)
# 注意:Python单例中__init__无法像Java/C#那样私有化
def __init__(self):
print("🖨️ 初始化打印机(仅执行一次)")

# 【核心2】类方法:不依赖实例,通过类本身调用
# cls指向类对象,用于创建和操作类级别的属性
@classmethod
def get_instance(cls):
# 检查类变量是否为None(Python推荐用is判断None)
if cls._instance is None:
cls._instance = cls() # 创建唯一实例并缓存
return cls._instance

# 业务方法
def print(self, content):
print(f"打印内容:{content}")

# ============== 测试代码 ==============
if __name__ == "__main__":
# 通过类方法获取实例(而非直接调用构造函数)
p1 = Printer.get_instance()
p2 = Printer.get_instance()

# Python中用is判断对象身份(内存地址是否相同)
print(f"p1和p2是同一个对象:{p1 is p2}") # True

p1.print("员工考勤表")
p2.print("部门周报")

🏗️ 架构级应用

把单例模式的思想从"控制类的实例数量"放大到"控制服务的实例数量",就变成了架构层面的全局唯一服务。

  • 主从数据库架构:只有一个主库负责写操作,多个从库负责读操作

  • 分布式锁:保证整个集群中同一时间只有一个服务能执行某个操作

  • 定时任务调度:整个集群中只有一个节点能执行定时任务,避免重复执行

  • 注册中心主节点:Nacos/Eureka等注册中心,只有一个主节点负责集群管理

🏭 工业级中间件案例

  • ZooKeeper/etcd:通过Raft/ZAB一致性协议保证集群永远只有一个Leader节点

  • Redis分布式锁:通过SETNX命令创建全局唯一标记实现分布式锁

  • MySQL主库:关系型数据库主从架构中全局唯一的写节点

⚠️ 实战优化避坑(三语完整实现)

坑点1:多线程安全问题

问题:多线程环境下可能创建多个实例
解决方案:双重检查锁(DCL)+ 内存可见性保证

// Java 双重检查锁(DCL)实现线程安全单例
public class Printer {
// 【核心1】volatile关键字:保证内存可见性和禁止指令重排序
// 原因:instance = new Printer()不是原子操作,可能重排序为:
// 1.分配内存 2.赋值给引用 3.初始化对象
// volatile禁止2和3重排序,避免其他线程拿到未初始化的对象
private static volatile Printer instance;

private Printer() {}

public static Printer getInstance() {
// 【核心2】第一次检查(无锁):提高性能,避免每次调用都加锁
if (instance == null) {
// 【核心3】同步块:类级别锁,保证同一时间只有一个线程执行
synchronized (Printer.class) {
// 【核心4】第二次检查(有锁):防止多个线程排队进入同步块后重复创建
if (instance == null) {
instance = new Printer();
}
}
}
return instance;
}
}

// C# 双重检查锁(DCL)实现线程安全单例
public class Printer
{
// volatile保证内存可见性,禁止编译器优化导致的指令重排
private static volatile Printer instance;

// 【关键】独立锁对象:避免使用typeof/类对象作为锁(更细粒度控制)
// readonly确保锁对象引用不会被修改
private static readonly object _lock = new object();

private Printer() {}

public static Printer GetInstance()
{
// 第一次无锁检查:快速路径,实例已存在时无需加锁
if (instance == null)
{
// lock是Monitor的语法糖,确保线程互斥访问
lock (_lock)
{
// 第二次有锁检查:防止等待锁的线程重复创建实例
if (instance == null)
{
instance = new Printer();
}
}
}
return instance;
}
}

# Python 双重检查锁实现线程安全单例
import threading

class Printer:
# 类变量存储唯一实例
_instance = None

# 【关键】线程锁:保证多线程环境下实例创建的原子性
# threading.Lock()创建互斥锁,with语句自动管理加锁/释放
_lock = threading.Lock()

def __init__(self):
print("🖨️ 初始化打印机(仅执行一次)")

@classmethod
def get_instance(cls):
# 第一次检查(无锁):避免每次调用都竞争锁,提高性能
if cls._instance is None:
# with上下文管理器:自动 acquire() 和 release()
with cls._lock:
# 第二次检查(有锁):防止多个线程排队后重复创建
if cls._instance is None:
cls._instance = cls()
return cls._instance

坑点2:反射破坏单例

问题:通过反射可以绕过私有构造函数创建新实例
解决方案:

  • Java/C#:使用枚举单例

  • Python:构造函数添加实例存在性检查

// Java 枚举单例(最佳实践)
public enum Printer {
INSTANCE;

public void print(String content) {
System.out.println("打印内容:" + content);
}
}

// C# 枚举单例(注意:C#不支持Java风格的枚举方法定义,以下为等效实现思路)
// 在C#中,推荐使用静态只读字段或Lazy<T>实现线程安全单例
public sealed class Printer
{
// 私有构造函数防止外部实例化
private Printer() { }

// 静态只读实例,由CLR保证线程安全(类加载时初始化)
public static readonly Printer INSTANCE = new Printer();

public void Print(string content)
{
Console.WriteLine("打印内容:" + content);
}
}

# Python 构造函数检查
class Printer:
_instance = None
_lock = threading.Lock()

def __init__(self):
if Printer._instance is not None:
raise RuntimeError("请使用get_instance()方法获取实例")
print("🖨️ 初始化打印机(仅执行一次)")

@classmethod
def get_instance(cls):
if cls._instance is None:
with cls._lock:
if cls._instance is None:
cls._instance = cls()
return cls._instance

坑点3:序列化破坏单例

问题:反序列化时会创建新的实例
解决方案:重写序列化/反序列化方法

// Java
import java.io.Serializable;

public class Printer implements Serializable {
private static volatile Printer instance;

private Printer() {}

public static Printer getInstance() {
if (instance == null) {
synchronized (Printer.class) {
if (instance == null) {
instance = new Printer();
}
}
}
return instance;
}

private Object readResolve() {
return getInstance();
}
}

// C#
using System;
using System.Runtime.Serialization;

[Serializable]
public class Printer : ISerializable
{
private static volatile Printer instance;
private static readonly object _lock = new object();

private Printer() {}

public static Printer GetInstance()
{
if (instance == null)
{
lock (_lock)
{
if (instance == null)
{
instance = new Printer();
}
}
}
return instance;
}

public void GetObjectData(SerializationInfo info, StreamingContext context)
{
info.SetType(typeof(SingletonSerializationHelper));
}

[Serializable]
private class SingletonSerializationHelper : IObjectReference
{
public object GetRealObject(StreamingContext context)
{
return Printer.GetInstance();
}
}
}

# Python
import pickle
import threading

class Printer:
_instance = None
_lock = threading.Lock()

def __init__(self):
if Printer._instance is not None:
raise RuntimeError("请使用get_instance()方法获取实例")
print("🖨️ 初始化打印机(仅执行一次)")

@classmethod
def get_instance(cls):
if cls._instance is None:
with cls._lock:
if cls._instance is None:
cls._instance = cls()
return cls._instance

def __reduce__(self):
return (Printer.get_instance, ())

📝 本课总结

层级核心体现
代码级 核心三要素:私有构造 + 静态实例 + 静态工厂方法getInstance()
架构级 整个集群只能有一个主节点,全局唯一服务
工业级 ZooKeeper/etcd分布式协调、Redis分布式锁、数据库主库


第2章 工厂方法模式(Factory Method)- 创建型

核心一句话:定义一个创建对象的接口,让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类

🏠 生活真实故事

你开了一家饮品店,前台店员只负责接单:

  • 顾客说"来一杯珍珠奶茶",店员喊"珍珠奶茶师傅做一杯"

  • 顾客说"来一杯柠檬茶",店员喊"柠檬茶师傅做一杯"

  • 以后上新"杨枝甘露",只需要新招一个杨枝甘露师傅,前台接单流程完全不用改

📚 文科类比

  • 出版社编辑分工:前台接稿,散文、小说、诗歌分别交给对应编辑处理

  • 报社记者分工:统一采编流程,时政、娱乐、体育记者各写各的内容

  • 培训机构老师分工:招生前台统一接待,语文、数学、英语老师分科授课

💻 代码级:GoF 经典实现(三语标准)

Java 经典实现

// ============== 抽象产品 ==============
// 【核心1】抽象产品:定义产品的统一接口
// 客户端通过此接口使用产品,无需关心具体实现
interface Drink {
String make();
}

// ============== 具体产品 ==============
// 【核心2】具体产品:实现抽象产品接口
// 每个具体产品对应一种具体的业务实现
class BubbleTea implements Drink {
@Override
public String make() {
return "🧋 珍珠奶茶:红茶+牛奶+珍珠";
}
}

class LemonTea implements Drink {
@Override
public String make() {
return "🍋 柠檬茶:绿茶+新鲜柠檬+蜂蜜";
}
}

// ============== 抽象工厂 ==============
// 【核心3】抽象工厂:声明创建产品的方法(工厂方法)
// 将对象的创建延迟到子类,实现创建与使用的分离
interface DrinkFactory {
Drink createDrink();
}

// ============== 具体工厂 ==============
// 【核心4】具体工厂:实现工厂方法,负责创建对应的具体产品
// 每个具体产品都有一个对应的具体工厂
class BubbleTeaFactory implements DrinkFactory {
@Override
public Drink createDrink() {
// 工厂方法的核心:在这里决定创建哪种产品
return new BubbleTea();
}
}

class LemonTeaFactory implements DrinkFactory {
@Override
public Drink createDrink() {
return new LemonTea();
}
}

// ============== 测试类 ==============
public class FactoryMethodTest {
// 【优势】客户端只依赖抽象(DrinkFactory和Drink)
// 新增产品类型时,只需新增对应的具体工厂,无需修改此代码
public static void orderDrink(DrinkFactory factory) {
Drink drink = factory.createDrink(); // 多态:运行时确定具体产品
System.out.println("出品:" + drink.make());
}

public static void main(String[] args) {
// 通过传入不同的工厂创建不同的产品
orderDrink(new BubbleTeaFactory());
orderDrink(new LemonTeaFactory());
}
}

C# 经典实现

// ============== 抽象产品 ==============
// 【核心1】抽象产品接口:定义产品的统一契约
// 客户端面向接口编程,降低耦合
public interface IDrink
{
string Make();
}

// ============== 具体产品 ==============
// 【核心2】具体产品:实现接口的具体类
public class BubbleTea : IDrink
{
public string Make()
{
return "🧋 珍珠奶茶:红茶+牛奶+珍珠";
}
}

public class LemonTea : IDrink
{
public string Make()
{
return "🍋 柠檬茶:绿茶+新鲜柠檬+蜂蜜";
}
}

// ============== 抽象工厂 ==============
// 【核心3】抽象工厂接口:声明创建产品的工厂方法
// 遵循依赖倒置原则:高层模块不依赖低层模块,都依赖抽象
public interface IDrinkFactory
{
IDrink CreateDrink();
}

// ============== 具体工厂 ==============
// 【核心4】具体工厂:每个工厂负责创建一种产品
// 新增产品时只需新增工厂,符合开闭原则
public class BubbleTeaFactory : IDrinkFactory
{
public IDrink CreateDrink()
{
return new BubbleTea();
}
}

public class LemonTeaFactory : IDrinkFactory
{
public IDrink CreateDrink()
{
return new LemonTea();
}
}

// ============== 测试类 ==============
public class FactoryMethodTest
{
// 客户端代码只依赖抽象接口,运行时多态决定具体产品
public static void OrderDrink(IDrinkFactory factory)
{
IDrink drink = factory.CreateDrink();
Console.WriteLine("出品:" + drink.Make());
}

public static void Main()
{
// 通过不同工厂创建不同产品,客户端无需关心创建细节
OrderDrink(new BubbleTeaFactory());
OrderDrink(new LemonTeaFactory());
}
}

Python 经典实现

from abc import ABC, abstractmethod

# ============== 抽象产品 ==============
# 【核心1】抽象产品:通过ABC和@abstractmethod强制子类实现方法
# 这是Python中定义抽象基类的标准方式
class Drink(ABC):
@abstractmethod
def make(self):
pass

# ============== 具体产品 ==============
# 【核心2】具体产品:继承抽象基类并实现抽象方法
class BubbleTea(Drink):
def make(self):
return "🧋 珍珠奶茶:红茶+牛奶+珍珠"

class LemonTea(Drink):
def make(self):
return "🍋 柠檬茶:绿茶+新鲜柠檬+蜂蜜"

# ============== 抽象工厂 ==============
# 【核心3】抽象工厂:同样使用ABC定义接口
class DrinkFactory(ABC):
@abstractmethod
def create_drink(self):
pass

# ============== 具体工厂 ==============
# 【核心4】具体工厂:实现工厂方法,返回具体产品实例
class BubbleTeaFactory(DrinkFactory):
def create_drink(self):
return BubbleTea() # 工厂方法的核心:决定实例化哪个类

class LemonTeaFactory(DrinkFactory):
def create_drink(self):
return LemonTea()

# ============== 测试代码 ==============
# 客户端函数只接收抽象工厂,运行时多态决定产品类型
def order_drink(factory):
drink = factory.create_drink()
print(f"出品:{drink.make()}")

if __name__ == "__main__":
# 传入不同工厂即可生产不同产品
order_drink(BubbleTeaFactory())
order_drink(LemonTeaFactory())

🏗️ 架构级应用

把工厂方法的思想从"创建对象"放大到"创建服务实例",就变成了架构层面的服务工厂。

  • 依赖注入容器:Spring IoC、ASP.NET Core DI,负责创建和管理所有Bean的生命周期

  • 容器化部署:Docker、Kubernetes,根据配置自动创建和销毁服务实例

  • 插件系统:Eclipse、VS Code,通过工厂方法动态加载插件

  • 对象池:数据库连接池、线程池,通过工厂方法复用对象

🏭 工业级中间件案例

  • Spring IoC容器:全世界最经典的工厂模式实现,管理所有应用组件的创建和依赖注入

  • Kubernetes:根据用户定义的YAML文件,自动创建Pod、Service、Deployment等资源

  • MyBatis:通过SqlSessionFactory创建SqlSession,隐藏数据库连接的创建细节

  • Log4j:通过LoggerFactory创建Logger实例,统一日志对象的创建过程

⚠️ 实战优化避坑(三语完整实现)

坑点1:类膨胀问题

问题:每新增一个产品就要新增一个工厂类,导致类数量爆炸
解决方案:

  • 使用简单工厂模式(静态工厂)简化

  • 使用反射动态创建产品

  • 使用枚举工厂

// Java 简单工厂(静态工厂)简化
public class SimpleDrinkFactory {
public static Drink createDrink(String type) {
switch (type) {
case "bubble":
return new BubbleTea();
case "lemon":
return new LemonTea();
default:
throw new IllegalArgumentException("未知饮品类型");
}
}
}

// C# 简单工厂
public class SimpleDrinkFactory
{
public static IDrink CreateDrink(string type)
{
return type switch
{
"bubble" => new BubbleTea(),
"lemon" => new LemonTea(),
_ => throw new ArgumentException("未知饮品类型")
};
}
}

# Python 简单工厂
class SimpleDrinkFactory:
@staticmethod
def create_drink(type):
if type == "bubble":
return BubbleTea()
elif type == "lemon":
return LemonTea()
else:
raise ValueError("未知饮品类型")

坑点2:工厂方法与业务逻辑耦合

问题:工厂类中包含了过多的业务逻辑,违反单一职责原则
解决方案:

  • 将业务逻辑移到产品类中

  • 使用抽象工厂模式分离产品族

  • 使用配置文件映射产品类型和实现类

坑点3:无法处理有参数的构造函数

问题:标准工厂方法只能创建无参构造函数的产品
解决方案:

  • 在工厂方法中添加参数

  • 使用建造者模式创建复杂产品

📝 本课总结

层级核心体现
代码级 核心四要素:抽象产品、具体产品、抽象工厂、具体工厂
架构级 服务的自动化创建、生命周期管理、依赖注入
工业级 Spring IoC、Kubernetes、MyBatis SqlSessionFactory


第3章 策略模式(Strategy)- 行为型

核心一句话:定义一系列算法,把它们一个个封装起来,并且使它们可互相替换。策略模式让算法独立于使用它的客户而变化

🏠 生活真实故事

你要从家去机场,有三种出行方案:

  • 赶时间、行李多 → 打车(50元,25分钟)

  • 想省钱、不赶时间 → 地铁(5元,40分钟)

  • 天气好、想锻炼 → 骑车(2元,60分钟)
    你可以根据当时的情况随时切换出行方式,不用把所有逻辑写死在一个函数里。

📚 文科类比

  • 沟通策略:同一个观点,对长辈用温情叙事,对学者用逻辑论证,对同龄人用幽默段子

  • 写作策略:同一个题目,可以写成记叙文、议论文、散文

  • 促销策略:同一商品,可以用打折、满减、送积分三种不同方式

💻 代码级:GoF 经典实现(三语标准)

Java 经典实现

// ============== 抽象策略 ==============
// 【核心1】抽象策略:定义算法的统一接口
// 所有具体策略都必须实现此接口,确保可以互相替换
interface TravelStrategy {
void go(String start, String end);
}

// ============== 具体策略 ==============
// 【核心2】具体策略:实现抽象策略接口的具体算法
// 每个具体策略封装一种独立的算法/行为
class TaxiStrategy implements TravelStrategy {
@Override
public void go(String start, String end) {
System.out.printf("🚕 %s→%s,打车:费用80元,耗时30分钟%n", start, end);
}
}

class SubwayStrategy implements TravelStrategy {
@Override
public void go(String start, String end) {
System.out.printf("🚇 %s→%s,地铁:费用6元,耗时50分钟%n", start, end);
}
}

class BikeStrategy implements TravelStrategy {
@Override
public void go(String start, String end) {
System.out.printf("🚲 %s→%s,骑行:费用0元,耗时90分钟%n", start, end);
}
}

// ============== 上下文 ==============
// 【核心3】上下文:持有策略引用,负责调用策略的方法
// 上下文不关心具体策略的实现,只依赖抽象接口
class Traveler {
// 组合(Composition)关系:上下文"有一个"策略
private TravelStrategy strategy;

// 通过构造函数注入策略(依赖注入的一种形式)
public Traveler(TravelStrategy strategy) {
this.strategy = strategy;
}

// 【关键】运行时动态切换策略,这是策略模式的核心优势
public void setStrategy(TravelStrategy strategy) {
this.strategy = strategy;
}

// 委托:将具体行为委托给策略对象执行
public void travel(String start, String end) {
strategy.go(start, end);
}
}

// ============== 测试类 ==============
public class StrategyTest {
public static void main(String[] args) {
// 初始选择打车策略
Traveler person = new Traveler(new TaxiStrategy());
person.travel("家", "机场");

// 【优势】运行时动态切换策略,无需修改Traveler类
person.setStrategy(new SubwayStrategy());
person.travel("机场", "酒店");

person.setStrategy(new BikeStrategy());
person.travel("酒店", "景区");
}
}

C# 经典实现

// ============== 抽象策略 ==============
// 【核心1】抽象策略接口:定义所有策略必须实现的契约
public interface ITravelStrategy
{
void Go(string start, string end);
}

// ============== 具体策略 ==============
// 【核心2】具体策略:封装不同的算法实现
public class TaxiStrategy : ITravelStrategy
{
public void Go(string start, string end)
{
Console.WriteLine($"🚕 {start}→{end},打车:费用80元,耗时30分钟");
}
}

public class SubwayStrategy : ITravelStrategy
{
public void Go(string start, string end)
{
Console.WriteLine($"🚇 {start}→{end},地铁:费用6元,耗时50分钟");
}
}

public class BikeStrategy : ITravelStrategy
{
public void Go(string start, string end)
{
Console.WriteLine($"🚲 {start}→{end},骑行:费用0元,耗时90分钟");
}
}

// ============== 上下文 ==============
// 【核心3】上下文:持有策略引用,将行为委托给策略
public class Traveler
{
// 使用接口类型而非具体类型,实现运行时多态
private ITravelStrategy _strategy;

public Traveler(ITravelStrategy strategy)
{
_strategy = strategy;
}

// 支持运行时动态切换策略
public void SetStrategy(ITravelStrategy strategy)
{
_strategy = strategy;
}

// 委托调用:上下文不实现逻辑,完全交给策略
public void Travel(string start, string end)
{
_strategy.Go(start, end);
}
}

// ============== 测试类 ==============
public class StrategyTest
{
public static void Main()
{
// 初始策略:打车
Traveler person = new Traveler(new TaxiStrategy());
person.Travel("家", "机场");

// 动态切换策略:地铁(无需修改Traveler类)
person.SetStrategy(new SubwayStrategy());
person.Travel("机场", "酒店");

// 动态切换策略:骑行
person.SetStrategy(new BikeStrategy());
person.Travel("酒店", "景区");
}
}

Python 经典实现

from abc import ABC, abstractmethod

# ============== 抽象策略 ==============
# 【核心1】抽象策略:使用ABC定义抽象基类
# 强制子类必须实现go方法,保证接口一致性
class TravelStrategy(ABC):
@abstractmethod
def go(self, start, end):
pass

# ============== 具体策略 ==============
# 【核心2】具体策略:继承抽象基类,实现具体算法
class TaxiStrategy(TravelStrategy):
def go(self, start, end):
print(f"🚕 {start}→{end},打车:费用80元,耗时30分钟")

class SubwayStrategy(TravelStrategy):
def go(self, start, end):
print(f"🚇 {start}→{end},地铁:费用6元,耗时50分钟")

class BikeStrategy(TravelStrategy):
def go(self, start, end):
print(f"🚲 {start}→{end},骑行:费用0元,耗时90分钟")

# ============== 上下文 ==============
# 【核心3】上下文:持有策略对象,委托执行
class Traveler:
def __init__(self, strategy):
# 构造函数注入策略对象
self.strategy = strategy

# 运行时动态切换策略
def set_strategy(self, strategy):
self.strategy = strategy

# 委托给策略对象执行具体算法
def travel(self, start, end):
self.strategy.go(start, end)

# ============== 测试代码 ==============
if __name__ == "__main__":
# 创建上下文并注入初始策略
person = Traveler(TaxiStrategy())
person.travel("家", "机场")

# 动态切换策略,无需修改Traveler类(符合开闭原则)
person.set_strategy(SubwayStrategy())
person.travel("机场", "酒店")

person.set_strategy(BikeStrategy())
person.travel("酒店", "景区")

🏗️ 架构级应用

把策略模式的思想从"切换算法"放大到"切换服务/路由流量",就变成了架构层面的流量治理。

  • 负载均衡:Nginx、HAProxy支持轮询、加权轮询、IP哈希等多种负载均衡策略

  • API网关路由:根据请求头、请求参数、客户端IP等条件动态路由请求

  • 灰度发布:将流量按比例切到新版本服务,验证没问题后再全量切换

  • 多环境部署:开发环境、测试环境、生产环境使用不同的配置和策略

🏭 工业级中间件案例

  • Nginx:支持多种负载均衡策略和请求转发策略

  • Spring Cloud Gateway:基于策略的路由、限流、熔断

  • Hystrix:断路器模式,支持多种降级策略

  • 促销规则引擎:电商平台的各种促销活动,都是策略模式的典型应用

⚠️ 实战优化避坑(三语完整实现)

坑点1:策略类过多

问题:策略数量增多后,会产生大量的策略类,增加系统复杂度
解决方案:

  • 使用枚举策略

  • 使用Lambda表达式简化策略实现

  • 使用享元模式共享策略实例

// Java 枚举策略
public enum TravelStrategyEnum {
TAXI((start, end) -> System.out.printf("🚕 %s→%s,打车:费用80元,耗时30分钟%n", start, end)),
SUBWAY((start, end) -> System.out.printf("🚇 %s→%s,地铁:费用6元,耗时50分钟%n", start, end)),
BIKE((start, end) -> System.out.printf("🚲 %s→%s,骑行:费用0元,耗时90分钟%n", start, end));

private final TravelStrategy strategy;

TravelStrategyEnum(TravelStrategy strategy) {
this.strategy = strategy;
}

public TravelStrategy getStrategy() {
return strategy;
}
}

// C# 委托策略
public delegate void TravelStrategyDelegate(string start, string end);

public static class TravelStrategies
{
public static readonly TravelStrategyDelegate Taxi = (start, end) =>
Console.WriteLine($"🚕 {start}→{end},打车:费用80元,耗时30分钟");

public static readonly TravelStrategyDelegate Subway = (start, end) =>
Console.WriteLine($"🚇 {start}→{end},地铁:费用6元,耗时50分钟");

public static readonly TravelStrategyDelegate Bike = (start, end) =>
Console.WriteLine($"🚲 {start}→{end},骑行:费用0元,耗时90分钟");
}

# Python 函数式策略
def taxi_strategy(start, end):
print(f"🚕 {start}→{end},打车:费用80元,耗时30分钟")

def subway_strategy(start, end):
print(f"🚇 {start}→{end},地铁:费用6元,耗时50分钟")

def bike_strategy(start, end):
print(f"🚲 {start}→{end},骑行:费用0元,耗时90分钟")

class Traveler:
def __init__(self, strategy):
self.strategy = strategy

def set_strategy(self, strategy):
self.strategy = strategy

def travel(self, start, end):
self.strategy(start, end)

坑点2:客户端需要了解所有策略

问题:客户端必须知道所有策略的区别,才能选择合适的策略,违反迪米特法则
解决方案:

  • 使用简单工厂模式封装策略选择逻辑

  • 使用上下文自动选择策略

坑点3:策略与上下文耦合

问题:策略类需要访问上下文的内部数据,导致耦合
解决方案:

  • 将需要的数据作为参数传递给策略方法

  • 使用回调函数

📝 本课总结

层级核心体现
代码级 核心三要素:抽象策略、具体策略、上下文
架构级 流量治理、负载均衡、灰度发布、多环境部署
工业级 Nginx、Spring Cloud Gateway、Hystrix、促销规则引擎


第4章 观察者模式(Observer)- 行为型

核心一句话:定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新

🏠 生活真实故事

你关注了一位B站UP主:

  • UP主发布新视频时,所有关注的粉丝都会自动收到推送

  • 粉丝不需要每隔5分钟刷新页面问"更新了吗?"

  • 粉丝可以随时关注、取关,UP主和粉丝互不干涉内部逻辑

📚 文科类比

  • 公众号订阅:作者发布文章,所有订阅者自动收到推送

  • 班级群通知:老师发通知,所有群成员自动看到

  • 报纸订阅:报社发行新报纸,所有订户都会收到

💻 代码级:GoF 经典实现(三语标准)

Java 经典实现

import java.util.ArrayList;
import java.util.List;

// ============== 被观察者接口 ==============
// 【核心1】被观察者接口(Subject):定义管理观察者的标准方法
// 所有被观察者必须实现此接口,保证订阅/发布机制的一致性
interface UpMaster {
void subscribe(Fan fan); // 订阅:添加观察者
void unsubscribe(Fan fan); // 取消订阅:移除观察者
void publish(String content); // 发布:通知所有观察者
}

// ============== 观察者接口 ==============
// 【核心2】观察者接口(Observer):定义接收通知的标准方法
interface Fan {
void receive(String upName, String content);
}

// ============== 具体被观察者 ==============
// 【核心3】具体被观察者:维护观察者列表,状态变化时通知所有观察者
class BilibiliUP implements UpMaster {
private String name;
// 使用List存储所有订阅的观察者(一对多关系)
private List<Fan> fans = new ArrayList<>();

public BilibiliUP(String name) {
this.name = name;
}

@Override
public void subscribe(Fan fan) {
fans.add(fan); // 将观察者加入列表
System.out.printf("✅ %s 关注了 %s%n", ((ConcreteFan)fan).getName(), name);
}

@Override
public void unsubscribe(Fan fan) {
fans.remove(fan); // 从列表移除观察者
System.out.printf("❌ %s 取关了 %s%n", ((ConcreteFan)fan).getName(), name);
}

@Override
public void publish(String content) {
System.out.printf("%n📢 %s 发布新内容:%s%n", name, content);
// 【关键】遍历所有观察者,逐个调用receive方法通知
// 这是"推"模式:被观察者主动将数据推送给观察者
for (Fan fan : fans) {
fan.receive(name, content);
}
}
}

// ============== 具体观察者 ==============
// 【核心4】具体观察者:实现接收通知的逻辑
class ConcreteFan implements Fan {
private String name;

public ConcreteFan(String name) {
this.name = name;
}

public String getName() {
return name;
}

@Override
public void receive(String upName, String content) {
System.out.printf("📱 %s 收到推送:%s 更新啦 → %s%n", name, upName, content);
}
}

// ============== 测试类 ==============
public class ObserverTest {
public static void main(String[] args) {
// 创建被观察者(UP主)
UpMaster up = new BilibiliUP("编程小课堂");
// 创建多个观察者(粉丝)
Fan fan1 = new ConcreteFan("小明");
Fan fan2 = new ConcreteFan("小红");
Fan fan3 = new ConcreteFan("小李");

// 粉丝订阅UP主
up.subscribe(fan1);
up.subscribe(fan2);
up.subscribe(fan3);

// UP主发布内容,所有粉丝自动收到通知
up.publish("设计模式入门教程");

// 粉丝取消订阅
up.unsubscribe(fan3);

// 再次发布,只有剩余粉丝收到通知
up.publish("Python实战案例");
}
}

C# 经典实现

using System;
using System.Collections.Generic;

// ============== 被观察者接口 ==============
public interface IUpMaster
{
void Subscribe(IFan fan);
void Unsubscribe(IFan fan);
void Publish(string content);
}

// ============== 观察者接口 ==============
public interface IFan
{
void Receive(string upName, string content);
string Name { get; }
}

// ============== 具体被观察者 ==============
public class BilibiliUP : IUpMaster
{
private string _name;
private List<IFan> _fans = new List<IFan>();

public BilibiliUP(string name)
{
_name = name;
}

public void Subscribe(IFan fan)
{
_fans.Add(fan);
Console.WriteLine($"✅ {fan.Name} 关注了 {_name}");
}

public void Unsubscribe(IFan fan)
{
_fans.Remove(fan);
Console.WriteLine($"❌ {fan.Name} 取关了 {_name}");
}

public void Publish(string content)
{
Console.WriteLine($"\\n📢 {_name} 发布新内容:{content}");
foreach (IFan fan in _fans)
{
fan.Receive(_name, content);
}
}
}

// ============== 具体观察者 ==============
public class ConcreteFan : IFan
{
public string Name { get; private set; }

public ConcreteFan(string name)
{
Name = name;
}

public void Receive(string upName, string content)
{
Console.WriteLine($"📱 {Name} 收到推送:{upName} 更新啦 → {content}");
}
}

// ============== 测试类 ==============
public class ObserverTest
{
public static void Main()
{
IUpMaster up = new BilibiliUP("编程小课堂");
IFan fan1 = new ConcreteFan("小明");
IFan fan2 = new ConcreteFan("小红");
IFan fan3 = new ConcreteFan("小李");

up.Subscribe(fan1);
up.Subscribe(fan2);
up.Subscribe(fan3);

up.Publish("设计模式入门教程");

up.Unsubscribe(fan3);

up.Publish("Python实战案例");
}
}

Python 经典实现

from abc import ABC, abstractmethod

# ============== 被观察者接口 ==============
class UpMaster(ABC):
@abstractmethod
def subscribe(self, fan):
pass

@abstractmethod
def unsubscribe(self, fan):
pass

@abstractmethod
def publish(self, content):
pass

# ============== 观察者接口 ==============
class Fan(ABC):
@abstractmethod
def receive(self, up_name, content):
pass

# ============== 具体被观察者 ==============
class BilibiliUP(UpMaster):
def __init__(self, name):
self.name = name
self._fans = []

def subscribe(self, fan):
self._fans.append(fan)
print(f"✅ {fan.name} 关注了 {self.name}")

def unsubscribe(self, fan):
self._fans.remove(fan)
print(f"❌ {fan.name} 取关了 {self.name}")

def publish(self, content):
print(f"\\n📢 {self.name} 发布新内容:{content}")
for fan in self._fans:
fan.receive(self.name, content)

# ============== 具体观察者 ==============
class ConcreteFan(Fan):
def __init__(self, name):
self.name = name

def receive(self, up_name, content):
print(f"📱 {self.name} 收到推送:{up_name} 更新啦 → {content}")

# ============== 测试代码 ==============
if __name__ == "__main__":
up = BilibiliUP("编程小课堂")
fan1 = ConcreteFan("小明")
fan2 = ConcreteFan("小红")
fan3 = ConcreteFan("小李")

up.subscribe(fan1)
up.subscribe(fan2)
up.subscribe(fan3)

up.publish("设计模式入门教程")

up.unsubscribe(fan3)

up.publish("Python实战案例")

🏗️ 架构级应用

把观察者模式的思想从"对象间通知"放大到"服务间通信",就变成了架构层面的发布-订阅架构。

  • 事件驱动架构:系统通过事件进行通信,松耦合、高扩展性

  • 异步通信:服务之间通过消息队列进行异步通信,提高系统吞吐量

  • 微服务解耦:微服务之间通过事件进行交互,避免直接依赖

  • UI更新:前端框架(React、Vue)的响应式更新机制

🏭 工业级中间件案例

  • RocketMQ/Kafka/RabbitMQ:工业级消息队列,发布-订阅模式的终极实现

  • Spring事件机制:Spring框架内置的事件发布和监听机制

  • Vue/React:前端框架的响应式数据更新,本质上是观察者模式

  • Redis发布订阅:Redis提供的轻量级消息发布订阅功能

⚠️ 实战优化避坑(三语完整实现)

坑点1:消息循环依赖

问题:观察者和被观察者之间形成循环依赖,导致无限递归通知
解决方案:

  • 避免观察者同时也是被观察者

  • 在通知方法中添加循环检测

  • 使用异步通知

坑点2:内存泄漏

问题:观察者没有及时取消订阅,导致被观察者持有观察者的引用,无法被垃圾回收
解决方案:

  • 显式调用取消订阅方法

  • 使用弱引用持有观察者

  • 使用自动取消订阅的机制

// Java 使用弱引用防止内存泄漏
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.List;

public class BilibiliUP implements UpMaster {
private String name;
private List<WeakReference<Fan>> fans = new ArrayList<>();

public BilibiliUP(String name) {
this.name = name;
}

@Override
public void subscribe(Fan fan) {
fans.add(new WeakReference<>(fan));
System.out.printf("✅ %s 关注了 %s%n", ((ConcreteFan)fan).getName(), name);
}

@Override
public void unsubscribe(Fan fan) {
fans.removeIf(ref -> ref.get() == fan || ref.get() == null);
System.out.printf("❌ %s 取关了 %s%n", ((ConcreteFan)fan).getName(), name);
}

@Override
public void publish(String content) {
System.out.printf("%n📢 %s 发布新内容:%s%n", name, content);
fans.removeIf(ref -> ref.get() == null); // 清理已被回收的引用
for (WeakReference<Fan> ref : fans) {
Fan fan = ref.get();
if (fan != null) {
fan.receive(name, content);
}
}
}
}

坑点3:通知顺序问题

问题:观察者收到通知的顺序不确定,可能导致业务逻辑错误
解决方案:

  • 为观察者添加优先级

  • 按优先级顺序通知观察者

📝 本课总结

层级核心体现
代码级 核心四要素:被观察者接口、观察者接口、具体被观察者、具体观察者
架构级 发布-订阅架构、事件驱动、异步通信、微服务解耦
工业级 RocketMQ/Kafka/RabbitMQ、Spring事件机制、Vue/React响应式更新


第5章 装饰器模式(Decorator)- 结构型

核心一句话:动态地给一个对象添加一些额外的职责。就增加功能来说,装饰器模式比生成子类更为灵活

🏠 生活真实故事

你去买煎饼果子:

  • 基础煎饼6元

  • 可以加鸡蛋(+2元)、加火腿(+3元)、加辣条(+1.5元)

  • 加料可以任意组合、叠加

  • 不用为"煎饼+鸡蛋"、“煎饼+火腿”、"煎饼+鸡蛋+火腿"单独创建新品类

📚 文科类比

  • 语句修饰:基础句"花开了" → “娇艳的花开了” → “春风拂过,娇艳的花像笑脸一般开了”

  • 文章润色:原始素材 + 导语 + 注释 + 配图说明

  • 穿搭装饰:基础衣服 + 帽子 + 围巾 + 首饰

💻 代码级:GoF 经典实现(三语标准)

Java 经典实现

// ============== 抽象组件 ==============
// 【核心1】抽象组件:定义被装饰对象和装饰器的统一接口
// 这是装饰器模式的基础,确保装饰器可以替代原始组件
interface Jianbing {
String getDescription();
double getPrice();
}

// ============== 具体组件 ==============
// 【核心2】具体组件:被装饰的原始对象
// 这是装饰的起点,所有功能叠加都基于此对象
class PlainJianbing implements Jianbing {
@Override
public String getDescription() {
return "基础煎饼";
}

@Override
public double getPrice() {
return 6.0;
}
}

// ============== 抽象装饰器 ==============
// 【核心3】抽象装饰器:持有一个组件引用,实现相同接口
// 这是装饰器模式的关键:装饰器本身也是组件,可以嵌套装饰
abstract class JianbingDecorator implements Jianbing {
// 组合关系:装饰器"包含"一个组件(被装饰的对象)
protected Jianbing jianbing;

// 通过构造函数传入被装饰的对象
public JianbingDecorator(Jianbing jianbing) {
this.jianbing = jianbing;
}
}

// ============== 具体装饰器 ==============
// 【核心4】具体装饰器:在调用被装饰对象方法前后添加新功能
class EggDecorator extends JianbingDecorator {
public EggDecorator(Jianbing jianbing) {
super(jianbing); // 传入被装饰的对象(可能是具体组件或另一个装饰器)
}

@Override
public String getDescription() {
// 先调用被装饰对象的方法,再叠加自己的功能
return jianbing.getDescription() + " + 鸡蛋";
}

@Override
public double getPrice() {
// 在被装饰对象的价格基础上增加自己的价格
return jianbing.getPrice() + 2.0;
}
}

class HamDecorator extends JianbingDecorator {
public HamDecorator(Jianbing jianbing) {
super(jianbing);
}

@Override
public String getDescription() {
return jianbing.getDescription() + " + 火腿";
}

@Override
public double getPrice() {
return jianbing.getPrice() + 3.0;
}
}

// ============== 测试类 ==============
public class DecoratorTest {
public static void main(String[] args) {
// 基础煎饼,无装饰
Jianbing food1 = new PlainJianbing();
System.out.printf("🥞 %s 总价:¥%.1f%n", food1.getDescription(), food1.getPrice());

// 【关键】嵌套装饰:火腿装饰器包装鸡蛋装饰器,鸡蛋装饰器包装基础煎饼
// 形成装饰链:HamDecorator -> EggDecorator -> PlainJianbing
// 调用从外向内传递,结果从内向外叠加
Jianbing food2 = new HamDecorator(new EggDecorator(new PlainJianbing()));
System.out.printf("🥞 %s 总价:¥%.1f%n", food2.getDescription(), food2.getPrice());
}
}

C# 经典实现

// ============== 抽象组件 ==============
// 【核心1】抽象组件:定义被装饰对象和装饰器的统一接口
public interface IJianbing
{
string GetDescription();
double GetPrice();
}

// ============== 具体组件 ==============
// 【核心2】具体组件:原始对象,可以被装饰器包装
public class PlainJianbing : IJianbing
{
public string GetDescription()
{
return "基础煎饼";
}

public double GetPrice()
{
return 6.0;
}
}

// ============== 抽象装饰器 ==============
// 【核心3】抽象装饰器:实现接口并持有组件引用
// 使用abstract强制子类必须重写方法
public abstract class JianbingDecorator : IJianbing
{
// 被装饰的组件(可以是具体组件或另一个装饰器)
protected IJianbing _jianbing;

public JianbingDecorator(IJianbing jianbing)
{
_jianbing = jianbing;
}

// 声明为abstract,强制子类实现
public abstract string GetDescription();
public abstract double GetPrice();
}

// ============== 具体装饰器 ==============
// 【核心4】具体装饰器:在委托调用前后添加新功能
public class EggDecorator : JianbingDecorator
{
// 使用base调用父类构造函数传入被装饰对象
public EggDecorator(IJianbing jianbing) : base(jianbing) { }

public override string GetDescription()
{
// 委托给被装饰对象,然后叠加自己的功能
return _jianbing.GetDescription() + " + 鸡蛋";
}

public override double GetPrice()
{
return _jianbing.GetPrice() + 2.0;
}
}

public class HamDecorator : JianbingDecorator
{
public HamDecorator(IJianbing jianbing) : base(jianbing) { }

public override string GetDescription()
{
return _jianbing.GetDescription() + " + 火腿";
}

public override double GetPrice()
{
return _jianbing.GetPrice() + 3.0;
}
}

// ============== 测试类 ==============
public class DecoratorTest
{
public static void Main()
{
// 基础组件
IJianbing food1 = new PlainJianbing();
Console.WriteLine($"🥞 {food1.GetDescription()} 总价:¥{food1.GetPrice():F1}");

// 【关键】嵌套装饰:层层包装,形成装饰链
// 调用顺序:HamDecorator.GetPrice() -> EggDecorator.GetPrice() -> PlainJianbing.GetPrice()
IJianbing food2 = new HamDecorator(new EggDecorator(new PlainJianbing()));
Console.WriteLine($"🥞 {food2.GetDescription()} 总价:¥{food2.GetPrice():F1}");
}
}

Python 经典实现

from abc import ABC, abstractmethod

# ============== 抽象组件 ==============
# 【核心1】抽象组件:定义被装饰对象和装饰器的统一接口
class Jianbing(ABC):
@abstractmethod
def get_description(self):
pass

@abstractmethod
def get_price(self):
pass

# ============== 具体组件 ==============
# 【核心2】具体组件:原始对象,可以被装饰器包装
class PlainJianbing(Jianbing):
def get_description(self):
return "基础煎饼"

def get_price(self):
return 6.0

# ============== 抽象装饰器 ==============
# 【核心3】抽象装饰器:继承抽象组件并持有组件引用
# Python中可以不声明abstractmethod,但继承ABC表明这是抽象类
class JianbingDecorator(Jianbing):
def __init__(self, jianbing):
# 存储被装饰的对象(组件或另一个装饰器)
self._jianbing = jianbing

# ============== 具体装饰器 ==============
# 【核心4】具体装饰器:继承抽象装饰器,实现功能叠加
class EggDecorator(JianbingDecorator):
def get_description(self):
# 先调用被装饰对象的方法,再追加自己的描述
return self._jianbing.get_description() + " + 鸡蛋"

def get_price(self):
# 在被装饰对象的价格基础上增加
return self._jianbing.get_price() + 2.0

class HamDecorator(JianbingDecorator):
def get_description(self):
return self._jianbing.get_description() + " + 火腿"

def get_price(self):
return self._jianbing.get_price() + 3.0

# ============== 测试代码 ==============
if __name__ == "__main__":
# 基础组件,无装饰
food1 = PlainJianbing()
print(f"🥞 {food1.get_description()} 总价:¥{food1.get_price():.1f}")

# 【关键】嵌套装饰:从内到外依次包装
# 执行顺序:HamDecorator.get_price()调用EggDecorator.get_price()
# EggDecorator.get_price()调用PlainJianbing.get_price()
# 返回结果层层叠加:6.0 + 2.0 + 3.0 = 11.0
food2 = HamDecorator(EggDecorator(PlainJianbing()))
print(f"🥞 {food2.get_description()} 总价:¥{food2.get_price():.1f}")

🏗️ 架构级应用

把装饰器模式的思想从"包装对象"放大到"包装服务/请求",就变成了架构层面的中间件/过滤器链。

  • API网关过滤器链:请求到达业务服务之前,依次经过鉴权、限流、日志、监控等多个过滤器

  • AOP面向切面编程:在不改动业务代码的前提下,给业务方法添加日志、事务、权限等功能

  • 反向代理:Nginx作为反向代理,在请求到达后端服务之前添加缓存、压缩、SSL终止等功能

  • 服务网格:Istio/Linkerd,在不改动业务代码的前提下,为微服务提供统一的治理能力

🏭 工业级中间件案例

  • Java IO流:全世界最经典的装饰器模式实现,InputStream/OutputStream的各种包装类

  • Spring AOP:通过动态代理实现面向切面编程,本质上是装饰器模式

  • ASP.NET Core中间件:请求处理管道,由多个中间件组成,层层包装请求

  • Istio服务网格:通过Sidecar代理为微服务提供流量控制、安全、监控等能力

⚠️ 实战优化避坑(三语完整实现)

坑点1:嵌套层级过深

问题:装饰器嵌套层级过多,导致代码难以理解和调试
解决方案:

  • 限制装饰器的嵌套层数

  • 使用建造者模式构建装饰器链

  • 使用组合代替多层嵌套

// Java 使用建造者模式构建装饰器链
public class JianbingBuilder {
private Jianbing jianbing;

public JianbingBuilder() {
jianbing = new PlainJianbing();
}

public JianbingBuilder addEgg() {
jianbing = new EggDecorator(jianbing);
return this;
}

public JianbingBuilder addHam() {
jianbing = new HamDecorator(jianbing);
return this;
}

public Jianbing build() {
return jianbing;
}
}

// 使用
Jianbing food = new JianbingBuilder()
.addEgg()
.addHam()
.build();

坑点2:与代理模式混淆

问题:装饰器模式和代理模式结构非常相似,容易混淆
解决方案:

  • 装饰器模式:增强原对象功能,层层叠加,目标还是本体

  • 代理模式:控制访问、做拦截/中转,侧重"管控"而非"叠加功能"

坑点3:装饰器顺序问题

问题:装饰器的顺序会影响最终结果,顺序错误可能导致业务逻辑错误
解决方案:

  • 明确规定装饰器的执行顺序

  • 使用注解或配置文件指定装饰器顺序

📝 本课总结

层级核心体现
代码级 核心四要素:抽象组件、具体组件、抽象装饰器、具体装饰器
架构级 中间件、过滤器链、AOP面向切面、服务网格
工业级 Java IO流、Spring AOP、ASP.NET Core中间件、Istio服务网格

五大入门设计模式速查表

模式名称类别核心一句话生活场景工业级案例
单例模式 创建型 全局唯一实例,统一访问入口 公司唯一打印机 ZooKeeper/etcd、Redis分布式锁
工厂方法模式 创建型 把对象创建交给子类,创建与使用分离 饮品店分工制作 Spring IoC、Kubernetes
策略模式 行为型 同一目标,多种算法,动态切换 多种出行方式 Nginx负载均衡、促销规则引擎
观察者模式 行为型 一对多订阅-发布,状态变更自动通知 B站UP主更新 RocketMQ/Kafka、Spring事件
装饰器模式 结构型 动态叠加功能,替代继承 煎饼加配料 Java IO流、Spring AOP、Istio


第二篇:结构型模式(7个)


第6章 代理模式(Proxy)- 结构型

核心一句话:为其他对象提供一种代理以控制对这个对象的访问

🏠 生活真实故事

你想租一套房子,直接找房东很麻烦:

  • 你不知道哪些房东有房出租

  • 你需要自己和房东谈价格、签合同、处理维修问题

  • 房东也不想天天被不同的租客打扰

于是你找了房产中介:

  • 中介帮你筛选房源、带你看房

  • 中介帮你和房东谈价格、签合同

  • 房子出了问题,你直接找中介,中介再找房东处理

  • 你和房东都不用直接打交道,所有事情都通过中介完成

📚 文科类比

  • 明星经纪人:明星不直接接工作,所有商务洽谈、行程安排都由经纪人负责

  • 翻译官:你和外国人交流,不需要直接对话,通过翻译官转达

  • 大使馆:你要和外国政府打交道,不需要直接联系对方政府,通过本国大使馆办理

  • 门卫:你要进公司大楼,不需要直接联系公司老板,先经过门卫登记检查

💻 代码级:GoF 经典实现(三语标准)

Java 经典实现

// ============== 抽象主题 ==============
// 【核心1】抽象主题:定义真实主题和代理的共同接口
// 客户端面向此接口编程,无需区分真实主题和代理
interface HouseRental {
void rentHouse();
}

// ============== 真实主题 ==============
// 【核心2】真实主题:实际执行业务逻辑的对象
// 代理模式的目的就是控制对这个对象的访问
class Landlord implements HouseRental {
@Override
public void rentHouse() {
System.out.println("房东:出租房子");
}
}

// ============== 代理类 ==============
// 【核心3】代理类:持有真实主题的引用,控制对其的访问
// 可以在调用真实主题前后添加额外逻辑(权限控制、日志、缓存等)
class RealEstateAgent implements HouseRental {
// 组合关系:代理持有真实主题的引用
private Landlord landlord;

public RealEstateAgent(Landlord landlord) {
this.landlord = landlord;
}

@Override
public void rentHouse() {
// 【代理的核心价值】在调用真实主题前后添加控制逻辑
System.out.println("中介:筛选房源、带看房"); // 前置处理
landlord.rentHouse(); // 委托给真实主题执行业务
System.out.println("中介:签合同、收中介费"); // 后置处理
}
}

// ============== 测试类 ==============
public class ProxyTest {
public static void main(String[] args) {
// 创建真实主题
Landlord landlord = new Landlord();
// 创建代理,将真实主题传入
HouseRental agent = new RealEstateAgent(landlord);

// 客户端面向接口编程,感知不到代理的存在
// 实际执行的是代理的逻辑,代理再委托给真实主题
agent.rentHouse();
}
}

C# 经典实现

// ============== 抽象主题 ==============
// 【核心1】抽象主题:定义真实主题和代理的共同接口
public interface IHouseRental
{
void RentHouse();
}

// ============== 真实主题 ==============
// 【核心2】真实主题:实际执行业务逻辑的对象
public class Landlord : IHouseRental
{
public void RentHouse()
{
Console.WriteLine("房东:出租房子");
}
}

// ============== 代理类 ==============
// 【核心3】代理类:控制对真实主题的访问
// 代理和真实主题实现相同接口,客户端无需区分
public class RealEstateAgent : IHouseRental
{
private Landlord _landlord;

public RealEstateAgent(Landlord landlord)
{
_landlord = landlord;
}

public void RentHouse()
{
// 前置增强:代理在调用真实主题前执行额外逻辑
Console.WriteLine("中介:筛选房源、带看房");
// 委托给真实主题
_landlord.RentHouse();
// 后置增强:调用完成后执行额外逻辑
Console.WriteLine("中介:签合同、收中介费");
}
}

// ============== 测试类 ==============
public class ProxyTest
{
public static void Main()
{
Landlord landlord = new Landlord();
// 面向接口编程:声明为接口类型
IHouseRental agent = new RealEstateAgent(landlord);

// 客户端只关心接口,不关心是代理还是真实主题
agent.RentHouse();
}
}

Python 经典实现

from abc import ABC, abstractmethod

# ============== 抽象主题 ==============
# 【核心1】抽象主题:定义真实主题和代理的共同接口
class HouseRental(ABC):
@abstractmethod
def rent_house(self):
pass

# ============== 真实主题 ==============
# 【核心2】真实主题:实际执行业务逻辑的对象
class Landlord(HouseRental):
def rent_house(self):
print("房东:出租房子")

# ============== 代理类 ==============
# 【核心3】代理类:持有真实主题引用,控制对其访问
class RealEstateAgent(HouseRental):
def __init__(self, landlord):
# 存储真实主题引用,用于后续委托调用
self._landlord = landlord

def rent_house(self):
# 前置处理:代理在调用真实主题前添加额外逻辑
print("中介:筛选房源、带看房")
# 委托给真实主题执行核心业务
self._landlord.rent_house()
# 后置处理:调用完成后添加额外逻辑
print("中介:签合同、收中介费")

# ============== 测试代码 ==============
if __name__ == "__main__":
landlord = Landlord()
# 代理包装真实主题
agent = RealEstateAgent(landlord)

# 客户端面向抽象接口编程
agent.rent_house()

🏗️ 架构级应用

把代理模式的思想从"控制对象访问"放大到"控制服务访问",就变成了架构层面的远程代理/服务代理。

  • 远程代理:为不同地址空间的对象提供本地代表,隐藏远程调用的细节

  • 虚拟代理:延迟加载大对象,只有在真正需要时才创建

  • 保护代理:控制对对象的访问权限,不同用户有不同的访问权限

  • 缓存代理:为昂贵的操作结果提供缓存,避免重复计算

🏭 工业级中间件案例

  • Spring AOP:通过动态代理实现面向切面编程,在不改动业务代码的前提下添加日志、事务、权限等功能

  • RPC框架(Dubbo/gRPC):为远程服务提供本地代理,让调用远程服务像调用本地方法一样简单

  • Nginx反向代理:作为后端服务的代理,隐藏后端服务的真实地址,提供负载均衡、缓存、SSL终止等功能

  • MyBatis Mapper代理:为Mapper接口生成代理对象,隐藏SQL执行的细节

⚠️ 实战优化避坑(三语完整实现)

坑点1:静态代理类膨胀问题

问题:每一个真实主题都需要一个对应的代理类,导致类数量爆炸
解决方案:使用动态代理,在运行时动态生成代理类

// Java JDK动态代理
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class DynamicProxyHandler implements InvocationHandler {
private Object target;

public DynamicProxyHandler(Object target) {
this.target = target;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("代理:前置处理");
Object result = method.invoke(target, args);
System.out.println("代理:后置处理");
return result;
}

public static Object getProxy(Object target) {
return Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new DynamicProxyHandler(target)
);
}
}

// 使用
public class ProxyTest {
public static void main(String[] args) {
HouseRental landlord = new Landlord();
HouseRental proxy = (HouseRental) DynamicProxyHandler.getProxy(landlord);

proxy.rentHouse();
}
}

// C# 动态代理(使用Castle.Core)
using Castle.DynamicProxy;

public class DynamicInterceptor : IInterceptor
{
public void Intercept(IInvocation invocation)
{
Console.WriteLine("代理:前置处理");
invocation.Proceed();
Console.WriteLine("代理:后置处理");
}
}

// 使用
public class ProxyTest
{
public static void Main()
{
ProxyGenerator generator = new ProxyGenerator();
IHouseRental landlord = new Landlord();
IHouseRental proxy = generator.CreateInterfaceProxyWithTarget<IHouseRental>(landlord, new DynamicInterceptor());

proxy.RentHouse();
}
}

# Python 动态代理
class DynamicProxy:
def __init__(self, target):
self._target = target

def __getattr__(self, name):
attr = getattr(self._target, name)
if callable(attr):
def wrapper(*args, **kwargs):
print("代理:前置处理")
result = attr(*args, **kwargs)
print("代理:后置处理")
return result
return wrapper
return attr

# 使用
if __name__ == "__main__":
landlord = Landlord()
proxy = DynamicProxy(landlord)

proxy.rent_house()

坑点2:与装饰器模式混淆

问题:代理模式和装饰器模式结构非常相似,容易混淆
解决方案:

  • 代理模式:控制访问、做拦截/中转,侧重"管控"而非"叠加功能"

  • 装饰器模式:增强原对象功能,层层叠加,目标还是本体

坑点3:代理对象与真实对象类型不一致

问题:动态代理生成的对象类型和真实对象类型不同,可能导致类型转换错误
解决方案:始终面向接口编程,不要依赖具体实现类

📝 本课总结

层级核心体现
代码级 核心三要素:抽象主题、真实主题、代理类
架构级 远程代理、虚拟代理、保护代理、缓存代理
工业级 Spring AOP、Dubbo/gRPC、Nginx反向代理、MyBatis Mapper


第7章 外观模式(Facade)- 结构型

核心一句话:为子系统中的一组接口提供一个统一的入口。外观模式定义了一个高层接口,这个接口使得这一子系统更加容易使用

🏠 生活真实故事

你去医院看病,需要经历很多步骤:

  • 挂号

  • 找医生看病

  • 缴费

  • 抽血化验

  • 拿药

如果没有导诊台,你需要自己跑遍各个科室,非常麻烦。
有了导诊台之后:

  • 你只需要告诉导诊台你哪里不舒服

  • 导诊台会告诉你先去哪里挂号,再去哪里找医生

  • 所有复杂的流程都由导诊台帮你协调,你只需要按照导诊台的指示做就行

📚 文科类比

  • 政务大厅总窗口:你不需要跑遍各个部门,只需要在总窗口提交材料,总窗口会帮你处理所有流程

  • 书籍目录:你不需要一页一页翻书找内容,通过目录就能快速找到你需要的章节

  • 会议主持人:主持人协调所有参会人员的发言顺序,控制会议流程,让会议有序进行

  • 酒店前台:你不需要联系酒店的各个部门,所有需求(入住、退房、叫餐、打扫)都通过前台处理

💻 代码级:GoF 经典实现(三语标准)

Java 经典实现

// ============== 子系统 ==============
// 【子系统】CPU:复杂子系统的一个组成部分
class CPU {
public void start() {
System.out.println("CPU启动");
}

public void shutdown() {
System.out.println("CPU关闭");
}
}

// 【子系统】Memory:复杂子系统的另一个组成部分
class Memory {
public void start() {
System.out.println("内存启动");
}

public void shutdown() {
System.out.println("内存关闭");
}
}

// 【子系统】HardDrive:复杂子系统的第三个组成部分
class HardDrive {
public void start() {
System.out.println("硬盘启动");
}

public void shutdown() {
System.out.println("硬盘关闭");
}
}

// ============== 外观类 ==============
// 【核心】外观类:为复杂子系统提供统一的简化接口
// 客户端只需要和外观类交互,无需了解子系统的内部细节
class Computer {
// 外观类持有所有子系统的引用,负责协调它们的工作
private CPU cpu;
private Memory memory;
private HardDrive hardDrive;

public Computer() {
// 外观类负责初始化所有子系统(也可以外部注入)
cpu = new CPU();
memory = new Memory();
hardDrive = new HardDrive();
}

// 【关键】封装复杂的启动流程:按正确顺序调用各子系统
public void start() {
System.out.println("电脑开始启动…");
cpu.start(); // 先启动CPU
memory.start(); // 再启动内存
hardDrive.start(); // 最后启动硬盘
System.out.println("电脑启动完成");
}

// 【关键】封装复杂的关闭流程:按正确顺序调用各子系统
// 注意关闭顺序与启动顺序相反(先关硬盘,再关内存,最后关CPU)
public void shutdown() {
System.out.println("电脑开始关闭…");
hardDrive.shutdown();
memory.shutdown();
cpu.shutdown();
System.out.println("电脑关闭完成");
}
}

// ============== 测试类 ==============
public class FacadeTest {
public static void main(String[] args) {
// 客户端只需要创建外观类,调用简单的方法
// 无需了解CPU、Memory、HardDrive的存在
Computer computer = new Computer();

computer.start(); // 一键启动所有子系统
System.out.println();
computer.shutdown(); // 一键关闭所有子系统
}
}

C# 经典实现

// ============== 子系统 ==============
// 【子系统】CPU:复杂子系统的组成部分
public class CPU
{
public void Start()
{
Console.WriteLine("CPU启动");
}

public void Shutdown()
{
Console.WriteLine("CPU关闭");
}
}

// 【子系统】Memory:复杂子系统的组成部分
public class Memory
{
public void Start()
{
Console.WriteLine("内存启动");
}

public void Shutdown()
{
Console.WriteLine("内存关闭");
}
}

// 【子系统】HardDrive:复杂子系统的组成部分
public class HardDrive
{
public void Start()
{
Console.WriteLine("硬盘启动");
}

public void Shutdown()
{
Console.WriteLine("硬盘关闭");
}
}

// ============== 外观类 ==============
// 【核心】外观类:封装复杂子系统的调用流程,提供简化接口
public class Computer
{
// 外观类内部管理所有子系统
private CPU _cpu;
private Memory _memory;
private HardDrive _hardDrive;

public Computer()
{
_cpu = new CPU();
_memory = new Memory();
_hardDrive = new HardDrive();
}

// 封装启动流程:按正确顺序协调各子系统
public void Start()
{
Console.WriteLine("电脑开始启动…");
_cpu.Start();
_memory.Start();
_hardDrive.Start();
Console.WriteLine("电脑启动完成");
}

// 封装关闭流程:顺序与启动相反
public void Shutdown()
{
Console.WriteLine("电脑开始关闭…");
_hardDrive.Shutdown();
_memory.Shutdown();
_cpu.Shutdown();
Console.WriteLine("电脑关闭完成");
}
}

// ============== 测试类 ==============
public class FacadeTest
{
public static void Main()
{
// 客户端只与外观类交互,完全隐藏子系统的复杂性
Computer computer = new Computer();

computer.Start();
Console.WriteLine();
computer.Shutdown();
}
}

Python 经典实现

# ============== 子系统 ==============
# 【子系统】CPU:复杂子系统的组成部分
class CPU:
def start(self):
print("CPU启动")

def shutdown(self):
print("CPU关闭")

# 【子系统】Memory:复杂子系统的组成部分
class Memory:
def start(self):
print("内存启动")

def shutdown(self):
print("内存关闭")

# 【子系统】HardDrive:复杂子系统的组成部分
class HardDrive:
def start(self):
print("硬盘启动")

def shutdown(self):
print("硬盘关闭")

# ============== 外观类 ==============
# 【核心】外观类:封装子系统的复杂交互,提供简洁的统一接口
class Computer:
def __init__(self):
# 外观类内部初始化并管理所有子系统
self._cpu = CPU()
self._memory = Memory()
self._hard_drive = HardDrive()

# 封装启动流程:协调各子系统按正确顺序启动
def start(self):
print("电脑开始启动…")
self._cpu.start()
self._memory.start()
self._hard_drive.start()
print("电脑启动完成")

# 封装关闭流程:按相反顺序关闭子系统
def shutdown(self):
print("电脑开始关闭…")
self._hard_drive.shutdown()
self._memory.shutdown()
self._cpu.shutdown()
print("电脑关闭完成")

# ============== 测试代码 ==============
if __name__ == "__main__":
# 客户端只与外观类交互,无需了解子系统细节
computer = Computer()

computer.start()
print()
computer.shutdown()

🏗️ 架构级应用

把外观模式的思想从"封装子系统"放大到"封装微服务集群",就变成了架构层面的聚合层/门面层。

  • BFF层(Backend For Frontend):前端不直接调用多个微服务,而是调用一个BFF服务,由BFF服务聚合多个微服务的结果返回给前端

  • API网关:作为整个微服务集群的唯一入口,对外隐藏了内部所有服务的地址和细节

  • 中台架构:业务中台把多个业务系统的通用能力封装起来,对外提供统一的接口

  • 第三方SDK封装:将复杂的第三方API封装成简单易用的接口,降低调用复杂度

🏭 工业级中间件案例

  • Spring Cloud Gateway:作为微服务集群的统一入口,提供路由、限流、熔断等功能

  • 阿里云/腾讯云SDK:将复杂的云服务API封装成简单易用的接口

  • MyBatis:将复杂的JDBC操作封装成简单的Mapper接口

  • React/Vue组件库:将复杂的UI组件封装成简单易用的标签

⚠️ 实战优化避坑(三语完整实现)

坑点1:门面类膨胀问题

问题:门面类包含了太多的逻辑,变成了"上帝类",违反单一职责原则
解决方案:

  • 将门面类拆分成多个子门面类,每个子门面类负责一部分功能

  • 使用分层架构,将复杂逻辑下沉到子系统中

// 拆分多个子门面
class ComputerStartFacade {
private CPU cpu;
private Memory memory;
private HardDrive hardDrive;

public ComputerStartFacade() {
cpu = new CPU();
memory = new Memory();
hardDrive = new HardDrive();
}

public void start() {
System.out.println("电脑开始启动…");
cpu.start();
memory.start();
hardDrive.start();
System.out.println("电脑启动完成");
}
}

class ComputerShutdownFacade {
private CPU cpu;
private Memory memory;
private HardDrive hardDrive;

public ComputerShutdownFacade() {
cpu = new CPU();
memory = new Memory();
hardDrive = new HardDrive();
}

public void shutdown() {
System.out.println("电脑开始关闭…");
hardDrive.shutdown();
memory.shutdown();
cpu.shutdown();
System.out.println("电脑关闭完成");
}
}

坑点2:过度使用外观模式

问题:为了简单而过度封装,导致系统失去灵活性
解决方案:

  • 只在需要简化复杂接口时使用外观模式

  • 保留直接访问子系统的接口,供高级用户使用

坑点3:外观类与子系统耦合过紧

问题:子系统的变化会导致外观类的变化
解决方案:

  • 面向接口编程,外观类依赖子系统的接口而不是具体实现

  • 使用依赖注入将子系统注入到外观类中

📝 本课总结

层级核心体现
代码级 核心二要素:子系统、外观类
架构级 BFF层、API网关、中台架构、第三方SDK封装
工业级 Spring Cloud Gateway、云服务SDK、MyBatis、UI组件库


第8章 模板方法模式(Template Method)- 行为型

核心一句话:定义一个操作中的算法的骨架,而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤

🏠 生活真实故事

泡一杯饮品的流程是固定的:

  • 把水烧开

  • 把原料放入杯中

  • 倒入开水

  • 加入调料

  • 不同的饮品只是步骤2和步骤4不同:

    • 泡咖啡:步骤2放咖啡粉,步骤4加糖和奶

    • 泡茶:步骤2放茶叶,步骤4加柠檬或蜂蜜

    你不需要为每种饮品重新写一遍完整的流程,只需要实现不同的步骤即可。

    📚 文科类比

    • 作文固定格式:所有作文都有"开头-正文-结尾"的结构,不同的作文只是内容不同

    • 考试流程:所有考试都有"发卷-答题-交卷-阅卷"的流程,不同的考试只是题目不同

    • 会议流程:所有会议都有"开场-发言-讨论-总结-散会"的流程,不同的会议只是主题不同

    • 简历模板:所有简历都有"个人信息-教育经历-工作经历-项目经验"的结构,不同的人只是内容不同

    💻 代码级:GoF 经典实现(三语标准)

    Java 经典实现

    // ============== 抽象模板类 ==============
    abstract class CaffeineBeverage {
    // 模板方法:定义算法骨架,用final防止子类重写
    public final void prepareRecipe() {
    boilWater();
    brew();
    pourInCup();
    addCondiments();
    }

    // 抽象方法:由子类实现
    protected abstract void brew();
    protected abstract void addCondiments();

    // 具体方法:通用步骤
    private void boilWater() {
    System.out.println("把水烧开");
    }

    private void pourInCup() {
    System.out.println("倒入杯中");
    }
    }

    // ============== 具体子类 ==============
    class Coffee extends CaffeineBeverage {
    @Override
    protected void brew() {
    System.out.println("冲泡咖啡粉");
    }

    @Override
    protected void addCondiments() {
    System.out.println("加入糖和牛奶");
    }
    }

    class Tea extends CaffeineBeverage {
    @Override
    protected void brew() {
    System.out.println("浸泡茶叶");
    }

    @Override
    protected void addCondiments() {
    System.out.println("加入柠檬");
    }
    }

    // ============== 测试类 ==============
    public class TemplateMethodTest {
    public static void main(String[] args) {
    CaffeineBeverage coffee = new Coffee();
    CaffeineBeverage tea = new Tea();

    System.out.println("制作咖啡:");
    coffee.prepareRecipe();

    System.out.println("\\n制作茶:");
    tea.prepareRecipe();
    }
    }

    C# 经典实现

    // ============== 抽象模板类 ==============
    public abstract class CaffeineBeverage
    {
    // 模板方法:定义算法骨架,用sealed防止子类重写
    public sealed void PrepareRecipe()
    {
    BoilWater();
    Brew();
    PourInCup();
    AddCondiments();
    }

    // 抽象方法:由子类实现
    protected abstract void Brew();
    protected abstract void AddCondiments();

    // 具体方法:通用步骤
    private void BoilWater()
    {
    Console.WriteLine("把水烧开");
    }

    private void PourInCup()
    {
    Console.WriteLine("倒入杯中");
    }
    }

    // ============== 具体子类 ==============
    public class Coffee : CaffeineBeverage
    {
    protected override void Brew()
    {
    Console.WriteLine("冲泡咖啡粉");
    }

    protected override void AddCondiments()
    {
    Console.WriteLine("加入糖和牛奶");
    }
    }

    public class Tea : CaffeineBeverage
    {
    protected override void Brew()
    {
    Console.WriteLine("浸泡茶叶");
    }

    protected override void AddCondiments()
    {
    Console.WriteLine("加入柠檬");
    }
    }

    // ============== 测试类 ==============
    public class TemplateMethodTest
    {
    public static void Main()
    {
    CaffeineBeverage coffee = new Coffee();
    CaffeineBeverage tea = new Tea();

    Console.WriteLine("制作咖啡:");
    coffee.PrepareRecipe();

    Console.WriteLine("\\n制作茶:");
    tea.PrepareRecipe();
    }
    }

    Python 经典实现

    from abc import ABC, abstractmethod

    # ============== 抽象模板类 ==============
    class CaffeineBeverage(ABC):
    # 模板方法:定义算法骨架
    def prepare_recipe(self):
    self.boil_water()
    self.brew()
    self.pour_in_cup()
    self.add_condiments()

    # 抽象方法:由子类实现
    @abstractmethod
    def brew(self):
    pass

    @abstractmethod
    def add_condiments(self):
    pass

    # 具体方法:通用步骤
    def boil_water(self):
    print("把水烧开")

    def pour_in_cup(self):
    print("倒入杯中")

    # ============== 具体子类 ==============
    class Coffee(CaffeineBeverage):
    def brew(self):
    print("冲泡咖啡粉")

    def add_condiments(self):
    print("加入糖和牛奶")

    class Tea(CaffeineBeverage):
    def brew(self):
    print("浸泡茶叶")

    def add_condiments(self):
    print("加入柠檬")

    # ============== 测试代码 ==============
    if __name__ == "__main__":
    coffee = Coffee()
    tea = Tea()

    print("制作咖啡:")
    coffee.prepare_recipe()

    print("\\n制作茶:")
    tea.prepare_recipe()

    🏗️ 架构级应用

    把模板方法的思想从"定义算法骨架"放大到"定义系统流程骨架",就变成了架构层面的流程模板。

    • 框架生命周期:所有框架都有固定的生命周期流程,开发者只需要实现特定的钩子方法

    • 数据处理流程:数据采集、清洗、转换、存储的固定流程

    • 任务模板:定时任务、批处理任务的固定执行流程

    • 工作流引擎:定义工作流的固定节点和流转规则

    🏭 工业级中间件案例

    • Spring MVC:定义了请求处理的固定流程,开发者只需要实现Controller方法

    • MyBatis:定义了SQL执行的固定流程,开发者只需要编写SQL语句

    • JUnit:定义了测试的固定流程(@Before、@Test、@After)

    • Hadoop MapReduce:定义了Map和Reduce的固定流程,开发者只需要实现Map和Reduce方法

    ⚠️ 实战优化避坑(三语完整实现)

    坑点1:流程僵化问题

    问题:模板方法定义的流程太固定,无法灵活调整
    解决方案:使用钩子方法(Hook Method)让子类可以控制流程的执行

    // 添加钩子方法
    abstract class CaffeineBeverage {
    public final void prepareRecipe() {
    boilWater();
    brew();
    pourInCup();
    // 通过钩子方法控制是否执行该步骤
    if (customerWantsCondiments()) {
    addCondiments();
    }
    }

    protected abstract void brew();
    protected abstract void addCondiments();

    // 钩子方法:默认返回true,子类可以重写
    protected boolean customerWantsCondiments() {
    return true;
    }

    private void boilWater() {
    System.out.println("把水烧开");
    }

    private void pourInCup() {
    System.out.println("倒入杯中");
    }
    }

    // 子类重写钩子方法
    class Coffee extends CaffeineBeverage {
    @Override
    protected void brew() {
    System.out.println("冲泡咖啡粉");
    }

    @Override
    protected void addCondiments() {
    System.out.println("加入糖和牛奶");
    }

    // 重写钩子方法,不加调料
    @Override
    protected boolean customerWantsCondiments() {
    return false;
    }
    }

    坑点2:继承层次过深

    问题:为了复用流程,导致继承层次过深,代码难以理解
    解决方案:

    • 优先使用组合代替继承

    • 将通用流程提取成独立的工具类

    坑点3:模板方法过于庞大

    问题:模板方法包含了太多的步骤,变得难以维护
    解决方案:

    • 将复杂的模板方法拆分成多个小的模板方法

    • 使用责任链模式代替复杂的模板方法

    📝 本课总结

    层级核心体现
    代码级 核心二要素:抽象模板类(定义算法骨架)、具体子类(实现特定步骤)
    架构级 框架生命周期、数据处理流程、任务模板、工作流引擎
    工业级 Spring MVC、MyBatis、JUnit、Hadoop MapReduce


    第9章 适配器模式(Adapter)- 结构型

    核心一句话:将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作

    🏠 生活真实故事

    你买了一个港版的手机,充电器是三脚插头,但是你家里的插座都是两脚的。
    你不能直接用这个充电器,也不能把手机拆了换充电器,更不能把家里的插座都换成三脚的。
    于是你买了一个转换插头:

    • 转换插头的一头是三脚插座,插港版充电器

    • 转换插头的另一头是两脚插头,插家里的插座

    • 这样你就可以正常使用港版手机了,不需要改动任何原有设备

    📚 文科类比

    • 翻译官:你说中文,外国人说英文,翻译官把中文翻译成英文,把英文翻译成中文,让你们可以交流

    • 古籍白话文翻译:古人写的文言文我们看不懂,翻译成白话文我们就能看懂了

    • 单位换算:你习惯用公斤,美国人习惯用磅,通过单位换算你就能理解美国人说的重量了

    • 视频格式转换器:你的播放器只支持MP4格式,下载的视频是MKV格式,通过转换器转换成MP4就能播放了

    💻 代码级:GoF 经典实现(三语标准)

    Java 经典实现

    // ============== 目标接口 ==============
    // 【核心1】目标接口:客户端期望使用的接口
    // 客户端只认识这个接口,不认识被适配者
    interface Power5V {
    void output5V();
    }

    // ============== 被适配者 ==============
    // 【核心2】被适配者:已有但接口不兼容的类
    // 这个类功能完好,但接口不符合客户端要求
    class Power220V {
    public void output220V() {
    System.out.println("输出220V交流电");
    }
    }

    // ============== 适配器类 ==============
    // 【核心3】适配器:将被适配者的接口转换为目标接口
    // 适配器实现目标接口,内部持有被适配者的引用
    class PowerAdapter implements Power5V {
    // 组合关系:适配器"包含"被适配者
    private Power220V power220V;

    public PowerAdapter(Power220V power220V) {
    this.power220V = power220V;
    }

    @Override
    public void output5V() {
    // 调用被适配者的方法,然后进行转换
    power220V.output220V();
    // 添加转换逻辑(模拟电压转换)
    System.out.println("转换为5V直流电");
    }
    }

    // ============== 客户端 ==============
    // 客户端只依赖目标接口,不依赖被适配者
    class Phone {
    public void charge(Power5V power) {
    System.out.println("手机开始充电…");
    power.output5V(); // 只调用目标接口的方法
    System.out.println("手机充电完成");
    }
    }

    // ============== 测试类 ==============
    public class AdapterTest {
    public static void main(String[] args) {
    // 创建被适配者(已有的220V电源)
    Power220V power220V = new Power220V();
    // 创建适配器,将被适配者包装起来
    Power5V adapter = new PowerAdapter(power220V);

    // 客户端通过目标接口使用被适配者的功能
    Phone phone = new Phone();
    phone.charge(adapter);
    }
    }

    C# 经典实现

    // ============== 目标接口 ==============
    // 【核心1】目标接口:客户端期望使用的接口
    public interface IPower5V
    {
    void Output5V();
    }

    // ============== 被适配者 ==============
    // 【核心2】被适配者:已有但接口不兼容的类
    public class Power220V
    {
    public void Output220V()
    {
    Console.WriteLine("输出220V交流电");
    }
    }

    // ============== 适配器类 ==============
    // 【核心3】适配器:实现目标接口,包装被适配者
    public class PowerAdapter : IPower5V
    {
    private Power220V _power220V;

    public PowerAdapter(Power220V power220V)
    {
    _power220V = power220V;
    }

    public void Output5V()
    {
    // 委托给被适配者,然后转换结果
    _power220V.Output220V();
    Console.WriteLine("转换为5V直流电");
    }
    }

    // ============== 客户端 ==============
    // 客户端只面向目标接口编程
    public class Phone
    {
    public void Charge(IPower5V power)
    {
    Console.WriteLine("手机开始充电…");
    power.Output5V();
    Console.WriteLine("手机充电完成");
    }
    }

    // ============== 测试类 ==============
    public class AdapterTest
    {
    public static void Main()
    {
    // 创建被适配者
    Power220V power220V = new Power220V();
    // 通过适配器转换为客户端需要的接口
    IPower5V adapter = new PowerAdapter(power220V);

    Phone phone = new Phone();
    phone.Charge(adapter);
    }
    }

    Python 经典实现

    from abc import ABC, abstractmethod

    # ============== 目标接口 ==============
    # 【核心1】目标接口:客户端期望使用的接口
    class Power5V(ABC):
    @abstractmethod
    def output_5v(self):
    pass

    # ============== 被适配者 ==============
    # 【核心2】被适配者:已有但接口不兼容的类
    class Power220V:
    def output_220v(self):
    print("输出220V交流电")

    # ============== 适配器类 ==============
    # 【核心3】适配器:继承目标接口,包装被适配者
    class PowerAdapter(Power5V):
    def __init__(self, power_220v):
    # 持有被适配者的引用
    self._power_220v = power_220v

    def output_5v(self):
    # 调用被适配者的方法,然后进行转换
    self._power_220v.output_220v()
    print("转换为5V直流电")

    # ============== 客户端 ==============
    # 客户端只面向目标接口编程
    class Phone:
    def charge(self, power):
    print("手机开始充电…")
    power.output_5v()
    print("手机充电完成")

    # ============== 测试代码 ==============
    if __name__ == "__main__":
    # 创建被适配者
    power_220v = Power220V()
    # 创建适配器进行接口转换
    adapter = PowerAdapter(power_220v)

    phone = Phone()
    phone.charge(adapter)

    🏗️ 架构级应用

    把适配器模式的思想从"转换对象接口"放大到"转换系统接口",就变成了架构层面的系统适配器。

    • 系统集成:将多个接口不兼容的系统集成在一起,不需要改动原有系统

    • 新旧系统对接:新系统和旧系统接口不兼容,通过适配器进行转换

    • 多协议转换:将不同的通信协议(HTTP、TCP、MQTT)转换成统一的内部协议

    • 多数据源适配:将不同的数据源(MySQL、Oracle、MongoDB)转换成统一的数据访问接口

    🏭 工业级中间件案例

    • 消息队列适配器:将不同的消息队列(RocketMQ、Kafka、RabbitMQ)转换成统一的接口

    • 数据库适配器:JDBC/ODBC将不同的数据库接口转换成统一的接口

    • 日志框架适配器:SLF4J将不同的日志框架(Log4j、Logback、JUL)转换成统一的接口

    • Spring MVC消息转换器:将不同的请求/响应格式(JSON、XML)转换成统一的Java对象

    ⚠️ 实战优化避坑(三语完整实现)

    坑点1:适配器过多问题

    问题:需要适配的接口太多,导致适配器类数量爆炸
    解决方案:

    • 使用双向适配器,一个适配器可以适配多个接口

    • 使用类适配器(多重继承)减少适配器数量(Java不支持多重继承,C#和Python支持)

    # Python 双向适配器
    class TwoWayAdapter(Power5V, Power220V):
    def __init__(self, power):
    self._power = power

    def output_5v(self):
    if isinstance(self._power, Power220V):
    self._power.output_220v()
    print("转换为5V直流电")

    def output_220v(self):
    if isinstance(self._power, Power5V):
    self._power.output_5v()
    print("转换为220V交流电")

    坑点2:与桥接模式混淆

    问题:适配器模式和桥接模式结构相似,容易混淆
    解决方案:

    • 适配器模式:事后补救,解决已经存在的接口不兼容问题

    • 桥接模式:事前设计,将抽象和实现分离,让它们可以独立变化

    坑点3:过度使用适配器模式

    问题:为了兼容而过度使用适配器,导致系统变得复杂
    解决方案:

    • 优先修改原有接口,只有在无法修改原有接口时才使用适配器

    • 统一接口规范,从源头上避免接口不兼容问题

    📝 本课总结

    层级核心体现
    代码级 核心三要素:目标接口、被适配者、适配器类
    架构级 系统集成、新旧系统对接、多协议转换、多数据源适配
    工业级 JDBC/ODBC、SLF4J、消息队列适配器、Spring MVC消息转换器


    第10章 建造者模式(Builder)- 创建型

    核心一句话:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示

    🏠 生活真实故事

    你去餐厅点一份汉堡:

    • 汉堡可以加生菜、番茄、芝士、牛肉、鸡肉、培根

    • 每个人的口味不同,加的配料也不同

    • 如果为每种配料组合都创建一个构造函数,会有几十上百个构造函数,非常麻烦

    于是餐厅提供了定制汉堡服务:

    • 你可以选择加什么配料,不加什么配料

    • 厨师按照你的选择一步步组装汉堡

    • 最后给你一个完整的汉堡

    📚 文科类比

    • 写小说:先搭好小说的框架(人物、情节、结局),然后一步步填充内容

    • 装修房子:先确定装修风格,然后一步步进行水电改造、铺地板、刷墙、买家具

    • 组装电脑:你可以选择不同的CPU、内存、硬盘、显卡,然后组装成一台完整的电脑

    • 制作PPT:先确定PPT的结构(封面、目录、内容页、结尾),然后一步步填充内容

    💻 代码级:GoF 经典实现(三语标准)

    Java 经典实现

    // ============== 产品类 ==============
    class Computer {
    private String cpu;
    private String memory;
    private String hardDrive;
    private String graphicsCard;

    public void setCpu(String cpu) {
    this.cpu = cpu;
    }

    public void setMemory(String memory) {
    this.memory = memory;
    }

    public void setHardDrive(String hardDrive) {
    this.hardDrive = hardDrive;
    }

    public void setGraphicsCard(String graphicsCard) {
    this.graphicsCard = graphicsCard;
    }

    @Override
    public String toString() {
    return "Computer{" +
    "cpu='" + cpu + '\\'' +
    ", memory='" + memory + '\\'' +
    ", hardDrive='" + hardDrive + '\\'' +
    ", graphicsCard='" + graphicsCard + '\\'' +
    '}';
    }
    }

    // ============== 抽象建造者 ==============
    interface ComputerBuilder {
    void buildCpu();
    void buildMemory();
    void buildHardDrive();
    void buildGraphicsCard();
    Computer getComputer();
    }

    // ============== 具体建造者 ==============
    class OfficeComputerBuilder implements ComputerBuilder {
    private Computer computer;

    public OfficeComputerBuilder() {
    computer = new Computer();
    }

    @Override
    public void buildCpu() {
    computer.setCpu("Intel i5");
    }

    @Override
    public void buildMemory() {
    computer.setMemory("8GB");
    }

    @Override
    public void buildHardDrive() {
    computer.setHardDrive("512GB SSD");
    }

    @Override
    public void buildGraphicsCard() {
    computer.setGraphicsCard("集成显卡");
    }

    @Override
    public Computer getComputer() {
    return computer;
    }
    }

    class GamingComputerBuilder implements ComputerBuilder {
    private Computer computer;

    public GamingComputerBuilder() {
    computer = new Computer();
    }

    @Override
    public void buildCpu() {
    computer.setCpu("Intel i9");
    }

    @Override
    public void buildMemory() {
    computer.setMemory("32GB");
    }

    @Override
    public void buildHardDrive() {
    computer.setHardDrive("2TB SSD");
    }

    @Override
    public void buildGraphicsCard() {
    computer.setGraphicsCard("NVIDIA RTX 4090");
    }

    @Override
    public Computer getComputer() {
    return computer;
    }
    }

    // ============== 指挥者 ==============
    class Director {
    public Computer construct(ComputerBuilder builder) {
    builder.buildCpu();
    builder.buildMemory();
    builder.buildHardDrive();
    builder.buildGraphicsCard();
    return builder.getComputer();
    }
    }

    // ============== 测试类 ==============
    public class BuilderTest {
    public static void main(String[] args) {
    Director director = new Director();

    Computer officeComputer = director.construct(new OfficeComputerBuilder());
    System.out.println("办公电脑:" + officeComputer);

    Computer gamingComputer = director.construct(new GamingComputerBuilder());
    System.out.println("游戏电脑:" + gamingComputer);
    }
    }

    C# 经典实现

    // ============== 产品类 ==============
    // 【核心1】产品类:被构建的复杂对象
    public class Computer
    {
    public string Cpu { get; set; }
    public string Memory { get; set; }
    public string HardDrive { get; set; }
    public string GraphicsCard { get; set; }

    public override string ToString()
    {
    return $"Computer{{ Cpu='{Cpu}', Memory='{Memory}', HardDrive='{HardDrive}', GraphicsCard='{GraphicsCard}' }}";
    }
    }

    // ============== 抽象建造者 ==============
    // 【核心2】抽象建造者:定义构建步骤的接口
    public interface IComputerBuilder
    {
    void BuildCpu();
    void BuildMemory();
    void BuildHardDrive();
    void BuildGraphicsCard();
    Computer GetComputer();
    }

    // ============== 具体建造者 ==============
    // 【核心3】具体建造者:实现构建步骤,每种配置一个建造者
    public class OfficeComputerBuilder : IComputerBuilder
    {
    private Computer _computer;

    public OfficeComputerBuilder()
    {
    _computer = new Computer();
    }

    public void BuildCpu()
    {
    _computer.Cpu = "Intel i5";
    }

    public void BuildMemory()
    {
    _computer.Memory = "8GB";
    }

    public void BuildHardDrive()
    {
    _computer.HardDrive = "512GB SSD";
    }

    public void BuildGraphicsCard()
    {
    _computer.GraphicsCard = "集成显卡";
    }

    public Computer GetComputer()
    {
    return _computer;
    }
    }

    public class GamingComputerBuilder : IComputerBuilder
    {
    private Computer _computer;

    public GamingComputerBuilder()
    {
    _computer = new Computer();
    }

    public void BuildCpu()
    {
    _computer.Cpu = "Intel i9";
    }

    public void BuildMemory()
    {
    _computer.Memory = "32GB";
    }

    public void BuildHardDrive()
    {
    _computer.HardDrive = "2TB SSD";
    }

    public void BuildGraphicsCard()
    {
    _computer.GraphicsCard = "NVIDIA RTX 4090";
    }

    public Computer GetComputer()
    {
    return _computer;
    }
    }

    // ============== 指挥者 ==============
    // 【核心4】指挥者:封装构建流程,确保按正确顺序构建
    public class Director
    {
    public Computer Construct(IComputerBuilder builder)
    {
    builder.BuildCpu();
    builder.BuildMemory();
    builder.BuildHardDrive();
    builder.BuildGraphicsCard();
    return builder.GetComputer();
    }
    }

    // ============== 测试类 ==============
    public class BuilderTest
    {
    public static void Main()
    {
    Director director = new Director();

    // 同一构建流程,不同建造者产出不同配置
    Computer officeComputer = director.Construct(new OfficeComputerBuilder());
    Console.WriteLine("办公电脑:" + officeComputer);

    Computer gamingComputer = director.Construct(new GamingComputerBuilder());
    Console.WriteLine("游戏电脑:" + gamingComputer);
    }
    }

    Python 经典实现

    # ============== 产品类 ==============
    # 【核心1】产品类:被构建的复杂对象
    class Computer:
    def __init__(self):
    self.cpu = None
    self.memory = None
    self.hard_drive = None
    self.graphics_card = None

    def __str__(self):
    return f"Computer{{ cpu='{self.cpu}', memory='{self.memory}', hard_drive='{self.hard_drive}', graphics_card='{self.graphics_card}' }}"

    # ============== 抽象建造者 ==============
    from abc import ABC, abstractmethod

    # 【核心2】抽象建造者:定义构建步骤的抽象基类
    class ComputerBuilder(ABC):
    @abstractmethod
    def build_cpu(self):
    pass

    @abstractmethod
    def build_memory(self):
    pass

    @abstractmethod
    def build_hard_drive(self):
    pass

    @abstractmethod
    def build_graphics_card(self):
    pass

    @abstractmethod
    def get_computer(self):
    pass

    # ============== 具体建造者 ==============
    # 【核心3】具体建造者:实现构建步骤
    class OfficeComputerBuilder(ComputerBuilder):
    def __init__(self):
    self.computer = Computer() # 初始化空产品

    def build_cpu(self):
    self.computer.cpu = "Intel i5"

    def build_memory(self):
    self.computer.memory = "8GB"

    def build_hard_drive(self):
    self.computer.hard_drive = "512GB SSD"

    def build_graphics_card(self):
    self.computer.graphics_card = "集成显卡"

    def get_computer(self):
    return self.computer

    class GamingComputerBuilder(ComputerBuilder):
    def __init__(self):
    self.computer = Computer()

    def build_cpu(self):
    self.computer.cpu = "Intel i9"

    def build_memory(self):
    self.computer.memory = "32GB"

    def build_hard_drive(self):
    self.computer.hard_drive = "2TB SSD"

    def build_graphics_card(self):
    self.computer.graphics_card = "NVIDIA RTX 4090"

    def get_computer(self):
    return self.computer

    # ============== 指挥者 ==============
    # 【核心4】指挥者:封装构建流程
    class Director:
    def construct(self, builder):
    builder.build_cpu()
    builder.build_memory()
    builder.build_hard_drive()
    builder.build_graphics_card()
    return builder.get_computer()

    # ============== 测试代码 ==============
    if __name__ == "__main__":
    director = Director()

    # 不同建造者构建不同配置的产品
    office_computer = director.construct(OfficeComputerBuilder())
    print("办公电脑:", office_computer)

    gaming_computer = director.construct(GamingComputerBuilder())
    print("游戏电脑:", gaming_computer)

    🏗️ 架构级应用

    把建造者模式的思想从"构建复杂对象"放大到"构建复杂系统",就变成了架构层面的系统构建器。

    • 配置构建:构建复杂的系统配置对象,支持链式调用

    • 请求构建:构建复杂的HTTP请求、数据库查询请求

    • 文档构建:构建复杂的PDF、Excel、Word文档

    • 部署构建:构建复杂的应用部署包、Docker镜像

    🏭 工业级中间件案例

    • StringBuilder:Java/C#中用于构建复杂字符串的建造者

    • SQL构建器(MyBatis Plus、JOOQ):用于构建复杂的SQL查询语句

    • Lombok @Builder:自动为Java类生成建造者模式代码

    • Dockerfile:用于构建Docker镜像的建造者模式

    • Maven/Gradle:用于构建Java项目的建造者模式

    ⚠️ 实战优化避坑(三语完整实现)

    坑点1:经典建造者模式过于繁琐

    问题:经典建造者模式需要创建抽象建造者、具体建造者、指挥者等多个类,过于繁琐
    解决方案:使用链式建造者(内部类建造者)简化代码

    // 链式建造者(最常用的实现方式)
    class Computer {
    private String cpu;
    private String memory;
    private String hardDrive;
    private String graphicsCard;

    // 私有构造函数,只能通过Builder创建
    private Computer(Builder builder) {
    this.cpu = builder.cpu;
    this.memory = builder.memory;
    this.hardDrive = builder.hardDrive;
    this.graphicsCard = builder.graphicsCard;
    }

    // 静态内部建造者类
    public static class Builder {
    private String cpu;
    private String memory;
    private String hardDrive;
    private String graphicsCard;

    public Builder cpu(String cpu) {
    this.cpu = cpu;
    return this;
    }

    public Builder memory(String memory) {
    this.memory = memory;
    return this;
    }

    public Builder hardDrive(String hardDrive) {
    this.hardDrive = hardDrive;
    return this;
    }

    public Builder graphicsCard(String graphicsCard) {
    this.graphicsCard = graphicsCard;
    return this;
    }

    public Computer build() {
    return new Computer(this);
    }
    }

    @Override
    public String toString() {
    return "Computer{" +
    "cpu='" + cpu + '\\'' +
    ", memory='" + memory + '\\'' +
    ", hardDrive='" + hardDrive + '\\'' +
    ", graphicsCard='" + graphicsCard + '\\'' +
    '}';
    }
    }

    // 使用
    public class BuilderTest {
    public static void main(String[] args) {
    Computer computer = new Computer.Builder()
    .cpu("Intel i7")
    .memory("16GB")
    .hardDrive("1TB SSD")
    .graphicsCard("NVIDIA RTX 3060")
    .build();

    System.out.println(computer);
    }
    }

    坑点2:与工厂模式混淆

    问题:建造者模式和工厂模式都是创建型模式,容易混淆
    解决方案:

    • 工厂模式:创建简单对象,关注"创建什么"

    • 建造者模式:创建复杂对象,关注"怎么创建",一步步组装

    坑点3:建造者类与产品类耦合过紧

    问题:产品类的变化会导致建造者类的变化
    解决方案:

    • 面向接口编程,建造者依赖产品的接口而不是具体实现

    • 将产品类的属性提取成接口

    📝 本课总结

    层级核心体现
    代码级 核心四要素:产品类、抽象建造者、具体建造者、指挥者
    架构级 配置构建、请求构建、文档构建、部署构建
    工业级 StringBuilder、SQL构建器、Lombok @Builder、Dockerfile


    第11章 责任链模式(Chain of Responsibility)- 行为型

    核心一句话:使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止

    🏠 生活真实故事

    你在公司请假:

    • 请假1天以内,组长可以审批

    • 请假3天以内,经理可以审批

    • 请假7天以内,总监可以审批

    • 请假7天以上,需要总经理审批

    你不需要知道谁有多少审批权限,只需要把请假申请交给组长:

    • 如果组长能审批,就直接审批

    • 如果组长不能审批,就交给经理

    • 如果经理不能审批,就交给总监

    • 以此类推,直到有人能审批为止

    📚 文科类比

    • 公文流转:一份公文从基层部门开始,逐级向上传递,直到有相应权限的部门审批

    • 信访流程:信访人先到街道信访办,解决不了再到区信访办,再到市信访办

    • 安检关卡:你去机场坐飞机,需要依次经过身份证检查、行李安检、人身安检、登机口检查

    • 客服热线:你打客服热线,先由普通客服处理,解决不了转高级客服,再转专家客服

    💻 代码级:GoF 经典实现(三语标准)

    Java 经典实现

    // ============== 抽象处理者 ==============
    // 【核心1】抽象处理者:定义处理请求的接口和链的链接方式
    abstract class LeaveApprover {
    // 持有对下一个处理者的引用,形成链式结构
    protected LeaveApprover nextApprover;

    // 设置下一个处理者,构建责任链
    public void setNextApprover(LeaveApprover nextApprover) {
    this.nextApprover = nextApprover;
    }

    // 抽象方法:每个处理者实现自己的审批逻辑
    public abstract void approve(int days);
    }

    // ============== 具体处理者 ==============
    // 【核心2】具体处理者:实现处理逻辑,无法处理时传递给下一个
    class TeamLeader extends LeaveApprover {
    @Override
    public void approve(int days) {
    // 判断自己是否有权限处理
    if (days <= 1) {
    System.out.println("组长审批通过:请假" + days + "天");
    } else if (nextApprover != null) {
    // 【关键】超出自己权限,传递给链中的下一个处理者
    nextApprover.approve(days);
    } else {
    System.out.println("请假天数超过审批权限");
    }
    }
    }

    class Manager extends LeaveApprover {
    @Override
    public void approve(int days) {
    if (days <= 3) {
    System.out.println("经理审批通过:请假" + days + "天");
    } else if (nextApprover != null) {
    nextApprover.approve(days);
    } else {
    System.out.println("请假天数超过审批权限");
    }
    }
    }

    class Director extends LeaveApprover {
    @Override
    public void approve(int days) {
    if (days <= 7) {
    System.out.println("总监审批通过:请假" + days + "天");
    } else if (nextApprover != null) {
    nextApprover.approve(days);
    } else {
    System.out.println("请假天数超过审批权限");
    }
    }
    }

    // ============== 测试类 ==============
    public class ChainOfResponsibilityTest {
    public static void main(String[] args) {
    // 创建处理者
    LeaveApprover teamLeader = new TeamLeader();
    LeaveApprover manager = new Manager();
    LeaveApprover director = new Director();

    // 【关键】构建责任链:设置处理者的顺序
    teamLeader.setNextApprover(manager);
    manager.setNextApprover(director);

    // 测试不同天数的请假:从链头开始处理
    // 1天:组长处理
    teamLeader.approve(1);
    // 3天:组长无法处理,传递给经理
    teamLeader.approve(3);
    // 7天:组长->经理都无法处理,传递给总监
    teamLeader.approve(7);
    // 10天:都无权处理
    teamLeader.approve(10);
    }
    }

    C# 经典实现

    // ============== 抽象处理者 ==============
    // 【核心1】抽象处理者:定义处理请求的接口
    public abstract class LeaveApprover
    {
    // 持有下一个处理者的引用
    protected LeaveApprover _nextApprover;

    public void SetNextApprover(LeaveApprover nextApprover)
    {
    _nextApprover = nextApprover;
    }

    public abstract void Approve(int days);
    }

    // ============== 具体处理者 ==============
    // 【核心2】具体处理者:实现处理逻辑,无法处理时传递给下一个
    public class TeamLeader : LeaveApprover
    {
    public override void Approve(int days)
    {
    if (days <= 1)
    {
    Console.WriteLine("组长审批通过:请假" + days + "天");
    }
    else if (_nextApprover != null)
    {
    // 传递给链中的下一个处理者
    _nextApprover.Approve(days);
    }
    else
    {
    Console.WriteLine("请假天数超过审批权限");
    }
    }
    }

    public class Manager : LeaveApprover
    {
    public override void Approve(int days)
    {
    if (days <= 3)
    {
    Console.WriteLine("经理审批通过:请假" + days + "天");
    }
    else if (_nextApprover != null)
    {
    _nextApprover.Approve(days);
    }
    else
    {
    Console.WriteLine("请假天数超过审批权限");
    }
    }
    }

    public class Director : LeaveApprover
    {
    public override void Approve(int days)
    {
    if (days <= 7)
    {
    Console.WriteLine("总监审批通过:请假" + days + "天");
    }
    else if (_nextApprover != null)
    {
    _nextApprover.Approve(days);
    }
    else
    {
    Console.WriteLine("请假天数超过审批权限");
    }
    }
    }

    // ============== 测试类 ==============
    public class ChainOfResponsibilityTest
    {
    public static void Main()
    {
    LeaveApprover teamLeader = new TeamLeader();
    LeaveApprover manager = new Manager();
    LeaveApprover director = new Director();

    // 【关键】构建责任链
    teamLeader.SetNextApprover(manager);
    manager.SetNextApprover(director);

    // 从链头开始,请求沿链传递直到被处理
    teamLeader.Approve(1);
    teamLeader.Approve(3);
    teamLeader.Approve(7);
    teamLeader.Approve(10);
    }
    }

    Python 经典实现

    from abc import ABC, abstractmethod

    # ============== 抽象处理者 ==============
    # 【核心1】抽象处理者:定义处理接口和链式结构
    class LeaveApprover(ABC):
    def __init__(self):
    self.next_approver = None # 下一个处理者

    def set_next_approver(self, next_approver):
    self.next_approver = next_approver

    @abstractmethod
    def approve(self, days):
    pass

    # ============== 具体处理者 ==============
    # 【核心2】具体处理者:实现处理逻辑,无法处理时传递给下一个
    class TeamLeader(LeaveApprover):
    def approve(self, days):
    if days <= 1:
    print(f"组长审批通过:请假{days}天")
    elif self.next_approver is not None:
    # 【关键】超出权限,传递给下一个处理者
    self.next_approver.approve(days)
    else:
    print("请假天数超过审批权限")

    class Manager(LeaveApprover):
    def approve(self, days):
    if days <= 3:
    print(f"经理审批通过:请假{days}天")
    elif self.next_approver is not None:
    self.next_approver.approve(days)
    else:
    print("请假天数超过审批权限")

    class Director(LeaveApprover):
    def approve(self, days):
    if days <= 7:
    print(f"总监审批通过:请假{days}天")
    elif self.next_approver is not None:
    self.next_approver.approve(days)
    else:
    print("请假天数超过审批权限")

    # ============== 测试代码 ==============
    if __name__ == "__main__":
    team_leader = TeamLeader()
    manager = Manager()
    director = Director()

    # 【关键】构建责任链:设置处理顺序
    team_leader.set_next_approver(manager)
    manager.set_next_approver(director)

    # 从链头开始提交请求,沿链传递直到被处理
    team_leader.approve(1)
    team_leader.approve(3)
    team_leader.approve(7)
    team_leader.approve(10)

    🏗️ 架构级应用

    把责任链模式的思想从"对象链处理请求"放大到"服务链处理请求",就变成了架构层面的过滤器链/拦截器链。

    • API网关过滤器链:请求到达业务服务之前,依次经过鉴权、限流、日志、监控等多个过滤器

    • Servlet过滤器链:Java Web中的请求处理管道,由多个过滤器组成

    • Spring拦截器链:Spring MVC中的请求拦截器链

    • Netty Pipeline:Netty中的请求处理管道,由多个ChannelHandler组成

    • 审批流引擎:企业中的审批流程,由多个审批节点组成

    🏭 工业级中间件案例

    • Servlet Filter:Java EE标准的过滤器链

    • Spring Interceptor:Spring MVC的拦截器链

    • Netty Pipeline:Netty的事件处理管道

    • Spring Cloud Gateway过滤器链:API网关的请求处理管道

    • Activiti/Camunda:工作流引擎,基于责任链模式实现

    ⚠️ 实战优化避坑(三语完整实现)

    坑点1:请求无人处理问题

    问题:如果责任链上没有处理者能处理请求,会导致请求丢失
    解决方案:

    • 在责任链的末尾添加一个默认处理者,处理所有未被处理的请求

    • 在抽象处理者中添加默认处理逻辑

    // 添加默认处理者
    class DefaultApprover extends LeaveApprover {
    @Override
    public void approve(int days) {
    System.out.println("请假申请被驳回:无人能审批" + days + "天的请假");
    }
    }

    // 构建责任链时添加默认处理者
    teamLeader.setNextApprover(manager);
    manager.setNextApprover(director);
    director.setNextApprover(new DefaultApprover());

    坑点2:链条过长导致性能问题

    问题:责任链过长,请求需要经过很多处理者才能被处理,导致性能下降
    解决方案:

    • 优化责任链结构,减少不必要的处理者

    • 使用跳表等数据结构加速请求处理

    • 将责任链拆分成多个子链

    坑点3:责任链顺序问题

    问题:处理者的顺序错误会导致业务逻辑错误
    解决方案:

    • 明确规定处理者的执行顺序

    • 使用注解或配置文件指定处理者的顺序

    📝 本课总结

    层级核心体现
    代码级 核心二要素:抽象处理者、具体处理者(组成责任链)
    架构级 API网关过滤器链、Servlet过滤器链、Spring拦截器链、Netty Pipeline
    工业级 Servlet Filter、Spring Interceptor、Netty、Spring Cloud Gateway、工作流引擎


    第12章 命令模式(Command)- 行为型

    核心一句话:将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可撤销的操作

    🏠 生活真实故事

    你去餐厅吃饭:

    • 你不需要直接告诉厨师做什么菜,只需要告诉服务员你要点什么菜

    • 服务员把你的订单写在纸上,交给厨房

    • 厨师按照订单做菜

    • 如果你想加菜,只需要再告诉服务员,服务员再写一个新订单交给厨房

    • 如果你想退菜,只需要告诉服务员,服务员去厨房取消订单

    在这里,订单就是一个命令对象:

    • 命令对象封装了"做什么菜"和"谁来做"

    • 服务员只需要传递命令,不需要知道命令的具体内容

    • 厨师只需要执行命令,不需要知道是谁点的菜

    📚 文科类比

    • 遥控器按钮:每个按钮都是一个命令对象,按下按钮就执行对应的命令

    • 写纸条传指令:你把要做的事写在纸条上,交给别人去做,别人不需要知道为什么要做

    • 军令状:将军把命令写在军令状上,交给士兵去执行,士兵只需要执行命令

    • 邮件/短信:你把要传达的信息写在邮件里,发给对方,对方收到后执行对应的操作

    💻 代码级:GoF 经典实现(三语标准)

    Java 经典实现

    // ============== 命令接口 ==============
    // 【核心1】命令接口:声明执行操作的统一方法
    // 所有具体命令都必须实现此接口,确保调用者可以统一处理
    interface Command {
    void execute();
    }

    // ============== 接收者 ==============
    // 【核心2】接收者:实际执行业务逻辑的对象
    // 命令对象内部持有接收者的引用,将操作委托给接收者
    class Light {
    public void on() {
    System.out.println("灯打开了");
    }

    public void off() {
    System.out.println("灯关闭了");
    }
    }

    // ============== 具体命令 ==============
    // 【核心3】具体命令:封装请求的所有信息(接收者+操作)
    // 将请求封装为对象,使请求可以像对象一样被传递、存储、排队
    class LightOnCommand implements Command {
    private Light light; // 持有接收者引用

    public LightOnCommand(Light light) {
    this.light = light;
    }

    @Override
    public void execute() {
    // 命令对象将操作委托给接收者
    light.on();
    }
    }

    class LightOffCommand implements Command {
    private Light light;

    public LightOffCommand(Light light) {
    this.light = light;
    }

    @Override
    public void execute() {
    light.off();
    }
    }

    // ============== 调用者 ==============
    // 【核心4】调用者:持有命令对象,在适当时机调用命令
    // 调用者不需要知道命令的具体内容,只负责触发执行
    class RemoteControl {
    private Command command;

    // 可以动态设置命令(运行时绑定)
    public void setCommand(Command command) {
    this.command = command;
    }

    // 触发命令执行
    public void pressButton() {
    command.execute();
    }
    }

    // ============== 测试类 ==============
    public class CommandTest {
    public static void main(String[] args) {
    // 创建接收者
    Light light = new Light();
    // 创建命令对象,绑定接收者
    Command lightOn = new LightOnCommand(light);
    Command lightOff = new LightOffCommand(light);

    RemoteControl remote = new RemoteControl();

    // 设置并执行"开灯"命令
    remote.setCommand(lightOn);
    remote.pressButton();

    // 动态切换为"关灯"命令
    remote.setCommand(lightOff);
    remote.pressButton();
    }
    }

    C# 经典实现

    // ============== 命令接口 ==============
    // 【核心1】命令接口:定义执行操作的统一方法
    public interface ICommand
    {
    void Execute();
    }

    // ============== 接收者 ==============
    // 【核心2】接收者:实际执行操作的对象
    public class Light
    {
    public void On()
    {
    Console.WriteLine("灯打开了");
    }

    public void Off()
    {
    Console.WriteLine("灯关闭了");
    }
    }

    // ============== 具体命令 ==============
    // 【核心3】具体命令:封装请求为对象
    public class LightOnCommand : ICommand
    {
    private Light _light;

    public LightOnCommand(Light light)
    {
    _light = light;
    }

    public void Execute()
    {
    _light.On(); // 委托给接收者执行
    }
    }

    public class LightOffCommand : ICommand
    {
    private Light _light;

    public LightOffCommand(Light light)
    {
    _light = light;
    }

    public void Execute()
    {
    _light.Off();
    }
    }

    // ============== 调用者 ==============
    // 【核心4】调用者:触发命令执行
    public class RemoteControl
    {
    private ICommand _command;

    public void SetCommand(ICommand command)
    {
    _command = command;
    }

    public void PressButton()
    {
    _command.Execute();
    }
    }

    // ============== 测试类 ==============
    public class CommandTest
    {
    public static void Main()
    {
    Light light = new Light();
    ICommand lightOn = new LightOnCommand(light);
    ICommand lightOff = new LightOffCommand(light);

    RemoteControl remote = new RemoteControl();

    // 设置并执行命令
    remote.SetCommand(lightOn);
    remote.PressButton();

    remote.SetCommand(lightOff);
    remote.PressButton();
    }
    }

    Python 经典实现

    from abc import ABC, abstractmethod

    # ============== 命令接口 ==============
    # 【核心1】命令接口:定义执行操作的统一方法
    class Command(ABC):
    @abstractmethod
    def execute(self):
    pass

    # ============== 接收者 ==============
    # 【核心2】接收者:实际执行业务逻辑的对象
    class Light:
    def on(self):
    print("灯打开了")

    def off(self):
    print("灯关闭了")

    # ============== 具体命令 ==============
    # 【核心3】具体命令:封装请求为对象,包含接收者和操作
    class LightOnCommand(Command):
    def __init__(self, light):
    self._light = light # 绑定接收者

    def execute(self):
    self._light.on() # 委托给接收者执行

    class LightOffCommand(Command):
    def __init__(self, light):
    self._light = light

    def execute(self):
    self._light.off()

    # ============== 调用者 ==============
    # 【核心4】调用者:持有命令对象,触发执行
    class RemoteControl:
    def __init__(self):
    self._command = None

    def set_command(self, command):
    self._command = command

    def press_button(self):
    self._command.execute()

    # ============== 测试代码 ==============
    if __name__ == "__main__":
    light = Light()
    light_on = LightOnCommand(light)
    light_off = LightOffCommand(light)

    remote = RemoteControl()

    # 设置并执行"开灯"命令
    remote.set_command(light_on)
    remote.press_button()

    # 切换为"关灯"命令
    remote.set_command(light_off)
    remote.press_button()

    🏗️ 架构级应用

    把命令模式的思想从"封装对象请求"放大到"封装系统请求",就变成了架构层面的消息队列/任务队列。

    • 任务队列:将任务封装成命令对象,放入队列中,由消费者异步执行

    • 定时任务:将定时执行的任务封装成命令对象,由调度器在指定时间执行

    • 撤销/重做:将操作封装成命令对象,记录操作历史,支持撤销和重做

    • 事务日志:将数据库操作封装成命令对象,记录事务日志,用于故障恢复

    🏭 工业级中间件案例

    • 消息队列(RocketMQ/Kafka/RabbitMQ):将消息封装成命令对象,进行异步传递

    • 定时任务框架(Quartz/XXL-Job):将定时任务封装成命令对象,进行调度执行

    • 数据库事务日志:将数据库操作封装成命令对象,记录事务日志

    • 编辑器撤销功能:将编辑操作封装成命令对象,支持撤销和重做

    • Linux Shell命令:每个Shell命令都是一个命令对象

    ⚠️ 实战优化避坑(三语完整实现)

    坑点1:命令类过多问题

    问题:每一个操作都需要一个命令类,导致类数量爆炸
    解决方案:

    • 使用泛型命令减少命令类数量

    • 使用函数式接口简化命令实现(Java 8+、C#、Python都支持)

    // Java 8+ 函数式命令
    @FunctionalInterface
    interface Command {
    void execute();
    }

    // 使用
    public class CommandTest {
    public static void main(String[] args) {
    Light light = new Light();

    // 直接使用Lambda表达式创建命令,不需要单独的命令类
    Command lightOn = () -> light.on();
    Command lightOff = () -> light.off();

    RemoteControl remote = new RemoteControl();

    remote.setCommand(lightOn);
    remote.pressButton();

    remote.setCommand(lightOff);
    remote.pressButton();
    }
    }

    坑点2:与策略模式混淆

    问题:命令模式和策略模式结构相似,容易混淆
    解决方案:

    • 命令模式:封装请求,关注"做什么",支持撤销、排队、日志等

    • 策略模式:封装算法,关注"怎么做",支持动态切换算法

    坑点3:命令执行失败问题

    问题:命令执行失败可能导致系统状态不一致
    解决方案:

    • 实现命令的撤销方法,执行失败时回滚

    • 使用事务保证命令的原子性

    📝 本课总结

    层级核心体现
    代码级 核心四要素:命令接口、具体命令、接收者、调用者
    架构级 任务队列、定时任务、撤销/重做、事务日志
    工业级 消息队列、定时任务框架、数据库事务日志、编辑器撤销功能

    赞(0)
    未经允许不得转载:171主机测评 » 【1】23个设计模式精讲全集_上册
    分享到: 更多 (0)

    评论 抢沙发

    • 昵称 (必填)
    • 邮箱 (必填)
    • 网址