一天一模式之12命令模式

已于 2022-05-20 14:19:23 修改
阅读量415 收藏
点赞数 1
分类专栏： 设计模式 文章标签： 命令模式
于 2019-04-19 23:14:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kt1776133839/article/details/89409743
版权

原博文：https://blog.csdn.net/KongZhongNiao/article/details/80480910

定义

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

结构和说明

Command：

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

ConcreteCommand：

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

Receiver：

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

Invoker：

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

Client：

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

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

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
具体的命令实现对象
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();
    }

}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
接收者对象
package cn.javass.dp.command.example1;
/**
 * 接收者对象
 */
public class Receiver {
    /**
     * 示意方法，真正执行命令相应的操作
     */
    public void action(){
        //真正执行命令操作的功能代码
    }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
调用者
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();
    }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
示意，负责创建命令对象，并设定它的接受者
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);
    }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

体会命令模式

如何开机

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

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

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

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

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

有何问题

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

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

使用模式的解决方案

使用模式解决问题的思路

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

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

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

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

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

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

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

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

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
技嘉主板类，开机命令的真正实现者，在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("机器已经正常打开，请操作");
    }
}
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
微星主板类，开机命令的真正实现者，在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("机器已经正常打开，请操作");
    }
}
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
命令接口，声明执行的操作
package cn.javass.dp.command.example2;
/**
 * 命令接口，声明执行的操作
 */
public interface Command {
    /**
     * 执行命令对应的操作
     */
    public void execute();
}
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
开机命令的实现，实现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();
    }
}
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
机箱对象，本身有按钮，持有按钮对应的命令对象
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();
    }
}
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
连线、组装、 客户端
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
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

理解命令模式

认识命令模式

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();
}
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
技嘉主板类，命令的真正实现者，在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 reset(){
        System.out.println("技嘉主板现在正在重新启动机器，请等候");
        System.out.println("机器已经正常打开，请操作");
    }
}
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
微星主板类，命令的真正实现者，在Command模式中充当Receiver
package cn.javass.dp.command.example3;
/**
 * 微星主板类，命令的真正实现者，在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("机器已经正常打开，请操作");
    }
    /**
     * 真正的重新启动机器命令的实现
     */
    public void reset(){
        System.out.println("微星主板现在正在重新启动机器，请等候");
        System.out.println("机器已经正常打开，请操作");
    }
}
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
命令接口，声明执行的操作
package cn.javass.dp.command.example3;
/**
 * 命令接口，声明执行的操作
 */
public interface Command {
    /**
     * 执行命令对应的操作
     */
    public void execute();
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
开机命令的实现，实现Command接口，
package cn.javass.dp.command.example3;
/**
 * 开机命令的实现，实现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();
    }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
重启机器命令的实现，实现Command接口，
package cn.javass.dp.command.example3;
/**
 * 重启机器命令的实现，实现Command接口，
 * 持有重启机器命令的真正实现，通过调用接收者的方法来实现命令
 */
public class ResetCommand implements Command{
    /**
     * 持有真正实现命令的接收者——主板对象
     */
    private MainBoardApi mainBoard = null;
    /**
     * 构造方法，传入主板对象
     * @param mainBoard 主板对象
     */
    public ResetCommand(MainBoardApi mainBoard) {
        this.mainBoard = mainBoard;
    }

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

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
机箱对象，本身有按钮，持有按钮对应的命令对象
package cn.javass.dp.command.example3;

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

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
组合、客户端
package cn.javass.dp.command.example3;

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

        //2：为机箱上的按钮设置对应的命令，让按钮知道该干什么
        Box box = new Box();
        //先正确配置，就是开机按钮对开机命令，重启按钮对重启命令
        box.setOpenCommand(openCommand);
        box.setResetCommand(resetCommand);

        //3：然后模拟按下机箱上的按钮
        System.out.println("正确配置下------------------------->");
        System.out.println(">>>按下开机按钮：>>>");
        box.openButtonPressed();
        System.out.println(">>>按下重启按钮：>>>");
        box.resetButtonPressed();

        //然后来错误配置一回，反正是进行参数化配置
        //就是开机按钮对重启命令，重启按钮对开机命令
        box.setOpenCommand(resetCommand);
        box.setResetCommand(openCommand);
        //4：然后还是来模拟按下机箱上的按钮
        System.out.println("错误配置下------------------------->");
        System.out.println(">>>按下开机按钮：>>>");
        box.openButtonPressed();
        System.out.println(">>>按下重启按钮：>>>");
        box.resetButtonPressed();
    }
}
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37

参数化配置

所谓命令模式的参数化配置，指的是：**可以用不同的命令对象，去参数化

配置客户的请求。**

像前面描述的那样：客户按下一个按钮，到底是开机还是重启，那要看参

数化配置的是哪一个具体的按钮对象，如果参数化的是开机的命令对象，那就执
行开机的功能，如果参数化的是重启的命令对象，那就执行重启的功能。

虽然按
下的是同一个按钮，相当于是同一个请求，但是为请求配置不同的按钮对象，那
就会执行不同的功能。

可撤销的操作

可撤销操作的意思就是：放弃该操作，回到未执行该操作前的状态。

这是

一个非常重要的功能，几乎所有GUI应用里都有撤消操作的功能。GUI的菜单是命
令模式最典型的应用之一，所以你总是能在菜单上找到撤销这样的菜单项。
既然这么常用，那该如何实现呢？

有两种基本的思路来实现可撤销的操作，一种是补偿式，又称反操作式：
比如被撤销的操作是加的功能，那撤消的实现就变成减的功能；同理被撤销的操
作是打开的功能，那么撤销的实现就变成关闭的功能。

