一天一模式之12命令模式

最新推荐文章于 2023-06-30 08:50:22 发布

天空鸟_时光不老

最新推荐文章于 2023-06-30 08:50:22 发布

阅读量307

点赞数

分类专栏：设计模式文章标签：命令命令池

本文链接：https://blog.csdn.net/KongZhongNiao/article/details/80480910

版权

本文详细介绍了命令模式的概念、结构和应用场景。通过实例展示了如何使用命令模式来实现开机过程，强调了命令模式的核心是封装请求，并讨论了如何通过命令模式实现可撤销操作和宏命令。此外，还探讨了命令模式在参数化配置、队列请求和日志请求中的应用，以及其优缺点和适用场景。

摘要由CSDN通过智能技术生成

初识命令模式

定义

将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数
化；对请求排队或记录请求日志，以及支持可撤销的操作。

结构和说明

Command：

定义命令的接口，声明执行的方法。

ConcreteCommand：

命令接口实现对象，是“虚”的实现；通常会持有接收者，并调用接收者
的功能来完成命令要执行的操作。

Receiver：

接收者，真正执行命令的对象。任何类都可能成为一个接收者，只要它能
够实现命令要求实现的相应功能。

Invoker：

要求命令对象执行请求，通常会持有命令对象，可以持有很多的命令对
象。这个是客户端真正触发命令并要求命令执行相应操作的地方，也就是说相当
于使用命令对象的入口。

Client：

创建具体的命令对象，并且设置命令对象的接收者。注意这个不是我们常
规意义上的客户端，而是在组装命令对象和接收者，或许，把这个Client称为装
配者会更好理解，因为真正使用命令的客户端是从Invoker来触发执行。

示例代码

命令接口，声明执行的操作

package cn.javass.dp.command.example1;
/**
 * 命令接口，声明执行的操作
 */
public interface Command {
   
    /**
     * 执行命令对应的操作
     */
    public void execute();
}

具体的命令实现对象

package cn.javass.dp.command.example1;
/**
 * 具体的命令实现对象
 */
public class ConcreteCommand implements Command {
   
    /**
     * 持有相应的接受者对象
     */
    private Receiver receiver = null;
    /**
     * 示意，命令对象可以有自己的状态
     */
    private String state;
    /**
     * 构造方法，传入相应的接受者对象
     * @param receiver 相应的接受者对象
     */
    public ConcreteCommand(Receiver receiver){
        this.receiver = receiver;
    }

    public void execute() {
        //通常会转调接受者对象的相应方法，让接受者来真正执行功能
        receiver.action();
    }

}

接收者对象

package cn.javass.dp.command.example1;
/**
 * 接收者对象
 */
public class Receiver {
   
    /**
     * 示意方法，真正执行命令相应的操作
     */
    public void action(){
        //真正执行命令操作的功能代码
    }
}

调用者

package cn.javass.dp.command.example1;
/**
 * 调用者
 */
public class Invoker {
   
    /**
     * 持有命令对象
     */
    private Command command = null;
    /**
     * 设置调用者持有的命令对象
     * @param command 命令对象
     */
    public void setCommand(Command command) {
        this.command = command;
    }
    /**
     * 示意方法，要求命令执行请求
     */
    public void runCommand() {
        //调用命令对象的执行方法
        command.execute();
    }
}

示意，负责创建命令对象，并设定它的接受者

package cn.javass.dp.command.example1;

public class Client {
   
    /**
     * 示意，负责创建命令对象，并设定它的接受者
     */
    public void assemble(){
        //创建接受者
        Receiver receiver = new Receiver();
        //创建命令对象，设定它的接收者
        Command command = new ConcreteCommand(receiver);
        //创建Invoker，把命令对象设置进去
        Invoker invoker = new Invoker();
        invoker.setCommand(command);
    }
}

体会命令模式

如何开机

当我们按下启动按钮过后呢？谁来处理？如何处理？都经历了怎样的过

程，才让电脑真正的启动起来，供我们使用呢？
如果现在要求用软件把开机的过程表现出来，该如何实现？

首先把开机的过程总结一下，主要就这么几个步骤：首先加载电源，然后
是设备检查，再然后是装载系统，最后电脑就正常启动了。可是谁来完成这些过
程？如何完成？

不能让使用电脑的客户——就是我们来做这些工作吧，真正完成这些工作
的是主板，那么客户和主板如何发生联系呢？现实中，是用连接线把按钮连接到
主板上的，这样当客户按下按钮的时候，就相当于发命令给主板，让主板去完成
后续的工作。

