【JAVA设计模式第三课】命令模式让boss给我们加工资

【JAVA设计模式-第三课】命令模式-让boss给我们加工资


 

  •  命令模式

 命令模式又称动作模式或事物模式。

将一个请求封装为一个对象,使用户可以用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可撤销的操作。

原文:

Command Pattern(Another Name:Action , Transaction)

   Encapsulate a request as an object, thereby letting you parameterize clients with different request, queue or log requests, and support undoable operations.

--《Design Patterns》GOF    

 

在设计开发中,很多时候,我们都会遇到这样的情况:一个对象(请求者)请求另一个对象(被请求者)并调用其方法去执行某个动作或者达到某一目的。而这个请求者可能并不需要或者根本无法直接和被请求者打交道,也就是请求者不想或者无法含有被请求者的引用,那么就可以使用命令模式。比如:我们想让boss加工资,但是boss经常出差或者其他什么的(你懂的啊、、),我们根本无法直接联系到他。但是我们的目的是明确的,就是“boss要给我们加工资”。所以就可以把“boss要给我们加工资”作为一个命令。我们只要能将这个“命令”被执行,加工资就现实啦 ^_U。

【X】:命令模式中,当一个对象请求另一个对象并调用其方法时,不和被请求者(接受者)直接通信,而是将这个“请求”封装到一个叫“命令”的对象中,其封装手段是将“请求”封装在“命令”对象的一个方法中。命令模式的核心就是使用命令对象来封装方法调用,即将请求者的请求,"接受者调用方法”封装到命令对象的一个方法中。这样,当一个对象请求另一个对象调用方法来完成某项任务时,只需和命令对象通信就可以了,让命令对象去调用封装了“请求”的那个方法。如下图所示:

命令模式

接下来,我们来分析一下在命令模式的结构中的各个角色。角色包括四种角色,分别为请求者(Invoker)、接收者(Receiver)、命令接口(Command)、具体命令(ConcreteCommand)。

【注释】:

  • 请求者(Invoker):请求者是一个包含了Command接口变量的类的实例。两者的关系为关联关系(类A的属性包括类B或者对象B,则类A与B相关联)。请求者中的Command接口变量可以存放任何具体命令的引用(上转型存储)。请求者负责调用具体命令,让具体命令执行那些封装了“请求”的方法,如execute()方法。
  • 接收者(Receiver):接收者是一个类的实例,负责执行与请求相关的操作。
  • 命令接口(Command):命令是一个接口,规定了用来封装“请求”的若干个方法,比如execute()、undo()等方法。
  • 具体命令(ConcreteCommand) :具体命令是实现了命令接口(Command)的类的实例。具体命令必须实现命令接口中的所有抽象方法,比如execute()方法,使该方法封装一个"请求"。具体命令和命令接口之间的关系就是实现关系。在具体命令中包含了一个接收者变量的类实例,So,两者之间的关系为关联关系。

下图(命令模式的UML类图)

命令模式

 下面是类图及具体的代码实现:让boss给我们加工资。

命令模式-类图1

  • 接收者源码
 1 /**
 2  * 接收者
 3  */
 4 public class CompanyBloc {
 5     /**
 6      * 处理"加薪"命令
 7      */
 8     public void addSalary(){
 9         System.out.println("公司董事会商议决定的,让boss给员工加工资.");
10     }
11 }
  • 命令接口源码
