设计模式之命令模式

命令模式

概述

在软件系统中，“行为请求者”与“行为实现者”通常呈现一种“紧耦合”。但在某些场合，比如要对行为进行“记录、撤销/重做、事务”等处理，这种无法抵御变化的紧耦合是不合适的。在这种情况下，如何将“行为请求者”与“行为实现者”解耦？将一组行为抽象为对象，实现二者之间的松耦合。这就是命令模式（Command Pattern）。

在开发过程中，命令模式并不是很常见，而在现实生活中，处处充满了命令模式。比如顾客到餐厅点餐，顾客将点好的菜交给店员，这时候店员再下命令给厨师，这期间店员就充当了”行为请求者”，厨师充当了“行为实现者”。

示例程序

示例程序中就演示下单的命令，店员接收到顾客点的菜单之后将他交给对应的厨房，让厨师制作。

UML图

代码实现

ICook

public interface ICook {
    void doCooking();
}

ICook实现类

@Slf4j
public class NoodlesCook implements ICook {
    @Override
    public void doCooking() {
        log.info("做面条的厨师正在做面条");
    }
}

@Slf4j
public class SteakCook implements ICook {
    @Override
    public void doCooking() {
        log.info("做牛排的厨师正在做牛排");
    }
}

ICuisine

public interface ICuisine {
    void cook();
}

ICuisine实现类

@AllArgsConstructor
public class NoodlesCuisine implements ICuisine {
    ICook cook;

    @Override
    public void cook() {
        cook.doCooking();
    }
}

@AllArgsConstructor
public class SteakCuisine implements ICuisine {
    ICook cook;

    @Override
    public void cook() {
        cook.doCooking();
    }
}

Waiter

@Slf4j
public class Waiter {
    private List<ICuisine> list = new ArrayList<>();

    //加入菜单
    public void order(ICuisine cuisine){
        list.add(cuisine);
    }

    //做菜
    public synchronized void placeOrder(){
        for (ICuisine cuisine : list){
            cuisine.cook();
        }
        list.clear();
    }
}

Test

@SpringBootTest
class Practice1700ApplicationTests {

    @Test
    void contextLoads() {
        ICuisine noodlesCuisine = new NoodlesCuisine(new NoodlesCook());
        ICuisine steakCuisine = new SteakCuisine(new SteakCook());

        Waiter waiter = new Waiter();
        waiter.order(noodlesCuisine);
        waiter.order(steakCuisine);

        waiter.placeOrder();
    }

}

//结果
2022-06-21 15:32:57.114  INFO 1164 --- [           main] c.y.practice1700.cook.impl.NoodlesCook   : 做面条的厨师正在做面条
2022-06-21 15:32:57.114  INFO 1164 --- [           main] c.y.practice1700.cook.impl.SteakCook     : 做牛排的厨师正在做牛排

总结

通过这样的实现方式，相较于if-else语句，降低了耦合性，也方便其他的命令和实现的扩展。但同时这样的设计模式也带来了一些问题，就是在各种命令与实现的组合下，会扩展出很多实现类，需要进行管理。