设计模式 c++版（8）——命令模式

最新推荐文章于 2022-08-18 20:04:34 发布
最新推荐文章于 2022-08-18 20:04:34 发布
阅读量240 收藏
点赞数
分类专栏： 设计模式 文章标签： c 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jecklin_online/article/details/82843938
版权

定义：

将一个请求封装成一个对象，从而让你使用不同的请求把客户端参数化，对请求排队或者记录请求日志，可以提供命令的撤销和恢复功能

示例一：命令模式（通用版）


1. 类图15-4

 

2. 类图说明

① Receive 接收者角色。该角色就是干活的角色，命令传递到这里是应该被执行的。
② Command 命令角色。需要执行的所有命令都在这里声明。
③ Invoker 调用者角色。接收到命令，并执行命令。

 

3. 代码清单15-1:

    **********  1. 通用命令模式，代码清单15-1:***************//

//通用Receiver
class Receiver
{
public:
    virtual void    doSomething() = 0;
};

//具体Receiver
class ConcreteReciver1:public Receiver
{
public:
    virtual void    doSomething()
    {
        qDebug() << "ConcreteReciver1 doSomething";
    }
};

//抽象Command
class Command
{
public:
    virtual void    execute() = 0;
};

class ConcreteCommand1:public Command
{
public:
    ConcreteCommand1(Receiver *receiver)
    {
        this->m_receiver = receiver;
    }
    virtual void    execute()
    {
        this->m_receiver->doSomething();
    }

private:
    Receiver *m_receiver;
};

class ConcreteCommand2:public Command
{
public:
    ConcreteCommand2(Receiver *receiver)
    {
        this->m_receiver = receiver;
    }
    virtual void    execute()
    {
        this->m_receiver->doSomething();
    }

private:
    Receiver *m_receiver;
};

//调用者
class Invoker
{
public:
    void    setCommand(Command *command)
    {
        this->m_command = command;
    }
    void    action()
    {
        this->m_command->execute();
    }

private:
    Command *m_command;
};

int main()
{
    Invoker invoker;
    Receiver *receiver = new ConcreteReciver1();
    Command *command = new ConcreteCommand1(receiver);
    invoker.setCommand(command);
    invoker.action();
    
    
    return 0;
}


二、命令模式的应用

1. 优点：

  •  类间解耦。调用者角色与接收者角色之间没有任何依赖关系，调用者实现功能时只需要调用Command 抽象类 的execute方法就可以，不需要了解到底是哪个接收者执行。
  •  可扩展性。Command的子类可以非常容易地扩展，而调用者Invoker和高层次的模块不产生严重的代码耦合。
  •  命令模式结合其他模式会更好。命令模式可以结合责任链模式，实现命令族解析任务；结合模板方法模式，则可以减少Command子类的膨胀问题。

 

2. 缺点

在Command的子类：如果有N个命令，问题就出来了，Command的子类就不是几个，而是N个，这个类膨胀的非常大，在项目中需要慎重考虑使用。


3. 使用场景：

只要你认为是命令的地方就可以采用命令模式，例如GUI开发中，一个按钮的点击是一个命令，可以采用命令模式；模拟DOS命令的时候，也要采用命令模式；触发-反馈机制的处理等。

 

示例二：项目开发过程（初步设计）

1.需求分析：

为旅行社内部建立管理系统 : 用来管理客户、旅游资源、票务以及内部事务，整体上类似于一个小型的MIS系统。
该项目的成员分工分为需求组(Requirement Group,RG)、美工组(Page Group,PG)、代码组(Code Group,CG)

 

2. 类图，类图15-1

 

3. 类图说明：

抽象中的每个方法，都是一个命令，给出命令然后由相关人员去执行。


4. 代码清单15-1:

    **********  2. 项目开发过程（初步设计），代码清单15-1:***************//

//抽象组
class Group
{
public:
    virtual void    find()      = 0;     //找到某个组
    virtual void    add()       = 0;     //被要求增加功能
    virtual void    delete1()   = 0;     //被要求删除功能
    virtual void    change()    = 0;     //被要求修改功能
    virtual void    plan()      = 0;     //被要求给出所有的变更计划
};

