三亩地 三亩地SAN MU DI · CODE DIARY
交流投稿
ARTICLE DETAIL

日记详情

真实记录编程学习的某一天，欢迎挑你感兴趣的翻一翻。

首页/学习日记/日记详情

Java行为型设计模式实战：责任链与命令模式详解

发布时间：2026/8/10 4:44:52 三亩地 编程学习日记
Java行为型设计模式实战：责任链与命令模式详解

1. 行为型设计模式概述

当我们在编写复杂软件系统时，经常会遇到对象间通信和职责分配的问题。行为型模式正是为了解决这类问题而生的，它们关注对象之间的交互方式和职责分配，让代码更加灵活、可维护。作为设计模式三大类别之一（创建型、结构型、行为型），行为型模式在实际开发中应用最为广泛。

我在十多年的Java开发经历中发现，合理运用行为型模式可以显著提升代码质量。特别是在处理复杂业务逻辑时，这些模式能帮助我们避免硬编码的条件判断，减少模块间的耦合度。比如电商系统中的订单状态流转、游戏开发中的角色行为管理，或是企业级应用中的业务流程控制，行为型模式都能大显身手。

2. 责任链模式（Chain of Responsibility）

2.1 模式定义与适用场景

责任链模式允许你将请求沿着处理链传递，直到有一个对象处理它为止。这种模式最常见的应用场景就是多级审批流程。比如在一个OA系统中，请假申请可能需要经过组长、部门经理、HR总监等多级审批，每级审批者都有自己明确的审批权限。

提示：当你不确定哪个对象应该处理请求，或者想让多个对象都有机会处理请求时，责任链模式是个不错的选择。

2.2 Java实现示例

public abstract class Approver { protected Approver successor; public void setSuccessor(Approver successor) { this.successor = successor; } public abstract void processRequest(LeaveRequest request); } public class GroupLeader extends Approver { @Override public void processRequest(LeaveRequest request) { if (request.getDays() <= 3) { System.out.println("组长批准"+request.getName()+"请假"+request.getDays()+"天"); } else if (successor != null) { successor.processRequest(request); } } } // 使用示例 Approver groupLeader = new GroupLeader(); Approver deptManager = new DeptManager(); Approver hrDirector = new HRDirector(); groupLeader.setSuccessor(deptManager); deptManager.setSuccessor(hrDirector); groupLeader.processRequest(new LeaveRequest("张三", 5));

2.3 实战经验与注意事项

在实际项目中，我总结了几个使用责任链模式的要点：

  1. 链的构建方式：可以采用配置文件定义处理链，这样修改处理顺序时不需要改代码。Spring框架中的拦截器链就是很好的例子。

  2. 性能考量：如果链过长，可能会影响性能。可以考虑设置最大处理深度，或者对频繁调用的场景使用缓存。

  3. 请求终止条件：明确什么情况下请求处理应该终止，避免出现无限循环。可以在基类中定义默认处理逻辑。

常见坑点：忘记设置successor导致链断裂，或者循环引用形成环状链。建议在setSuccessor方法中加入环状检测。

3. 命令模式（Command）

3.1 模式核心思想

命令模式将"请求"封装成对象，使得可以用不同的请求对客户进行参数化。这个模式最大的价值在于解耦了请求发送者和接收者。我在开发文本编辑器时，就用命令模式完美实现了撤销/重做功能。

3.2 典型应用场景

  • GUI按钮和菜单项操作
  • 事务型系统
  • 宏命令（一组命令的组合）
  • 任务队列

3.3 C#实现示例

public interface ICommand { void Execute(); void Undo(); } public class CopyCommand : ICommand { private string text; public CopyCommand(string text) { this.text = text; } public void Execute() { Clipboard.SetText(text); } public void Undo() { Clipboard.Clear(); } } // 调用示例 Stack<ICommand> history = new Stack<ICommand>(); ICommand copyCmd = new CopyCommand("Hello World"); copyCmd.Execute(); history.Push(copyCmd); // 撤销 if (history.Count > 0) { history.Pop().Undo(); }

