java设计模式——命令模式

命令模式属于23种设计模式中行为模式中的一个，它也是一种简单实用非常普遍的设计模式。
首先看下GOF对命令模式的定义：将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。
命令模式主要应用于将行为调用者与实现者解耦。比如我们以前惯用的写代码的方式是LogicProcess logic = new LogicProcess();  然后紧接着调用实现方法logic.process()，这种写法其实非常普遍，但这种写法把行为调用者和行为实现者耦合在了一起，一般情况下并没有什么问题的，但当调用逻辑比较复杂或则调用行为有多种实现时就非常不利于程序的扩展。
命令模式的适用场景描述：
（1）整个调用过程比较繁杂，或者存在多处这种调用。使用Command类对该调用加以封装，便于功能的再利用。
（2）调用前后需要对调用参数进行某些处理。
（3）调用前后需要进行某些额外处理，比如日志，缓存，记录历史操作等。
命令模式结构图如下：

命令模式的参与角色：
（1）抽象命令角色（Command）：抽象命令，包含命令执行的抽象方法
（2）命令接收者（Receiver）：命令接收者角色，它包含所有命令的具体行为实现方法。
（3）具体命令角色（ConcreteCommand）：它包含一个命令接收者对象，并调用接收者的对象相应实现方法。
（4）命令调用者角色（Invoker）：提供给客户端调用，接收客户端所传递的具体命令对象。
下面看具体代码实现：
1、第一个文件抽象命令角色：Command.java

点击(此处)折叠或打开

1. /**
2.  * 抽象命令接口
3.  */
4. public interface Command {
5.     /**
6.      * 命令执行方法
7.      */
8.     public void execute();
9. }

2、第二个文件命令接收者角色：Document.java

点击(此处)折叠或打开

1. /**
2.  * 命令接收者 Receiver
3.  */
4. public class Document {
5.  
6.     /**
7.      * 操作实体对象
8.      */
9.     public static StringBuffer sbr = new StringBuffer();
10.     
11.     /**
12.      * 计数器
13.      */
14.     public static int count = 0;
15.     
16.     /**
17.      * 撤销实现方法
18.      */
19.     public void undo(){
20.         System.out.println("调用撤销实现方法，字符串递减");
21.         sbr.deleteCharAt(sbr.length()-1);
22.         count --;
23.         System.out.println("当前文本为：" + sbr.toString());
24.     }
25.     
26.     /**
27.      * 恢复实现方法
28.      */
29.     public void redo(){
30.         System.out.println("调用恢复实现方法，字符串递加");
31.         this.sbr.append(count);
32.         count ++;
33.         System.out.println("当前文本为：" + sbr.toString());
34.     }
35.     
36.     /**
37.      * 执行实现方法
38.      */
39.     public void add(){
40.         System.out.println("调用执行实现方法，字符串递加");
41.         this.sbr.append(count);
42.         count ++;
43.         System.out.println("当前文本为：" + sbr.toString());
44.     }
45. }

3、第三个文件具体命令角色：AddCommand.java

点击(此处)折叠或打开

1. /**
2.  * 执行命令实现类
3.  */
4. public class AddCommand implements Command {
5.  
6.     /**
7.      * 命令接受者对象
8.      */
9.     public Document doucment;
10.     
11.     /**
12.      * 构造方法
13.      * @param document
14.      */
15.     public AddCommand(Document document){
16.         this.doucment = document;
17.     }
18.     
19.     @Override
20.     public void execute() {
21.         // TODO Auto-generated method stub
22.         this.doucment.add();
23.     }
24. }

4、第四个文件具体命令角色：UndoCommand.java

点击(此处)折叠或打开

1. /**
2.  * 撤销命令实现类
3.  */
4. public class UndoCommand implements Command {
5.  
6.     /**
7.      * 命令接受者对象
8.      */
9.     public Document doucment;
10.     
11.     /**
12.      * 构造方法
13.      * @param document
14.      */
15.     public UndoCommand(Document document){
16.         this.doucment = document;
17.     }
18.     
19.     @Override
20.     public void execute() {
21.         // TODO Auto-generated method stub
22.         this.doucment.undo();
23.     }
24. }

5、第五个文件具体命令角色：RedoCommand.java

点击(此处)折叠或打开

1. /**
2.  * 恢复命令实现类
3.  */
4. public class RedoCommand implements Command {
5.  
6.     /**
7.      * 命令接受者对象
8.      */
9.     public Document doucment;
10.     
11.     /**
12.      * 构造方法
13.      * @param document
14.      */
15.     public RedoCommand(Document document){
16.         this.doucment = document;
17.     }
18.     
19.     @Override
20.     public void execute() {
21.         // TODO Auto-generated method stub
22.         this.doucment.redo();
23.     }
24.  
25. }

6、第六个文件调用者角色：Invoker.java

点击(此处)折叠或打开

1. /**
2.  * 提供给客户端的命令调用方法
3.  * @author feng
4.  *
5.  */
6. public class Invoker {
7.  
8.     /**
9.      * 命令对象
10.      */
11.     public Command command;
12.     
13.     /**
14.      * 命令设置方法
15.      * @param command
16.      */
17.     public void setCommand(Command cmd){
18.         this.command = cmd;
19.     }
20.     
21.     /**
22.      * 命令执行方法
23.      */
24.     public void execute(){
25.         this.command.execute();
26.     }
27. }

7、第七个文件TestMain.java

点击(此处)折叠或打开

1. /**
2.  * 测试Main方法
3.  */
4. public class TestMain {
5.  
6.     public static void main(String args[]){
7.         Document doc = new Document(); //文档实体对象
8.         AddCommand addCmd = new AddCommand(doc); //具体命令实体对象
9.         UndoCommand undoCmd = new UndoCommand(doc); //具体命令实体对象
10.         RedoCommand redoCmd = new RedoCommand(doc); //具体命令实体对象
11.         Invoker invoker = new Invoker(); //调用者对象
12.         invoker.setCommand(addCmd);
13.         invoker.execute();
14.         invoker.setCommand(addCmd);
15.         invoker.execute();
16.         invoker.setCommand(undoCmd);
17.         invoker.execute();
18.         invoker.setCommand(redoCmd);
19.         invoker.execute();
20.     }
21. }

虽然代码看似挺多，但其实命令模式的结构还是比较清晰的，总的来说命令模式的使用流程就是首先创建一个抽象命令，然后创建多个具体命令实现抽象命令接口，然后创建一个命令接受者角色，它包含各种的行为的具体实现，然后再有一个命令调用者角色，提供给客户端，用于接收客户端的参数。
下面总结下命令模式的优点：
（1）命令模式将行为调用者和各种行为分隔开，降低程序的耦合，便于程序扩展。
（2）命令模式将行为的具体实现封装起来，客户端无需关心行为的具体实现。
（3）命令模式可为多种行为提供统一的调用入口，便于程序对行为的管理和控制。

转载于:https://my.oschina.net/u/3345581/blog/913351