//抽象组
class RequirementGroup:public Group
{
public:
    virtual void    find()   {qDebug() << "find RequirementGroup";}
    virtual void    add()    {qDebug() << "add a request";}
    virtual void    delete1(){qDebug() << "delete a request";}
    virtual void    change() {qDebug() << "change a request";}
    virtual void    plan()   {qDebug() << "plan";}
};

//美工组
class PageGroup:public Group
{
public:
    virtual void    find()   {qDebug() << "find PageGroup";}
    virtual void    add()    {qDebug() << "add a request";}
    virtual void    delete1(){qDebug() << "delete a request";}
    virtual void    change() {qDebug() << "change a request";}
    virtual void    plan()   {qDebug() << "plan";}
};

//代码组
class CodeGroup:public Group
{
public:
    virtual void    find()   {qDebug() << "find CodeGroup";}
    virtual void    add()    {qDebug() << "add a request";}
    virtual void    delete1(){qDebug() << "delete a request";}
    virtual void    change() {qDebug() << "change a request";}
    virtual void    plan()   {qDebug() << "plan";}
};

int main()
{
    //找需求组改
    Group *rg = new RequirementGroup();
    rg->find();
    rg->add();
    rg->plan();
    
    //找美工组改
    Group *pg = new PageGroup();
    pg->find();
    pg->delete1();
    pg->plan();
    
    return 0;
}


5. 设计问题

每次修改计划，都需要找到一个组，然后布置任务，然后出计划，需求增多时非常复杂，我们需要增加一个负责人，下面进行改善

 

示例三：项目开发过程（改善版）

1. 类图15-2：

 

2. 类图说明：

在类图上增加了一个Invoker类，其作用是根据客户的命令安排不同的组员进行工作。当客户需要再界面上删除一条记录，Invoker类接收到该 String 类型命令后，通知美工组 PageGroup 开始 delete, 然后再找到代码组 DodeGroup 后台不要存到数据库中，最后反馈给客户一个执行计划。

 

3. 问题：

客户的命令是一个 String 类型的，这有非常多的变化，在系统设计中，字符串没有约束力。

 

4. 改善方案：

对客户发出的命令进行封装，每个命令是一个对象，避免用户，负责人，组员之间的交流误差，封装后的结果是，客户说一个命令，我们的项目组就开始启动，不用思考、解析命名字符串

 

5. 改善后类图 15-3

 

6. 类图说明

Command 抽象类只有一个方法 execute，其作用就是执行命令，子类非常坚决的实现该命令。
Command 抽象类 ：客户发出的命令，定义三个工作组的成员变量，供子类使用；定义一个抽象方法execute，由子类来实现
CInvoker 实现类：项目负责人，setComand 接收客户发的命令，action方法执行命令

 

7. 代码清单15-2:

    **********  2. 项目开发过程（改善版），代码清单15-2:***************//


//抽象组
class Group
{
public:
    virtual void    find()      = 0;     //找到某个组
    virtual void    add()       = 0;     //被要求增加功能
    virtual void    delete1()   = 0;     //被要求删除功能
    virtual void    change()    = 0;     //被要求修改功能
    virtual void    plan()      = 0;     //被要求给出所有的变更计划
};

//抽象组
class RequirementGroup:public Group
{
public:
    virtual void    find()   {qDebug() << "find RequirementGroup";}
    virtual void    add()    {qDebug() << "add a request";}
    virtual void    delete1(){qDebug() << "delete a request";}
    virtual void    change() {qDebug() << "change a request";}
    virtual void    plan()   {qDebug() << "plan";}
};

//美工组
class PageGroup:public Group
{
public:
    virtual void    find()   {qDebug() << "find PageGroup";}
    virtual void    add()    {qDebug() << "add a request";}
    virtual void    delete1(){qDebug() << "delete a request";}
    virtual void    change() {qDebug() << "change a request";}
    virtual void    plan()   {qDebug() << "plan";}
};

//代码组
class CodeGroup:public Group
{
public:
    virtual void    find()   {qDebug() << "find CodeGroup";}
    virtual void    add()    {qDebug() << "add a request";}
    virtual void    delete1(){qDebug() << "delete a request";}
    virtual void    change() {qDebug() << "change a request";}
    virtual void    plan()   {qDebug() << "plan";}
};