3.4 实战技巧

  1. 复合命令：可以创建宏命令，将多个命令组合成一个命令执行。这在批量操作时特别有用。

  2. 命令日志：记录执行过的命令，不仅可以实现撤销，还能用于审计和重放。

  3. 异步命令：对于耗时操作，可以让命令实现异步执行接口，避免阻塞UI线程。

踩过的坑：命令对象如果包含外部状态引用，在撤销时可能导致状态不一致。建议采用深拷贝或备忘录模式配合使用。

4. 解释器模式（Interpreter）

4.1 模式理解

解释器模式定义了一个语言的文法，并用该文法解释语言中的句子。虽然不常用，但在特定领域（如规则引擎、SQL解析等）非常强大。我曾经用解释器模式开发过一个业务规则引擎，允许业务人员通过简单语法配置复杂规则。

4.2 模式结构

解释器模式通常包含：

  • 抽象表达式(Expression)
  • 终结符表达式(TerminalExpression)
  • 非终结符表达式(NonterminalExpression)
  • 上下文(Context)

4.3 C++实现示例

class Expression { public: virtual bool interpret(const string& context) = 0; }; class TerminalExpression : public Expression { string data; public: TerminalExpression(string data) : data(data) {} bool interpret(const string& context) override { return context.find(data) != string::npos; } }; class OrExpression : public Expression { Expression* expr1; Expression* expr2; public: OrExpression(Expression* e1, Expression* e2) : expr1(e1), expr2(e2) {} bool interpret(const string& context) override { return expr1->interpret(context) || expr2->interpret(context); } }; // 使用示例 Expression* rule = new OrExpression( new TerminalExpression("VIP"), new TerminalExpression("Premium") ); cout << rule->interpret("VIP用户") << endl; // 输出1

4.4 应用建议

  1. 性能优化：解释器模式可能会创建大量小对象，可以考虑享元模式共享终结符。

  2. 文法复杂度：对于复杂文法，建议结合解析器生成工具（如ANTLR）使用，而不是手写解释器。

  3. 扩展性：设计文法时要考虑未来可能的扩展，避免频繁修改表达式类结构。

实际项目中，解释器模式往往与其他模式结合使用。比如在规则引擎中，可能会组合策略模式来处理不同的规则类型。

5. 迭代器模式（Iterator）

5.1 模式价值

迭代器模式提供了一种顺序访问聚合对象元素的方法，而又不暴露其底层表示。现代编程语言大多内置了迭代器支持（如Java的Iterable接口、C#的IEnumerable），但理解其原理对设计复杂数据结构很有帮助。

5.2 JavaScript实现示例

class MyCollection { constructor() { this.items = []; } addItem(item) { this.items.push(item); } [Symbol.iterator]() { let index = 0; const items = this.items; return { next() { return index < items.length ? { value: items[index++], done: false } : { done: true }; } }; } } // 使用示例 const collection = new MyCollection(); collection.addItem("A"); collection.addItem("B"); collection.addItem("C"); for (const item of collection) { console.log(item); }

5.3 高级应用技巧

  1. 并行迭代：可以设计线程安全的迭代器，支持多线程环境下的并发访问。

  2. 过滤迭代器：创建带过滤条件的迭代器，只返回符合条件的元素。

  3. 惰性求值：对于大数据集，可以实现按需获取元素的迭代器，减少内存消耗。

在React等前端框架中，迭代器模式被广泛应用于列表渲染。理解这一模式有助于优化性能关键路径。

6. 中介者模式（Mediator）

6.1 问题场景

当对象之间存在大量直接关联，导致系统高度耦合时，中介者模式可以引入一个中间对象来封装交互。我在开发聊天室系统时，就用中介者模式解耦了用户之间的直接通信。

6.2 Java实现示例

public interface ChatMediator { void sendMessage(String msg, User user); void addUser(User user); } public class ChatRoom implements ChatMediator { private List<User> users; public ChatRoom() { this.users = new ArrayList<>(); } @Override public void sendMessage(String msg, User user) { for (User u : users) { if (u != user) { u.receive(msg); } } } @Override public void addUser(User user) { this.users.add(user); } } public abstract class User { protected ChatMediator mediator; protected String name; public User(ChatMediator med, String name) { this.mediator = med; this.name = name; } public abstract void send(String msg); public abstract void receive(String msg); }

