一天一種設計模式之九-----命令模式

一.命令模式簡介

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.下篇介紹職責鏈模式，敬請期待。