//抽象命令类
class Command
{
public:
    virtual void    execute() = 0;
    Command()
    {
        this->m_rg = new RequirementGroup();
        this->m_pg = new PageGroup();
        this->m_cg = new CodeGroup();
    }

protected:
    RequirementGroup *m_rg;
    PageGroup        *m_pg;
    CodeGroup        *m_cg;
};

//增加需求命令
class AddRequirementCommand:public Command
{
public:
    virtual void    execute()
    {
        this->m_rg->find();
        this->m_rg->add();
        this->m_rg->plan();
    }
};

//删除页面命令
class DeletePageCommand:public Command
{
public:
    virtual void    execute()
    {
        this->m_pg->find();
        this->m_pg->delete1();
        this->m_pg->plan();
    }
};

class Invoker
{
public:
    void    setCommand(Command *command)
    {
        this->m_command = command;
    }
    void    action()
    {
        this->m_command->execute();
    }

private:
    Command *m_command;
};


int main()
{
    //增加一项需求
    Invoker xiao;
    Command *command = new AddRequirementCommand();
    xiao.setCommand(command);
    xiao.action();
    
    //删除一个页面
    Invoker san;
    Command *command2 = new DeletePageCommand();
    san.setCommand(command2);
    san.action();
    return 0;
}


四、命令模式的扩展

4-1. 扩展一：增加需求

 

示例四：项目开发过程 （增加需求版）

 

1. 需求分析

接收到一个命令的时候通知每一个组

 

2. 修改方法

在 AddRequirementCommand 类的 execute 方法中增加对 PageGroup 和 CodePage 的调用即可

 

3. 修改后代码清单

class AddRequirementCommand:public Command
{
public:
    virtual void    execute()
    {
        this->m_rg->find();
        this->m_rg->add();
        this->m_pg->add();
        this->m_cg->add();
        this->m_rg->plan();
    }
};

 

4-2. 扩展二：回退功能

示例五：项目开发过程 （增加回退功能）

 

1. 需求分析

发出一个命令，在没有执行或执行后撤销

 

2. 解决方法

①结合备忘录模式还原最后状态。适合接收者为状态的变更情况，不适合事件处理
②通过增加一个新的命令，实现事件回滚。
撤销也是一个命令，即是 Command 的一个子类，实现功能是恢复刚删除的页面。命令由页面组接收，页面组必须有一个方法恢复最后删除的页面，也就是日志回滚机制，指定一个页面，回滚回去。


3. 代码清单15-4:

//    **********  4. 扩展二（回退功能），代码清单15-4:***************//


//抽象组
class Group
{
public:
    virtual void    find()      = 0;     //找到某个组
    virtual void    add()       = 0;     //被要求增加功能
    virtual void    delete1()   = 0;     //被要求删除功能
    virtual void    change()    = 0;     //被要求修改功能
    virtual void    plan()      = 0;     //被要求给出所有的变更计划
    virtual void    rollBack()  = 0;     //根据日志进行回滚 
};

//抽象组
class RequirementGroup:public Group
{
public:
    virtual void    find()   {qDebug() << "find RequirementGroup";}
    virtual void    add()    {qDebug() << "add a request";}
    virtual void    delete1(){qDebug() << "delete a request";}
    virtual void    change() {qDebug() << "change a request";}
    virtual void    plan()   {qDebug() << "plan";}
};

//美工组
class PageGroup:public Group
{
public:
    virtual void    find()   {qDebug() << "find PageGroup";}
    virtual void    add()    {qDebug() << "add a request";}
    virtual void    delete1(){qDebug() << "delete a request";}
    virtual void    change() {qDebug() << "change a request";}
    virtual void    plan()   {qDebug() << "plan";}
};

//代码组
class CodeGroup:public Group
{
public:
    virtual void    find()   {qDebug() << "find CodeGroup";}
    virtual void    add()    {qDebug() << "add a request";}
    virtual void    delete1(){qDebug() << "delete a request";}
    virtual void    change() {qDebug() << "change a request";}
    virtual void    plan()   {qDebug() << "plan";}
};

