一天一种设计模式之九-----命令模式

一.命令模式简介

1. 命令模式属于行为型模式。
   

2. 定义将一个请求封装为一个对象，从而使你可用不一样的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操做。

3. 结构：

1. Command类：是一个抽象类，类中对须要执行的命令进行声明，通常来讲要对外公布一个execute方法用来执行命令。

2. ConcreteCommand类：Command类的实现类，对抽象类中声明的方法进行实现。

3. client类：客户端调用的类。

4. invoker类：调用者，负责调用命令。

5. receiver类：接收者，负责接收命令而且执行命令。

4. 所谓对命令的封装，实际上就是把一系列命令的操做写到一个方法中，而后交给客户端调用。
   

5. 优势：

1. 容易设计一个命令队列；在须要的状况下，能够容易的将日志记录下来；

2. 容许接受请求的一方决定是否否决请求；能够容易的实现对请求的撤销和重作，把不一样的请求区分开来.

3. 须要实现撤销/恢复操做的功能时，这种设计比较有意义

4. 低耦合。
   

6. 缺点：

1. 若是命令不少，开发起来就头疼了，特别是不少简单的命令，实现起来几行代码的事，还要使用命令类来封装，累不累累不累，你就告诉我累不累~

7. 适用场景：对于大多数请求-响应模式的功能，比较适合使用命令模式，正如命令模式定义说的那样，命令模式对实现记录日志、撤销操做等功能比较方便。

8. 以前说过，命令模式和装饰模式有一些类似，不一样之处很明显了，装饰模式中的元素是一种链式结构，元素能够调用下一个元素的excute方法（经过递归）。而命令模式是经过invoker维护一个链式的元素链，由命令者invoker统一调用。
   

二.测试代码

    

public class MinlingmoshiTest2 {//至关于client
    public static void main(String[] args) {
        Receiver receiver=new Receiver();
        Command command=new ConcreteCommand(receiver);
        //这样的调用是客户端执行具体命令
        command.execute();
        //这样的调用是客户端通知调用者来执行命令，是命令模式。
        Invoker invoker=new Invoker();
        invoker.setCommand(command);
        invoker.action();
    }
}
class Invoker{//通知者
    private Command command;
    public void setCommand(Command command) {
        this.command = command;
    }
    public void action(){
        command.execute();
    }
}
abstract class Command{//命令类
    public abstract void execute();
}
class ConcreteCommand extends Command{
    private Receiver receiver;
    public ConcreteCommand(Receiver receiver){
        this.receiver=receiver;
    }
    @Override
    public void execute() {
        this.receiver.doSomething();
    }
}
class Receiver{//他是真正作业务逻辑的类
    public void doSomething(){
        System.out.println("接受这-业务逻辑处理");
    }
}

若是想要把命令串成一串命令，只须要在invoker里维护一个list就能够了，到时候add进不一样的command，方便对命令进行增删。

2.下面代码描述的是烤羊肉串的以及waiter之间的命令

    

public class MinlingMoshiTest {
    public static void main(String[] args) {
        Barbecuer barbecuer=new Barbecuer();
        Command command=new BakeChickenWing(barbecuer);
        Command command2=new BakeChickenWing(barbecuer);
        Command command3=new BakeMuttonCommond(barbecuer);
        Waiter waiter=new Waiter();
        waiter.setOrder(command);
        waiter.notify();
        waiter.setOrder(command2);
        waiter.notify();
        waiter.setOrder(command3);
        waiter.notify();
    }
}

/**
 * 抽象命令
 * @author 58
 *
 */
abstract class Command{
    protected Barbecuer barbecuer;
    public Command(Barbecuer barbecuer){
        this.barbecuer=barbecuer;
    }
    public abstract void excuteCommand();
}

class Barbecuer{
    public void bakeMutton(){
        System.out.println("烤肉串");
    }
    
    public void bakeChickenWing(){
        System.out.println("烤鸡翅");
    }
}

class BakeMuttonCommond extends Command{

    public BakeMuttonCommond(Barbecuer barbecuer) {
        super(barbecuer);
    }

    @Override
    public void excuteCommand() {
        barbecuer.bakeMutton();
    }
    
}

class BakeChickenWing extends Command{

    public BakeChickenWing(Barbecuer barbecuer) {
        super(barbecuer);
    }

    @Override
    public void excuteCommand() {
        barbecuer.bakeChickenWing();
    }
    
}

class Waiter{
    private List<Command> commands=new ArrayList<Command>();
    private boolean hasMutton=true;
    private boolean hasChickenWing=true;
    public void setOrder(Command command){
        
    }
    //TODO add
    //TODO remove
    //TODO NOTYFYALL
}

3.下篇介绍职责链模式，敬请期待。