下令模式

命令模式
命令模式：
命令模式有三个角色：1、接收者。2、命令者。3、调用者
这三个的关系是：接收者自己有方法，有属性，有自己的行为。命令者定义为一个接口，实现该接口的类持有接收者类，通过构造加载进来，同时有一个execute()方法，里面调用接收者的方法。调用者持有命令者接口，通过set方法加载进来，并有一个action()方法这里和execute()方法区分，里面调用execute()方法，所以调用者对外只暴露该action方法便可以实现不同的行为。实例化的过程为：
Receive receive = new Receive();
Command cc = new ConcreteCommand(receive);
Invoker ik = new Invoker();
ik.setCommand(cc);
ik.action();//这里即为调用的cc.execute()方法但是里面又调用的receiver的方法，这里就等于将调用者与接收者通过命令者解耦了，调用者不关心内部怎么实现，只需调用action()方法，就可以调用receive的方法，对外只暴露了一个方法。
这个模式可以用于队列请求，日志请求，还有struts框架的Action类也是用命令模式实现，就写到这里明天补充代码。

/** *//**
 * @author LX
 * 通用Reveiver类
 */
public abstract class Receiver {
    
    //抽象接收者，定义每个接收者必须完成的业务 
    public abstract void doSomething();
    //撤销
    public abstract void undo();
}
/** *//**
 *抽象Command类
 **/
public abstract class Command {
    
    public abstract void execute();
    public abstract void undo();
}
/** *//**
 *调用者类
 **/
public class Invoker {
     
    private Command command;
    
    public void setCommand(Command command){
        this.command=command;
    }
    
    public void action(){
        this.command.execute();
    }
}
/** *//**
 *具体接收者
 **/
public class ConcreteReceiver1 extends Receiver {

    @Override
    public void doSomething() {
    }

    @Override
    public void undo() {
        
    }
}
/** *//**
 *具体Command类
 **/
public class ConcreteCommand1 extends Command {
    
    private Receiver receiver;
    public ConcreteCommand1(Receiver receiver){
        this.receiver=receiver;
    }
    
    @Override
    public void execute() {
        receiver.doSomething();
    }

    @Override
    public void undo() {
        receiver.undo();
    }
}
/** *//**
 *测试类
 **/
public class Test {
    
    public static void main(String[] args) {
        Invoker invoker = new Invoker();
        Receiver receiver = new ConcreteReceiver1(); //定义接收者
        Command command = new ConcreteCommand1(receiver);//定义一个发送给接收者的命令
        invoker.setCommand(command);//把命令交给调用者去执行
        invoker.action();
    }
}

//更完美的Command类
public abstract class Command {
    //定义一个子类的全局共享变量
    protected final Receiver receiver;
    //实现类必须定义一个接收者
    public Command(Receiver receiver){
        this.receiver=receiver;
    }
    //每个命令类都必须有一个执行命令的方法
    public abstract void execute();
}
public class ConcreteCommand1 extends Command{
    
    //设置自己的默认构造
    public ConcreteCommand1(){
        super(new ConcreteReceiver1());
    }
    //设置新的接收者
    public ConcreteCommand1(Receiver receiver) {
        super(receiver);
    }
    //业务处理
    @Override
    public void execute() {
        super.receiver.doSomething();
    }
}
public class Test {
    public static void main(String[] args) {
        Invoker invoker = new Invoker();
        Command command = new ConcreteCommand1(); //无需知道具体接收者
        invoker.setCommand(command);
        invoker.action();
    }
}

关键命令调用类：

/** *//**
  * 该类持有Command抽象类，action方法即可调用
  * Command的子类方法名称都为execute
  **/
 public class invoker{
          private Command command;
          public setCommand(Command command){
             this.command = command            
        }
         public void action(){
             this.command.execute();
}       
}

Command抽象类，里面只含有execute()方法，所以其子类构造参数为命令执行者，并且持有命令执行者对象，execute方法里面即为命令执行者对象.方法

public abstract class Command{
    public abstract void execute();
 }
 
 public class Command1 extends Command{
    private Receiver receiver;
    public Command1(Receiver receiver){
        this.receiver = receiver;
 }
   @Override
   public void execute(){
     receiver.doSomething();
} 
}

以上Receiver就是具体的执行对象（抽象类），该模式体现了高内聚的特点，缺点为有N个命令就会有N个子类，导致类膨胀

相关推荐