//抽象命令类
class Command
{
public:
    virtual void    execute() = 0;
    Command()
    {
        this->m_rg = new RequirementGroup();
        this->m_pg = new PageGroup();
        this->m_cg = new CodeGroup();
    }

protected:
    RequirementGroup *m_rg;
    PageGroup        *m_pg;
    CodeGroup        *m_cg;
};

//增加需求命令
class AddRequirementCommand:public Command
{
public:
    virtual void    execute()
    {
        this->m_rg->find();
        this->m_rg->add();
        this->m_rg->plan();
    }
};

//删除页面命令
class DeletePageCommand:public Command
{
public:
    virtual void    execute()
    {
        this->m_pg->find();
        this->m_pg->delete1();
        this->m_pg->plan();
    }
};

//撤销删除
class CancelDeletePageCommand:public Command
{
public:
    virtual void    execute()
    {
        this->m_pg->rollBack();
    }
};

class Invoker
{
public:
    void    setCommand(Command *command)
    {
        this->m_command = command;
    }
    void    action()
    {
        this->m_command->execute();
    }

private:
    Command *m_command;
};


int main()
{
    //增加一项需求
    Invoker xiao;
    Command *command = new AddRequirementCommand();
    xiao.setCommand(command);
    xiao.action();
    
    //删除一个页面
    Invoker san;
    Command *command2 = new DeletePageCommand();
    san.setCommand(command2);
    san.action();
    return 0;
}

 

4. 代码分析

抽象组中增加了一个rollBack 方法，每个接收者都可以对自己实现的任务进行回滚
新增加一个命令 CancelDeletePageCommand 实现撤销
使用Invoker进行调用。


五、最佳实践

在旅行社的例子中，Receiver角色（即Group的三个实现类）没有暴露给Client， 而在通用的类图和源码中却出现了Client 对 Receiver角色的依赖。原因是每一个 模式到实际应用的时候都有一些变形，命令模式的Receiver在实际应用中都会被封装掉（除非非常必要，例如撤销处理），是因为在项目中：约定的优先级最高，每一个命令是对一个或多个 Receiver 的防撞，我们可以在项目中通过有意义的类名或命令名处理命令角色和接收者角色的耦合关系（即约定），减少高层模块（Client）对底层模块（Receiver）的依赖关系，提高系统稳定性。
建议：在实际的项目开发时采用封闭 Receiver 的方式 ， 减少 Client对 Receiver 的依赖，改方案只是对 Commandd抽象类及其子类有一定修改。


示例六：通用模式（改善版）

 

1. 代码清单15-5


    **********  5. 通用模式（改善版），代码清单15-5:***************//

//通用Receiver
class Receiver
{
public:
    virtual void    doSomething() = 0;
};

//具体Receiver
class ConcreteReciver1:public Receiver
{
public:
    virtual void    doSomething()
    {
        qDebug() << "ConcreteReciver1 doSomething";
    }
};//具体Receiver
class ConcreteReciver2:public Receiver
{
public:
    virtual void    doSomething()
    {
        qDebug() << "ConcreteReciver2 doSomething";
    }
};

//抽象Command
class Command
{
public:
    Command(){}
    Command(Receiver *receiver)
    {
        this->m_receiver = receiver;
    }
    virtual void    execute() = 0;
protected:
    Receiver    *m_receiver;
};

class ConcreteCommand1:public Command
{
public:
    ConcreteCommand1()
    {
        this->m_receiver = new ConcreteReciver1();
    }
    ConcreteCommand1(Receiver *receiver)
    {
        this->m_receiver = receiver;
    }

    virtual void    execute()
    {
        this->m_receiver->doSomething();
    }

private:
    Receiver *m_receiver;
};

class ConcreteCommand2:public Command
{
public:
    ConcreteCommand2()
    {
        this->m_receiver = new ConcreteReciver2();
    }
    ConcreteCommand2(Receiver *receiver)
    {
        this->m_receiver = receiver;
    }
    virtual void    execute()
    {
        this->m_receiver->doSomething();
    }

private:
    Receiver *m_receiver;
};

