0 命令模式和責任鏈模式

命令模式和責任鏈模式是兩種完全相反的模式。

命令模式是需要將請求排隊處理。因此將請求封裝成對象放入隊列。

而責任鏈模式則是，可能同一對象需要多個函數只有一個函數能處理。或是多個函數都需要處理。

1 命令模式

1.0 需求

高並發情況下，將延遲並發執行的命令，於是將所提交的命令封裝成對象存儲在一個隊列中，然後一個處理者順序執行。

將請求封裝為對象，也就是說要處理的資源處理的命令封裝成對象。然後一個Command作為基類。

每種命令使用一個類封裝，都繼承Command。

然後一個處理的對象Process，有add的接口，將Command保存，一個do接口，開始執行所有的命令。

1.1 實現

當然為了效率，是可以傳指針的，但是需要是智能指針，因為，多線程的問題。

// 封裝命令實際類
class SubStr 
{
public:
    Substr(string str):str(str){}
    void sub();
private:
    string str;
};

// 封裝命令實際類
class CatStr 
{
public:
    Catstr(string str):str(str){}
    void Cat();
private:
    string str;
};

// 為了實現多態的基類
class ABCommand 
{
public:
    virtual void do() =0 ;
};

// 提供同一接口的類
class SubCommand :public ABCommand
{
public:
    SubCommand(SubStr obj):obj(obj){}
    void do(){obj->sub()；}
private:
    SubStr obj;
};

// 另一個，省略了

//接受者，具體的執行者
class Process 
{
public:
    void add();
    void do();
private:
    vector<Command> list;
}

1.2 擴展

消息隊列也是將請求封裝成對象，然後依次處理。

2 責任鏈模式

2.0 需求

當一個對象的處理過程需要經過多級的時候，也就是說，一個對象可能被不同的命令處理。

那麽就需要責任鏈模式。

2.1 實現

責任鏈模式的實現，是這樣的：

將處理請求的函數，封裝為一個類。類繼承自同一個基類。類中還有一個基類的指針用於保存下一級處理的類。

而處理請的函數應該判斷是否能夠處理該請求，如果不能處理，就向下一級轉發。

//處理類的基類
class AbHandler
{
public:
  virtual bool exc(Req * req)=0;
private:
  AbHandler *_next; //這個用於保存責任鏈的下一個
};


//處理類，根據信息判斷是否可以執行。
class Exc1Handler:AbHandler
{
public:
  Exc1Handler(AbHandler* handler):_next(handler);
  virtual bool exc(Req * req)
  {
    if(/*判斷req信息和本類的其他數據成員是否能夠處理該請求*/)
    {
      //do
      return true；
    }
    return _next->exc(req);
  }
};

//鏈的終端，確保一定可以執行。
class EndHandler:Abhandler
{
//其他不變，構造函數傳入參數為空
public:
  virtual bool exc()
  {
    //提示信息
    return false;
  }
};

int main()
{
  EndHandler *endHandler=new EndHandler;
  Exc1Handler *exc1=new Exc1Handler(endHandler);
  //.....添加其他的。
  Exc9Handler *exc9=new Exc9Handler(exc8);
  //另外一個請求類。。。
  Req req;
  exc9->exc(req);
}

2.2 缺點

從上面的代碼可以看出：責任鏈的創建過程還是比較復雜的。因為需要一級級的創建。

因此可以更改為使用vector封裝函數對象，然後處理的時候使用for來處理

設計模式-命令模式（行為）、責任鏈模式（行為）