1 /**
2  * 规定了用于封装"请求"的方法
3  */
4 public interface Command {
5     /**
6      * 封装"请求"的方法
7      */
8     public abstract void execute();
9 }
  • 具体命令源码
 1 /**
 2  * 具体命令
 3  */
 4 public class ConcreteCommand implements Command{
 5     private  CompanyBloc receiver;//接收者
 6     
 7     public ConcreteCommand(CompanyBloc receiver){
 8         this.receiver = receiver;
 9     }
10     
11     @Override
12     public void execute() {  //封装"请求"
13         receiver.addSalary(); //加工资
14     }
15 
16 }
  • 请求者源码
 1 /**
 2  * 请求者
 3  */
 4 public class Employee {
 5     private Command command;
 6 
 7     public Employee(Command command) {
 8         this.command = command;
 9     }
10 
11     /**
12      * 让具体命令执行execute()方法
13      */
14     public void startExecuteCommand() {
15         command.execute();
16     }
17     
18 }
  • 命令模式运行源码
 1 /**
 2  * 使用命令模式
 3  */
 4 public class Application {
 5     public static void main(String[] args) {
 6         //创建接收者
 7         CompanyBloc receiver = new CompanyBloc();
 8         //创建具体命令并制定接收者
 9         Command command = new ConcreteCommand(receiver);
10         //创建请求者
11         Employee invoker = new Employee(command);
12         invoker.startExecuteCommand();
13     }
14 }
  •  运行结果
公司董事会商议决定的,让boss给员工加工资.

 命令模式中,居然有命令执行的动作,当然也还有命令撤销的动作。即与execute()相对于的方法undo()来撤销execute()方法的执行效果。当然如果execute()方法的执行效果不可撤销(比如:我们退出系统--当退出命令发出,那么就不能撤销该命令了。),那在具体实现(命令)中就不必去实现undo()方法了。

还是针对,以“让boss给我们加工资”为例。我们要求boss给我们加工资,这只是要求,boss们有很多种执行方法,如:同意加工资,不同意加工资,同意之后又反悔撤销了命令,So 我们要在命令接口中增加一些新的方法如undo()。

 下面是类图及具体代码实现:

命令模式-类图2

 1 /**
 2  * 接收者
 3  */
 4 public class CompanyBloc {
 5     /**
 6      * 处理"加薪"命令
 7      */
 8     public void addSalary(){
 9         System.out.println("公司董事会商议决定的,让boss给员工加工资.");
10     }
11     
12     /**
13      * 不处理"加薪"命令(取消命令)
14      */
15     public void cancelSalary(){
16         System.out.println("公司董事会经过商讨, 做出如下艰难的决定:暂时不让boss给员工加工资.");
17     }
18     
19 }
 1 /**
 2  * 规定了用于封装"请求"的方法及撤销命令的方法
 3  */
 4 public interface Command {
 5     /**
 6      * 封装"请求"的方法
 7      */
 8     public abstract void execute();
 9     
10     /**
11      * 撤销"命令"
12      */
13     public abstract void undo();
14 }
 1 /**
 2  * 具体命令
 3  */
 4 public class ConcreteCommand implements Command{
 5     private  CompanyBloc receiver;//接收者
 6     
 7     public ConcreteCommand(CompanyBloc receiver){
 8         this.receiver = receiver;
 9     }
10     
11     @Override
12     public void execute() {  //封装"请求"
13         receiver.addSalary(); //加工资
14     }
15 
16     @Override
17     public void undo() {
18         receiver.cancelSalary();//取消加工资
19     }
20 
21 }
 1 /**
 2  * 请求者
 3  */
 4 public class Employee {
 5     private Command command;
 6 
 7     public Employee(Command command) {
 8         this.command = command;
 9     }
10 
11     /**
12      * 让具体命令执行execute()方法
13      */
14     public void startExecuteCommand() {
15         command.execute();
16     }
17     
18     /**
19      * 让具体命令执行undo()方法
20      */
21     public void undoCommand(){
22         command.undo();
23     }
24     
25 }
 1 /**
 2  * 使用命令模式
 3  */
 4 public class Application {
 5     public static void main(String[] args) {
 6         //创建接收者
 7         CompanyBloc receiver = new CompanyBloc();
 8         //创建具体命令并制定接收者
 9         Command command = new ConcreteCommand(receiver);
10         //创建请求者
11         Employee invoker = new Employee(command);
12         invoker.startExecuteCommand();
13         invoker.undoCommand();
14     }
15 }
公司董事会商议决定的,让boss给员工加工资.
公司董事会经过商讨, 做出如下艰难的决定:暂时不让boss给员工加工资.

