一、基础概念

1、将一个请求封装为一个对象，使您可以用不同的请求对客户进行参数化。

2、对请求排队或记录请求日志，以及支持可撤销的操作。

3、将命令对象与执行命令的对象分离，实现调用者和接收者的解耦。

其中命令对象是关键，它包含了一个接收者和一个执行操作的方法。该命令对象绑定一个接收者对象，并通过调用接收者相应的操作来完成执行请求的功能。

二、UML类图

三、角色设计

角色	描述
抽象命令类	定义命令的接口，声明执行的方法
具体命令角色	具体命令类，实现了命令接口，绑定接收者，并实现执行命令的操作
接收者类	知道如何实施与执行一个请求相关的操作
调用者类	接收命令请求并执行命令
客户端类	创建命令对象并设定它的接收者

四、案例分析

1、基本实现

主要包含以下几个部分：

1、Command抽象命令类：定义了命令的公共接口一般是一个execute()方法。

2、ConcreteCommand具体命令角色：实现了Command接口，是具体的命令类，包含对Receiver对象的引用。其execute()方法会调用Receiver的相应方法。

3、Receiver接收者类：命令对象Indirect调用的接收者对象。实现了具体的业务逻辑。

4、Invoker调用者类：请求的调用者。其持有Command对象的引用，并通过command.execute()间接调用Receiver。

5、Client客户端类：创建Command和Receiver对象，并创建Invoker传入Command对象，最后调用Invoker的invoke()方法触发执行。

这个实现让调用者Invoker和接收者Receiver解耦，Invoker只与Command接口发生依赖，不需要知道具体的命令与接收者。

抽象命令类：

public interface Command {
    /**
     * 执行方法
     */
    void execute();
}

接收者类：

public class Receiver {
    /**
     * 真正执行命令相应的操作
     */
    public void action(){
        System.out.println("执行操作");
    }
}

具体命令角色类：

public class ConcreteCommand implements Command {

    //持有相应的接收者对象
    private Receiver receiver = null;
    /**
     * 构造方法
     */
    public ConcreteCommand(Receiver receiver){
        this.receiver = receiver;
    }

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

}

调用者类：

public class Invoker {
    /**
     * 持有命令对象
     */
    private Command command = null;
    /**
     * 构造方法
     */
    public Invoker(Command command){
        this.command = command;
    }
    /**
     * 行动方法
     */
    public void action(){
        command.execute();
    }
}

客户端：

public class Client {

    public static void main(String[] args) {
        //创建接收者
        Receiver receiver = new Receiver();
        //创建命令对象，设定它的接收者
        Command command = new ConcreteCommand(receiver);
        //创建请求者，把命令对象设置进去
        Invoker invoker = new Invoker(command);
        //执行方法
        invoker.action();
    }

}

运行结果如下：

2、点餐案例

这个点餐的命令模式案例，主要演示了几个角色对象之间的关系：

1、Waiter是接收者对象，知道如何执行点餐操作。

2、OrderCommand是命令对象，它封装了一个点餐请求，绑定了接收者Waiter。可以调用execute()执行点餐。

3、Customer是调用者对象，它通过命令对象indirect地执行点餐请求。可以设定并触发命令。

4、Client是客户端，进行对象的创建和使用。

抽象命令类：

public interface Command {

    public void execute();

}

服务员（接收者类）：

public class Waiter {

    public void takeOrder(String food) {
        System.out.println("服务员:收到点餐,食物是:" + food);
    }

}

点餐命令类（具体的命令类）：

public class OrderCommand implements Command {

    private Waiter waiter;
    private String food;

    public OrderCommand(Waiter waiter, String food) {
        this.waiter = waiter;
        this.food = food;
    }

    @Override
    public void execute() {
        waiter.takeOrder(food);
    }

}

顾客（调用者类）：

public class Customer {

    private Command command;

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

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

}

客户端类：

public class Client {
    
    public static void main(String[] args) {
        Waiter waiter = new Waiter();
        Command cmd = new OrderCommand(waiter, "番茄炒蛋");

        Customer customer = new Customer();
        customer.setOrder(cmd);
        customer.orderUp();
    }
    
}

运行结果如下：