初学 Java 设计模式（十五）：实战命令模式 「扫码点餐」

一、命令模式介绍

1. 解决的问题

主要解决在系统中，行为请求者和行为实现者紧耦合的问题。

2. 定义

命令模式是一种行为设计模式，它可将请求转换为一个包含与请求相关的所有信息的独立对象。这个转换会根据不同的请求将方法参数化、延迟请求执行或将其放入队列中，且能实现可撤销操作。

3. 应用场景

• 需要通过操作来参数化对象，可使用命令模式。
• 将操作放入队列中、延迟操作的执行或者远程执行操作，可使用命令模式。
• 实现操作回滚功能，可使用命令模式。

二、命令模式优缺点

1. 优点

• 单一职责原则：可以解耦触发和执行操作的类。
• 开闭原则：可以在不修改已有客户端代码的情况下，在程序中创建新的命令
• 可以实行撤销和恢复功能。
• 可以实现操作的延迟执行。
• 可以将一组简单命令组合成一个复杂命令。

2. 缺点

• 代码可能会变得更加复杂，因为在发送者和接收者之间增加了一个全新的层次。

三、命令模式应用实例：扫码点餐

1. 实例场景

今年五一五天假，很多小伙伴可能以及迫不及待地要出去玩了。出去除了看风景以外，最重要的就是体验一下当地的美食。找到心仪的店，当然少不了排队，排队的同时服务员会给一个二维码提前点餐了，当我们选好了想要吃的美食，确定下单，后台系统自动将订单打印给不同的厨师。

这时，我们的订单就是一个命令，它在厨师制作之前一直在队列中等待。命令包含制作这些美食的所有信息。厨师可以根据这个订单直接制作，不需要和我们确认订单信息。

今天，我们就以扫码点餐为例，介绍一下命令模式。

2. 命令模式实现

2.1 工程结构

command-pattern
└─ src
    ├─ main
    │    └─ java
    │    └─ org.design.pattern.command
    │       ├─ model
    │       │    ├─ cook
    │       │    │    ├─ Cook.java
    │       │    │    └─ impl
    │       │    │         ├─ ChiefCook.java
    │       │    │         └─  CustomCook.java
    │       │    └─ dish
    │       │         ├─ Dish.java
    │       │         └─ impl
    │       │              ├─ BraisedIntestines.java
    │       │              ├─ FriedPeanuts.java
    │       │              ├─ LocalPotChicken.java
    │       │              └─ ShreddedCabbage.java
    │       └─ service
    │            └─ OrderService.java
    │                 └─ impl
    │                    └─ OrderServiceImpl.java
    └─ test
        └─ java
            └─ org.design.pattern.command
                  └─ OrderServiceTest.java

2.2 代码实现

2.2.1 实体类

厨师接口

/**
 * 厨师接口
 */
public interface Cook {

    /**
     * 做饭
     * @param dishName 菜名
     */
    void cooking(String dishName);
}

主厨实体类

/**
 * 主厨
 */
@Slf4j
public class ChiefCook implements Cook {

    /**
     * 做饭
     *
     * @param dishName 菜名
     */
    @Override
    public void cooking(String dishName) {
        log.info("主厨制作{}", dishName);
    }
}

普通厨师实体类

/**
 * 普通厨师
 */
@Slf4j
public class CustomCook implements Cook {

    /**
     * 做饭
     *
     * @param dishName 菜名
     */
    @Override
    public void cooking(String dishName) {
        log.info("普通厨师制作{}", dishName);
    }
}

美食接口

/**
 * 美食接口
 */
public abstract class Dish {

    /**
     * 厨师
     */
    protected Cook cook;

    public Dish(Cook cook) {
        this.cook = cook;
    }

    /**
     * 制作
     */
    abstract public void cook();
}

九转大肠实体类

/**
 * 九转大肠
 */
public class BraisedIntestines extends Dish {

    public BraisedIntestines(Cook cook) {
        super(cook);
    }

    /**
     * 制作
     */
    @Override
    public void cook() {
        this.cook.cooking("九转大肠");
    }
}

油炸花生米实体类

/**
 * 油炸花生米
 */
public class FriedPeanuts extends Dish {

    public FriedPeanuts(Cook cook) {
        super(cook);
    }

    /**
     * 制作
     */
    @Override
    public void cook() {
        this.cook.cooking("油炸花生米");
    }
}