6.3 模式优缺点分析

优点：

  • 减少对象间的直接耦合
  • 简化对象间的交互
  • 更容易复用单个对象

缺点：

  • 中介者可能变得过于复杂
  • 可能成为性能瓶颈

在实际架构设计中，消息队列（如Kafka、RabbitMQ）本质上就是中介者模式的实现。理解这一模式有助于更好地使用这些中间件。

7. 备忘录模式（Memento）

7.1 模式应用场景

备忘录模式在不破坏封装性的前提下，捕获并外部化对象的内部状态，以便以后可以恢复到这个状态。典型的应用包括：

  • 文本编辑器的撤销功能
  • 游戏存档
  • 事务回滚

7.2 Python实现示例

class EditorMemento: def __init__(self, content): self._content = content @property def content(self): return self._content class Editor: def __init__(self): self._content = "" def type(self, text): self._content += text def save(self): return EditorMemento(self._content) def restore(self, memento): self._content = memento.content @property def content(self): return self._content # 使用示例 editor = Editor() editor.type("First line\n") save1 = editor.save() editor.type("Second line\n") print(editor.content) # 输出当前内容 editor.restore(save1) print(editor.content) # 回滚到第一次保存的状态

7.3 性能与实现考量

  1. 状态存储：对于大对象，频繁保存状态可能消耗大量内存。可以考虑增量存储或压缩技术。

  2. 深拷贝问题：如果对象包含复杂引用关系，确保备忘录能正确保存和恢复整个对象图。

  3. 版本兼容：长期保存的状态需要考虑版本兼容性问题，特别是当类结构发生变化时。

在实现撤销栈时，我通常会设置最大栈深度，避免内存无限增长。同时，对于不可逆操作（如文件删除），会给予用户明确提示。

8. 观察者模式（Observer）

8.1 模式核心

观察者模式定义了对象间的一对多依赖关系，当一个对象状态改变时，所有依赖它的对象都会得到通知并自动更新。这是应用最广泛的行为型模式之一，在GUI事件处理、发布-订阅系统等领域无处不在。

8.2 Java内置支持

Java标准库提供了Observable类和Observer接口，但实际开发中更推荐使用PropertyChangeListener或实现自己的观察者模式：

public interface Subject { void registerObserver(Observer o); void removeObserver(Observer o); void notifyObservers(); } public class WeatherData implements Subject { private List<Observer> observers; private float temperature; public WeatherData() { observers = new ArrayList<>(); } public void setMeasurements(float temp) { this.temperature = temp; notifyObservers(); } @Override public void registerObserver(Observer o) { observers.add(o); } @Override public void notifyObservers() { for (Observer o : observers) { o.update(temperature); } } }

8.3 现代变体与实践

  1. 事件总线：如EventBus、RxJava等响应式编程库，提供了更强大的观察者模式实现。

  2. 反应式系统：观察者模式是反应式编程的基础，理解它有助于学习React、Vue等前端框架。

  3. 性能优化：对于高频更新场景，可以考虑批量通知或异步通知。

在Android开发中，LiveData就是观察者模式的典型应用。我在开发一个实时数据监控系统时，通过合理使用观察者模式，将界面更新频率控制在合理范围，既保证了实时性，又避免了UI卡顿。

9. 状态模式（State）

9.1 模式动机

状态模式允许对象在内部状态改变时改变它的行为，看起来像是修改了它的类。我在开发订单系统时，用状态模式优雅地处理了订单状态流转，避免了大量的if-else判断。

9.2 状态机实现

public interface IOrderState { void Confirm(Order order); void Cancel(Order order); void Ship(Order order); } public class NewOrderState : IOrderState { public void Confirm(Order order) { order.State = new ConfirmedState(); } public void Cancel(Order order) { order.State = new CanceledState(); } public void Ship(Order order) { throw new InvalidOperationException("不能直接发货新订单"); } } public class Order { public IOrderState State { get; set; } public Order() { State = new NewOrderState(); } public void Confirm() { State.Confirm(this); } }

9.3 复杂状态管理

