佚格麻瓜1. 设计模式概述：为什么我们需要它们？
在软件开发领域，设计模式就像是建筑师的蓝图，为常见问题提供了经过验证的解决方案。我第一次真正理解设计模式的价值是在一个电商项目重构时——当时系统充斥着重复的订单状态判断代码，每次新增状态都需要修改十几处地方。直到引入状态模式后，这个问题才得到优雅解决。
设计模式本质上是对面向对象设计原则（SOLID原则）的具体实现。它们不是可以直接复制粘贴的代码，而是解决特定问题的模板。就像乐高积木的拼接方式，虽然每个积木块是固定的，但通过不同组合可以构建出无限可能。
重要提示：设计模式不是银弹，过度使用会导致代码过度设计。我见过不少开发者为了用模式而用模式，结果把简单系统复杂化。记住：当简单代码能满足需求时，不要强行套用模式。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 创建型模式：对象创建的优雅之道
2.1 单例模式(Singleton)：全局唯一的实例
数据库连接池是单例模式的经典应用。在我的一个高并发项目中，使用单例管理数据库连接避免了频繁创建销毁连接的开销：
java复制public class DatabasePool {
private static volatile DatabasePool instance;
private DatabasePool() {} // 私有构造
public static DatabasePool getInstance() {
if (instance == null) {
synchronized (DatabasePool.class) {
if (instance == null) {
instance = new DatabasePool();
}
}
}
return instance;
}
}
踩坑经验：单例在分布式系统中会失效，每个JVM都会有自己的实例。这时需要改用分布式缓存或中间件实现真正的全局唯一。
2.2 工厂方法模式(Factory Method)：解耦对象创建
在开发跨平台UI组件时，我深刻体会到工厂方法的价值。比如创建按钮：
typescript复制interface Button {
render(): void;
onClick(f: Function): void;
}
class WindowsButton implements Button { /*...*/ }
class MacButton implements Button { /*...*/ }
abstract class Dialog {
abstract createButton(): Button;
render() {
const button = this.createButton();
button.onClick(() => console.log('Clicked!'));
button.render();
}
}
class WindowsDialog extends Dialog {
createButton(): Button {
return new WindowsButton();
}
}
这样客户端代码只需调用dialog.render()，完全不用关心具体按钮类型。
2.3 建造者模式(Builder)：复杂对象的逐步构建
当我在开发一个文档导出系统时，建造者模式完美解决了导出配置的灵活性问题：
python复制class PDFBuilder:
def set_page_size(self, size): ...
def set_margin(self, margin): ...
def set_header(self, text): ...
def build(self) -> PDFDocument: ...
# 使用示例
builder = PDFBuilder()
builder.set_page_size('A4')
builder.set_margin('2cm')
builder.set_header('Monthly Report')
pdf = builder.build()
这种分步构建方式比在构造函数中传20多个参数清晰多了。
3. 结构型模式：对象组合的艺术
3.1 适配器模式(Adapter)：兼容不兼容的接口
最近在整合一个第三方支付SDK时遇到接口不匹配问题。适配器模式救了我：
javascript复制// 第三方支付接口
class ThirdPartyPayment {
pay(amountInCents) { ... }
}
// 我们的系统接口
class PaymentProcessor {
processPayment(amountInDollars) { ... }
}
// 适配器
class PaymentAdapter extends PaymentProcessor {
constructor(thirdPartyPayment) {
this.adaptee = thirdPartyPayment;
}
processPayment(amountInDollars) {
const cents = amountInDollars * 100;
return this.adaptee.pay(cents);
}
}
3.2 装饰器模式(Decorator)：动态添加功能
在开发日志系统时，装饰器模式让我们可以灵活组合日志功能：
python复制class Logger:
def log(self, message): pass
class FileLogger(Logger):
def log(self, message):
with open('log.txt', 'a') as f:
f.write(message + '\n')
class LoggerDecorator(Logger):
def __init__(self, logger):
self.logger = logger
class TimestampLogger(LoggerDecorator):
def log(self, message):
self.logger.log(f"[{datetime.now()}] {message}")
# 使用
logger = TimestampLogger(FileLogger())
logger.log("User logged in") # 输出带时间戳的日志
3.3 外观模式(Facade)：简化复杂子系统
在微服务架构中，我常用外观模式封装复杂的服务调用链：
java复制public class OrderFacade {
private InventoryService inventory;
private PaymentService payment;
private ShippingService shipping;
public OrderResult placeOrder(Order order) {
if (!inventory.checkStock(order)) {
throw new RuntimeException("Out of stock");
}
PaymentResult paymentResult = payment.process(order);
if (!paymentResult.success()) {
return OrderResult.failed("Payment failed");
}
ShippingInfo shippingInfo = shipping.scheduleDelivery(order);
return OrderResult.success(shippingInfo);
}
}
这样客户端只需与OrderFacade交互，不用了解底层多个服务的调用细节。
4. 行为型模式：对象间的交互智慧
4.1 观察者模式(Observer)：事件驱动的核心
在实现实时数据看板时，观察者模式是基石：
typescript复制interface Observer {
update(data: any): void;
}
class DataSource {
private observers: Observer[] = [];
addObserver(o: Observer) {
this.observers.push(o);
}
changeData(newData: any) {
this.observers.forEach(o => o.update(newData));
}
}
class Dashboard implements Observer {
update(data) {
console.log('Updating dashboard with:', data);
}
}
// 使用
const source = new DataSource();
source.addObserver(new Dashboard());
source.changeData({ temp: 25 }); // 自动通知所有观察者
4.2 策略模式(Strategy)：算法的自由切换
在开发电商促销系统时，策略模式让促销规则可以动态更换：
java复制interface DiscountStrategy {
double applyDiscount(double originalPrice);
}
class ChristmasDiscount implements DiscountStrategy {
public double applyDiscount(double price) {
return price * 0.7; // 30% off
}
}
class MemberDiscount implements DiscountStrategy {
public double applyDiscount(double price) {
return price * 0.9; // 10% off
}
}
class ShoppingCart {
private DiscountStrategy strategy;
public void setStrategy(DiscountStrategy s) {
this.strategy = s;
}
public double checkout(double subtotal) {
return strategy.applyDiscount(subtotal);
}
}
4.3 状态模式(State)：优雅处理状态转换
文章开头提到的订单系统重构，最终采用状态模式实现：
python复制class OrderState(ABC):
@abstractmethod
def next(self, order): pass
@abstractmethod
def prev(self, order): pass
class PendingState(OrderState):
def next(self, order):
order.state = PaidState()
def prev(self, order):
raise InvalidOperation("Can't go back from pending")
class PaidState(OrderState):
def next(self, order):
order.state = ShippedState()
def prev(self, order):
order.state = PendingState()
class Order:
def __init__(self):
self.state = PendingState()
def next_state(self):
self.state.next(self)
def prev_state(self):
self.state.prev(self)
5. 模式选择与组合实战经验
在实际项目中，我总结出几个选择设计模式的实用原则：
-
识别变化点：找出系统中可能变化的部分，用模式封装这些变化。比如支付方式经常增减，就用策略模式。
-
避免过度设计：如果需求很稳定，直接写简单代码。我曾在一个小型内部工具中强行使用抽象工厂，结果适得其反。
-
模式组合的艺术：
- 组合使用装饰器和工厂方法创建灵活的对象
- 观察者+中介者模式处理复杂事件通知
- 策略+模板方法实现可定制的算法骨架
-
重构到模式：不要一开始就设计模式，而是在重构过程中发现模式的应用点。这是我读过《重构》后的重要领悟。
最后分享一个真实案例：在开发文件导出系统时，我组合使用了：
- 建造者模式：分步构建导出配置
- 策略模式：选择不同的导出算法(PDF/Excel)
- 装饰器模式：动态添加水印、加密等功能
- 模板方法：定义导出流程骨架
这种组合让系统在保持灵活性的同时，代码依然清晰可维护。