AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

深入Java设计模式之命令模式

2023-08-29 99
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 深入Java设计模式之命令模式

概念

意图：将一个请求封装成一个对象，从而使您可以用不同的请求对客户进行参数化。

主要解决：在软件系统中，行为请求者与行为实现者通常是一种紧耦合的关系，但某些场合，比如需要对行为进行记录、撤销或重做、事务等处理时，这种无法抵御变化的紧耦合的设计就不太合适。

何时使用：在某些场合，比如要对行为进行"记录、撤销/重做、事务"等处理，这种无法抵御变化的紧耦合是不合适的。在这种情况下，如何将"行为请求者"与"行为实现者"解耦？将一组行为抽象为对象，可以实现二者之间的松耦合。

如何解决：通过调用者调用接受者执行命令，顺序：调用者→接受者→命令。

 

命令模式调用顺序

代码规范 

package com.lzhsite.technology.designPattern.command.GeneralDemo;
/**
 * 系统需要将请求调用者和请求接收者解耦，使得调用者和接收者不直接交互。
 * @author lzhcode
 *
 */
public class ClientForGeneralDemo
{
    public static void main(String[] args)
    {
        Receiver receiver = new Receiver();
        Command command = new ConcreteCommand(receiver);
        Invoker invoker = new Invoker();
        invoker.setCommand(command);
    }
}
package com.lzhsite.technology.designPattern.command.GeneralDemo;
public interface Command
{
    public void execute();
}
package com.lzhsite.technology.designPattern.command.GeneralDemo;
public class ConcreteCommand implements Command
{
    private Receiver receiver = null;
    private String state;
    public ConcreteCommand(Receiver receiver)
    {
        this.receiver = receiver;
    }
    public void execute()
    {
        receiver.action();
    }
}
package com.lzhsite.technology.designPattern.command.GeneralDemo;
public class Invoker
{
    private Command command = null;
    public void setCommand(Command command)
    {
        this.command = command;
    }
    public void runCommand()
    {
        command.execute();
    }
}
package com.lzhsite.technology.designPattern.command.GeneralDemo;
public class Receiver
{
    public void action()
    {
    }
}

适用场景

1.系统需要将请求调用者和请求接收者解耦，使得调用者和接收者不直接交互。

2.系统需要在不同的时间指定请求、将请求排队和执行请求。

3.系统需要支持命令的撤销(Undo)操作和恢复(Redo)操作。

4.系统需要将一组操作组合在一起，即支持宏命令。

优点

1.降低对象之间的耦合度。

2.新的命令可以很容易地加入到系统中。

3.可以比较容易地设计一个组合命令。

4.调用同一方法实现不同的功能

缺点

使用命令模式可能会导致某些系统有过多的具体命令类。因为针对每一个命令都需要设计一个具体命令类，因此某些系统可能需要大量具体命令类，这将影响命令模式的使用。

实际应用

点餐问题

定义命令接口 

package com.lzhsite.technology.designPattern.command.RestaurantDemo;
public interface ICommand
{
    public void execute();
    public void setCook(ICook cook);
    public int getTableNumber();
}

某道菜命令

package com.lzhsite.technology.designPattern.command.RestaurantDemo;
public class PorkCommand implements ICommand
{
    private int tableNumber;
    private ICook cook = null;
    public PorkCommand(int tableNumber)
    {
        this.tableNumber = tableNumber;
    }
    public void setCook(ICook cook)
    {
        this.cook = cook;
    }
    public int getTableNumber()
    {
        return this.tableNumber;
    }
    public void execute()
    {
        this.cook.cook(tableNumber, "蒜泥白肉");
    }
}
package com.lzhsite.technology.designPattern.command.RestaurantDemo;
public class ChopCommand implements ICommand {
  private int tableNumber;
  private ICook cook = null;
  public ChopCommand(int tableNumber) {
    this.tableNumber = tableNumber;
  }
  public void setCook(ICook cook) {
    this.cook = cook;
  }
  public int getTableNumber() {
    return this.tableNumber;
  }
  public void execute() {
    this.cook.cook(tableNumber, "绿豆排骨煲");
  }
}
package com.lzhsite.technology.designPattern.command.RestaurantDemo;
public class DuckCommand implements ICommand
{
    private int tableNumber;
    private ICook cook = null;
    public DuckCommand(int tableNumber)
    {
        this.tableNumber = tableNumber;
    }
    public void setCook(ICook cook)
    {
        this.cook = cook;
    }
    public int getTableNumber()
    {
        return this.tableNumber;
    }
    public void execute()
    {
        this.cook.cook(tableNumber, "北京烤鸭");
    }
}