对于复杂状态机，可以考虑：

  1. 状态表驱动：将状态转移规则存储在外部配置中，实现动态调整。

  2. 层次状态：使用组合模式实现嵌套状态，简化复杂状态机的管理。

  3. 历史状态：实现备忘录模式保存历史状态，支持回滚操作。

在电商系统中，订单、支付、物流等模块都有复杂的状态流转。通过状态模式，我们可以将业务规则封装在各个状态类中，使主业务逻辑保持简洁。

10. 策略模式（Strategy）

10.1 模式定义

策略模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换。策略模式让算法的变化独立于使用它的客户端。我在开发支付系统时，用策略模式支持了多种支付方式的无缝切换。

10.2 支付系统示例

public interface PaymentStrategy { void pay(double amount); } public class CreditCardStrategy implements PaymentStrategy { private String cardNumber; public CreditCardStrategy(String cardNumber) { this.cardNumber = cardNumber; } @Override public void pay(double amount) { System.out.println(amount + " paid with credit card"); } } public class ShoppingCart { private PaymentStrategy strategy; public void setPaymentStrategy(PaymentStrategy strategy) { this.strategy = strategy; } public void checkout(double amount) { strategy.pay(amount); } }

10.3 策略选择与组合

  1. 策略工厂：可以使用工厂模式动态创建策略对象。

  2. 策略组合：通过组合多个策略实现复杂行为，如折扣+满减的组合优惠。

  3. 策略参数化：将策略与参数分离，实现更灵活的配置。

在微服务架构中，API网关经常使用策略模式来实现路由、限流、熔断等策略的动态切换。理解这一模式对设计灵活的系统架构很有帮助。

11. 模板方法模式（Template Method）

11.1 模式特点

模板方法模式在父类中定义算法的骨架，而将一些步骤延迟到子类中实现。它允许子类在不改变算法结构的情况下重定义算法的某些步骤。我在开发数据导出功能时，用模板方法模式统一处理了文件创建、数据格式化、错误处理等通用逻辑。

11.3 实际应用技巧

  1. 钩子方法：在模板中定义可选步骤，子类可以决定是否覆盖它们。

  2. 访问控制：使用protected修饰模板方法，确保只有子类可以覆盖特定步骤。

  3. 算法复用：将多个相似算法中的公共部分提取到模板中，减少重复代码。

在框架设计中，模板方法模式非常常见。比如Spring的JdbcTemplate就使用了这种模式，将资源获取、异常处理等通用逻辑封装在模板中，用户只需关注SQL执行和结果处理。

12. 访问者模式（Visitor）

12.1 模式适用性

访问者模式表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。虽然使用频率不高，但在编译器设计、抽象语法树处理等场景非常有用。

12.2 编译器示例

class ExprVisitor { public: virtual void visit(NumberExpr* expr) = 0; virtual void visit(VariableExpr* expr) = 0; virtual void visit(BinaryExpr* expr) = 0; }; class Interpreter : public ExprVisitor { double result; public: double getResult() { return result; } void visit(NumberExpr* expr) override { result = expr->value; } void visit(BinaryExpr* expr) override { expr->left->accept(this); double left = result; expr->right->accept(this); double right = result; switch (expr->op) { case '+': result = left + right; break; case '-': result = left - right; break; } } };

12.3 模式优缺点

优点：

  • 容易添加新操作
  • 相关行为集中在一个访问者中
  • 访问者可以累积状态

缺点：

  • 增加新的元素类困难
  • 可能破坏封装

在实际项目中，访问者模式常与组合模式一起使用，用于处理复杂对象结构的遍历和操作。比如在开发报表引擎时，我用访问者模式实现了多种格式（HTML、PDF、Excel）的导出功能。

13. 行为型模式对比与选型

13.1 模式关系图

以下是主要行为型模式的关系对比：

模式关注点典型应用场景
策略算法替换支付方式、排序算法
状态状态改变行为订单状态机、游戏角色状态
观察者一对多通知事件处理、数据绑定
命令请求封装撤销/重做、任务队列
责任链请求传递链审批流程、过滤器链