为了更好的区分执行和撤销命令动作,我们将在具体接口中新增一个命令集存储器,用于存放各种不同的命令。每个命令都将带有一个命令名字。

类图如下:

命令模式-类图3

 1 /**
 2  * 接收者
 3  */
 4 public class CompanyBloc {
 5     /**
 6      * 处理"加薪"命令
 7      */
 8     public void addSalary(String order){
 9         System.out.println("【红】公司董事会商议决定的,同意【"+order+"】方案并择日落实执行.");
10     }
11     
12     /**
13      * 不处理"加薪"命令(取消命令)
14      */
15     public void cancelSalary(String order){
16         System.out.println("【黑】公司董事会经过商讨, 做出如下艰难的决定:撤销【"+order+"】");
17     }
18     
19 }
 1 /**
 2  * 规定了用于封装"请求"的方法及撤销命令的方法
 3  */
 4 public interface Command {
 5     /**
 6      * 封装"请求"的方法
 7      */
 8     public abstract void execute(String orderName);
 9     
10     /**
11      * 撤销"命令"
12      */
13     public abstract void undo();
14 }
 1 /**
 2  * 具体命令
 3  */
 4 public class ConcreteCommand implements Command{
 5     private  CompanyBloc receiver;//接收者
 6     private ArrayList<String> orders;
 7     public ConcreteCommand(CompanyBloc receiver){
 8         orders = new ArrayList<String>();
 9         this.receiver = receiver;
10     }
11     
12     @Override
13     public void execute(String orderName) {  //封装"请求"
14         orders.add(orderName);
15         receiver.addSalary(orderName); //加工资
16     }
17 
18     @Override
19     public void undo() {
20         if (orders.size() > 0) {
21             int size = orders.size();
22             String order = orders.get(size - 1);
23             orders.remove(size - 1);
24             receiver.cancelSalary(order);//取消命令
25         }else{
26             System.out.println("没有命令需要撤销");
27         }
28     }
29 
30 }
 1 /**
 2  * 请求者
 3  */
 4 public class Employee {
 5     private Command command;
 6 
 7     public Employee(Command command) {
 8         this.command = command;
 9     }
10 
11     /**
12      * 让具体命令执行execute()方法
13      */
14     public void startExecuteCommand(String orderName) {
15         command.execute(orderName);
16     }
17     
18     /**
19      * 让具体命令执行undo()方法
20      */
21     public void undoCommand(){
22         command.undo();
23     }
24     
25 }
 1 /**
 2  * 使用命令模式
 3  */
 4 public class Application {
 5     public static void main(String[] args) {
 6         //创建接收者
 7         CompanyBloc receiver = new CompanyBloc();
 8         //创建具体命令并制定接收者
 9         Command command = new ConcreteCommand(receiver);
10         //创建请求者
11         Employee invoker = new Employee(command);
12         String orderName = "要福利、要加薪。";
13         invoker.startExecuteCommand(orderName);
14         invoker.undoCommand();
15         orderName = "要福利、去旅游";
16         invoker.startExecuteCommand(orderName);
17         invoker.undoCommand();
18         invoker.undoCommand();
19     }
20 }

运行结果:

【红】公司董事会商议决定的,同意【要福利、要加薪。】方案并择日落实执行.
【黑】公司董事会经过商讨, 做出如下艰难的决定:撤销【要福利、要加薪。】
【红】公司董事会商议决定的,同意【要福利、去旅游】方案并择日落实执行.
【黑】公司董事会经过商讨, 做出如下艰难的决定:撤销【要福利、去旅游】
没有命令需要撤销

上一课:【JAVA设计模式-第二课】UML建模简介

原文地址:https://www.cnblogs.com/weijunqiang/p/3113377.html