点菜命令队列 

package com.lzhsite.technology.designPattern.command.RestaurantDemo;
import java.util.Queue;
import java.util.concurrent.ArrayBlockingQueue;
/**
 * 订单列表
 * 
 * @author lzhcode
 *
 */
public class CommandQueue {
  private static Queue<ICommand> commands = new ArrayBlockingQueue<ICommand>(200);
  public  static void addMenu(MenuCommand menuCommand) {
    for (ICommand command : menuCommand.getCommands()) {
      commands.add(command);
    }
  }
  public static void removeOneCommand() {
    if (commands.size() > 0) {
      commands.poll();
    }
  }
  public static ICommand getOneCommand() {
    ICommand command = null;
    if (commands.size() > 0) {
      command = commands.peek();
    }
    return command;
  }
}

订单命令 

package com.lzhsite.technology.designPattern.command.RestaurantDemo;
import java.util.Collection;
import java.util.concurrent.ArrayBlockingQueue;
public class MenuCommand implements ICommand
{
    private Collection<ICommand> commands = new ArrayBlockingQueue<ICommand>(100);
    public void addCommand(ICommand command)
    {
        commands.add(command);
    }
    public void execute()
    {
        CommandQueue.addMenu(this);
    }
    public void setCook(ICook cook)
    {
    }
    public int getTableNumber()
    {
        return 0;
    }
    public Collection<ICommand> getCommands()
    {
        return this.commands;
    }
}

定义菜类型接口

package com.lzhsite.technology.designPattern.command.RestaurantDemo;
public interface ICook
{
    public void cook(int tableNumber, String name);
}
package com.lzhsite.technology.designPattern.command.RestaurantDemo;
public class HotCook implements ICook, Runnable {
  private String name;
  public HotCook(String name) {
    this.name = name;
  }
  public void cook(int tableNumber, String name) {
    int cookTime = (int) (20 * Math.random());
    System.out.println(this.name + " 热菜厨师正在为 " + tableNumber + " 号桌做：" + name);
    try {
      Thread.sleep(cookTime);
    } catch (InterruptedException exception) {
      exception.printStackTrace();
    }
    System.out.println(this.name + " 热菜厨师为 " + tableNumber + " 号桌做好了：" + name + "， 共计耗时 = " + cookTime + " 秒");
  }
  public void run() {
    while (true) {
      synchronized (ClientForRestaurantDemo.Lock) {
        ICommand command = CommandQueue.getOneCommand();
        if (command != null) {
          if(command instanceof DuckCommand || command instanceof ChopCommand){
            command.setCook(this);
            command.execute();
            CommandQueue.removeOneCommand();
          }
        }
      }
      try {
        Thread.sleep(1000l);
      } catch (InterruptedException exception) {
        exception.printStackTrace();
      }
    }
  }
}
package com.lzhsite.technology.designPattern.command.RestaurantDemo;
public class ColdCook implements ICook, Runnable {
  private String name;
  public ColdCook(String name) {
    this.name = name;
  }
  public void cook(int tableNumber, String name) {
    int cookTime = (int) (20 * Math.random());
    System.out.println(this.name + " 冷菜厨师正在为 " + tableNumber + " 号桌做：" + name);
    try {
      Thread.sleep(cookTime);
    } catch (InterruptedException exception) {
      exception.printStackTrace();
    }
    System.out.println(this.name + " 冷菜厨师为 " + tableNumber + " 号桌做好了：" + name + "， 共计耗时 = " + cookTime + " 秒");
  }
  public void run() {
    while (true) {
      synchronized (ClientForRestaurantDemo.Lock) {
        ICommand command = CommandQueue.getOneCommand();
        if (command != null) {
          if(command instanceof PorkCommand){
            command.setCook(this);
            command.execute();
            CommandQueue.removeOneCommand();
          }
        }
      }
      try {
        Thread.sleep(1000l);
      } catch (InterruptedException exception) {
        exception.printStackTrace();
      }
    }
  }
}