另外一种方式是存储恢复式，意思就是把操作前的状态记录下来，然后要
撤销操作的时候就直接恢复回去就可以了。

这里先讲第一种方式，就是补偿式或者反操作式，第二种方式放到备忘录
模式中去讲解

范例需求

考虑一个计算器的功能，最简单的那种，只能实现加减法运算，现在要让

这个计算器支持可撤销的操作。

示例代码

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

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
具体的加法命令实现对象
package cn.javass.dp.command.example4;
/**
 * 具体的加法命令实现对象
 */
public class AddCommand implements Command{
    /**
     * 持有具体执行计算的对象
     */
    private OperationApi operation = null;
    /**
     * 操作的数据，也就是要加上的数据
     */
    private int opeNum;
    /**
     * 构造方法，传入具体执行计算的对象
     * @param operation 具体执行计算的对象
     * @param opeNum 要加上的数据
     */
    public AddCommand(OperationApi operation,int opeNum){
        this.operation = operation;
        this.opeNum = opeNum;
    }

    public void execute() {
        //转调接收者去真正执行功能，这个命令是做加法
        this.operation.add(opeNum);
    }

    public void undo() {
        //转调接收者去真正执行功能
        //命令本身是做加法，那么撤销的时候就是做减法了
        this.operation.substract(opeNum);
    }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
具体的减法命令实现对象
package cn.javass.dp.command.example4;
/**
 * 具体的减法命令实现对象
 */
public class SubstractCommand implements Command{
    /**
     * 持有具体执行计算的对象
     */
    private OperationApi operation = null;
    /**
     * 操作的数据，也就是要减去的数据
     */
    private int opeNum;
    /**
     * 构造方法，传入具体执行计算的对象
     * @param operation 具体执行计算的对象
     * @param opeNum 要减去的数据
     */
    public SubstractCommand(OperationApi operation,int opeNum){
        this.operation = operation;
        this.opeNum = opeNum;
    }   

    public void execute() {
        //转调接收者去真正执行功能，这个命令是做减法
        this.operation.substract(opeNum);
    }

    public void undo() {
        //转调接收者去真正执行功能
        //命令本身是做减法，那么撤销的时候就是做加法了
        this.operation.add(opeNum);
    }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
操作运算的接口
package cn.javass.dp.command.example4;
/**
 * 操作运算的接口
 */
public interface OperationApi {
    /**
     * 获取计算完成后的结果
     * @return 计算完成后的结果
     */
    public int getResult();
    /**
     * 设置计算开始的初始值
     * @param result 计算开始的初始值
     */
    public void setResult(int result);
    /**
     * 执行加法
     * @param num 需要加的数
     */
    public void add(int num);
    /**
     * 执行减法
     * @param num 需要减的数
     */
    public void substract(int num);
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
运算类，真正实现加减法运算
package cn.javass.dp.command.example4;
/**
 * 运算类，真正实现加减法运算
 */
public class Operation implements OperationApi{
    /**
     * 记录运算的结果
     */
    private int result;
    public int getResult() {
        return result;
    }
    public void setResult(int result) {
        this.result = result;
    }

    public void add(int num){
        //实现加法功能
        result += num;
    }
    public void substract(int num){
        //实现减法功能
        result -= num;
    }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
计算器类，计算器上有加法按钮、减法按钮，还有撤销和恢复的按钮
package cn.javass.dp.command.example4;
import java.util.*;
/**
 * 计算器类，计算器上有加法按钮、减法按钮，还有撤销和恢复的按钮
 */
public class Calculator {
    /**
     * 命令的操作的历史记录，在撤销时候用
     */
    private List<Command> undoCmds = new ArrayList<Command>();
    /**
     * 命令被撤销的历史记录，在恢复时候用
     */
    private List<Command> redoCmds = new ArrayList<Command>();

