设计模式实战：工厂模式+责任链模式——订单处理流程运行结果：代码说明：责任链模式： OrderHandler 是抽象

使用责任链模式实现订单处理系统

引言

在订单处理系统中，业务流程通常涉及多个步骤，例如支付验证、库存检查和物流配送。这些步骤需要按顺序执行，同时要求系统具备灵活性和可扩展性。为此，我们采用了责任链模式（Chain of Responsibility Pattern）结合工厂模式来设计订单处理流程。本文将详细介绍代码实现、Mermaid 时序图、使用这种设计模式的原因、其好处以及潜在的缺陷。

代码实现与设计

核心代码

以下是订单处理系统的核心实现：

抽象处理器：OrderHandler 定义了责任链的基础结构，通过 nextHandler 指向下一个处理器。
具体处理器：
- PaymentHandler：处理支付逻辑。
- InventoryHandler：检查库存状态。
- ShippingHandler：安排物流配送。
工厂模式：HandlerFactory 接口和 DefaultHandlerFactory 实现负责创建和组装责任链。
订单实体：Order 类封装订单信息（如金额和类型）。

运行代码后，订单依次经过支付、库存和物流处理，输出如下：

处理支付流程...
检查库存...
安排物流配送...

Mermaid 时序图

以下是订单处理流程的 Mermaid 时序图，展示了对象之间的交互：

sequenceDiagram
    actor User
    participant Main
    participant DefaultHandlerFactory as Factory
    participant PaymentHandler as Payment
    participant InventoryHandler as Inventory
    participant ShippingHandler as Shipping
    participant Order

    User->>Main: main()
    Main->>Factory: createHandlerChain()
    Factory->>Payment: new PaymentHandler()
    Factory->>Inventory: new InventoryHandler()
    Factory->>Shipping: new ShippingHandler()
    Factory->>Payment: setNextHandler(Inventory)
    Factory->>Inventory: setNextHandler(Shipping)
    Factory-->>Main: return Payment
    Main->>Order: new Order(199.99, "ONLINE")
    Main->>Payment: handleRequest(order)
    Payment->>Inventory: handleRequest(order)
    Inventory->>Shipping: handleRequest(order)
    Shipping-->>Inventory: return
    Inventory-->>Payment: return
    Payment-->>Main: return

时序图说明：

用户启动程序，Main 调用工厂创建责任链。
DefaultHandlerFactory 实例化处理器并按顺序链接：PaymentHandler -> InventoryHandler -> ShippingHandler。
Main 创建订单并将请求传递给链头（PaymentHandler）。
请求沿责任链依次传递，最终完成处理并返回。

使用责任链模式的原因

解耦请求发送者和接收者
客户端（Main）无需了解具体的处理逻辑或顺序，只需将请求交给责任链的头部。这种设计降低了模块间的耦合度。
动态调整处理流程
通过修改 setNextHandler 的调用顺序，可以轻松调整处理步骤。例如，若业务需求变为先检查库存再支付，只需在工厂中调整链的顺序。
支持扩展性
若需新增处理步骤（如“订单审核”），只需实现新的 OrderHandler 子类并插入链中，无需修改现有代码。
结合工厂模式提升封装性
工厂模式将责任链的创建过程集中管理，客户端无需关心链的构建细节，提高了系统的可维护性。

使用责任链模式的好处

灵活性
责任链支持动态调整处理器顺序或添加新处理器。例如，可以根据订单类型（线上/线下）构建不同的处理链。
单一职责原则
每个处理器专注于单一任务（如支付、库存），职责清晰，便于开发、测试和维护。
可扩展性
新增功能时，只需扩展新的处理器并插入链中，符合开闭原则（对扩展开放，对修改关闭）。
流程控制能力
每个处理器可根据条件决定是否继续传递请求。例如，若支付失败，PaymentHandler 可中止流程。

责任链模式的缺陷