定义服务员 

package com.lzhsite.technology.designPattern.command.RestaurantDemo;
public class Waiter
{
    public MenuCommand menuCommand = new MenuCommand();
    public void orderDish(ICommand command)
    {
        menuCommand.addCommand(command);
    }
    public void orderOver()
    {
        this.menuCommand.execute();
    }
}

程序启动入口 

package com.lzhsite.technology.designPattern.command.RestaurantDemo;
import java.util.concurrent.locks.Lock;
/**
 * 系统需要在不同的时间指定请求、将请求排队和执行请求。 系统需要将一组操作组合在一起，即支持宏命令。
 * 
 * @author lzhcode
 *
 */
public class ClientForRestaurantDemo {
  public static Byte Lock = 1;
  public static void main(String[] args) {
    // 4个厨师同时开始工作
    CookManager.runCookManager();
    // 一次循环相当于一个订单
    for (int i = 0; i < 5; i++) {
      Waiter waiter = new Waiter();
      ICommand chopCommand = new ChopCommand(i);
      ICommand duckCommand = new DuckCommand(i);
      ICommand porkCommand = new PorkCommand(i);
      waiter.orderDish(chopCommand);
      waiter.orderDish(duckCommand);
      waiter.orderDish(porkCommand);
      waiter.orderOver();
    }
  }
}
package com.lzhsite.technology.designPattern.command.RestaurantDemo;
public class CookManager {
  public static void runCookManager() {
    HotCook cook1 = new HotCook("张三");
    HotCook cook2 = new HotCook("李四");
    ColdCook cook3 = new ColdCook("王五");
    ColdCook cook4 = new ColdCook("钱六");
    Thread thread1 = new Thread(cook1);
    thread1.start();
    Thread thread2 = new Thread(cook2);
    thread2.start();
    Thread thread3 = new Thread(cook3);
    thread3.start();
    Thread thread4 = new Thread(cook4);
    thread4.start();
  }
}

代码附录

https://gitee.com/lzhcode/maven-parent/tree/master/lzh-technology/src/main/java/com/lzhsite/technology/designPattern/command


