设计模式系列：行为型-命令模式（Command Pattern）
简介
命令模式是一种行为型设计模式，它允许将请求或操作封装为一个对象，以便使用不同的请求或参数来调用相同的操作，同时实现撤销和重做的功能。
命令模式的核心思想是将请求发送者和请求接收者解耦，使得请求发送者不需要知道接收者的具体实现细节，只需要通过一个命令对象来发送请求即可。命令模式定义了一个命令接口，所有命令对象都需要实现该接口，该接口规定了要执行的操作。
在命令模式中，通常会有一个命令队列或命令历史记录，用于保存和回溯之前执行的操作。这样可以在需要时撤销或重做之前执行的操作。
结构
命令模式包含以下主要角色：
- 抽象命令类（Command）角色： 定义命令的接口，声明执行的方法。
- 具体命令（Concrete Command）角色：具体的命令，实现命令接口；通常会持有接收者，并调用接收者的功能来完成命令要执行的操作。
- 实现者/接收者（Receiver）角色： 接收者，真正执行命令的对象。任何类都可能成为一个接收者，只要它能够实现命令要求实现的相应功能。
- 调用者/请求者（Invoker）角色： 要求命令对象执行请求，通常会持有命令对象，可以持有很多的命令对象。这个是客户端真正触发命令并要求命令执行相应操作的地方，也就是说相当于使用命令对象的入口。
案例实现
将上面的案例用代码实现，那我们就需要分析命令模式的角色在该案例中由谁来充当。
服务员： 就是调用者角色，由她来发起命令。
资深大厨： 就是接收者角色，真正命令执行的对象。
订单： 命令中包含订单。
类图如下：
代码如下：
public interface Command {
void execute();//只需要定义一个统一的执行方法
}
public class OrderCommand implements Command {
//持有接受者对象
private SeniorChef receiver;
private Order order;
public OrderCommand(SeniorChef receiver, Order order){
this.receiver = receiver;
this.order = order;
}
public void execute() {
System.out.println(order.getDiningTable() + "桌的订单：");
Set<String> keys = order.getFoodDic().keySet();
for (String key : keys) {
receiver.makeFood(order.getFoodDic().get(key),key);
}
try {
Thread.sleep(100);//停顿一下 模拟做饭的过程
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(order.getDiningTable() + "桌的饭弄好了");
}
}
public class Order {
// 餐桌号码
private int diningTable;
// 用来存储餐名并记录份数
private Map<String, Integer> foodDic = new HashMap<String, Integer>();
public int getDiningTable() {
return diningTable;
}
public void setDiningTable(int diningTable) {
this.diningTable = diningTable;
}
public Map<String, Integer> getFoodDic() {
return foodDic;
}
public void setFoodDic(String name, int num) {
foodDic.put(name,num);
}
}
// 资深大厨类 是命令的Receiver
public class SeniorChef {
public void makeFood(int num,String foodName) {
System.out.println(num + "份" + foodName);
}
}
public class Waitor {
private ArrayList<Command> commands;//可以持有很多的命令对象
public Waitor() {
commands = new ArrayList();
}
public void setCommand(Command cmd){
commands.add(cmd);
}
// 发出命令 喊 订单来了，厨师开始执行
public void orderUp() {
System.out.println("美女服务员：叮咚，大厨，新订单来了.......");
for (int i = 0; i < commands.size(); i++) {
Command cmd = commands.get(i);
if (cmd != null) {
cmd.execute();
}
}
}
}
public class Client {
public static void main(String[] args) {
//创建2个order
Order order1 = new Order();
order1.setDiningTable(1);
order1.getFoodDic().put("西红柿鸡蛋面",1);
order1.getFoodDic().put("小杯可乐",2);
Order order2 = new Order();
order2.setDiningTable(3);
order2.getFoodDic().put("尖椒肉丝盖饭",1);
order2.getFoodDic().put("小杯雪碧",1);
//创建接收者
SeniorChef receiver=new SeniorChef();
//将订单和接收者封装成命令对象
OrderCommand cmd1 = new OrderCommand(receiver, order1);
OrderCommand cmd2 = new OrderCommand(receiver, order2);
//创建调用者 waitor
Waitor invoker = new Waitor();
invoker.setCommand(cmd1);
invoker.setCommand(cmd2);
//将订单带到柜台 并向厨师喊 订单来了
invoker.orderUp();
}
}
优缺点
1，优点：
- 降低系统的耦合度。命令模式能将调用操作的对象与实现该操作的对象解耦。
- 增加或删除命令非常方便。采用命令模式增加与删除命令不会影响其他类，它满足“开闭原则”，对扩展比较灵活。
- 可以实现宏命令。命令模式可以与组合模式结合，将多个命令装配成一个组合命令，即宏命令。
- 方便实现 Undo 和 Redo 操作。命令模式可以与后面介绍的备忘录模式结合，实现命令的撤销与恢复。
2，缺点：
- 使用命令模式可能会导致某些系统有过多的具体命令类。
- 系统结构更加复杂。
使用场景
- 系统需要将请求调用者和请求接收者解耦，使得调用者和接收者不直接交互。
- 系统需要在不同的时间指定请求、将请求排队和执行请求。
- 系统需要支持命令的撤销(Undo)操作和恢复(Redo)操作。
源码中的应用
JDK中
- java.lang.Runnable 接口：Runnable 接口是命令模式的一个典型应用。它将一个动作封装成一个对象，使得可以将其作为参数传递给其他方法或者线程。通过实现 Runnable 接口并覆写 run() 方法，可以实现具体的操作，然后将该实现对象传递给 Thread 类的构造函数，从而在新线程中执行。
public class MyRunnable implements Runnable {
@Override
public void run() {
// 执行具体操作
}
}
public class Main {
public static void main(String[] args) {
Runnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();
}
}
- javax.swing.Action 接口：Swing 中的 Action 接口也是命令模式的应用。Action 对象封装了一个动作，并可以与按钮、菜单等组件关联起来。每个 Action 对象都有一个 actionPerformed(ActionEvent e) 方法，用于执行相应的动作。
Action action = new AbstractAction("Click Me") {
@Override
public void actionPerformed(ActionEvent e) {
// 执行具体操作
}
};
- java.util.concurrent.Callable 接口：Callable 接口是另一个命令模式的应用，它类似于 Runnable 接口，但是可以返回一个结果，并且可以抛出异常。通过实现 Callable 接口并覆写 call() 方法，可以实现具体的操作，并且可以在 ExecutorService 中执行。
public class MyCallable implements Callable<String> {
@Override
public String call() throws Exception {
// 执行具体操作并返回结果
return "Hello, Callable!";
}
}
public class Main {
public static void main(String[] args) throws ExecutionException, InterruptedException {
Callable<String> myCallable = new MyCallable();
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(myCallable);
String result = future.get();
System.out.println(result); // 输出 "Hello, Callable!"
executor.shutdown();
}
}
Spring中
- Controller 类：在Spring MVC中，控制器类充当命令的角色，它们接收用户请求并采取相应的操作。每个控制器类通常对应一个特定的URL或URL模式，并负责处理该URL下的所有请求。
@Controller
public class UserController {
@Autowired
private UserService userService;
@GetMapping("/users/{id}")
public String getUser(@PathVariable Long id, Model model) {
User user = userService.getUserById(id);
model.addAttribute("user", user);
return "user-details";
}
// Other handler methods...
}
在这个例子中，UserController 充当了命令的角色，根据用户请求的不同，执行不同的操作。
- @Service 类：在Spring中，服务类通常充当命令的角色，它们封装了业务逻辑，并被其他组件调用以执行特定的操作。服务类可以通过依赖注入来管理它们之间的关系。
@Service
public class OrderService {
@Autowired
private OrderRepository orderRepository;
public void createOrder(Order order) {
// 执行创建订单的逻辑
orderRepository.save(order);
}
// Other service methods...
}
在这个例子中，OrderService 封装了创建订单的操作，并通过依赖注入的方式被其他组件调用。
- @Transactional 注解：在Spring中，
@Transactional注解可以用于声明事务边界，它可以将一系列操作封装成一个事务命令，并在事务管理器的支持下执行。
@Service
public class UserService {
@Autowired
private UserRepository userRepository;
@Transactional
public void createUser(User user) {
// 执行创建用户的逻辑
userRepository.save(user);
}
// Other service methods...
}
在这个例子中，@Transactional 注解将 createUser() 方法内的一系列数据库操作封装成一个事务命令，并确保它们在一个事务中执行。
微信：17873041739
