命令模式

来源：互联网发布：unity3d 2d骨骼动画编辑：程序博客网时间：2024/06/05 04:59

命令（Command）模式：
命令模式属于对象的行为模式。命令模式又称为行动模式或交易模式。
命令模式把一个请求或者操作封装到一个对象中。命令模式允许系统使用不同的请求把客户端参数化，对请求排队或者记录请求日志，可以提供命令
的撤销和恢复功能。

命令模式是对命令的封装。命令模式把发出命令的责任和执行命令的责任分割开，委派给不同的对象。每一个命令都是一个操作：
请求的一方发出请求要求执行一个操作；接受的一方收到请求，并执行操作。命令模式允许请求的一方和接收的一方独立开来，使得请求的一方不必
知道接收请求的一方的接口，更不必知道请求是怎么被接收，以及操作是否被执行、何时被执行，以及是怎么被执行的。

命令允许请求的一方和接收请求的一方能够独立演化，从而具有一下的优点：
（1）命令模式使新的命令很容易地被加入到系统里。
（2）允许接收请求的一方决定是否要否决要求。
（3）能较容易地设计一个命令队列。
（4）可以容易地实现对请求的Undo和Redo。
（5）在需要的情况下，可以较容易地将命令记录日志。

一、命令模式涉及到的五个角色：
1、客户角色：创建了一个具体命令对象并确定其接收者。
2、命令角色：声明了一个给所有具体命令类的抽象接口。这是一个抽象角色，通常由一个java接口或java抽象类实现。
3、具体命令角色：定义一个接受者和行为之间的弱耦合；实现execute方法，负责调用接收者的相应操作。execute方法通常叫做
执行方法。
4、请求者（Invoke）角色：负责调用命令对象执行请求，相关的方法叫做行动方法。
5、接收者（Receiver）角色：负责具体实施和执行一个请求。任何一个类都可以成为接收者，实施和执行请求的方法叫做行动方法。

Java代码  
//客户端  
        public class Client{  
            public static void main(String[] args){  
                Receiver receiver = new Receiver();  
                Command command = new ConcreteCommand(receiver);  
                Invoker invoker = new Invoker(command);  
                invoker.action();         
            }  
        }  
          
        //请求者角色  
        public class Invoker{  
            private Command command;  
              
            public Invoker(Command command){  
                this.command = command;  
            }  
              
            public void action(){  
                command.execute();  
            }  
        }  
          
        //接收者  
        public class Receiver{  
          
            public Receiver(){  
                //..............  
            }  
              
            //行动方法  
            public void action(){  
                System.out.println("Action has been taken.");  
            }  
        }  
          
        //抽象命令角色  
        public interface Command{  
            void execute();  
        }  
          
        //具体命令类  
        public class ConcreteCommand implements Command{  
            private Receiver receiver;  
              
            public ConcreteCommand(Receiver receiver){  
                this.receiver = receiver;  
            }  
              
            public void execute(){  
                receiver.action();  
            }  
        }  
          
        命令模式的活动序列  
            （1）客户端创建了一个ConcreteCommand对象，并指明了接收者；  
            （2）请求者对象保存了ConcreteCommand对象；  
            （3）请求者对象通过调用action()方法发出请求。如果命令是能撤销（Undo）的，那么ConcreteCommand保存了  
                 调用execute()方法之前的状态。  
            （4）ConcreteCommand对象调用接收的一方的方法执行请求。  
          
    //一个例子（创世纪）  
    //抽象命令类  
    public interface CommandFromGod{  
        public void execute();  
    }  
      
    //请求角色  
    import java.awt.*;  
    import java.awt.event.*;  
      
    public class TheWorld extends Frame implements ActionListener{  
        private LetThereBeLightCommand btnLight;  
        private LetThereBeLandCommand btnLand;  
        private ResetCommand btnReset;  
        private GodRestsCommand btnExit;  
        private Panel p;  
          
        public TheWorld(){  
            super("This is the world,and God says...");  
            p = new Panel();  
            p.setBackground(Color.black);  
              
            add(p);  
              
            btnLight = new LetThereBeLightCommand("Let there be light",p);  
            btnLand = new LetThereBeLandCommand("Let there be land",p);  
            btnReset = new ResetCommand("Reset",p);  
            btnExit = new GodRestsCommand("God rests");  
              
            p.add(btnLight);  
            p.add(btnLand);  
            p.add(btnReset);  
            p.add(btnExit);  
              
            btnLight.addActionListener(this);  
            btnLand.addActionListener(this);  
            btnReset.addActionListener(this);  
            btnExit.addActionListener(this);  
            setBounds(100,100,400,200);  
            setVisible(true);  
        }  
          
        public void actionPerformed(ActionEvent e){  
            Command obj = (Command)e.getSource();  
            obj.execute();  
        }  
          
        public static void main(String[] args){  
            new TheWorld();  
        }  
    }     
      
    import java.awt.*;  
    import java.awt.event.*;  
      
    public class LetThereBeLightCommand extends Button implements CommandFromGod{  
        private Panel p;  
          
        public LetThereBeLightCommand(String caption,Panel p){  
            super(caption);  
            this.p = p;  
        }  
          
        public void execute(){  
            p.setBackground(Color.white);  
        }  
    }  
      
    import java.awt.*;  
    import java.awt.event.*;  
      
    public class LetThereBeLandCommand extends Button implements CommandFromGod{  
        private Panel p;  
          
        public LetThereBeLandCommand(String caption,Panel p){  
            super(caption);  
            this.p = p;  
        }  
          
        public void execute(){  
            p.setBackground(Color.orange);  
        }  
    }  
      
    import java.awt.*;  
    import java.awt.event.*;  
      
    public class ResetCommand extends Button implements CommandFromGod{  
        private Panel p;  
          
        public ResetCommand(String caption,Panel p){  
            super(caption);  
            this.p = p;  
        }  
          
        public void execute(){  
            p.setBackground(Color.black);  
        }  
    }  
      
    import java.awt.*;  
    import java.awt.event.*;  
      
    public class GodRestsCommand extends Button implements CommandFromGod{  
        public GodRestsCommand(String caption){  
            super(caption);  
        }  
          
        public void execute(){  
            System.exit(0);  
        }  
    }  

