自学内容网 自学内容网
自学内容网 > 正文

命令设计模式

🕗 发布于 2024-10-09 14:56 命令模式  

简介

命令模式（Command Pattern）是对命令的封装，每一个命令都是一个操作：请求方发出请求要求执行一个操作；接收方收到请求，并执行操作。命令模式解耦了请求方和接收方，请求方只需请求执行命令，不用关心命令怎样被接收、怎样被操作及是否被执行等。命令模式属于行为型设计模式。

通用模板

  1. 创建接收者角色：该类负责具体实施或执行一个请求。

    // 接收者
public class Receiver {
    public void action() {
        System.out.println("执行具体操作");
    }
}

  2. 创建抽象命令角色：定义需要执行的所有命令行为。

    // 抽象命令接口
public interface ICommand {
    void execute();
}

  3. 创建具体命令角色：该类内部维护一个Receiver，在其execute（）方法中调用Receiver的相关方法。

    // 具体命令
public class ConcreteCommand implements ICommand {
    // 直接创建接收者，不暴露给客户端
    private Receiver receiver = new Receiver();

    @Override
    public void execute() {
        this.receiver.action();
    }
}

  4. 创建请求者角色：接收客户端的命令，并执行命令。

    // 请求者
public class Invoker {
    private ICommand cmd;

    public Invoker(ICommand cmd) {
        this.cmd = cmd;
    }

    public void action(){
        this.cmd.execute();
    }
}

模板测试

  1. 测试代码
    public class Client {
    public static void main(String[] args) {
        ConcreteCommand cmd = new ConcreteCommand();
        Invoker invoker = new Invoker(cmd);
        invoker.action();
    }
}
  2. 测试结果
    执行具体操作

应用场景

在日常生活中，命令模式是很常见的。比如，经历过黑白电视机年代的小伙伴应该都有过这样的经历。那个年代在看电视的时候，想要换个频道简直不容易。我们得走到电视机前扭动换台的旋钮，一顿“咔咔咔”折腾才能完成频道的切换。如今，遥控器的发明简直就是“解放战争”，我们躺在沙发上只需要轻轻一按遥控器即可完成频道的切换。这就是命令模式，将换台请求和换台处理完全解耦了。
当系统的某项操作具备命令语义，且命令实现不稳定（变化）时，可以通过命令模式解耦请求与实现，使用抽象命令接口使请求方的代码架构稳定，封装接收方具体命令的实现细节。接收方与抽象命令接口呈现弱耦合（内部方法无须一致），具备良好的扩展性。命令模式主要适用于以下应用场景。 （1）现实语义中具备“命令”的操作（如命令菜单、Shell命令等）。
（2）请求的调用者和接收者需要解耦，使得调用者和接收者不直接交互。
（3）需要抽象出等待执行的行为，比如撤销（Undo）操作和恢复（Redo）等操作。
（4）需要支持命令宏（即命令组合操作）。

优点

（1）通过引入中间件（抽象接口），解耦了命令请求与实现。
（2）扩展性良好，可以很容易地增加新命令。
（3）支持组合命令，支持命令队列。
（4）可以在现有命令的基础上，增加额外功能。比如日志记录，结合装饰器模式会更加灵活。

缺点

（1）具体命令类可能过多。
（2）命令模式的结果其实就是接收方的执行结果，但是为了以命令的形式进行架构、解耦请求与实现，引入了额外类型结构（引入了请求方与抽象命令接口），增加了理解上的困难。不过这也是设计模式的通病，抽象必然会额外增加类的数量；代码抽离肯定比代码聚合更难理解。

“生搬硬套”实战

场景描述

我们可以用一个遥控器控制家用电器（如电灯）作为例子。在这个场景中，遥控器是发出命令的对象，而家用电器则是执行命令的对象。

代码开发

  1. 创建接收者角色（这里指的是实际执行的对象灯）

    // 定义接收者类，即实际执行动作的对象——Light
public class Light {
    public void turnOn() {
        System.out.println("Light is on");
    }

    public void turnOff() {
        System.out.println("Light is off");
    }
}

  2. 创建抽象命令角色：（这里指的是抽象命令接口，定义执行和取消操作）

    // 定义一个命令接口