    private Command addCmd = null;
    private Command substractCmd = null;
    public void setAddCmd(Command addCmd) {
        this.addCmd = addCmd;
    }
    public void setSubstractCmd(Command substractCmd) {
        this.substractCmd = substractCmd;
    }   
    public void addPressed(){
        this.addCmd.execute();
        //把操作记录到历史记录里面
        undoCmds.add(this.addCmd);
    }
    public void substractPressed(){
        this.substractCmd.execute();
        //把操作记录到历史记录里面
        undoCmds.add(this.substractCmd);
    }
    public void undoPressed(){
        if(this.undoCmds.size()>0){
            //取出最后一个命令来撤销
            Command cmd = this.undoCmds.get(this.undoCmds.size()-1);
            cmd.undo();
            //如果还有恢复的功能，那就把这个命令记录到恢复的历史记录里面
            this.redoCmds.add(cmd );
            //然后把最后一个命令删除掉，
            this.undoCmds.remove(cmd);
        }else{
            System.out.println("很抱歉，没有可撤销的命令");
        }
    }
    public void redoPressed(){
        if(this.redoCmds.size()>0){
            //取出最后一个命令来重做
            Command cmd = this.redoCmds.get(this.redoCmds.size()-1);
            cmd.execute();      
            //把这个命令记录到可撤销的历史记录里面
            this.undoCmds.add(cmd);
            //然后把最后一个命令删除掉
            this.redoCmds.remove(cmd);
        }else{
            System.out.println("很抱歉，没有可恢复的命令");
        }
    }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
组装命令和接收者
package cn.javass.dp.command.example4;

public class Client {
    public static void main(String[] args) {
        //1：组装命令和接收者
        //创建接收者
        OperationApi operation = new Operation();
        //创建命令对象，并组装命令和接收者
        AddCommand addCmd = new AddCommand(operation,5);
        SubstractCommand substractCmd = new SubstractCommand(operation,3);

        //2：把命令设置到持有者，就是计算器里面
        Calculator calculator = new Calculator();
        calculator.setAddCmd(addCmd);
        calculator.setSubstractCmd(substractCmd);

        //3:模拟按下按钮，测试一下
        calculator.addPressed();
        System.out.println("一次加法运算后的结果为："+operation.getResult());
        calculator.substractPressed();
        System.out.println("一次减法运算后的结果为："+operation.getResult());

        //测试撤消
        calculator.undoPressed();
        System.out.println("撤销一次后的结果为："+operation.getResult());
        calculator.undoPressed();
        System.out.println("再撤销一次后的结果为："+operation.getResult());

        //测试恢复
        calculator.redoPressed();
        System.out.println("恢复操作一次后的结果为："+operation.getResult());
        calculator.redoPressed();
        System.out.println("再恢复操作一次后的结果为："+operation.getResult());
    }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36

宏命令

简单点说就是包含多个命令的命令，是一个命令的组合。

举个例子来说吧，设想一下你去饭店吃饭的过程：

1：宏命令在哪里？

现实中是当你你点完菜，说“点完了”的时候，服务员才会启动命令的执
行，请注意，这个时候执行的就不是一个命令了，而是执行一堆命令。

描述这一堆命令的就是菜单，如果把菜单也抽象成为一个命令，就相当于
一个大的命令，当客户说“点完了”的时候，就相当于触发这个大的命令，意思
就是执行菜单这个命令就可以了，这个菜单命令包含多个命令对象，一个命令对
象就相当于一道菜。那么这个菜单就相当于我们说的宏命令。

2：如何实现宏命令

宏命令从本质上讲类似于一个命令，基本上把它当命令对象进行处理。

但
是它跟普通的命令对象又有些不一样，就是宏命令包含有多个普通的命令对象，
执行一个宏命令，简单点说，就是执行宏命令里面所包含的所有命令对象，有点
打包执行的意味。

示例代码
命令接口，声明执行的操作
package cn.javass.dp.command.example5;

/**
 * 命令接口，声明执行的操作
 */
public interface Command {
    /**
     * 执行命令对应的操作
     */
    public void execute();
}
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
命令对象，绿豆排骨煲
package cn.javass.dp.command.example5;
/**
 * 命令对象，绿豆排骨煲
 */
public class ChopCommand implements Command{
    /**
     * 持有具体做菜的厨师的对象
     */
    private CookApi cookApi = null;
    /**
     * 设置具体做菜的厨师的对象
     * @param cookApi 具体做菜的厨师的对象
     */
    public void setCookApi(CookApi cookApi) {
        this.cookApi = cookApi;
    }

    public void execute() {
        this.cookApi.cook("绿豆排骨煲");
    }
}
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
命令对象，北京烤鸭
package cn.javass.dp.command.example5;
/**
 * 命令对象，北京烤鸭
 */
public class DuckCommand implements Command{
    private CookApi cookApi = null;
    public void setCookApi(CookApi cookApi) {
        this.cookApi = cookApi;
    }

    public void execute() {
        this.cookApi.cook("北京烤鸭");
    }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
命令对象，蒜泥白肉
package cn.javass.dp.command.example5;

/**
 * 命令对象，蒜泥白肉
 */
public class PorkCommand implements Command {
    private CookApi cookApi = null;

    public void setCookApi(CookApi cookApi) {
        this.cookApi = cookApi;
    }


    public void execute() {
        this.cookApi.cook("蒜泥白肉");
    }
}
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
菜单对象，是个宏命令对象
package cn.javass.dp.command.example5;
import java.util.*;
/**
 * 菜单对象，是个宏命令对象
 */
public class MenuCommand implements Command {
    /**
     * 用来记录组合本菜单的多道菜品，也就是多个命令对象
     */
    private Collection<Command> col = new ArrayList<Command>();
    /**
     * 点菜，把菜品加入到菜单中
     * @param cmd 客户点的菜
     */
    public void addCommand(Command cmd){
        col.add(cmd);
    }

    public void execute() {
        //执行菜单其实就是循环执行菜单里面的每个菜
        for(Command cmd : col){
            cmd.execute();
        }
    }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
厨师的接口
package cn.javass.dp.command.example5;
/**
 * 厨师的接口
 */
public interface CookApi {
    /**
     * 示意，做菜的方法
     * @param name 菜名
     */
    public void cook(String name);
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
厨师对象，做热菜
package cn.javass.dp.command.example5;
/**
 * 厨师对象，做热菜
 */
public class HotCook implements CookApi{