二、在什么情况下应当使用命令模式
1、使用命令模式作为“回呼”在面向对象系统中的替代。“回呼”讲的便是先将一个函数登记上，然后在以后调用此函数。
2、需要在不同的时间指定请求，将请求排队。一个命令对象和原先的请求发出者可以有不同的生命期。换言之，原先的请求
   发出者可能已经不在了，而命令对象本身仍然是活动的。这时命令的接收者可以是在本地，也可以在网络的另外一个地址。
   命令对象可以在串行化之后传送到另外一台机器上去。
3、系统需要支持命令的撤销（Undo）。命令对象可以把状态存储起来，等到客户端需要撤销命令所产生的效果时，可以调用
   undo（）方法，把命令所产生的效果撤销掉。命令对象还可以提供redo（）方法，以供客户端在需要时，再重新实施命令
   的效果。
4、如果一个系统要将系统中所有的数据更新到日志里，以便在系统崩溃时，可以根据日志里读回所有的数据更新命令，重新调用
   execute()方法一条一条执行这些命令，从而恢复系统在崩溃前所做的数据更新。
5、一个系统需要支持交易（transaction）。一个交易结构封装了一组数据更新命令。使用命令模式来实现交易结构可以使系统
   增加新的交易类型。826P；

三、使用命令模式的优点和缺点

1、优点
（1）命令模式把请求一个操作的对象与知道怎么执行一个操作的对象分割开。
（2）命令类与其他任何别的类一样，可以修改和推广。
（3）你可以把命令对象聚合在一起，合成为合成命令。比如上面的例子里所讨论的宏命令便是合成命令的例子。合成命令
      是合成模式的应用。
（4）由于加进新的具体命令类不影响其他的类，因此增加新的具体命令类很容易。
2、缺点
使用命令模式会导致某些系统有过多的具体命令类。某些系统可能需要几十个，几百个甚至几千个具体命令类，这会使命令模式

在这样的系统里变得不实际。