设计模式精讲：23种经典模式的实践指南

2026年2月10日 互联网

一、设计模式的核心价值与分类体系

设计模式是软件工程中经过验证的解决方案模板，其价值体现在三个方面：提升代码复用性（如工厂模式统一对象创建逻辑）、降低系统耦合度（如观察者模式解耦事件发布与订阅）、增强系统扩展性（如策略模式动态切换算法）。根据处理问题的层级，23种经典模式可分为三大类：

  1. 创建型模式（5种）：封装对象创建过程，解决资源初始化复杂性问题
  2. 结构型模式（7种）：优化类/对象组合关系，构建灵活的系统架构
  3. 行为型模式（11种）：规范对象间通信机制，提升业务逻辑可维护性

二、创建型模式深度解析

1. 工厂模式家族

简单工厂通过静态方法封装对象创建逻辑，适用于对象类型较少且不频繁变更的场景。例如日志系统初始化：

  1. public class LogFactory {
  2.     public static ILogger createLogger(String type) {
  3.         if ("file".equals(type)) return new FileLogger();
  4.         if ("db".equals(type)) return new DatabaseLogger();
  5.         throw new IllegalArgumentException("Unknown log type");
  6.     }
  7. }

工厂方法模式将创建逻辑延迟到子类实现，满足开闭原则。以支付系统为例：

  1. public abstract class PaymentFactory {
  2.     public abstract IPayment createPayment();
  3.     public void processPayment(double amount) {
  4.         IPayment payment = createPayment();
  5.         payment.pay(amount);
  6.     }
  7. }
  9. public class AlipayFactory extends PaymentFactory {
  10.     @Override
  11.     public IPayment createPayment() { return new Alipay(); }
  12. }

抽象工厂模式创建产品族而非单个产品，适用于需要同时生成多个关联对象的场景。如跨平台UI组件库：

  1. public interface Button { void render(); }
  2. public interface Checkbox { void check(); }
  4. public abstract class GUIFactory {
  5.     public abstract Button createButton();
  6.     public abstract Checkbox createCheckbox();
  7. }

2. 建造者模式

适用于复杂对象分步骤构建的场景，典型应用包括SQL语句构建、报表生成等。以订单对象构建为例：

  1. public class OrderBuilder {
  2.     private Order order = new Order();
  4.     public OrderBuilder setCustomer(String name) {
  5.         order.setCustomer(name); return this;
  6.     }
  8.     public Order build() { return order; }
  9. }
  11. // 使用方式
  12. Order order = new OrderBuilder()
  13.     .setCustomer("Alice")
  14.     .setItems(Arrays.asList("A","B"))
  15.     .build();

3. 单例模式

确保全局唯一实例的三种实现方式：

  • 饿汉式：类加载时初始化（线程安全但可能浪费资源）
  • 双重检查锁：延迟初始化+线程安全（需volatile关键字）
  • 静态内部类：利用类加载机制保证线程安全（推荐方式）

三、结构型模式实践指南

1. 适配器模式

解决接口不兼容问题，分为类适配（继承）和对象适配（组合）两种形式。例如旧版支付接口适配：

  1. public class OldPaymentAdapter implements NewPayment {
  2.     private OldPayment oldPayment;
  4.     @Override
  5.     public boolean pay(double amount, String currency) {
  6.         // 转换参数后调用旧接口
  7.         return oldPayment.process(amount * 6.5); // 假设汇率6.5
  8.     }
  9. }

2. 装饰器模式

动态扩展对象功能，相比继承更灵活。以数据加密装饰器为例：

  1. public abstract class DataProcessor {
  2.     public abstract String process(String data);
  3. }
  5. public class EncryptDecorator extends DataProcessor {
  6.     private DataProcessor processor;
  8.     public EncryptDecorator(DataProcessor processor) {
  9.         this.processor = processor;
  10.     }
  12.     @Override
  13.     public String process(String data) {
  14.         return encrypt(processor.process(data));
  15.     }
  17.     private String encrypt(String data) { /* 加密逻辑 */ }
  18. }

3. 外观模式

为复杂子系统提供统一入口，例如电商下单流程：

  1. public class OrderFacade {
  2.     private InventoryService inventory;
  3.     private PaymentService payment;
  4.     private ShippingService shipping;
  6.     public void placeOrder(Order order) {
  7.         inventory.checkStock(order);
  8.         payment.process(order.getAmount());
  9.         shipping.scheduleDelivery(order);
  10.     }
  11. }

四、行为型模式实战技巧

1. 观察者模式

实现事件驱动架构的核心模式，典型应用包括GUI事件处理、消息通知系统。以股票价格监控为例：

  1. public interface StockObserver {
  2.     void update(String symbol, double price);
  3. }
  5. public class StockMarket {
  6.     private List<StockObserver> observers = new ArrayList<>();
  8.     public void addObserver(StockObserver observer) {
  9.         observers.add(observer);
  10.     }
  12.     public void priceChanged(String symbol, double price) {
  13.         observers.forEach(o -> o.update(symbol, price));
  14.     }
  15. }

2. 责任链模式

将请求处理者组成链式结构，适用于审批流程、异常处理等场景。以请假审批为例：

  1. public abstract class Approver {
  2.     protected Approver successor;
  4.     public void setSuccessor(Approver successor) {
  5.         this.successor = successor;
  6.     }
  8.     public abstract void processRequest(LeaveRequest request);
  9. }
  11. public class TeamLeader extends Approver {
  12.     @Override
  13.     public void processRequest(LeaveRequest request) {
  14.         if (request.getDays() <= 3) {
  15.             System.out.println("Team leader approved");
  16.         } else if (successor != null) {
  17.             successor.processRequest(request);
  18.         }
  19.     }
  20. }

3. 策略模式

封装可互换的算法家族，例如排序策略实现：

  1. public interface SortStrategy {
  2.     void sort(List<Integer> list);
  3. }
  5. public class QuickSort implements SortStrategy {
  6.     @Override
  7.     public void sort(List<Integer> list) { /* 快速排序实现 */ }
  8. }
  10. public class Context {
  11.     private SortStrategy strategy;
  13.     public void setStrategy(SortStrategy strategy) {
  14.         this.strategy = strategy;
  15.     }
  17.     public void executeSort(List<Integer> list) {
  18.         strategy.sort(list);
  19.     }
  20. }

五、模式选择与组合应用

实际开发中常需组合使用多种模式：

  1. MVC架构：组合观察者（Model变化通知View）、策略（不同View渲染策略）、组合（View包含多个子组件）
  2. 插件系统：组合工厂方法（创建插件实例）、责任链（插件处理流程）、外观（简化插件API）
  3. 分布式事务：组合备忘录（事务快照）、命令（事务操作封装）、状态（事务状态机）

六、设计模式应用原则

  1. 避免过度设计：在简单场景中直接编码比使用模式更高效
  2. 理解模式本质：关注模式解决的问题而非具体实现
  3. 考虑维护成本：某些模式会增加系统复杂度（如抽象工厂）
  4. 结合语言特性：利用现代语言特性简化模式实现（如Java8的函数式接口）

掌握设计模式需要经历”记忆-理解-应用-创新”四个阶段。建议通过以下方式提升：1）分析开源项目中的模式应用 2）在重构时尝试引入合适模式 3）编写模式对比文档明确适用场景。最终目标是建立模式思维，在编码时自然联想到最佳实践方案。

最新文章