public interface ICommand {
    void execute();

    void undo();
}

  3. 创建具体命令角色（这里指的是开灯和关灯的具体命令实现类）

    // 具体的开灯命令类
public class LightOnCommand implements ICommand{
    private final Light light;

    public LightOnCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.turnOn();
    }

    @Override
    public void undo() {
        light.turnOff();
    }
}

    // 具体关灯命令类
public class LightOffCommand implements ICommand {
    private final Light light;

    public LightOffCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.turnOff();
    }

    @Override
    public void undo() {
        light.turnOn();
    }
}

  4. 创建请求者角色（这里指的就是遥控器）

    // 定义一个调用者——遥控器类，它将保存命令并执行
public class RemoteControl {
    private ICommand command;

    public void setCommand(ICommand command) {
        this.command = command;
    }

    public void pressButton() {
        command.execute();
    }

    public void undo() {
        command.undo();
    }
}

至此，我们就通过“生搬硬套”命令模式的模板设计出一套遥控器开关灯的案例，接下来我们进行测试：

  • 测试代码

    public class Client {
    public static void main(String[] args) {
        Light light = new Light();
        RemoteControl remote = new RemoteControl();

        // 设置打开电灯的命令
        remote.setCommand(new LightOnCommand(light));
        remote.pressButton(); // 执行命令：打开电灯
        remote.undo(); // 撤销命令：关闭电灯

        // 设置关闭电灯的命令
        remote.setCommand(new LightOffCommand(light));
        remote.pressButton(); // 执行命令：关闭电灯
        remote.undo(); // 撤销命令：打开电灯
    }
}

  • 测试结果

    Light is on
Light is off
Light is off
Light is on
场景描述2

假如我们开发一个播放器，播放器有播放功能、拖动进度条功能、停止播放功能、暂停功能，我们在操作播放器的时候并不是直接调用播放器的方法，而是通过一个控制条去传达指令给播放器内核，具体传达什么指令，会被封装为一个个按钮。那么每个按钮就相当于对一条命令的封装。用控制条实现了用户发送指令与播放器内核接收指令的解耦。

代码开发2

  1. 创建接收者角色（这里指的是实际执行的对象播放器）

    // 定义接收者类，即实际执行动作的对象——播放器
public class GPlayer {
    public void play() {
        System.out.println("正常播放");
    }

    public void speed() {
        System.out.println("拖动进度条");
    }

    public void stop() {
        System.out.println("停止播放");
    }

    public void pause() {
        System.out.println("暂停播放");
    }
}

  2. 创建抽象命令角色：（这里指的是抽象命令接口，定义执行命令操作）

    // 定义一个命令接口
public interface IAction {
    void execute();
}

  3. 创建具体命令角色（这里指的是播放、暂停、停止、加速具体命令实现类）

    // 具体的播放命令
public class PlayAction implements IAction {
    private GPlayer player;

    public PlayAction(GPlayer player) {
        this.player = player;
    }

    @Override
    public void execute() {
        player.play();
    }
}

    // 具体的暂停命令
public class PauseAction implements IAction {
    private GPlayer player;

    public PauseAction(GPlayer player) {
        this.player = player;
    }

    @Override
    public void execute() {
        player.pause();
    }
}

    // 具体的停止命令
public class StopAction implements IAction {
    private GPlayer player;

    public StopAction(GPlayer player) {
        this.player = player;
    }

    @Override
    public void execute() {
        player.stop();
    }
}

    // 具体的拖动进度条命令
public class SpeedAction implements IAction {
    private GPlayer player;

    public SpeedAction(GPlayer player) {
        this.player = player;
    }

    @Override
    public void execute() {
        player.speed();
    }
}

  4. 创建请求者角色（这里指的就是播放器控制面板）

    import java.util.ArrayList;
import java.util.List;

// 定义一个调用者——控制面板类，它将保存命令并执行
public class Controller {
    private List<IAction> actions = new ArrayList<>();

    public void addAction(IAction action) {
        actions.add(action);
    }


    public void execute(IAction action) {
        action.execute();
    }

    public void executes() {
        for (IAction action : actions) {
            action.execute();
        }
        actions.clear();
    }
}