另外，从客户的角度来看，开机就是按下按钮，不管什么样的主板都是一
样的，也就是说，客户只管发出命令，谁接收命令，谁实现命令，如何实现，客
户是不关心的。

有何问题

把上面的问题抽象描述一下：客户端只是想要发出命令或者请求，不关心

请求的真正接收者是谁，也不关心具体如何实现，而且同一个请求的动作可以有
不同的请求内容，当然具体的处理功能也不一样，请问该怎么实现？

使用模式的解决方案

使用模式解决问题的思路

看看实际的电脑是如何处理上面描述的这个问题的

要用程序来解决上面提出的问题，一种自然的方案就是来模拟上述解决思路
在命令模式中，会定义一个命令的接口，用来约束所有的命令对象，每个命令实现
对象是对客户端某个请求的封装，对应于机箱上的按钮，一个机箱上可以有很多按钮，也
就相当于会有多个具体的命令实现对象。

在命令模式中，命令对象并不知道如何处理命令，会有相应的接收者对象来真正执
行命令。就像电脑的例子，机箱上的按钮并不知道如何处理功能，而是把这个请求转发给
主板，由主板来执行真正的功能，这个主板就相当于命令模式的接收者。

在命令模式中，命令对象和接收者对象的关系，并不是与生俱来的，需要有一个装
配的过程，命令模式中的Client对象就来实现这样的功能。这就相当于在电脑的例子中，
有了机箱上的按钮，也有了主板，还需要有一个连接线把这个按钮连接到主板上才行。

命令模式还会提供一个Invoker对象来持有命令对象，就像电脑的例子，机箱上会有
多个按钮，这个机箱就相当于命令模式的Invoker对象。

这样一来，命令模式的客户端就可
以通过Invoker来触发并要求执行相应的命令了，这也相当于真正的客户是按下机箱上的按
钮来操作电脑一样。

使用模式的解决方案的类图

示例代码

主板的接口

package cn.javass.dp.command.example2;
/**
 * 主板的接口
 */
public interface MainBoardApi {
   
    /**
     * 主板具有能开机的功能
     */
    public void open();
}

技嘉主板类，开机命令的真正实现者，在Command模式中充当Receiver

package cn.javass.dp.command.example2;
/**
 * 技嘉主板类，开机命令的真正实现者，在Command模式中充当Receiver
 */
public class GigaMainBoard implements MainBoardApi{
   
    /**
     * 真正的开机命令的实现
     */
    public void open(){
        System.out.println("技嘉主板现在正在开机，请等候");
        System.out.println("接通电源......");
        System.out.println("设备检查......");
        System.out.println("装载系统......");
        System.out.println("机器正常运转起来......");
        System.out.println("机器已经正常打开，请操作");
    }
}

微星主板类，开机命令的真正实现者，在Command模式中充当Receiver

package cn.javass.dp.command.example2;
/**
 * 微星主板类，开机命令的真正实现者，在Command模式中充当Receiver
 */
public class MsiMainBoard implements MainBoardApi{
   
    /**
     * 真正的开机命令的实现
     */
    public void open(){
        System.out.println("微星主板现在正在开机，请等候");
        System.out.println("接通电源......");
        System.out.println("设备检查......");
        System.out.println("装载系统......");
        System.out.println("机器正常运转起来......");
        System.out.println("机器已经正常打开，请操作");
    }
}

命令接口，声明执行的操作

package cn.javass.dp.command.example2;
/**
 * 命令接口，声明执行的操作
 */
public interface Command {
   
    /**
     * 执行命令对应的操作
     */
    public void execute();
}

开机命令的实现，实现Command接口，

package cn.javass.dp.command.example2;
/**
 * 开机命令的实现，实现Command接口，
 * 持有开机命令的真正实现，通过调用接收者的方法来实现命令
 */
public class OpenCommand implements Command{
   
    /**
     * 持有真正实现命令的接收者——主板对象
     */
    private MainBoardApi mainBoard = null;
    /**
     * 构造方法，传入主板对象
     * @param mainBoard 主板对象
     */
    public OpenCommand(MainBoardApi mainBoard) {
        this.mainBoard = mainBoard;
    }

    public void execute() {
        //对于命令对象，根本不知道如何开机，会转调主板对象
        //让主板去完成开机的功能
        this.mainBoard.open();
    }
}

机箱对象，本身有按钮，持有按钮对应的命令对象