地锅鸡实体类

/**
 * 地锅鸡
 */
public class LocalPotChicken extends Dish {

    public LocalPotChicken(Cook cook) {
        super(cook);
    }

    /**
     * 制作
     */
    @Override
    public void cook() {
        this.cook.cooking("地锅鸡");
    }
}

手撕包菜实体类

/**
 * 手撕包菜
 */
public class ShreddedCabbage extends Dish {

    public ShreddedCabbage(Cook cook) {
        super(cook);
    }

    /**
     * 制作
     */
    @Override
    public void cook() {
        this.cook.cooking("手撕包菜");
    }
}

2.2.2 服务类

点餐服务接口

/**
 * 点餐服务接口
 */
public interface OrderService {

    /**
     * 点菜
     * @param dish 菜
     */
    void order(Dish dish);

    /**
     * 下单
     */
    void placeOrder();
}

点餐服务实现类

/**
 * 点餐服务实现类
 */
public class OrderServiceImpl implements OrderService {

    private List<Dish> dishList = new ArrayList<>();

    /**
     * 点菜
     *
     * @param dish 菜
     */
    @Override
    public void order(Dish dish) {
        dishList.add(dish);
    }

    /**
     * 下单
     */
    @Override
    public synchronized void placeOrder() {
        for (Dish dish : dishList) {
            dish.cook();
        }
        dishList.clear();
    }
}

2.3 测试验证

2.3.1 测试验证类

public class OrderServiceTest {

    @Test
    public void testPlaceOrder() {
        Cook chiefCook = new ChiefCook();
        Cook customCook = new CustomCook();
        Dish braisedIntestines = new BraisedIntestines(chiefCook);
        Dish localPotChicken = new LocalPotChicken(chiefCook);
        Dish friedPeanuts = new FriedPeanuts(customCook);
        Dish shreddedCabbage = new ShreddedCabbage(customCook);

        OrderService orderService = new OrderServiceImpl();
        orderService.order(braisedIntestines);
        orderService.order(localPotChicken);
        orderService.order(friedPeanuts);
        orderService.order(shreddedCabbage);
        orderService.placeOrder();
    }
}

2.3.2 测试结果

21:08:41.617 [main] INFO  o.d.p.c.model.cook.impl.ChiefCook - 主厨制作九转大肠
21:08:41.620 [main] INFO  o.d.p.c.model.cook.impl.ChiefCook - 主厨制作地锅鸡
21:08:41.620 [main] INFO  o.d.p.c.model.cook.impl.CustomCook - 普通厨师制作油炸花生米
21:08:41.620 [main] INFO  o.d.p.c.model.cook.impl.CustomCook - 普通厨师制作手撕包菜

Process finished with exit code 0

四、命令模式结构

1. 触发者（Invoker）—— 亦称 “发送者（Sender）”类负责对请求进行初始化，其中必须包含一个成员变量来存储对命令对象的引用。

   发送者触发命令，而不向接收者这集发送请求，且发送者并不负责创建命令对象：通常会通过构造函数从客户端处获取预先生成的命令。

2. 命令（Command）接口通常仅声明一个执行命令的方法。

3. 具体命令（Concrete Commands）会实现各种类型的请求。

   具体命令自身并不完成工作，而是会将调用委派给一个业务逻辑对象，当然为了简化代码，也合并该对象。

   接收对象执行方法所需的参数可声明为具体命令的成员对象，同时可以将命令对象设为不可变，仅允许通过构造早函数来对这些成员变量进行初始化。

4. 接收者（Receiver）类包含部分业务逻辑。

   基本上，任何对象都可以作为接收者。绝大部分命令只处理如何将请求传递给接收者的细节，接收者自行完成实际的工作。

5. 客户端（Client）会创建并配置具体命令对象。

   客户端必须将接收者实体在内的所有请求参数传递给命令的构造函数，之后，生成的命令就可以与一个或多个发送者相关联。

设计模式并不难学，其本身就是多年经验提炼出的开发指导思想，关键在于多加练习，带着使用设计模式的思想去优化代码，就能构建出更合理的代码。

源码地址：https://github.com/yiyufxst/design-pattern-java

参考资料：
小博哥重学设计模式：https://github.com/fuzhengwei/itstack-demo-design
深入设计模式：https://refactoringguru.cn/design-patterns/catalog