    public void cook(String name) {
        System.out.println("本厨师正在做："+name);
    }
}
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
厨师对象，做凉菜
package cn.javass.dp.command.example5;

/**
 * 厨师对象，做凉菜
 */
public class CoolCook implements CookApi {
    public void cook(String name) {
        System.out.println("凉菜"+name+"已经做好，本厨师正在装盘。" );
    }
}
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
服务员，负责组合菜单，负责组装每个菜和具体的实现者，
package cn.javass.dp.command.example5;
import java.util.*;
/**
 * 服务员，负责组合菜单，负责组装每个菜和具体的实现者，
 * 还负责执行调用，相当于标准Command模式的Client+Invoker
 */
public class Waiter {
    /**
     * 持有一个宏命令对象——菜单
     */
    private MenuCommand menuCommand = new MenuCommand();
    /**
     * 客户点菜
     * @param cmd 客户点的菜，每道菜是一个命令对象
     */
    public void orderDish(Command cmd){
        //客户传过来的命令对象是没有和接收者组装的
        //在这里组装吧
        CookApi hotCook = new HotCook();
        CookApi coolCook = new CoolCook();
        //判读到底是组合凉菜师傅还是热菜师傅
        //简单点根据命令的原始对象的类型来判断
        if(cmd instanceof DuckCommand){
            ((DuckCommand)cmd).setCookApi(hotCook);
        }else if(cmd instanceof ChopCommand){
            ((ChopCommand)cmd).setCookApi(hotCook);
        }else if(cmd instanceof PorkCommand){
            //这是个凉菜，所以要组合凉菜的师傅
            ((PorkCommand)cmd).setCookApi(coolCook);
        }
        //添加到菜单中
        menuCommand.addCommand(cmd);
    }
    /**
     * 客户点菜完毕，表示要执行命令了，这里就是执行菜单这个组合命令
     */
    public void orderOver(){
        this.menuCommand.execute();
    }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
客户
package cn.javass.dp.command.example5;

public class Client {
    public static void main(String[] args) {
        //只是负责向服务员点菜就好了
        //创建服务员
        Waiter waiter = new Waiter();

        //创建命令对象，就是要点的菜
        Command chop = new ChopCommand();
        Command duck = new DuckCommand();
        Command pork = new PorkCommand();

        //点菜，就是把这些菜让服务员记录下来
        waiter.orderDish(chop);
        waiter.orderDish(duck);
        waiter.orderDish(pork);

        //点菜完毕
        waiter.orderOver();
    }
}
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

队列请求

所谓队列请求，就是对命令对象进行排队，组成工作队列，然后依次取出
命令对象来执行。多用多线程或者线程池来进行命令队列的处理，当然也可以不
用多线程，就是一个线程，一个命令一个命令的循环处理，就是慢点。

示例代码

命令接口，声明执行的操作
package cn.javass.dp.command.example6;
/**
 * 命令接口，声明执行的操作
 */
public interface Command {
    /**
     * 执行命令对应的操作
     */
    public void execute();
    /**
     * 设置命令的接收者
     * @param cookApi 命令的接收者 
     */
    public void setCookApi(CookApi cookApi);
    /**
     * 返回发起请求的桌号，就是点菜的桌号
     * @return 发起请求的桌号
     */
    public int getTableNum();
}
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
命令对象，北京烤鸭
package cn.javass.dp.command.example6;
/**
 * 命令对象，北京烤鸭
 */
public class DuckCommand implements Command{
    private CookApi cookApi = null;
    public void setCookApi(CookApi cookApi) {
        this.cookApi = cookApi;
    }
    private int tableNum;
    public DuckCommand(int tableNum){
        this.tableNum = tableNum;
    }
    public int getTableNum(){
        return this.tableNum;
    }

    public void execute() {
        this.cookApi.cook(tableNum,"北京烤鸭");
    }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
命令对象，绿豆排骨煲
package cn.javass.dp.command.example6;


/**
 * 命令对象，绿豆排骨煲
 */
public class ChopCommand implements Command{
    /**
     * 持有具体做菜的厨师的对象
     */
    private CookApi cookApi = null;
    /**
     * 设置具体做菜的厨师的对象
     * @param cookApi 具体做菜的厨师的对象
     */
    public void setCookApi(CookApi cookApi) {
        this.cookApi = cookApi;
    }
    /**
     * 点菜的桌号
     */
    private int tableNum;
    /**
     * 构造方法，传入点菜的桌号
     * @param tableNum 点菜的桌号
     */
    public ChopCommand(int tableNum){
        this.tableNum = tableNum;
    }
    public int getTableNum(){
        return this.tableNum;
    }

    public void execute() {
        this.cookApi.cook(tableNum,"绿豆排骨煲");
    }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
命令队列类
package cn.javass.dp.command.example6;
import java.util.*;
/**
 * 命令队列类
 */
public class CommandQueue {
    /**
     * 用来存储命令对象的队列
     * 请注意：这里没有使用java.util.Queue，是因为常用的实现Queue接口的LinkedList类要求存放的对象是可排序的，
     * 排序是使用的Comparator，这跟要演示的功能没有多大关系，反而会增加复杂性。
     * 另外一个需要的功能是把命令对象按照先后顺序排好就可以了，只要是有序的就可以了。
     * 因此为了演示的简洁性，就直接使用List了。
     */
    private static List<Command> cmds = new ArrayList<Command>();
    /**
     * 服务员传过来一个新的菜单
     * 需要同步：是因为同时会有很多的服务员传入菜单，而同时又有很多厨师在从队列里取值
     * @param menu 传入的菜单
     */
    public synchronized static void addMenu(MenuCommand menu){
        //一个菜单对象包含很多命令对象
        for(Command cmd : menu.getCommands()){
            cmds.add(cmd);
        }
    }
    /**
     * 厨师从命令队列里面获取命令对象进行处理，也是需要同步的
     */
    public synchronized static Command getOneCommand(){
        Command cmd = null;
        if(cmds.size() > 0 ){
            //取出队列的第一个，因为是约定的按照加入的先后来处理
            cmd = cmds.get(0);
            //同时从队列里面取掉这个命令对象
            cmds.remove(0);
        }
        return cmd;
    }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
厨师的接口
package cn.javass.dp.command.example6;
/**
 * 厨师的接口
 */
public interface CookApi {
    /**
     * 示意，做菜的方法
     * @param tableNum 点菜的桌号
     * @param name 菜名
     */
    public void cook(int tableNum,String name);
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
厨师对象，做热菜的厨师
package cn.javass.dp.command.example6;

/**
 * 厨师对象，做热菜的厨师
 */
public class HotCook implements CookApi,Runnable{
    /**
     * 厨师姓名
     */
    private String name;
    /**
     * 构造方法，传入厨师姓名
     * @param name 厨师姓名
     */
    public HotCook(String name){
        this.name = name;
    }