13.2 选型建议

  1. 交互方式：如果对象间的交互复杂多变，考虑中介者模式。

  2. 算法选择：如果需要在运行时选择算法，使用策略模式。

  3. 状态管理：如果对象行为随状态改变，状态模式比大量条件判断更优雅。

  4. 请求处理：如果请求可能需要多个处理者，责任链模式更灵活。

  5. 历史记录：如果需要支持撤销操作，命令模式或备忘录模式更适合。

在我的架构设计经验中，行为型模式常常组合使用。比如电商系统可能同时使用观察者模式（库存通知）、状态模式（订单状态）、策略模式（促销计算）和命令模式（订单操作）。理解每种模式的适用场景和限制，才能在设计中做出合理选择。

14. 行为型模式在框架中的应用

14.1 Spring框架中的行为模式

  1. 观察者模式：ApplicationEvent和ApplicationListener机制
  2. 模板方法：JdbcTemplate、RestTemplate等模板类
  3. 策略模式：资源加载策略、缓存策略
  4. 责任链模式：Spring Security的过滤器链

14.2 React框架中的行为模式

  1. 观察者模式：状态管理和组件更新
  2. 策略模式：渲染策略、调和算法
  3. 命令模式：Redux中的action和reducer

理解这些模式在流行框架中的应用，有助于我们更好地使用框架，并在必要时扩展框架功能。

15. 行为型模式面试精要

15.1 常见面试题

  1. 观察者模式和发布-订阅模式的区别？
  2. 策略模式和状态模式的结构相似，它们的主要区别是什么？
  3. 什么情况下你会选择命令模式而不是策略模式？
  4. 如何优化责任链模式的性能？
  5. 模板方法模式和策略模式都封装算法，它们各自的适用场景是什么？

15.2 回答技巧

  1. 结合实战经验：用实际项目例子说明模式应用，比单纯解释概念更有说服力。

  2. 对比分析：当被问及相似模式时，从意图、结构和适用场景三个维度进行比较。

  3. 优缺点平衡：不要只讲优点，也要说明模式的局限性和适用边界。

  4. 扩展思考：展示对模式变体和组合使用的理解，比如"在这个项目中，我组合使用了观察者模式和中介者模式..."

在面试架构师岗位时，我经常被要求设计一个支持多种通知方式的系统。通过组合使用观察者模式（通知事件）、策略模式（通知方式选择）和桥接模式（通知渠道实现），我能够给出一个灵活可扩展的设计方案，这往往能给面试官留下深刻印象。

16. 行为型模式最佳实践

16.1 模式滥用警示

  1. 过度设计：不是所有变化点都需要用设计模式，简单条件判断有时更直接。

  2. 模式嵌套过深：多个模式组合可能导致代码难以理解，保持适度。

  3. 忽视语言特性：现代语言（如函数式编程特性）可能提供更简洁的实现方式。

16.2 实用建议

  1. 渐进式应用：从最痛点开始引入模式，而不是一开始就设计完美架构。

  2. 文档注释：对使用的模式进行说明，帮助团队成员理解设计意图。

  3. 重构为模式：先写出可工作的代码，再通过重构引入模式，而不是一开始就强制使用模式。

在我的编程实践中，发现很多模式其实是在重构过程中自然浮现的。比如当发现多个类中有相似的条件判断处理状态时，就是引入状态模式的好时机；当算法选择逻辑变得复杂时，策略模式就能派上用场。关键是要培养识别这些"模式味道"的能力。

17. 行为型模式演进趋势

17.1 函数式编程的影响

许多行为型模式在函数式编程中有更简洁的实现方式。比如：

  • 策略模式 → 高阶函数
  • 命令模式 → 闭包/lambda
  • 观察者模式 → 响应式流

17.2 云原生架构中的模式

在微服务和云原生架构中，行为型模式有了新的应用形式：

  • 中介者模式 → 服务网格
  • 责任链模式 → 中间件管道
  • 命令模式 → CQRS模式

理解这些传统模式在现代架构中的演变，有助于我们在新环境下做出更好的设计决策。比如在开发云原生应用时，我经常将传统的对象间交互模式转换为服务间的消息交互模式，本质上是将行为型模式的应用层级从对象提升到了服务。

编程学习 学习日记 实战经验
← 返回列表