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

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

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

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

二、创建型模式深度解析

1. 工厂模式家族

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

public class LogFactory {
    public static ILogger createLogger(String type) {
        if ("file".equals(type)) return new FileLogger();
        if ("db".equals(type)) return new DatabaseLogger();
        throw new IllegalArgumentException("Unknown log type");
    }
}

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

public abstract class PaymentFactory {
    public abstract IPayment createPayment();
    public void processPayment(double amount) {
        IPayment payment = createPayment();
        payment.pay(amount);
    }
}
public class AlipayFactory extends PaymentFactory {
    @Override
    public IPayment createPayment() { return new Alipay(); }
}

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

public interface Button { void render(); }
public interface Checkbox { void check(); }
public abstract class GUIFactory {
    public abstract Button createButton();
    public abstract Checkbox createCheckbox();
}

2. 建造者模式

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

public class OrderBuilder {
    private Order order = new Order();
    public OrderBuilder setCustomer(String name) {
        order.setCustomer(name); return this;
    }
    public Order build() { return order; }
}
// 使用方式
Order order = new OrderBuilder()
    .setCustomer("Alice")
    .setItems(Arrays.asList("A","B"))
    .build();

3. 单例模式

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

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

三、结构型模式实践指南

1. 适配器模式

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

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

2. 装饰器模式

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

public abstract class DataProcessor {
    public abstract String process(String data);
}
public class EncryptDecorator extends DataProcessor {
    private DataProcessor processor;
    public EncryptDecorator(DataProcessor processor) {
        this.processor = processor;
    }
    @Override
    public String process(String data) {
        return encrypt(processor.process(data));
    }
    private String encrypt(String data) { /* 加密逻辑 */ }
}

3. 外观模式

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

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

四、行为型模式实战技巧

1. 观察者模式

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

public interface StockObserver {
    void update(String symbol, double price);
}
public class StockMarket {
    private List<StockObserver> observers = new ArrayList<>();
    public void addObserver(StockObserver observer) {
        observers.add(observer);
    }
    public void priceChanged(String symbol, double price) {
        observers.forEach(o -> o.update(symbol, price));
    }
}

2. 责任链模式

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

public abstract class Approver {
    protected Approver successor;
    public void setSuccessor(Approver successor) {
        this.successor = successor;
    }
    public abstract void processRequest(LeaveRequest request);
}
public class TeamLeader extends Approver {
    @Override
    public void processRequest(LeaveRequest request) {
        if (request.getDays() <= 3) {
            System.out.println("Team leader approved");
        } else if (successor != null) {
            successor.processRequest(request);
        }
    }
}

3. 策略模式

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

public interface SortStrategy {
    void sort(List<Integer> list);
}
public class QuickSort implements SortStrategy {
    @Override
    public void sort(List<Integer> list) { /* 快速排序实现 */ }
}
public class Context {
    private SortStrategy strategy;
    public void setStrategy(SortStrategy strategy) {
        this.strategy = strategy;
    }
    public void executeSort(List<Integer> list) {
        strategy.sort(list);
    }
}

五、模式选择与组合应用

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

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

六、设计模式应用原则

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

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