    public void cook(int tableNum,String name) {
        //每次做菜的时间是不一定的，用个随机数来模拟一下
        int cookTime = (int)(20 * Math.random());
        System.out.println(this.name+"厨师正在为"+tableNum+"号桌做："+name);
        try {
            //让线程休息这么长时间，表示正在做菜
            Thread.sleep(cookTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(this.name+"厨师为"+tableNum+"号桌做好了："+name+",共计耗时="+cookTime+"秒");
    }

    public void run() {
        while(true){
            //到命令队列里面获取命令对象
            Command cmd = CommandQueue.getOneCommand();
            if(cmd != null){
                //说明取到命令对象了，这个命令对象还没有设置接收者
                //因为前面都还不知道到底哪一个厨师来真正执行这个命令
                //现在知道了，就是当前厨师实例，设置到命令对象里面
                cmd.setCookApi(this);
                //然后真正执行这个命令
                cmd.execute();
            }
            //休息1秒
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
后厨的管理类，通过此类让后厨的厨师进行运行状态
package cn.javass.dp.command.example6;
/**
 * 后厨的管理类，通过此类让后厨的厨师进行运行状态
 */
public class CookManager {
    /**
     * 用来控制是否需要创建厨师，如果已经创建过了就不要再执行了
     */
    private static boolean runFlag = false;
    /**
     * 运行厨师管理，创建厨师对象并启动他们相应的现程，
     * 无论运行多少次，创建厨师对象和启动线程的工作就只做一次
     */
    public static void runCookManager(){
        if(!runFlag){
            runFlag = true;
            //创建三位厨师
            HotCook cook1 = new HotCook("张三");
            HotCook cook2 = new HotCook("李四");
            HotCook cook3 = new HotCook("王五");
            //启动他们的线程
            Thread t1 = new Thread(cook1);
            t1.start();
            Thread t2 = new Thread(cook2);
            t2.start();
            Thread t3 = new Thread(cook3);
            t3.start();
        }
    }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
菜单对象，是个宏命令对象
package cn.javass.dp.command.example6;
import java.util.*;
/**
 * 菜单对象，是个宏命令对象
 */
public class MenuCommand implements Command {

    /**
     * 用来记录组合本菜单的多道菜品，也就是多个命令对象
     */
    private Collection<Command> col = new ArrayList<Command>();
    /**
     * 点菜，把菜品加入到菜单中
     * @param cmd 客户点的菜
     */
    public void addCommand(Command cmd){
        col.add(cmd);
    }
    public void setCookApi(CookApi cookApi){
        //什么都不用做
    }
    public int getTableNum(){
        //什么都不用做
        return 0;
    }
    /**
     * 获取菜单中的多个命令对象
     * @return 菜单中的多个命令对象
     */
    public Collection<Command> getCommands(){
        return this.col;
    }   

    public void execute() {
        //执行菜单就是把菜单传递给后厨
        CommandQueue.addMenu(this);
    }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
服务员，负责组合菜单,还负责执行调用
package cn.javass.dp.command.example6;
import java.util.*;
/**
 * 服务员，负责组合菜单,还负责执行调用
 */
public class Waiter {
    /**
     * 持有一个宏命令对象——菜单
     */
    private MenuCommand menuCommand = new MenuCommand();
    /**
     * 客户点菜
     * @param cmd 客户点的菜，每道菜是一个命令对象
     */
    public void orderDish(Command cmd){
        //添加到菜单中
        menuCommand.addCommand(cmd);
    }
    /**
     * 客户点菜完毕，表示要执行命令了，这里就是执行菜单这个组合命令
     */
    public void orderOver(){
        this.menuCommand.execute();
    }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
客户
package cn.javass.dp.command.example6;

public class Client {
    public static void main(String[] args) {
        //先要启动后台，让整个程序运行起来
        CookManager.runCookManager();

        //为了简单，直接用循环模拟多个桌号点菜
        for(int i = 0;i<5;i++){
            //创建服务员
            Waiter waiter = new Waiter();
            //创建命令对象，就是要点的菜
            Command chop = new ChopCommand(i);
            Command duck = new DuckCommand(i);
            //点菜，就是把这些菜让服务员记录下来
            waiter.orderDish(chop);
            waiter.orderDish(duck);
            //点菜完毕
            waiter.orderOver();
        }       
    }
}

/*
张三厨师正在为0号桌做：绿豆排骨煲
张三厨师为0号桌做好了：绿豆排骨煲,共计耗时=13秒
王五厨师正在为0号桌做：北京烤鸭
李四厨师正在为1号桌做：绿豆排骨煲
李四厨师为1号桌做好了：绿豆排骨煲,共计耗时=5秒
王五厨师为0号桌做好了：北京烤鸭,共计耗时=18秒
张三厨师正在为1号桌做：北京烤鸭
张三厨师为1号桌做好了：北京烤鸭,共计耗时=1秒
李四厨师正在为2号桌做：绿豆排骨煲
李四厨师为2号桌做好了：绿豆排骨煲,共计耗时=12秒
王五厨师正在为2号桌做：北京烤鸭
王五厨师为2号桌做好了：北京烤鸭,共计耗时=7秒
张三厨师正在为3号桌做：绿豆排骨煲
张三厨师为3号桌做好了：绿豆排骨煲,共计耗时=15秒
李四厨师正在为3号桌做：北京烤鸭
王五厨师正在为4号桌做：绿豆排骨煲
李四厨师为3号桌做好了：北京烤鸭,共计耗时=17秒
王五厨师为4号桌做好了：绿豆排骨煲,共计耗时=16秒
张三厨师正在为4号桌做：北京烤鸭
张三厨师为4号桌做好了：北京烤鸭,共计耗时=0秒
*/
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45

日志请求

所谓日志请求，就是把请求的历史记录保存下来，一般是采用永久存储的

方式。如果运行请求的过程中，系统崩溃了，那么在系统再次运行时，就可以从
保存的历史记录里面获取日志请求，并重新执行命令。

日志请求的实现有两种方案，一种就是直接使用Java中的序列化方法，另
外一种就是在命令对象里面添加上存储和装载的方法，其实就是让命令对象自己
实现类似序列化的功能。当然要简单就直接使用Java中的序列化 。

示例代码

其他相同、命令序列化

命令对象，绿豆排骨煲
package cn.javass.dp.command.example7;

import java.io.Serializable;


/**
 * 命令对象，绿豆排骨煲
 */
public class ChopCommand implements Command,Serializable{
    /**
     * 持有具体做菜的厨师的对象
     */
    private CookApi cookApi = null;
    /**
     * 设置具体做菜的厨师的对象
     * @param cookApi 具体做菜的厨师的对象
     */
    public void setCookApi(CookApi cookApi) {
        this.cookApi = cookApi;
    }
    /**
     * 点菜的桌号
     */
    private int tableNum;
    /**
     * 构造方法，传入点菜的桌号
     * @param tableNum 点菜的桌号
     */
    public ChopCommand(int tableNum){
        this.tableNum = tableNum;
    }
    public int getTableNum(){
        return this.tableNum;
    }

    public void execute() {
        this.cookApi.cook(tableNum,"绿豆排骨煲");
    }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
命令对象，北京烤鸭
package cn.javass.dp.command.example7;

import java.io.Serializable;

/**
 * 命令对象，北京烤鸭
 */
public class DuckCommand implements Command,Serializable{
    private CookApi cookApi = null;
    public void setCookApi(CookApi cookApi) {
        this.cookApi = cookApi;
    }
    private int tableNum;
    public DuckCommand(int tableNum){
        this.tableNum = tableNum;
    }
    public int getTableNum(){
        return this.tableNum;
    }

    public void execute() {
        this.cookApi.cook(tableNum,"北京烤鸭");
    }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
读写文件的辅助工具类
package cn.javass.dp.command.example7;

import java.io.*;
import java.util.*;
/**
 * 读写文件的辅助工具类
 */
public class FileOpeUtil {
    /**
     * 私有化构造方法，避免外部无谓的创建类实例
     * 这个工具类不需要创建类实例
     */
    private FileOpeUtil() {
    }
    /**
     * 读文件，从文件里面获取存储的List对象
     * @param pathName 文件路径和文件名
     * @return 存储的List对象
     */
    public static List readFile(String pathName) {
        List list = new ArrayList();
        ObjectInputStream oin = null;
        try {
            File f = new File(pathName);
            if(f.exists()){
                oin = new ObjectInputStream(
                        new BufferedInputStream(new FileInputStream(f))
                );
                list = (List)oin.readObject();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            try {
                if(oin!=null){
                    oin.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return list;
    }
    /**
     * 写文件，把list对象写出到文件中去
     * @param pathName 文件路径和文件名
     * @param list 要写到文件的list对象
     */
    public static void writeFile(String pathName,List list){
        File f = new File(pathName);
        ObjectOutputStream oout = null;
        try {
            oout = new ObjectOutputStream(
                    new BufferedOutputStream(new FileOutputStream(f))
            );
            oout.writeObject(list);         
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                oout.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
命令队列类
package cn.javass.dp.command.example7;
import java.util.*;

/**
 * 命令队列类
 */
public class CommandQueue {
    /**
     * 新添加的，文件名称
     */
    private final static String FILE_NAME = "CmdQueue.txt";
    /**
     * 用来存储命令对象的队列
     * 请注意：这里没有使用java.util.Queue，是因为常用的实现Queue接口的LinkedList类要求存放的对象是可排序的，
     * 排序是使用的Comparator，这跟要演示的功能没有多大关系，反而会增加复杂性。
     * 另外一个需要的功能是把命令对象按照先后顺序排好就可以了，只要是有序的就可以了。
     * 因此为了演示的简洁性，就直接使用List了。
     */
    private static List<Command> cmds = null;
    static{
        //获取上次没有做完的命令队列
        cmds = FileOpeUtil.readFile(FILE_NAME);
        if(cmds==null){
            cmds = new ArrayList<Command>();
        }
    }
    /**
     * 服务员传过来一个新的菜单
     * 需要同步：是因为同时会有很多的服务员传入菜单，而同时又有很多厨师在从队列里取值
     * @param menu 传入的菜单
     */
    public synchronized static void addMenu(MenuCommand menu){
        //一个菜单对象包含很多命令对象
        for(Command cmd : menu.getCommands()){
            cmds.add(cmd);
        }

        //记录请求日志
        FileOpeUtil.writeFile(FILE_NAME, cmds);
    }
    /**
     * 厨师从命令队列里面获取命令对象进行处理
     * 也是需要同步的
     */
    public synchronized static Command getOneCommand(){
        Command cmd = null;
        if(cmds.size() > 0 ){
            //取出队列的第一个，因为是约定的按照加入的先后来处理
            cmd = cmds.get(0);
            //同时从队列里面取掉这个命令对象
            cmds.remove(0);

            //记录请求日志
            FileOpeUtil.writeFile(FILE_NAME, cmds);
        }
        return cmd;
    }
}
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
客户
package cn.javass.dp.command.example7;

public class Client {
    public static void main(String[] args) {
        //先要启动后台，让整个程序运行起来
        CookManager.runCookManager();

        //为了简单，直接用循环模拟多个桌号点菜
        for(int i = 0;i<5;i++){
            //创建服务员
            Waiter waiter = new Waiter();
            //创建命令对象，就是要点的菜
            Command chop = new ChopCommand(i);
            Command duck = new DuckCommand(i);
            //点菜，就是把这些菜让服务员记录下来
            waiter.orderDish(chop);
            waiter.orderDish(duck);
            //点菜完毕
            waiter.orderOver();
        }       
    }
}

/*
张三厨师正在为0号桌做：绿豆排骨煲
张三厨师为0号桌做好了：绿豆排骨煲,共计耗时=13秒
王五厨师正在为0号桌做：北京烤鸭
李四厨师正在为1号桌做：绿豆排骨煲
李四厨师为1号桌做好了：绿豆排骨煲,共计耗时=5秒
王五厨师为0号桌做好了：北京烤鸭,共计耗时=18秒
张三厨师正在为1号桌做：北京烤鸭
张三厨师为1号桌做好了：北京烤鸭,共计耗时=1秒
李四厨师正在为2号桌做：绿豆排骨煲
李四厨师为2号桌做好了：绿豆排骨煲,共计耗时=12秒
王五厨师正在为2号桌做：北京烤鸭
王五厨师为2号桌做好了：北京烤鸭,共计耗时=7秒
张三厨师正在为3号桌做：绿豆排骨煲
张三厨师为3号桌做好了：绿豆排骨煲,共计耗时=15秒
李四厨师正在为3号桌做：北京烤鸭
王五厨师正在为4号桌做：绿豆排骨煲
李四厨师为3号桌做好了：北京烤鸭,共计耗时=17秒
王五厨师为4号桌做好了：绿豆排骨煲,共计耗时=16秒
张三厨师正在为4号桌做：北京烤鸭
张三厨师为4号桌做好了：北京烤鸭,共计耗时=0秒
*/
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45

命令模式的优缺点

  • 1：更松散的耦合
  • 2：更动态的控制
  • 3：能很自然的复合命令
  • 4：更好的扩展性

思考命令模式

命令模式的本质

命令模式的本质是：==封装请求==

何时选用命令模式

  • 1：如果需要抽象出需要执行的动作，并参数化这些对象，可以选用命令模式，把这
    些需要执行的动作抽象成为命令，然后实现命令的参数化配置
  • 2：如果需要在不同的时刻指定、排列和执行请求，可以选用命令模式，把这些请求
    封装成为命令对象，然后实现把请求队列化
  • 3：如果需要支持取消操作，可以选用命令模式，通过管理命令对象，能很容易的实
    现命令的恢复和重做的功能
  • 4：如果需要支持当系统崩溃时，能把对系统的操作功能重新执行一遍，可以选用命
    令模式，把这些操作功能的请求封装成命令对象，然后实现日志命令，就可以在
    系统恢复回来后，通过日志获取命令列表，从而重新执行一遍功能
  • 5：在需要事务的系统中，可以选用命令模式，命令模式提供了对事务进行建模的方
    法，命令模式有一个别名就是Transaction。

理解命令模式

退化的命令模式

前面讲到了智能命令，如果命令的实现对象超级智能，实现了命令所要求

的功能，那么就不需要接收者了，既然没有了接收者，那么也就不需要组装者
了。

Command智能

示例代码
Command接口
package cn.javass.dp.command.example8;

public interface Command {
    public void execute();
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
实现接口
package cn.javass.dp.command.example8;

public class PrintService implements Command{
    /**
     * 要输出的内容
     */
    private String str = "";
    /**
     * 构造方法，传入要输出的内容
     * @param s 要输出的内容
     */
    public PrintService(String s){
        str = s;
    }

    public void execute() {
        System.out.println("打印的内容为="+str);
    }
}
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
Invoker
package cn.javass.dp.command.example8;

public class Invoker {
    /**
     * 持有命令对象
     */
    private Command cmd = null;
    /**
     * 设置命令对象
     * @param cmd 命令对象
     */
    public void setCmd(Command cmd){
        this.cmd = cmd;
    }
    /**
     * 开始打印
     */
    public void startPrint(){
        //执行命令的功能
        this.cmd.execute();
    }
}
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
客户端
package cn.javass.dp.command.example8;

public class Client {
    public static void main(String[] args) {
        //准备要发出的命令
        Command cmd = new PrintService("退化的命令模式示例");
        //设置命令给持有者
        Invoker invoker = new Invoker();
        invoker.setCmd(cmd);

        //按下按钮，真正启动执行命令
        invoker.startPrint();
    }
}
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

Invoker 智能

示例代码
Command
package cn.javass.dp.command.example9;

public interface Command {
    public void execute();
    /**
     * 设置要输出的内容
     * @param s 要输出的内容
     */
    public void setStr(String s);
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
Invoker
package cn.javass.dp.command.example9;

public class Invoker {
    public void startPrint(Command cmd){    
        System.out.println("在Invoker中，输出服务前");
        cmd.execute();
        System.out.println("输出服务结束");
    }
}
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
客户端
package cn.javass.dp.command.example9;

public class Client {
    public static void main(String[] args) {
        //准备要发出的命令，没有具体实现类了
        Command cmd = new Command(){
            private String str = "";
            public void setStr(String s){
                str = s;
            }

            public void execute() {
                System.out.println("打印的内容为="+str);
            }
        };
        cmd.setStr("退化的命令模式类似于Java回调的示例");

        //这个时候的Invoker或许该称为服务了
        Invoker invoker = new Invoker();
        //按下按钮，真正启动执行命令
        invoker.startPrint(cmd);
    }
}
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
					<link href="https://csdnimg.cn/release/phoenix/mdeditor/markdown_views-258a4616f7.css" rel="stylesheet">
                  </div>
Famiglistimott
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
一天一模式之2简单工厂
天空鸟的博客
03-14 302
初识简单工厂 提供一个创建对象实例的功能，而无须关心其具体实现。被创建实例的类型可以是接口、抽象类，也可以是具体的类。 结构和说明 - Api：定义客户所需要的功能接口 - Impl：具体实现Api的实现类，可能会有多个 - Factory：工厂，选择合适的实现类来创建Api接口对象 - Client：客户端，通过Factory去获取Api接口对象，然后面向Api接口编程 ...
Invoker
newhonor
09-28 297
http://acm.hdu.edu.cn/showproblem.php?pid=6739 #include <iostream> #include <cstring> #include <queue> #include <vector> #include <algorithm> #include <cstdio> #...
【JAVA设计模式】15.命令模式
xin956631892的博客
09-25 129
命令模式即向一个invoker传入不同的命令，invoker将会根据传入的命令进行对应的操作 UML图： Invoker类接收一个命令作为参数，其invoke方法调用了command的执行方法： class Invoker { private Command command; public Invoker(Command command) { this...
命令模式的优点?_设计模式之-命令模式
weixin_29369347的博客
01-28 652
命令模式是一个高内聚的模式，将一个请求封装成一个对象，从而让你使用不同的请求把客户端参数化，对请求排队或者记录请求日志，可以提供命令的撤销和恢复功能。命令模式的通用类图如下：eceiver接收者角色，主要负责具体命令的执行Command命令角色，需要执行的所有命令的声明Invoker调用者角色，接收到命令，并执行命令。命令模式将请求方(Invoker)和执行方(Receiver)区分开了，扩展性也...
一天学通Java23种设计模式
05-16
在一天内学习Java的23种设计模式可能是一项挑战，但通过精心组织的学习路径和实际示例，这是完全可能的。这个压缩包“JAVA Design Patterns”显然包含了使用Eclipse IDE实现的每种设计模式的源代码，这对于理解和...
一天学通Java设计模式（2）
05-24
2. 命令模式：将请求封装为一个对象，以便使用不同的请求、队列或者日志请求，以及支持可撤销的操作。 3. 解释器模式：给定一个语言，定义它的文法表示，并提供一个解释器来处理这种语言中的句子。 4. 迭代器模式：...
云和恩墨oracle-dba的一天海报
12-14
根据给定的文件信息，我们可以总结出Oracle DBA（数据库管理员）一天的工作涉及多个关键方面，包括但不限于数据库状态检查、性能监控与优化、安全性管理以及数据保护等方面。下面将详细阐述这些知识点： ### 一、...
Redis的使用模式之计数器模式实例
09-10
Redis作为一个高性能的键值存储系统，其在计数器模式中的应用非常广泛。计数器模式可以帮助我们处理各种统计需求，如实时汇总、时间周期性汇总以及速度控制等。以下将详细阐述这些知识点： 1. **汇总计数器**： - ...
一天一个shell命令 文本操作系列-linux dd使用教程
01-11
今天第一天写，先说下写shell脚本的基本知识 1. shell脚本以.sh 为扩展名，通常运行 ./${filename}.sh 或者 sh ${filename}.sh 2. shell 脚本开头以 #!/bin/bash #!读作 “shebang” 3. 开启调试 #!/bin/bash –xv ...
命令模式
程序员
05-10 2358
今天学习了一下命令模式，现在来总结一下： Command命令模式
命令模式(Command Pattern)(一)：命令模式介绍
jialinqiang的专栏
05-18 6096
一、意图              将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤消的操作。 二、适用性 (1)系统需要将请求调用者和请求接收者解耦，使得调用者和接收者不直接交互。 (2)在不同的时刻指定、排列和执行请求。 (3)支持修改日志、撤销操作。 (4)系统需要将一组操作组合在一起
HDU 3293 Invoker
leiyu
08-09 224
Invoker On of Vance’s favourite hero is Invoker, Kael. As many people knows Kael can control the elements and combine them to invoke a powerful skill. Vance like Kael very much so he changes the map ...
Invoker(预处理+dp)
a12377978的博客
10-22 156
Invoker [Link](Problem - 6739 (hdu.edu.cn)) 题意 你有三个小技能，每使用一个小技能就会给你的卡槽留下一个相应的标记，卡槽最多有三个标记，当有一个新的标记到来且没有位置时最先到的标记被移除，依次顺移。卡槽内三个标记不同的无序组合可以放出不同的大招，当有三个标记后就可以放大招啦。现在给你一个大招序列，问你最少用多少次操作可以把这个大招序列发出去。 题解 首先发现每一个大招就确定了三个无序的标记，它是不符合局部贪心到整体最优的。但是假设当前到了第i位，那么从开始到第i位
MethodInvoker和Invoker
每天进步一点点
08-13 4845
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Threading; using System.Windows
深入学习 Spring HttpInvoker
BRAVE
03-07 8469
深入学习 Spring HttpInvoker 远程通信协议 RPC 远程过程调用，是一个计算机通信协议，允许一台计算机的程序，调用另一台计算机的子程序。如果涉及到的软件采用面向对象编程，亦可称为远程方法调用（如 Java RMI） RMI 一般指Java RMI (Java Remote Method Invocation) Java远程方法调用，只适用于Java程序之间的通...
设计模式--命令模式 ( 十五 )
我知道你很急,但是路要一步步走
02-19 165
1.0 点菜 using System; using System.Collections.Generic; namespace CommandDesign { class Program { static void Main(string[] args) { // 开店前的准备 Barbecue...
精通JavaEE：设计模式深度解析
12. **命令模式（Command Pattern）**：将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化，支持可撤销的操作。 13. **装饰模式（Decorator Pattern）**：动态地给一个对象添加一些额外的职责，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Famiglistimott

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值