14.命令模式

1.说明
请参见第一章节
2.命令模式说明
命令模式：将一个个请求封装成一个对象，从而使你可用不同的请求对客户进行参数化，对请求排队或记录请求日志，以及支持可撤销操作。 甚至可以将实现者进行分离，来实现业务分离，松耦合
优点：
1.能比较容易地设计一个命令队列。
2.在需要的的情况下，可以比较容易地将命令记录日志。
3.允许接受请求的一方决定是否要否决请求。
4.可以容易地实现对请求撤销或重做。
5.加入新的请求命令类，不影响其他类，因此增加新的具体命令很容易。
6.将操作对象的请求与执行请求的命令分离，实现松耦合
需知：在业务复杂设计中，如果“行为请求者”与“行为实现者”紧耦合，那么容易导致代码臃肿，结构混乱。这个时候可以通过命令模式来讲行为请求与行为实现分离。
同时对命令的记录，可以方便请求的管理，以及支持可撤销操作
3.UML

4.代码

//命令模式基类
#ifndef __COMMAND_H
#define __COMMAND_H

#include "Worker.h"

class CCommand
{
public:
    CCommand(CWorker* work)
    {
        m_work = work;
    }
    ~CCommand(){}  
    virtual void execute() = 0; 
protected:
    CWorker* m_work;
};

#endif
// peer派生类
#ifndef __PEERCMD_H
#define __PEERCMD_H

#include "Command.h"

class CPeerCmd:public CCommand
{
public:
    CPeerCmd(CWorker* work):CCommand(work)
    {

    }
    virtual void execute()
    {
        m_work->peercmd();
    }
};

#endif

//roate 派生类
#ifndef __ROATECMD_H
#define __ROATECMD_H


#include "Command.h"

class CRoateCmd:public CCommand
{
public: 
    CRoateCmd(CWorker* work):CCommand(work)
    {

    }
    virtual void execute()
    {
        m_work->roatecmd();
    }
};

#endif

//bak派生类
#ifndef __BAKCMD_H
#define __BAKCMD_H

#include "Worker.h"
#include "Command.h"

class CBakCmd:public CCommand
{
public:
    CBakCmd(CWorker* work):CCommand(work)
    {

    }
    virtual void execute()
    {
        m_work->bakcmd();
    }
};

#endif

//命令实现类
#ifndef __WORKER_H
#define __WORKER_H

#include <iostream>


class CWorker
{
public:
    CWorker()
    {

    }
    void bakcmd()
    {
        std::cout<<"bak finish."<<std::endl;
    }
    void peercmd()
    {
        std::cout<<"peer finish."<<std::endl;
    }
    void roatecmd()
    {
        std::cout<<"roate finish."<<std::endl;
    }
};

#endif

//命令聚合管理类

#ifndef __INVOKER_H
#define __INVOKER_H

#include <list>
#include "Command.h"

typedef std::list<CCommand*> ORDERCMD;

class CInvoker
{
public:     
    void add_cmd(CCommand* cmd)
    {
        m_order.push_back(cmd);
    }
    void remove_cmd(CCommand* cmd)
    {
        for (ORDERCMD::iterator it=m_order.begin(); it!=m_order.end(); )
        {
            if ((*it) == cmd)
            {
                it = m_order.erase(it);
                break;
            }
            else
                it++;
        }
    }
    void notify()
    {
        for (ORDERCMD::iterator it=m_order.begin(); it!=m_order.end(); it++)
        {
            (*it)->execute();            
        }
        m_order.clear();
    }
private:
    ORDERCMD m_order;

};

#endif

//client调用类
#include <iostream>
#include "Command.h"
#include "Bakcmd.h"
#include "Peercmd.h"
#include "Roatecmd.h"
#include "Invoker.h"
#include "Worker.h"


int main(void)
{
    CWorker* work = new CWorker();
    CInvoker* voker = new CInvoker();

    CCommand* bak = new CBakCmd(work);
    CCommand* peer = new CPeerCmd(work);
    CCommand* roate = new CRoateCmd(work);

    voker->add_cmd(bak);
    voker->add_cmd(peer);
    voker->add_cmd(peer);
    voker->add_cmd(roate);
    voker->add_cmd(roate);
    voker->notify();

    CCommand* peer1 = new CPeerCmd(work);
    CCommand* roate1 = new CRoateCmd(work);

    voker->add_cmd(roate1);
    voker->add_cmd(roate1);
    voker->add_cmd(peer1);
    voker->add_cmd(peer1);  
    voker->notify();

    return 0;
}