贵萌兄1. 为什么设计模式是工程师的必备技能
第一次接触设计模式是在2013年参与一个电商系统重构时。当时项目组里一位架构师指着我们写的2000行Service类说："这里至少有3个模式可以优化"。后来我才明白，设计模式不是炫技的工具，而是解决特定问题的经验结晶。
设计模式本质上是前辈工程师们总结出来的"最佳实践配方"。就像厨师有固定的食材搭配方法一样，工程师面对特定场景时，使用恰当的模式可以避免重复造轮子。根据我的观察，掌握8-10种常用模式就能覆盖日常开发中80%的设计场景。
提示：设计模式不是银弹，过度使用反而会增加系统复杂度。我的经验法则是：当发现自己在反复解决类似结构问题时，才考虑引入模式。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 单例模式：全局唯一的智慧
2.1 经典实现与线程安全
数据库连接池、配置管理器、日志服务...这些需要全局唯一实例的场景，单例模式是首选方案。下面是一个线程安全的双重检查锁定实现（Java示例）：
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;
}
}
volatile关键字防止指令重排序，synchronized块保证线程安全，双重检查则避免了每次获取实例都要加锁的性能损耗。这种实现方式在Spring等框架中被广泛采用。
2.2 现代语言的演进
在Go语言中，我们更推荐使用sync.Once来实现单例：
go复制var (
instance *DatabasePool
once sync.Once
)
func GetInstance() *DatabasePool {
once.Do(func() {
instance = &DatabasePool{}
})
return instance
}
Kotlin则直接内置了object关键字：
kotlin复制object DatabasePool {
fun connect() { ... }
}
3. 工厂模式：解耦的利器
3.1 简单工厂的适用场景
在支付系统开发中，我们经常需要根据支付类型创建不同的处理器。简单工厂模式非常适合这种场景：
python复制class PaymentFactory:
@staticmethod
def create_payment(method: str) -> Payment:
if method == "alipay":
return AlipayPayment()
elif method == "wechat":
return WeChatPayment()
elif method == "unionpay":
return UnionPayment()
raise ValueError(f"Unknown payment method: {method}")
虽然这违反了开闭原则（新增支付类型需要修改工厂类），但对于变化频率低的场景，简单工厂反而更直观。
3.2 抽象工厂的威力
当需要创建一系列相关对象时，抽象工厂展现出真正的价值。比如跨平台UI组件库：
typescript复制interface UIFactory {
createButton(): Button;
createDialog(): Dialog;
}
class MacFactory implements UIFactory {
createButton() { return new MacButton(); }
createDialog() { return new MacDialog(); }
}
class WinFactory implements UIFactory {
createButton() { return new WinButton(); }
createDialog() { return new WinDialog(); }
}
这种模式在React Native等跨平台框架中大量使用，使得平台相关代码集中在同一工厂中。
4. 观察者模式：事件驱动的核心
4.1 自定义实现示例
在电商订单系统中，订单状态变更需要触发库存扣减、物流通知、积分计算等多个动作。观察者模式完美解决这种一对多依赖：
java复制public interface OrderObserver {
void update(Order order);
}
public class Order {
private List<OrderObserver> observers = new ArrayList<>();
public void addObserver(OrderObserver o) {
observers.add(o);
}
public void changeStatus(Status newStatus) {
this.status = newStatus;
notifyObservers();
}
private void notifyObservers() {
for (OrderObserver o : observers) {
o.update(this);
}
}
}
4.2 现实框架中的应用
现代框架普遍提供更强大的事件总线实现。比如Spring的事件机制：
java复制@Component
public class InventoryService {
@EventListener
public void handleOrderEvent(OrderStatusEvent event) {
// 处理库存逻辑
}
}
Vue.js的响应式系统本质上也是观察者模式的变体，通过Object.defineProperty或Proxy实现数据监听。
5. 策略模式：灵活替换算法
5.1 电商促销案例
不同促销策略（满减、折扣、赠品）可以抽象为策略模式：
typescript复制interface PromotionStrategy {
apply(originalPrice: number): number;
}
class FullReduction implements PromotionStrategy {
apply(price: number) {
return price >= 300 ? price - 50 : price;
}
}
class Discount implements PromotionStrategy {
constructor(private readonly rate: number) {}
apply(price: number) {
return price * this.rate;
}
}
class PromotionContext {
constructor(private strategy: PromotionStrategy) {}
execute(price: number) {
return this.strategy.apply(price);
}
}
5.2 与工厂模式的结合
实际项目中，我们常将策略模式与工厂模式结合使用：
python复制class StrategyFactory:
@classmethod
def create_strategy(cls, promo_type: str) -> PromotionStrategy:
strategies = {
'full_reduction': FullReductionStrategy(),
'discount': lambda rate: DiscountStrategy(rate),
'gift': GiftStrategy()
}
return strategies.get(promo_type, DefaultStrategy())
这种组合在营销系统、计费规则等业务场景中非常实用。
6. 装饰器模式：动态增强功能
6.1 IO流中的经典应用
Java的IO流库是装饰器模式的教科书案例：
java复制InputStream in = new BufferedInputStream(
new GZIPInputStream(
new FileInputStream("data.gz")));
每个装饰器都继承自InputStream，可以在运行时任意组合功能。这种设计比静态继承灵活得多。
6.2 前端高阶组件
React中的高阶组件(HOC)也是装饰器思想的体现：
jsx复制function withLogging(WrappedComponent) {
return class extends React.Component {
componentDidMount() {
console.log(`Component ${WrappedComponent.name} mounted`);
}
render() {
return <WrappedComponent {...this.props} />;
}
};
}
const EnhancedButton = withLogging(Button);
这种模式在添加日志、权限控制等横切关注点时非常有用。
7. 代理模式：控制访问的守门人
7.1 虚拟代理优化性能
图片懒加载是虚拟代理的典型应用：
javascript复制class ImageProxy {
constructor(realImage) {
this.realImage = realImage;
this.placeholder = document.createElement('div');
}
display() {
if (!this.loaded) {
this.showPlaceholder();
this.realImage.load().then(() => {
this.replaceWithRealImage();
});
}
}
}
7.2 动态代理实现AOP
Spring AOP的核心就是基于动态代理实现的：
java复制@Aspect
@Component
public class LoggingAspect {
@Around("execution(* com.example.service.*.*(..))")
public Object logMethodCall(ProceedingJoinPoint pjp) throws Throwable {
long start = System.currentTimeMillis();
Object result = pjp.proceed();
long duration = System.currentTimeMillis() - start;
System.out.println(pjp.getSignature() + " executed in " + duration + "ms");
return result;
}
}
这种方式无需修改原有代码就能添加日志、事务等通用功能。
8. 模板方法模式：定义算法骨架
8.1 支付流程案例
电商支付流程通常包含固定步骤：
python复制class PaymentProcessor(ABC):
def process_order(self, order):
self.validate(order)
self.deduct_inventory(order)
self.create_shipment(order)
self.send_notification(order)
@abstractmethod
def validate(self, order): pass
@abstractmethod
def deduct_inventory(self, order): pass
def create_shipment(self, order):
# 默认实现
print("Creating standard shipment")
def send_notification(self, order):
# 默认实现
print("Sending email notification")
8.2 JdbcTemplate的启示
Spring的JdbcTemplate是模板方法的优秀实践：
java复制public <T> T execute(ConnectionCallback<T> action) throws DataAccessException {
Connection con = DataSourceUtils.getConnection(obtainDataSource());
try {
return action.doInConnection(con);
} finally {
DataSourceUtils.releaseConnection(con, getDataSource());
}
}
开发者只需关注SQL逻辑，连接管理、异常处理等样板代码由模板处理。
9. 实际项目中的模式组合
在微服务架构中，我们经常组合使用多种模式。比如：
- 使用工厂创建不同协议的API客户端
- 用策略模式处理不同商户的结算规则
- 通过观察者模式通知相关服务订单状态变更
- 用装饰器为请求添加认证、日志等通用功能
这种组合往往能产生1+1>2的效果。我在最近的一个项目中，通过合理运用模式组合，将核心代码量减少了40%，同时提高了可维护性。
10. 避免模式滥用的经验之谈
- 不要为了模式而模式：如果if-else就能清晰表达，就不要强行套用策略模式
- 警惕过度设计：在初创项目快速迭代阶段，简单直白的实现可能更合适
- 理解比记忆重要：重点掌握每个模式解决的问题场景，而不是具体实现
- 语言特性可能替代模式：现代语言的委托、扩展方法等特性可能比传统模式更简洁
我在代码评审中最常说的话是："这个模式用在这里真的必要吗？" 记住，设计模式的终极目标是让代码更清晰，而不是更"高级"。