《Head First 设计模式》：命令模式
2024-09-04 05:25:12
正文
一、定义
命令模式将“请求”封装成对象（命令对象），以便使用不同的“请求”来参数化其他对象。
要点：
- 命令模式可将“动作的请求者”从“动作的执行者”对象中解耦。
- 被解耦的两者之间通过命令对象进行沟通。命令对象封装了接收者和一个或多个动作。
- 命令对象提供一个 execute() 方法，该方法封装了接收者的动作。当此方法被调用时，接收者就会执行这些动作。
- 调用者持有一个或多个命令对象，通过调用命令对象的 execute() 方法发出请求，这会使得接收者的动作被调用。
二、实现步骤
1、创建接收者类
接收者类中包含要执行的动作。
（1）接收者A
/**
* 接收者A
*/
public class ReceiverA {
/**
* 动作1
*/
public void action1() {
System.out.println("ReceiverA do action1");
}
/**
* 动作2
*/
public void action2() {
System.out.println("ReceiverA do action2");
}
}
（2）接收者B
/**
* 接收者B
*/
public class ReceiverB {
/**
* 动作1
*/
public void action1() {
System.out.println("ReceiverB do action1");
}
/**
* 动作2
*/
public void action2() {
System.out.println("ReceiverB do action2");
}
}
2、创建命令接口
/**
* 命令接口
*/
public interface Command {
/**
* 执行命令
*/
public void execute();
}
3、创建具体的命令，并实现命令接口
命令对象中，封装了命令接收者和相关动作。
（1）命令A1
/**
* 命令A1
*/
public class ConcreteCommandA1 implements Command{
/**
* 接收者A
*/
ReceiverA receive;
public ConcreteCommandA1(ReceiverA receive) {
this.receive = receive;
}
@Override
public void execute() {
// 接收者A执行动作1
receive.action1();
}
}
（2）命令A2
/**
* 命令A2
*/
public class ConcreteCommandA2 implements Command{
/**
* 接收者A
*/
ReceiverA receive;
public ConcreteCommandA2(ReceiverA receive) {
this.receive = receive;
}
@Override
public void execute() {
// 接收者A执行动作2
receive.action2();
}
}
（3）命令B1
/**
* 命令B1
*/
public class ConcreteCommandB1 implements Command{
/**
* 接收者B
*/
ReceiverB receive;
public ConcreteCommandB1(ReceiverB receive) {
this.receive = receive;
}
@Override
public void execute() {
// 接收者B执行动作1
receive.action1();
}
}
（4）命令B2
/**
* 命令B2
*/
public class ConcreteCommandB2 implements Command{
/**
* 接收者B
*/
ReceiverB receive;
public ConcreteCommandB2(ReceiverB receive) {
this.receive = receive;
}
@Override
public void execute() {
// 接收者B执行动作2
receive.action2();
}
}
4、创建调用者
调用者通过持有的命令对象，来调用接收者的动作。
/**
* 调用者
*/
public class Invoker {
/**
* 命令对象
*/
Command command;
/**
* 设置命令
*/
public void setCommand(Command command) {
this.command = command;
}
/**
* 调用动作
*/
public void invoke() {
command.execute();
}
}
5、调用者执行命令
public class Test {
public static void main(String[] args) {
// 命令调用者
Invoker invoker = new Invoker();
// 命令接收者
ReceiverA receiverA = new ReceiverA();
ReceiverB receiverB = new ReceiverB();
// 创建命令，并指定接收者
Command commandA1 = new ConcreteCommandA1(receiverA);
Command commandA2 = new ConcreteCommandA2(receiverA);
Command commandB1 = new ConcreteCommandB1(receiverB);
Command commandB2 = new ConcreteCommandB2(receiverB);
// 调用者执行命令
invoker.setCommand(commandA1);
invoker.invoke();
invoker.setCommand(commandA2);
invoker.invoke();
invoker.setCommand(commandB1);
invoker.invoke();
invoker.setCommand(commandB2);
invoker.invoke();
}
}
三、举个栗子
1、背景
假设你要设计一个家电自动化遥控器的 API。这个遥控器具有七个可编程的插槽（每个都可以指定到一个不同的家电装置），每个插槽都有对应的“开”、“关”按钮。
你希望每个插槽都能够控制一个或一组装置。并且，这个遥控器适用于目前的装置和任何未来可能出现的装置。
2、实现
（1）创建家电类
/**
* 电灯（接收者）
*/
public class Light {
/**
* 电灯位置
*/
String location;
public Light(String location) {
this.location = location;
}
/**
* 开灯
*/
public void on() {
System.out.println(location + " light is on");
}
/**
* 关灯
*/
public void off() {
System.out.println(location + " light is off");
}
}
/**
* 音响（接收者）
*/
public class Stereo {
/**
* 打开音响
*/
public void on() {
System.out.println("Stereo is on");
}
/**
* 关闭音响
*/
public void off() {
System.out.println("Stereo is off");
}
/**
* 设置为播放CD
*/
public void setCd() {
System.out.println("Stereo is set for CD input");
}
/**
* 设置为播放DVD
*/
public void setDvd() {
System.out.println("Stereo is set for DVD input");
}
/**
* 设置音量
*/
public void setVolume(int volume) {
System.out.println("Stereo volume set to " + volume);
}
}
（2）创建命令接口
/**
* 命令接口
*/
public interface Command {
/**
* 执行命令
*/
public void execute();
}
（3）创建具体的命令，并继承命令接口
/**
* 无命令
*/
public class NoCommand implements Command {
@Override
public void execute() {}
}
/**
* 开灯命令
*/
public class LightOnCommand implements Command {
Light light;
public LightOnCommand(Light light) {
this.light = light;
}
@Override
public void execute() {
light.on();
}
}
/**
* 关灯命令
*/
public class LightOffCommand implements Command {
Light light;
public LightOffCommand(Light light) {
this.light = light;
}
@Override
public void execute() {
light.off();
}
}
/**
* 打开音响播放CD命令
*/
public class StereoOnWithCDCommand implements Command {
Stereo stereo;
public StereoOnWithCDCommand(Stereo stereo) {
this.stereo = stereo;
}
@Override
public void execute() {
stereo.on();
stereo.setCd();
stereo.setVolume(11);
}
}
/**
* 关闭音响命令
*/
public class StereoOffCommand implements Command {
Stereo stereo;
public StereoOffCommand(Stereo stereo) {
this.stereo = stereo;
}
@Override
public void execute() {
stereo.off();
}
}
（4）创建遥控器类
/**
* 遥控器（调用者）
*/
public class RemoteControl {
Command[] onCommands;
Command[] offCommands;
public RemoteControl() {
onCommands = new Command[7];
offCommands = new Command[7];
// 初始化插槽命令为无命令状态
Command noCommand = new NoCommand();
for (int i = 0; i < 7; i++) {
onCommands[i] = noCommand;
offCommands[i] = noCommand;
}
}
/**
* 设置插槽命令
*/
public void setCommand(int slot, Command onCommand, Command offCommand) {
onCommands[slot] = onCommand;
offCommands[slot] = offCommand;
}
/**
* “开”按钮被按下
*/
public void onButtonWasPushed(int slot) {
// 执行开命令
onCommands[slot].execute();
}
/**
* “关”按钮被按下
*/
public void offButtonWasPushed(int slot) {
// 执行关命令
offCommands[slot].execute();
}
}
（5）使用遥控器控制家电
public class Test {
public static void main(String[] args) {
// 遥控器
RemoteControl remoteControl = new RemoteControl();
// 家电
Light livingRoomLight = new Light("Living Room");
Light kitchenLight = new Light("Kitchen");
Stereo stereo = new Stereo();
// 创建命令，并指定家电
Command livingRoomLightOn = new LightOnCommand(livingRoomLight);
Command livingRoomLightOff = new LightOffCommand(livingRoomLight);
Command kitchenLightOn = new LightOnCommand(kitchenLight);
Command kitchenLightOff = new LightOffCommand(kitchenLight);
Command stereoOnWithCD = new StereoOnWithCDCommand(stereo);
Command stereoOff = new StereoOffCommand(stereo);
// 设置插槽命令
remoteControl.setCommand(0, livingRoomLightOn, livingRoomLightOff);
remoteControl.setCommand(1, kitchenLightOn, kitchenLightOff);
remoteControl.setCommand(2, stereoOnWithCD, stereoOff);
// 遥控器执行命令
remoteControl.onButtonWasPushed(0);
remoteControl.offButtonWasPushed(0);
remoteControl.onButtonWasPushed(1);
remoteControl.offButtonWasPushed(1);
remoteControl.onButtonWasPushed(2);
remoteControl.offButtonWasPushed(2);
}
}
四、命令模式的更多用途
1、队列请求
命令可以将运算块打包（一个接收者和一组动作），然后将它传来传去，就像是一般的对象一样。即使在命令对象被创建许久之后，运算依然可以被调用。事实上，它甚至可以在不同的线程中被调用。
因此，命令模式可以用来实现队列请求。具体做法是：在工作队列的一端添加命令，另一端通过线程取出命令，调用它的 execute() 方法，等调用完成后，将此命令对象丢弃，再取出下一个命令……
2、日志请求
某些应用需要我们将所有的动作都记录在日志中，并能在系统死机后，重新调用这些动作恢复到之前的状态。
命令模式能够支持这一点。具体做法是：当我们执行命令时，利用序列化将命令对象存储在磁盘中。一旦系统死机，再利用反序列化将命令对象重新加载，并依次调用这些对象的 execute() 方法。
最新文章
- centos 6.6中的yum源更换成国内的阿里云yum源
- Python – locals和globals
- windows下的socket网络编程
- 关于mysql下hibernate实体类字段与数据库关键字冲突的问题
- 教你50招提升ASP.NET性能（十九）：静态集合
- VB.Net 字符串加密类
- 使用 JSSE 定制 SSL 连接的属性--转载
- (Error) The type AESKeyGenerator is not accessible due to restriction on required library.
- QT修改UI和源码后,程序页面还是原来页面的解决方法
- CSAPP：第八章 异常控制流2
- java web 开发入门 --- tomcat/servlet/jsp
- Luogu P4779 【模板】单源最短路径（标准版）(Dijkstra+堆优化模板）
- 团队作业之Rookie also want to fly
- 【BZOJ1970】[AHOI2005]矿藏编码（模拟）
- iOS设计模式 - 迭代器
- typescript数据类型
- 使用PyMongo访问需要认证的MongoDB
- java 位运算符,逻辑运算符
- C#高级编程 (第六版) 学习 第一章：.Net体系结构
- Qt ------ stylesheet 样式