设计模式-命令模式（Command）

一、命令模式概述

1.1 什么是命令模式

命令模式是一种数据驱动的设计模式，它属于行为型模式。请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令。

命令模式的主要优点是可以将请求封装成一个对象，从而使您可以用不同的请求对客户进行参数化。主要解决在软件系统中，行为请求者与行为实现者通常是一种紧耦合的关系，但某些场合，比如需要对行为进行记录、撤销或重做、事务等处理时，这种无法抵御变化的紧耦合的设计就不太合适。

1.2 简单实现命令模式

命令模式是一种行为设计模式，它允许将操作封装为对象。以下是一个简单的Java实现命令模式的例子：

首先，我们创建一个命令接口：

public interface Command {
    void execute();
}
1
2
3

然后，我们创建一个具体的命令类，例如打印命令：

public class PrintCommand implements Command {
    private String message;

    public PrintCommand(String message) {
        this.message = message;
    }

    @Override
    public void execute() {
        System.out.println("执行打印命令： " + message);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

接下来，我们创建一个接收者类，例如打印机：

public class Printer {
    public void print(String message) {
        System.out.println("打印： " + message);
    }
}
1
2
3
4
5

最后，我们创建一个调用者类，例如命令调用者：

public class CommandInvoker {
    private Command command;

    public CommandInvoker(Command command) {
        this.command = command;
    }

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

    public void executeCommand() {
        command.execute();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

现在，我们可以在主函数中测试这个命令模式：

public class Main {
    public static void main(String[] args) {
        Printer printer = new Printer();
        PrintCommand printCommand = new PrintCommand("Hello, World!");
        CommandInvoker commandInvoker = new CommandInvoker(printCommand);

        commandInvoker.executeCommand(); // 输出：执行打印命令： Hello, World!
    }
}
1
2
3
4
5
6
7
8
9

1.3 使用命令模式的注意事项

• 1、java中已经提供了一些内置的接口和类，可以方便地实现命令模式。例如，可以使用Runnable接口来实现无参数的命令，使用ActionListener接口来实现有参数的命令。
• 2、在Java中，命令对象通常被设计为匿名内部类的形式，以便将命令对象作为参数传递给其他方法。
• 3、如果需要支持撤销操作，则需要保存命令对象的历史记录。可以使用Java的Stack类来实现命令对象的堆栈管理。
• 4、如果需要支持修改命令，则需要设计一种方式来修改命令对象的状态。可以在命令对象中添加一个setState方法来实现状态修改。
• 5、如果命令对象的状态与接收者对象的状态有关，则需要考虑如何同步它们的状态。可以在命令对象中添加一个synchronized关键字来同步状态。
• 6、需要仔细考虑命令接口的设计，以便支持新的命令类型和扩展性。可以使用Java的泛型来实现命令接口的设计。
• 7、在实现具体的命令类时，需要考虑如何处理可能出现的异常情况。可以使用try-catch语句来捕获异常并进行处理。

二、命令模式的用途

• 1、将请求封装成一个对象，从而使你可用不同的请求把客户端参数化，对请求排队或者记录请求日志，以及支持可撤销和恢复操作。
• 2、将命令的请求者和命令的执行者进行解耦，将命令的实际执行者，封装进命令对象中，命令的调用者只需要调用命令对象的方法，这个方法会内部转调命令的实际执行者的方法完成真正的命令执行。这就是说，命令的调用者不需要关心具体命令是做什么的，只需要给我一个命令对象，我给你调用一把，具体这个命令对象自己内部做了什么，那不是我该关心的事。
• 3、支持请求的排队、记录日志、撤销操作等功能。
• 4、在Java中，命令模式常被应用在线程池中。

三、命令模式实现方式

3.1 使用匿名内部类实现命令模式

以下是一个简单的示例：

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

// 实现具体的命令类
class ConcreteCommand implements Command {
    private Receiver receiver;

    public ConcreteCommand(Receiver receiver) {
        this.receiver = receiver;
    }

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

// 定义一个接收者类
class Receiver {
    public void action() {
        System.out.println("执行操作");
    }
}

// 使用匿名内部类实现命令模式
public class Main {
    public static void main(String[] args) {
        Receiver receiver = new Receiver();
        Command command = new ConcreteCommand(receiver);
        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
26
27
28
29
30
31
32
33
34

在这个示例中，我们首先定义了一个命令接口 Command，然后实现了一个具体的命令类 ConcreteCommand，它接收一个 Receiver 对象作为参数。接着，我们定义了一个接收者类 Receiver，它有一个 action() 方法用于执行操作。最后，在 main 方法中，我们创建了一个 Receiver 对象和一个 ConcreteCommand 对象，并通过调用 execute() 方法来执行操作。

3.2 使用Lambda表达式实现命令模式

首先，定义一个命令接口：

public interface Command {
    void execute();
}
1
2
3

然后，创建一个具体的命令类，实现该接口：

public class ConcreteCommand implements Command {
    private Receiver receiver;

    public ConcreteCommand(Receiver receiver) {
        this.receiver = receiver;
    }

    @Override
    public void execute() {
        receiver.action();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

接下来，创建一个接收者类，它有一个 action() 方法用于执行操作：

public class Receiver {
    public void action() {
        System.out.println("执行操作");
    }
}
1
2
3
4
5

最后，使用 Lambda 表达式创建并执行命令：

public class Main {
    public static void main(String[] args) {
        Receiver receiver = new Receiver();
        Command command = (Command) () -> receiver.action();
        command.execute();
    }
}
1
2
3
4
5
6
7

在这个示例中，我们使用了 Lambda 表达式来简化命令对象的创建过程。

3.3 使用Java内置的函数式接口实现命令模式

首先，定义一个函数式接口 Command：

@FunctionalInterface
public interface Command {
    void execute();
}
1
2
3
4

然后，创建一个具体的命令类，实现该接口：

public class ConcreteCommand implements Command {
    private Receiver receiver;

    public ConcreteCommand(Receiver receiver) {
        this.receiver = receiver;
    }

    @Override
    public void execute() {
        receiver.action();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

接下来，创建一个接收者类，它有一个 action() 方法用于执行操作：

public class Receiver {
    public void action() {
        System.out.println("执行操作");
    }
}
1
2
3
4
5

最后，使用 Java 8 的 Lambda 表达式创建并执行命令：

public class Main {
    public static void main(String[] args) {
        Receiver receiver = new Receiver();
        Command command = () -> receiver.action();
        command.execute();
    }
}
1
2
3
4
5
6
7

在这个示例中，我们使用了 Java 内置的函数式接口 Command 来实现命令模式。通过使用 Lambda 表达式，我们可以简化命令对象的创建过程。

3.4 使用策略模式和命令模式结合实现命令模式

首先，定义一个命令接口：

public interface Command {
    void execute();
}
1
2
3

然后，创建具体的命令类，实现命令接口：

public class ConcreteCommandA implements Command {
    @Override
    public void execute() {
        System.out.println("执行命令A");
    }
}

public class ConcreteCommandB implements Command {
    @Override
    public void execute() {
        System.out.println("执行命令B");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

接下来，定义一个上下文类，用于存储和调用命令对象：

import java.util.HashMap;
import java.util.Map;

public class Context {
    private Map<String, Command> commandMap = new HashMap<>();

    public void registerCommand(String commandName, Command command) {
        commandMap.put(commandName, command);
    }

    public void executeCommand(String commandName) {
        Command command = commandMap.get(commandName);
        if (command != null) {
            command.execute();
        } else {
            System.out.println("未找到对应的命令");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

最后，在客户端代码中使用策略模式和命令模式结合

public class Client {
    public static void main(String[] args) {
        // 创建命令对象
        Command commandA = new ConcreteCommandA();
        Command commandB = new ConcreteCommandB();

        // 创建上下文对象，并注册命令对象
        Context context = new Context();
        context.registerCommand("commandA", commandA);
        context.registerCommand("commandB", commandB);

        // 使用上下文对象执行命令
        context.executeCommand("commandA");
        context.executeCommand("commandB");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

运行客户端代码，输出结果如下：

执行命令A
执行命令B
1
2