package cn.javass.dp.command.example2;
/**
 * 机箱对象，本身有按钮，持有按钮对应的命令对象
 */
public class Box {
   
    /**
     * 开机命令对象
     */
    private Command openCommand;
    /**
     * 设置开机命令对象
     * @param command 开机命令对象
     */
    public void setOpenCommand(Command command){
        this.openCommand = command;
    }
    /**
     * 提供给客户使用，接受并相应用户请求，相当于按钮被按下触发的方法
     */
    public void openButtonPressed(){
        //按下按钮，执行命令
        openCommand.execute();
    }
}

连线、组装、客户端

package cn.javass.dp.command.example2;

public class Client {
    public static void main(String[] args) {
        //1：把命令和真正的实现组合起来，相当于在组装机器，
        //把机箱上按钮的连接线插接到主板上。
        MainBoardApi mainBoard = new MsiMainBoard();
        OpenCommand openCommand = new OpenCommand(mainBoard);


        //真正的客户端测试

        //2：为机箱上的按钮设置对应的命令，让按钮知道该干什么
        Box box = new Box();
        box.setOpenCommand(openCommand);

        //3：然后模拟按下机箱上的按钮
        box.openButtonPressed();
    }
}

理解命令模式

认识命令模式

1：命令模式的关键

命令模式的关键之处就是把请求封装成为对象，也就是命令对象，并定义
了统一的执行操作的接口，这个命令对象可以被存储、转发、记录、处理、撤销
等，整个命令模式都是围绕这个对象在进行。

2：命令模式的组装和调用

在命令模式中经常会有一个命令的组装者，用它来维护命令的“虚”实现
和真实实现之间的关系。如果是超级智能的命令，也就是说命令对象自己完全实
现好了，不需要接收者，那就是命令模式的退化，不需要接收者，自然也不需要
组装者了。

而真正的用户就是具体化请求的内容，然后提交请求进行触发就好了。真
正的用户会通过invoker来触发命令。

在实际开发中，Client和Invoker可以融合在一起，由客户在使用命令模式
时，先进行命令对象和接收者的组装，组装完成后，再调用命令执行请求。

3：命令模式的接收者

接收者可以是任意的类，对它没有什么特殊要求，这个对象知道如何真正

执行命令的操作，执行时是从command的实现类里面转调过来。

一个接收者对象可以处理多个命令，接收者和命令之间没有约定的对应关
系。接收者提供的方法个数、名称、功能和命令中的可以不一样，只要能够通过
调用接收者的方法来实现命令对应的功能就可以了。

4：智能命令

在标准的命令模式里面，命令的实现类是没有真正实现命令要求的功能

的，真正执行命令的功能的是接收者。

如果命令的实现对象比较智能，它自己就能真实地实现命令要求的功能，
而不再需要调用接收者，那么这种情况就称为智能命令。

也可以有半智能的命令，命令对象知道部分实现，其它的还是需要调用接
收者来完成，也就是说命令的功能由命令对象和接收者共同来完成。

5：发起请求的对象和真正实现的对象是解耦的

请求究竟由谁处理，如何处理，发起请求的对象是不知道的，也就是发起

请求的对象和真正实现的对象是解耦的。发起请求的对象只管发出命令，其它的
就不管了。

6：命令模式的调用顺序示意图

使用命令模式的过程分成两个阶段，一个阶段是组装命令对象和接收者对
象的过程，另外一个阶段是触发调用Invoker，来让命令真正执行的过程。

再看看真正执行命令时的调用顺序示意图

示例代码

添加一个重启按钮

主板的接口

package cn.javass.dp.command.example3;
/**
 * 主板的接口
 */
public interface MainBoardApi {
   
    /**
     * 主板具有能开机的功能
     */
    public void open();
    /**
     * 主板具有实现重启的功能
     */
    public void reset();
}

技嘉主板类，命令的真正实现者，在Command模式中充当Receiver

package cn.javass.dp.command.example3;
/**
 * 技嘉主板类，命令的真正实现者，在Command模式中充当Receiver
 */
public class GigaMainBoard implements MainBoardApi{
   
    /**
     * 真正的开机命令的实现
     */
    public void open(){
        System.out.println("技嘉主板现在正在开机，请等候");
        System.out.println("接通电源......");
        System.out.println("设备检查......");
        System.out.println("装载系统......");
        System.out.println("机器正常运转起来......");
        System.out.println("机器已经正常打开，请操作");
    }
    /**
     * 真正的重新启动机器命令的实现
     */
    public void