【设计模式】深入解析设计模式的四要素：构建可维护代码的核心法则_个设计框架 ----二个逻辑、四个要素、四个要点-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_38628970/article/details/146063386

前言

设计模式是软件开发中的“武林秘籍”，它总结了前辈们在复杂项目中反复验证的最佳实践。但许多人仅停留在“知道模式名称”，却不知如何正确应用。究其根本，是因为忽略了设计模式的四要素——它们是理解与运用模式的基石。本文将通过通俗比喻、经典案例和代码演示，带你掌握设计模式的精髓。

一、设计模式的四要素是什么？

设计模式并非随意堆砌的代码套路，其核心由四要素构成，如同建造房屋的蓝图：

四要素

模式名称（Pattern Name）：模式的“身份证”
问题（Problem）：模式要解决的痛点
解决方案（Solution）：模式的结构与协作
效果（Consequences）：模式的代价与收益

四要素关系

模式名称让你快速沟通；
问题告诉你何时使用；
解决方案指导你如何实现；
效果帮助你权衡利弊。

二、四要素深度解析与实例

模式名称：代码的“共同语言”

核心作用：提供简洁的词汇，让开发者高效沟通。
类比：医生用“肺炎”代替“肺部感染引起的咳嗽发烧”，避免冗长描述。
示例：
- 这里用观察者模式处理事件通知” → 无需解释如何实现发布-订阅逻辑。
- 用工厂方法解耦对象创建” → 直接表明意图。

// 示例：单例模式（Singleton）的名称直接表明“全局唯一实例”
class Database {
  private static instance: Database;

  private constructor() {}

  public static getInstance(): Database {
    if (!Database.instance) {
      Database.instance = new Database();
    }
    return Database.instance;
  }
}

// 使用名称“单例”明确约束
const db1 = Database.getInstance();
const db2 = Database.getInstance();
console.log(db1 === db2); // true

问题：识别模式的“触发条件”

核心作用：明确模式的应用场景，避免滥用。
关键问题：
- 代码是否存在重复？
- 模块是否过度耦合？
- 扩展是否需要修改旧代码？
实例场景：
- 问题：一个商品价格变化需要通知库存模块、促销模块等多个组件。
- 痛点：直接调用各模块的更新方法会导致紧耦合。
- 适用模式：观察者模式（一对多的依赖关系）。

// 问题：商品价格变化后，如何通知多个模块？
class Product {
    private double price;
    private Inventory inventory;
    private Promotion promotion;

    public void setPrice(double price) {
        this.price = price;
        // 直接调用其他模块 → 耦合度高！
        inventory.update(price);
        promotion.checkDiscount(price);
    }
}

解决方案：模式的结构与协作

核心作用：提供可复用的设计模板，包含参与者（类/对象）和协作关系。
设计原则：遵循开闭原则、单一职责原则等。
观察者模式解决方案：
- Subject（主题）：维护观察者列表，提供注册/通知方法。
- Observer（观察者）：定义更新接口。

// 观察者模式解决方案
interface Observer {
  update(price: number): void;
}

class Product {
  private price: number = 100;
  private observers: Observer[] = [];

  public addObserver(observer: Observer): void {
    this.observers.push(observer);
  }

  public setPrice(price: number): void {
    this.price = price;
    this.notifyObservers();
  }

  private notifyObservers(): void {
    this.observers.forEach(observer => observer.update(this.price));
  }
}

// 具体观察者
class Inventory implements Observer {
  update(price: number): void {
    console.log(`Inventory: Update stock for price ${price}`);
  }
}

// 客户端代码
const product = new Product();
product.addObserver(new Inventory());
product.setPrice(90); // 自动通知所有观察者

效果：权衡利弊的“决策指南”

核心作用：明确模式的优缺点，避免盲目使用。
常见权衡：
- 灵活性 vs 复杂度：如抽象工厂提升扩展性，但增加类数量。
- 性能 vs 可维护性：如代理模式增加间接层可能影响性能。
观察者模式的效果分析：
优点：
- 解耦主题与观察者，支持动态添加/删除观察者。
缺点：
- 观察者过多时通知效率低。
- 循环依赖可能导致无限递归。

// 潜在问题：观察者中调用Subject的方法可能导致循环更新
class Promotion implements Observer {
  constructor(private product: Product) {}

  update(price: number): void {
    if (price < 80) {
      this.product.setPrice(79); // 危险！可能触发无限循环
    }
  }
}

三、综合案例：策略模式的四要素实践

1. 模式名称

策略模式（Strategy）：定义算法族，封装每个算法，使其可互换。

2. 问题

需要根据不同场景切换算法（如支付方式、排序逻辑）。
避免在代码中堆砌大量if-else条件分支。

3. 解决方案

策略接口：声明算法方法（如pay()）。
具体策略：实现不同算法（如微信支付、支付宝支付）。
上下文（Context）：持有策略引用，委托执行。

4. 效果

优点：
- 算法可独立扩展，符合开闭原则。
- 消除条件语句，提升可读性。
缺点：
- 策略类数量可能过多。
- 客户端需理解不同策略的区别。

// 策略接口
interface PaymentStrategy {
  pay(amount: number): void;
}

// 具体策略
class WechatPay implements PaymentStrategy {
  pay(amount: number): void {
    console.log(`Paid ${amount} via WeChat.`);
  }
}

class CreditCardPay implements PaymentStrategy {
  pay(amount: number): void {
    console.log(`Paid ${amount} via Credit Card.`);
  }
}

// 上下文
class ShoppingCart {
  constructor(private paymentStrategy: PaymentStrategy) {}

  checkout(amount: number): void {
    this.paymentStrategy.pay(amount);
  }
}

// 客户端代码
const cart = new ShoppingCart(new WechatPay());
cart.checkout(100); // "Paid 100 via WeChat."

// 动态切换策略
cart.paymentStrategy = new CreditCardPay();
cart.checkout(200); // "Paid 200 via Credit Card."