文章标签：
Java
设计模式
关键词：
Java设计模式
Java设计模式命令模式
设计模式命令模式
Java命令模式
lzhcode
目录
相关文章
小王老师呀
|
25天前
|
设计模式 消息中间件 搜索推荐
Java 设计模式——观察者模式：从优衣库不使用新疆棉事件看系统的动态响应
【11月更文挑战第17天】观察者模式是一种行为设计模式，定义了一对多的依赖关系，使多个观察者对象能直接监听并响应某一主题对象的状态变化。本文介绍了观察者模式的基本概念、商业系统中的应用实例，如优衣库事件中各相关方的动态响应，以及模式的优势和实际系统设计中的应用建议，包括事件驱动架构和消息队列的使用。
小王老师呀
45 6
技术混子
|
1月前
|
设计模式 Java 数据库连接
Java编程中的设计模式：单例模式的深度剖析
【10月更文挑战第41天】本文深入探讨了Java中广泛使用的单例设计模式，旨在通过简明扼要的语言和实际示例，帮助读者理解其核心原理和应用。文章将介绍单例模式的重要性、实现方式以及在实际应用中如何优雅地处理多线程问题。
技术混子
38 4
进步`于辰
|
2月前
|
设计模式 Java 程序员
[Java]23种设计模式
本文介绍了设计模式的概念及其七大原则，强调了设计模式在提高代码重用性、可读性、可扩展性和可靠性方面的作用。文章还简要概述了23种设计模式，并提供了进一步学习的资源链接。
进步`于辰
54 0
[Java]23种设计模式
大数据文摘
|
1月前
|
设计模式 JavaScript Java
Java设计模式：建造者模式详解
建造者模式是一种创建型设计模式，通过将复杂对象的构建过程与表示分离，使得相同的构建过程可以创建不同的表示。本文详细介绍了建造者模式的原理、背景、应用场景及实际Demo，帮助读者更好地理解和应用这一模式。
大数据文摘
48 0
全干程序员demo
|
2月前
|
设计模式 监控 算法
Java设计模式梳理：行为型模式（策略，观察者等）
本文详细介绍了Java设计模式中的行为型模式，包括策略模式、观察者模式、责任链模式、模板方法模式和状态模式。通过具体示例代码，深入浅出地讲解了每种模式的应用场景与实现方式。例如，策略模式通过定义一系列算法让客户端在运行时选择所需算法；观察者模式则让多个观察者对象同时监听某一个主题对象，实现松耦合的消息传递机制。此外，还探讨了这些模式与实际开发中的联系，帮助读者更好地理解和应用设计模式，提升代码质量。
全干程序员demo
81 0
Java设计模式梳理：行为型模式（策略，观察者等）
艾利克斯冰
|
3月前
|
存储 设计模式 安全
Java设计模式-备忘录模式（23）
Java设计模式-备忘录模式（23）
艾利克斯冰
47 3
艾利克斯冰
|
3月前
|
设计模式 存储 算法
Java设计模式-命令模式（16）
Java设计模式-命令模式（16）
艾利克斯冰
39 2
艾利克斯冰
|
3月前
|
设计模式 存储 缓存
Java设计模式 - 解释器模式（24）
Java设计模式 - 解释器模式（24）
艾利克斯冰
40 1
艾利克斯冰
|
3月前
|
设计模式 安全 Java
Java设计模式-迭代器模式（21）
Java设计模式-迭代器模式（21）
艾利克斯冰
35 1
艾利克斯冰
|
3月前
|
设计模式 缓存 监控
Java设计模式-责任链模式（17）
Java设计模式-责任链模式（17）
艾利克斯冰
61 1

热门文章

最新文章

  • 1
    3、Python与设计模式--建造者模式
  • 2
    设计模式之禅之六大设计原则-迪米特原则
  • 3
    [浪子学编程][MS Enterprise Library]ObjectBuilder之设计模式(一)：策略模式
  • 4
    MapReduce设计模式学习
  • 5
    学习设计模式之单例模式
  • 6
    【设计模式】—— 模板方法Template
  • 7
    【HeadFirst 设计模式学习笔记】5 单例模式
  • 8
    设计模式-限制性多例模式
  • 9
    Java并发编程中的设计模式解析(一)
  • 10
    云计算设计模式（四）——消费者的竞争模式
  • 1
    【Java开发指南 | 第三十一篇】Java 包(package)
    80
  • 2
    【Java开发指南 | 第二十九篇】Java接口
    48
  • 3
    【Java开发指南 | 第二十八篇】Java封装
    53
  • 4
    【Java开发指南 | 第二十六篇】Java多态
    40
  • 5
    【Java开发指南 | 第二十四篇】Java继承
    61
  • 6
    【Java开发指南 | 第九篇】访问实例变量和方法、继承、接口
    57
  • 7
    【Java开发指南 | 第八篇】Java变量、构造方法、创建对象
    93
  • 8
    Java Stream API详解与使用
    96
  • 9
    Java医院绩效考核系统源码B/S+avue+MySQL助力医院实现精细化管理
    82
  • 10
    《手把手教你》系列技巧篇（四十三）-java+ selenium自动化测试-处理https 安全问题或者非信任站点-上篇（详解教程）
    134

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    【案例实战】SpringBoot整合阿里云文件上传OSS