性能开销
请求需逐个处理器传递，即使某些步骤对特定订单不适用（如小型订单无需物流），也会增加调用开销。
调试复杂性
当链较长或逻辑复杂时，跟踪请求流向和定位问题可能变得困难，尤其在链未正确配置时。
链配置错误风险
若工厂未正确组装链（如遗漏处理器或顺序错误），可能导致流程不完整，且此类问题在运行时才暴露。
过度设计风险
对于简单流程，责任链模式可能显得复杂，直接顺序调用可能更高效。

总结

通过结合责任链模式和工厂模式，我们实现了一个灵活、可扩展的订单处理系统。责任链模式解耦了处理步骤并支持动态调整，而工厂模式封装了链的创建过程。这种设计特别适合需要频繁调整流程或扩展功能的场景。

然而，开发者需注意其潜在缺陷，如性能开销和调试难度。在实际应用中，可通过添加条件判断或日志机制优化体验。对于简单场景，应评估是否需要如此复杂的设计。

未来的改进方向包括：

根据订单类型动态调整链结构。
添加日志记录请求流转，便于调试。
优化性能，避免不必要的链传递。

这种设计模式的选择体现了软件设计中的权衡艺术，既满足当前需求，又为未来扩展预留空间。

// 1. 定义处理请求的抽象处理器（责任链基础）
abstract class OrderHandler {
    protected OrderHandler nextHandler; // 下一个处理器
    
    public void setNextHandler(OrderHandler nextHandler) {
        this.nextHandler = nextHandler;
    }
    
    abstract void handleRequest(Order order);
}

// 2. 订单实体类
class Order {
    private double amount; // 订单金额
    private String type;   // 订单类型
    
    public Order(double amount, String type) {
        this.amount = amount;
        this.type = type;
    }
    
    public double getAmount() { return amount; }
    public String getType() { return type; }
}

// 3. 具体处理器实现
class PaymentHandler extends OrderHandler {
    @Override
    void handleRequest(Order order) {
        System.out.println("处理支付流程...");
        if (nextHandler != null) {
            nextHandler.handleRequest(order);
        }
    }
}

class InventoryHandler extends OrderHandler {
    @Override
    void handleRequest(Order order) {
        System.out.println("检查库存...");
        if (nextHandler != null) {
            nextHandler.handleRequest(order);
        }
    }
}

class ShippingHandler extends OrderHandler {
    @Override
    void handleRequest(Order order) {
        System.out.println("安排物流配送...");
        if (nextHandler != null) {
            nextHandler.handleRequest(order);
        }
    }
}

// 4. 工厂接口和实现
interface HandlerFactory {
    OrderHandler createHandlerChain();
}

class DefaultHandlerFactory implements HandlerFactory {
    @Override
    public OrderHandler createHandlerChain() {
        // 创建处理器
        OrderHandler payment = new PaymentHandler();
        OrderHandler inventory = new InventoryHandler();
        OrderHandler shipping = new ShippingHandler();
        
        // 构建责任链
        payment.setNextHandler(inventory);
        inventory.setNextHandler(shipping);
        
        return payment; // 返回链头
    }
}

// 5. 测试代码
public class Main {
    public static void main(String[] args) {
        // 使用工厂创建责任链
        HandlerFactory factory = new DefaultHandlerFactory();
        OrderHandler handlerChain = factory.createHandlerChain();
        
        // 创建订单并处理
        Order order = new Order(199.99, "ONLINE");
        handlerChain.handleRequest(order);
    }
}

运行结果：

处理支付流程...
检查库存...
安排物流配送...

代码说明：

责任链模式：
- OrderHandler 是抽象处理器，定义了链式结构（通过 nextHandler）
- 具体处理器（PaymentHandler、InventoryHandler、ShippingHandler）实现具体的处理逻辑
- 每个处理器可以决定是否将请求传递给下一个处理器
工厂模式：
- HandlerFactory 接口定义创建责任链的方法
- DefaultHandlerFactory 实现具体的创建逻辑，负责实例化和组装整个责任链
结合使用：
- 工厂模式负责创建和管理责任链的构建过程
- 责任链模式处理实际的业务逻辑流程
- 这种组合提供了灵活性和可扩展性