//调用者
class Invoker
{
public:
    void    setCommand(Command *command)
    {
        this->m_command = command;
    }
    void    action()
    {
        this->m_command->execute();
    }

private:
    Command *m_command;
};

int main()
{
    Invoker invoker;
    Command *command = new ConcreteCommand1();
    invoker.setCommand(command);
    invoker.action();
    
    
    return 0;
}

 

2. 代码分析

在Command父类中声明了一个接收者，通过构造函数约定每个具体命令都必须指定接收者，根据开发场景要求可以有多个接收者时，需要用到集合类型。

 

参考文献《秦小波. 设计模式之禅》（第2版） (华章原创精品) 机械工业出版社

Jecklin_online
关注
专栏目录
设计模式C++版
06-13
设计模式C++版文档主要聚焦于面向对象设计与分析的核心——设计模式，并以C++语言实现为示范。这份文档详尽阐述了23种GoF（Gang of Four）设计模式，并结合具体的C++源码示例，旨在帮助读者深入理解并掌握这些设计...
线程池的 execute() 方法是如何执行的？
R先生专栏
03-16 4064
线程池的 execute() 方法是如何执行的？ 执行流程 一般情况下，我们使用线程池经常会用到它的 execute() 方法去提交任务，那么你知道它的执行流程吗？我们首先来看下源码实现： public void execute(Runnable command) {        if (command == null)  &nbsp
线程池execute方法的源码解析
suchenbin的博客
10-05 1477
本文是线程池execute方法的源码，在此之前可以先看下【线程池的创建】。 ThreadPoolExecutor中execute方法 newCachedThreadPool、newFixedThreadPool、newSingleThreadExecutor的execute方法在ThreadPoolExecutor中。 1）、顶层入口； package java.util.concurr...
c++ virtual小结
ahaitongxue的专栏
11-02 148
#include &lt;stdio.h&gt; #include "iostream" using namespace std; class Node; typedef void (Node::*SEL_SCHEDULE)(); #define schedule_selector(_SELECTOR) (SEL_SCHEDULE)(&amp;_SELECTOR) class Scheduler ...
Java线程池解析
m0_73330311的博客
08-18 639
LinkedBlockingQueue（可设置容量队列）基于链表结构的阻塞队列，按FIFO排序任务，容量可以选择进行设置，不设置的话，将是一个无边界的阻塞队列，最大长度为Integer.MAX_VALUE，吞吐量通常要高于ArrayBlockingQuene；在使用线程池处理任务的时候，任务代码可能抛出RuntimeException，抛出异常后，线程池可能捕获它，也可能创建一个新的线程来代替异常的线程，我们可能无法感知任务出现了异常，因此我们需要考虑线程池异常情况。...
java中的 execute()方法_这个java .execute()方法调用是什么意思？
weixin_32063287的博客
02-19 9337
execute是SwingWorker的方法。您所看到的是anonymous class正在实例化并立即调用其execute方法。我不得不承认我对代码编译感到有些惊讶，因为它似乎将execute的结果分配给worker变量，文档告诉我们execute是void函数。如果我们稍微解构一下代码，它就会更清晰。首先，我们创建一个扩展SwingWorker的匿名类并同时创建它的一个实例(这是括号中的大部分...
c++设计模式GoF23
10-28
### c++设计模式GoF23 #### 0. 引言 - **设计模式的重要性**：“Next to My Life, Software Is My Passion”——Robert C. Martin 的名言揭示了软件设计的重要地位。掌握设计模式意味着理解面向对象分析与设计...
设计模式——GFour
08-22
《设计模式——GFour》是一本深受IT从业者喜爱的经典书籍，尤其在C++开发者中具有广泛影响力。设计模式是软件工程领域中的一种最佳实践，它总结了在特定情境下解决问题的常见方法，使得代码可读性更强，复用性更高，...
C++设计模式.pdf
06-12
### C++设计模式精解——GoF 23种设计模式解析及C++实现源码 #### 0. 引言 设计模式是面向对象编程领域的重要组成部分，它为解决常见的设计问题提供了一系列标准化的解决方案。GoF(四人组)提出的23种设计模式被...
Java线程池系列之execute和submit区别
forever的专栏
01-08 1万+
这是几年前的一道面试题了，网上的答案一般都是 1. execute只能提交Runnable类型的任务，没有返回值，而submit既能提交Runnable类型任务也能提交Callable类型任务，返回Future类型。 2. execute方法提交的任务异常是直接抛出的，而submit方法是是捕获了异常的，当调用FutureTask的get方法时，才会抛出异常。 我们可能看过n多次但又忘了n多加1次，那么我们到底应该如何才能彻底理解和记住这两者的区别呢，这就要从ThreadPoolExecutor的根
线程池-两种提交任务的方法execute()与submit()详解
张念磊的博客
12-10 1万+
引言 线程池中有两个提交任务的方法 向线程池提交任务的两种方式大致如下： 方式一：调用execute()方法 // todo 源码 方式二：调用submit()方法 // todo 源码 一、区别 以上的submit()和execute()两类方法的区别在哪里呢？大致有以下三点： 1.二者所接收的参数不一样 Execute()方法只能接收Runnable类型的参数，而submit()方法可以接收Callable、Runnable两种类型的参数。Callable类型的任务是可以返回执行结果的，而Runnabl
线程池的设计与原理解析(二)之---execute()方法
qq_35529931的博客
08-22 1754
在使用线程池的时候，我们会使用到提交线程池的方法execute()。 public void execute(Runnable command) { e.execute(command); } 它的主要作用是提交执行任务，参数支持Runnable, execute()没有返回值，同时，它的任务里必须捕获异常。 execute（）的工作主要流程如下图所示: 接下来就主要去看看这个execute()方法的源码含义 1.当传入一个 null的 Runnable的时候，会进行抛出异常 if (co
execute
wzzcywyy的博客
12-18 1339
public final void execute（） 安排这个SwingWorker在工作 线程上执行。有一些工作线程可用。在事件的所有工作者线程都忙于处理其他 SwingWorkers这个SwingWorker被放置在一个等待队列。 注意： SwingWorker只能执行一次。SwingWorker多次执行 不会导致调用该 doInBackground方法两次。
Java线程池ThreadPoolExecutor中execute()方法原理
山鬼谣的专栏
02-24 2万+
环境 Java：1.8 前言 线程池之前知是知道，但是印象不是很深刻，今天看了下源码，发现源码很好理解，所以记录下； 线程池 要了解线程池，首先要了解线程池里面的状态控制变量ctl。 线程池的ctl是一个原子的AtomicInteger 这个ctl包含两个参数： runState 线程的状态 workerCount 激活的线程数 它的低29位用于存放当前的线程数，因此一个线程池在理论上最...
Java线程池execute()方法源码解析
不说话装高手
09-23 1万+
先看作者给出的注释来理解线程池到底有什么作用 * Thread pools address two different problems: they usually* provide improved performance when executing large numbers of* asynchronous tasks, due to reduced per-task invocatio...
execute（）方法
热门推荐
Jinandawang的博客
06-13 7万+
方法execute： 用于执行返回多个结果集、多个更新计数或二者组合的语句。 因为多数程序员不会需要该高级功能。execute方法应该仅在语句能返回多个ResultSet对象、多个更新计数或ResultSet对象与更新计数的组合时使用。 当执行某个已存储过程 或动态执行未知 SQL 字符串（即应用程序程序员在编译时未知）时，有可能出现多个结果的情况，尽管这种情况很少见。因为方法 execut...
线程池中 submit() 和 execute() 方法的区别
syilt的博客
05-25 1700
execute()：只能执行 Runnable 类型的任务。 submit()：可以执行 Runnable 和 Callable 类型的任务。 submit()能获取返回值（异步）以及处理Exception。execute()方法不行。 ...
C++设计模式解析：GoF23种模式详解
"C++设计模式.pdf 是一本详细介绍GoF23种设计模式的书籍，包含C++实现的源码，旨在帮助读者理解和掌握面向对象分析和设计的关键——设计模式。作者通过自己的学习经验和实际项目应用，解析了每种模式，并提供了实践...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值