至此，我们就通过“生搬硬套”命令模式的模板设计出一套通过播放器控制面板上的按钮来控制播放器的案例，接下来我们进行测试：

  • 代码测试
    public class Client {
    public static void main(String[] args) {
        GPlayer player = new GPlayer();
        Controller controller = new Controller();
        controller.execute(new PlayAction(player));

        controller.addAction(new PauseAction(player));
        controller.addAction(new PlayAction(player));
        controller.addAction(new StopAction(player));
        controller.addAction(new SpeedAction(player));

        controller.executes();
    }
}
  • 测试结果
    正常播放
暂停播放
正常播放
停止播放
拖动进度条

总结

在软件系统中，行为请求者与行为实现者通常是一种紧耦合关系，因为这样的实现简单明了。但紧耦合关系缺乏扩展性，在某些场合中，当需要对行为进行记录、撤销或重做等处理时，只能修改源码。而命令模式通过在请求与实现间引入一个抽象命令接口，解耦了请求与实现，并且中间件是抽象的，它由不同的子类实现，因此具备扩展性。所以，命令模式的本质是解耦命令请求与处理。


原文地址：https://blog.csdn.net/Android_xue/article/details/142758068

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

相关文章

  • Vue3学习（一）

    ref创建的变量必须要用.value的方式去获取和修改数据reactive重新分配一个新对象，会失去响应式，要想不失去响应式，可以使用Object.assign(变量名,新对象) 的方式，给目标变量一

    阅读更多2024-10-09
  • 倪师学习笔记-天纪-01

    神与形对应，形是神的实例，神是形的规律总结概括。把握时机，引导事情向期望的方向发展。介绍课程内容，介绍部分概念。

    阅读更多2024-10-09
  • Springboot配置优先级

    在SpringBoot项目当中，我们要想配置一个属性，可以通过这五种方式当中的任意一种来配置都可 以，那么如果项目中同时存在这五种配置文件，且都配置了同一个属性，如：Tomcat端口号，到底哪一份配置

    阅读更多2024-10-09
  • 【小白向】机器人入门之ROS系统的学习（Ubuntu24.04+ROS2）

    而提到软件部分，我们就不得不提到一个在机器人领域不可避免的系统——ROS系统。ROS就是传说中的机器人操作系统（Robot Operating System），但其本身并不是一个操作系统，而是可以安装

    阅读更多2024-10-09
  • 【JS】requestIdleCallback实现分块执行

    【JS】requestIdleCallback实现分块执行

    阅读更多2024-10-09
  • Spring对IOC的实现

    控制反转IOC+ 控制反转是一种思想+ 控制反转是为了降低程序耦合度，提高程序扩展力，达到OCP原则，达到DIP原则+ 控制反转，反转是什么？ - 将对象的创建权利交出去，交给第三方容器负责

    阅读更多2024-10-09
  • 智融SW3566DC/DC+快充协议二合一IC

    SW3566 是一款高集成度的多快充协议双口充电SOC芯片，支持C+C/A+C/A+A口任意口快充输出， 支持双口独立限流。其集成了7A高效率同步降压变换器，支持PD3.1/QC/SCP/UFCS 等

    阅读更多2024-10-09
  • SpringBoot框架下的教育系统开发全解析

    同时，一个大型的计算机网站系统，必须有一个正确的设计指导思想，通过合理选择数据结构、网络结构、操作系统以及开发环境，构成一个完善的网络体系结构，才能充分发挥计算机信息管理的优势。目前，界面设计已经成为

    阅读更多2024-10-09
  • ClickHouse性能调优 - 当磁盘IO是瓶颈的时候

    ClickHouse的性能调优问题是一个大的话题。虽然ClickHouse以其高速的数据处理能力而闻名，但在实际使用中，磁盘IO常常成为影响系统性能的瓶颈。本文将探讨在磁盘IO成为瓶颈时，如何通过一系

    阅读更多2024-10-09
  • Java之方法的使用

    修饰符 返回值 方法名称（形式参数）{当无参数的时候形式参数中什么都不写。

    阅读更多2024-10-09
自学内容网
Copyright © 2015-2024