设计模式实战：23种经典模式解析与应用场景

1. 设计模式概述：软件工程中的通用解决方案

2003年我第一次接触设计模式时，正面临一个复杂的订单处理系统重构。当if-else嵌套达到7层时，代码已经变成了"面条式"的灾难。直到在《设计模式：可复用面向对象软件的基础》这本经典著作中发现了23种设计模式，才真正理解了什么是优雅的代码结构。

设计模式不是具体的代码实现，而是针对特定场景的解决方案模板。就像建筑领域的拱形结构能解决承重问题一样，在软件开发中，单例模式解决全局访问问题，观察者模式处理事件通知，工厂模式应对对象创建复杂性。这些模式凝聚了众多工程师的智慧结晶，是应对软件复杂性的有效武器。

2. 创建型模式：对象创建的优雅之道

2.1 单例模式（Singleton）

我在配置管理系统中最常使用的模式。核心在于确保一个类只有一个实例，并提供一个全局访问点。但要注意多线程环境下的双重检查锁定问题：

java复制public class ConfigManager {
    private static volatile ConfigManager instance;
    
    private ConfigManager() {}
    
    public static ConfigManager getInstance() {
        if (instance == null) {
            synchronized (ConfigManager.class) {
                if (instance == null) {
                    instance = new ConfigManager();
                }
            }
        }
        return instance;
    }
}

警告：过度使用单例会导致代码难以测试，应仅用于真正的全局唯一场景

2.2 工厂方法模式（Factory Method）

去年开发支付网关时，需要支持微信、支付宝、银联等多种支付方式。通过工厂方法将对象创建延迟到子类：

python复制class PaymentFactory:
    def create_payment(self, payment_type):
        if payment_type == "wechat":
            return WechatPayment()
        elif payment_type == "alipay":
            return AlipayPayment()
        else:
            raise ValueError("不支持的支付类型")

2.3 抽象工厂模式（Abstract Factory）

在跨平台UI开发中特别有用。比如要创建一套适配Windows和Mac的按钮、文本框组件：

typescript复制interface GUIFactory {
    createButton(): Button;
    createTextBox(): TextBox;
}

class WinFactory implements GUIFactory {
    createButton() { return new WinButton(); }
    createTextBox() { return new WinTextBox(); }
}

3. 结构型模式：构建灵活的代码架构

3.1 适配器模式（Adapter）

最近在整合第三方地图服务时深有体会。当接口不兼容时，适配器就像转接头：

javascript复制class GoogleMap {
    show(lat, lng) { /*...*/ }
}

class BaiduMapAdapter {
    constructor(baiduMap) {
        this.map = baiduMap;
    }
    
    show(lat, lng) {
        const [bdLat, bdLng] = convertToBaiduCoord(lat, lng);
        this.map.display(bdLat, bdLng);
    }
}

3.2 装饰器模式（Decorator）

给同事讲解这个模式时，我喜欢用咖啡加料的例子：

python复制class Coffee:
    def cost(self):
        return 5

class MilkDecorator:
    def __init__(self, coffee):
        self._coffee = coffee
    
    def cost(self):
        return self._coffee.cost() + 2

3.3 外观模式（Facade）

上周重构的一个复杂订单系统，用外观模式简化接口：

java复制public class OrderFacade {
    private InventoryService inventory;
    private PaymentService payment;
    private ShippingService shipping;
    
    public void placeOrder(Order order) {
        inventory.checkStock(order);
        payment.process(order);
        shipping.scheduleDelivery(order);
    }
}

4. 行为型模式：对象间的智能交互

4.1 观察者模式（Observer）

实现事件系统的经典方案。我在电商平台中用它处理订单状态变更：

typescript复制interface Observer {
    update(order: Order): void;
}

class OrderNotifier {
    private observers: Observer[] = [];
    
    addObserver(obs: Observer) {
        this.observers.push(obs);
    }
    
    notify(order: Order) {
        this.observers.forEach(obs => obs.update(order));
    }
}

4.2 策略模式（Strategy）

去年优化推荐算法时的最佳实践。将算法封装成可互换的策略：

python复制class RecommendationStrategy:
    def recommend(self, user):
        pass

class CollaborativeFiltering(RecommendationStrategy):
    def recommend(self, user):
        # 实现协同过滤逻辑
        pass

class ContentBased(RecommendationStrategy):
    def recommend(self, user):
        # 实现基于内容的推荐
        pass

4.3 模板方法模式（Template Method）

在开发数据导出功能时，固定流程中的步骤变化：

java复制abstract class DataExporter {
    final void export() {
        prepareData();
        formatData();
        save();
    }
    
    abstract void formatData();
}

5. 模式选择与组合实践

5.1 识别模式应用场景

通过代码异味判断该用哪种模式：

• 大量条件判断 → 考虑策略/状态模式
• 直接new对象 → 考虑工厂方法
• 接口不兼容 → 适配器模式
• 组件耦合严重 → 中介者模式

5.2 模式组合案例

在电商促销系统中，我这样组合模式：

1. 用装饰器叠加优惠券折扣
2. 用策略选择计算方式（满减/折扣）
3. 用观察者通知库存系统

javascript复制// 伪代码示例
order.applyCoupon(new DiscountCoupon(0.9))
     .applyStrategy(new Full100Minus20())
     .addObserver(new InventoryUpdater());

5.3 避免模式滥用

曾见过一个过度设计的案例：简单CRUD用了7种模式。记住：

• 模式是手段不是目的
• KISS原则优先
• 当模式让代码更复杂时就该重构

6. 现代开发中的模式演进

6.1 函数式编程的影响

很多模式在FP中变得简单。比如策略模式可以用高阶函数实现：

python复制def recommend_by(strategy, user):
    return strategy(user)

recommend_by(collaborative_filtering, current_user)

6.2 响应式编程中的观察者

RxJS等库将观察者模式发挥到极致：

typescript复制fromEvent(button, 'click')
  .pipe(throttleTime(1000))
  .subscribe(handleClick);

6.3 微服务架构中的模式

• API网关 → 外观模式
• 服务发现 → 抽象工厂
• 熔断器 → 状态模式

7. 个人实践心得

十五年经验告诉我：

1. 模式要"内化"不是"套用"
2. 先从简单实现开始，发现痛点再引入模式
3. 每个模式都有代价（复杂度/性能）
4. 理解意图比记住结构更重要

最近帮团队做代码审查时，发现最常被误用的是单例和工厂。记住：如果你的"全局唯一"其实不需要唯一，或者你的"工厂"只是包装了new，那就该重新思考设计了。