14、设计模式之命令模式

定义

将一个请求封装为一个对象，是发出请求的责任和执行请求的责任分开。这样两者之间通过命令对象进行沟通，这样方便将命令对象就行存储、传递、调用、增加与管理。

结构

命令模式主要包含以下主要角色：

• 抽象命令类（Command）：定义命令的接口，声明执行的方法。
• 具体命令类（Concrete Command）：具体的命令，实现命令接口；通常会持有接收者，并调用接收者的功能来完成命令要执行的操作。
• 接收者/实现者（Receiver）：执行命令的对象。
• 请求者/调用者（Invoker）：要求命令对象执行请求，通常会持有命令对象，可以持有很多的命令对象。这个是客户端真正触发命令并要求命令执行相应操作的地方，也就是使用命令对象的入口。

案例

【例】顾客点餐
顾客像女服务员点餐，女服务员把订单交给厨师，厨师根据订单做菜。

订单对象，包含餐桌号以及餐品信息

package com.hupp.command;

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

/**
 * 订单类
 */
public class Order {
    
    
    //餐桌号
    private int diningTable;
    //点的餐及份数
    private Map<String,Integer> foodDir = new HashMap();

    public int getDiningTable() {
    
    
        return diningTable;
    }

    public void setDiningTable(int diningTable) {
    
    
        this.diningTable = diningTable;
    }

    public Map<String, Integer> getFoodDir() {
    
    
        return foodDir;
    }

    public void setFoodDir(String name,int num) {
    
    
        foodDir.put(name,num);
    }
}

厨师对象

package com.hupp.command;

/**
 * 厨师
 */
public class SeniorChef {
    
    
    public void makeFood(String name, int num) {
    
    
        System.out.println(num+"份" +name);
    }
}

抽象命令类

package com.hupp.command;

/**
 * 抽象命令类
 */
public interface Command {
    
    
    void execute();
}

具体命令类，厨师执行订单上的命令，所以要有厨师类和订单类

package com.hupp.command;

import java.util.Map;
import java.util.Set;

/**
 * 具体的命令类,包含谁下的命令（订单）以及下命令给谁（厨师）
 */
public class OrderCommand implements Command{
    
    
    //接收者对象，厨师
    private SeniorChef receiver;

    //订单对象
    private Order order;

    public OrderCommand(SeniorChef receiver, Order order) {
    
    
        this.receiver = receiver;
        this.order = order;
    }

    @Override
    public void execute() {
    
    
        System.out.println(order.getDiningTable()+"桌的订单：");
        Map<String, Integer> foodDir = order.getFoodDir();
        Set<String> keys = foodDir.keySet();
        for (String foodName : keys) {
    
    
            receiver.makeFood(foodName,foodDir.get(foodName));
        }
        System.out.println(order.getDiningTable()+"桌的订单,已经准备完毕");
    }
}

服务员，发起一系列命令

package com.hupp.command;

import java.util.ArrayList;
import java.util.List;

/**
 * 服务员，请求者角色
 */
public class Waiter {
    
    

    private List<Command> commands = new ArrayList<>();

    public void setCommand(Command command) {
    
    
        commands.add(command);
    }

    //发起命令
    public void orderUp(){
    
    
        System.out.println("服务员说，订单来了。。。");
        for (Command command : commands) {
    
    
            if(command!=null){
    
    
                command.execute();
            }
        }
    }
}

客户端，下单

package com.hupp.command;

public class Client {
    
    
    public static void main(String[] args) {
    
    
        //创建订单1对象
        Order order1 = new Order();
        order1.setDiningTable(1);
        order1.setFoodDir("小葱拌豆腐", 1);
        order1.setFoodDir("炒面", 1);

        //创建订单2对象
        Order order2 = new Order();
        order2.setDiningTable(2);
        order2.setFoodDir("羊肉串", 10);
        order2.setFoodDir("啤酒", 2);

        //厨师对象
        SeniorChef receiver = new SeniorChef();
        OrderCommand orderCommand1 = new OrderCommand(receiver,order1);
        OrderCommand orderCommand2 = new OrderCommand(receiver,order2);

        //服务员对象
        Waiter waiter = new Waiter();
        waiter.setCommand(orderCommand1);
        waiter.setCommand(orderCommand2);
        waiter.orderUp();

    }
}

结果

优缺点

• 优点

1. 降低系统耦合度。命令模式能将调用操作的对象与实现该操作的对象解耦
2. 增加或删除命令非常方便，便于扩展，满足开闭原则
3. 可以实现宏命令。命令模式可以与组合模式结合使用，将多个命令装配成一个组合命令，即宏命令。
4. 命令模式与备忘录模式结合可以实现命令的撤销与恢复

• 缺点

1. 使得系统变得更加复杂，增加了代码阅读的难度
2. 使用命令模式可能会导致系统有过多的具体命令类