1. Toy模板网首页
  2. > Toy博客

《设计模式的艺术》笔记 - 命令模式

8月前 作者：vfdn 分类：Toy博客 阅读(43) 违法举报

这篇具有很好参考价值的文章主要介绍了《设计模式的艺术》笔记 - 命令模式。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

介绍

        命令模式将一个请求封装为一个对象，从而可用不同的请求对客户进行参数化；对请求排队或者记录请求日志，以及支持可撤销的操作。命令模式是一种对象行为模式，其别名为动作模式或事务模式。

实现

myclass.h

//
// Created by yuwp on 2024/1/12.
//

#ifndef DESIGNPATTERNS_MYCLASS_H
#define DESIGNPATTERNS_MYCLASS_H

#include <iostream>
#include <unordered_map>
#include <atomic>

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

class Reciever {    // 命令接收者，可以继承实现具体的接收类
public:
    virtual void action();
};

class ConcreteCommand : public Command {    // 具体命令类
public:
    ConcreteCommand();
    ~ConcreteCommand();
    void execute() override;

private:
    Reciever *m_reciever;
};

class Invoker { // 调用者类，命令发送者
public:
    Invoker(Command *command);
    void call();

private:
    Command *m_command;
};

#endif //DESIGNPATTERNS_MYCLASS_H

myclass.cpp

//
// Created by yuwp on 2024/1/12.
//

#include "myclass.h"
#include <thread>
#include <unistd.h>

ConcreteCommand::ConcreteCommand() {
    m_reciever = new Reciever();
}

ConcreteCommand::~ConcreteCommand() {
    if (m_reciever)
        delete m_reciever;
}

void ConcreteCommand::execute() {
    m_reciever->action();
}

void Reciever::action() {
    std::cout << "接收者处理命令" << std::endl;
}

Invoker::Invoker(Command *command) {
    m_command = command;
}

void Invoker::call() {
    m_command->execute();
}

main.cpp

#include <iostream>
#include <mutex>
#include "myclass.h"

int main() {
    Command *command = new ConcreteCommand();
    Invoker *invoker = new Invoker(command);
    invoker->call();

    return 0;
}

命令队列实现

        只需要增加一个CommandQueue类即可，Invoker中保存对CommandQueue的引用。

myclass.h

//
// Created by yuwp on 2024/1/12.
//

#ifndef DESIGNPATTERNS_MYCLASS_H
#define DESIGNPATTERNS_MYCLASS_H

#include <iostream>
#include <unordered_map>
#include <atomic>
#include <vector>

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

class Reciever {    // 命令接收者，可以继承实现具体的接收类
public:
    virtual void action();
};

class ConcreteCommand : public Command {    // 具体命令类
public:
    ConcreteCommand();
    ~ConcreteCommand();
    void execute() override;

private:
    Reciever *m_reciever;
};

class CommandQueue {
public:
    void execute();
    void addCommand(Command *command);
    void removeCommand(Command *command);

private:
    std::vector<Command *> m_commands;
};

class Invoker { // 调用者类，命令发送者
public:
    Invoker(CommandQueue *commands);
    void call();

private:
    CommandQueue *m_commands;
};

#endif //DESIGNPATTERNS_MYCLASS_H

myclass.cpp

//
// Created by yuwp on 2024/1/12.
//

#include "myclass.h"
#include <thread>
#include <unistd.h>

ConcreteCommand::ConcreteCommand() {
    m_reciever = new Reciever();
}

ConcreteCommand::~ConcreteCommand() {
    if (m_reciever)
        delete m_reciever;
}

void ConcreteCommand::execute() {
    m_reciever->action();
}

void Reciever::action() {
    std::cout << "接收者处理命令" << std::endl;
}

Invoker::Invoker(CommandQueue *commands) {
    m_commands = commands;
}

void Invoker::call() {
    m_commands->execute();
}

void CommandQueue::execute() {
    for (auto it = m_commands.begin(); it != m_commands.end(); ++it) {
        (*it)->execute();
    }
}

void CommandQueue::addCommand(Command *command) {
    m_commands.push_back(command);
}

void CommandQueue::removeCommand(Command *command) {
    for (auto it = m_commands.begin(); it != m_commands.end(); ) {
        if (*it == command) {
            it = m_commands.erase(it);
        } else {
            ++it;
        }
    }
}

main.cpp

#include <iostream>
#include <mutex>
#include "myclass.h"

int main() {
    Command *command = new ConcreteCommand();
    CommandQueue *queue = new CommandQueue();
    queue->addCommand(command);
    Invoker *invoker = new Invoker(queue);
    invoker->call();

    delete invoker;
    delete queue;
    delete command;

    return 0;
}

撤销操作

        在命令类中增加一个逆向操作，也可以通过保存对象的历史状态来实现状态回滚。

请求日志

        执行命令时增加日志的记录操作。

宏命令

        组合模式和命令模式的结合，可以实现批量命令的执行，与命令队列类似，不同的是宏命令类继承自命令抽象类(Command)，可以递归调用。

总结

优点

        1. 降低系统的耦合度。由于请求者与接收者之间不存在直接引用，因此请求者与接收者之间实现完全解耦，相同的请求者可以对应不同的接收者。同样，相同的接收者也可以供不同的请求者使用，两者之间具有良好的独立性。

        2. 新的命令可以很容易地加入系统中。由于增加新的具体命令类不会影响到其他类，因此增加新的具体命令类很容易，无须修改原有系统源代码甚至客户类代码，满足开闭原则的要求。

        3. 可以比较容易地设计一个命令队列或宏命令（组合命令）。

        4. 为请求的撤销（Undo）和恢复（Redo）操作提供了一种设计和实现方案。

缺点

        1. 使用命令模式可能会导致某些系统有过多的具体命令类。因为针对每一个对请求接收者的调用操作都需要设计一个具体命令类，因此在某些系统中可能需要提供大量的具体命令类，这将影响命令模式的使用。

适用场景

        1. 系统需要将请求调用者和请求接收者解耦，使得调用者和接收者不直接交互。请求调用者无须知道接收者的存在，也无须知道接收者是谁，接收者也无须关心何时被调用。

        2. 系统需要在不同的时间指定请求、将请求排队和执行请求。一个命令对象和请求的初始调用者可以有不同的生命期。换言之，最初的请求发出者可能已经不在了，而命令对象本身仍然是活动的，可以通过该命令对象去调用请求接收者，而无须关心请求调用者的存在性，可以通过请求日志文件等机制来具体实现。

        3. 系统需要支持命令的撤销（Undo）操作和恢复（Redo）操作。

        4. 系统需要将一组操作组合在一起形成宏命令。

练习

myclass.h

//
// Created by yuwp on 2024/1/12.
//

#ifndef DESIGNPATTERNS_MYCLASS_H
#define DESIGNPATTERNS_MYCLASS_H

#include <iostream>
#include <unordered_map>
#include <atomic>
#include <vector>

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

class BoardScreen {    // 命令接收者
public:
    void open();
    void create();
    void edit();
};

class OpenCommand : public Command {    // 具体命令类
public:
    OpenCommand(BoardScreen *reciever);
    void execute() override;

private:
    BoardScreen *m_reciever;
};

class CreateCommand : public Command {    // 具体命令类
public:
    CreateCommand(BoardScreen *reciever);
    void execute() override;

private:
    BoardScreen *m_reciever;
};

class EditCommand : public Command {    // 具体命令类
public:
    EditCommand(BoardScreen *reciever);
    void execute() override;

private:
    BoardScreen *m_reciever;
};

class Invoker { // 调用者类，命令发送者
public:
    Invoker(Command *command);
    void call();

private:
    Command *m_command;
};

#endif //DESIGNPATTERNS_MYCLASS_H

myclass.cpp

//
// Created by yuwp on 2024/1/12.
//

#include "myclass.h"
#include <thread>
#include <unistd.h>

void BoardScreen::open() {
    std::cout << "打开" << std::endl;
}

void BoardScreen::create() {
    std::cout << "新建" << std::endl;
}

void BoardScreen::edit() {
    std::cout << "编辑" << std::endl;
}

OpenCommand::OpenCommand(BoardScreen *reciever) {
    m_reciever = reciever;
}

void OpenCommand::execute() {
    m_reciever->open();
}

CreateCommand::CreateCommand(BoardScreen *reciever) {
    m_reciever = reciever;
}

void CreateCommand::execute() {
    m_reciever->create();
}

EditCommand::EditCommand(BoardScreen *reciever) {
    m_reciever = reciever;
}

void EditCommand::execute() {
    m_reciever->edit();
}

Invoker::Invoker(Command *command) {
    m_command = command;
}

void Invoker::call() {
    m_command->execute();
}

main.cpp文章来源地址https://www.toymoban.com/news/detail-808172.html

#include <iostream>
#include <mutex>
#include "myclass.h"

int main() {
    BoardScreen *boardScreen = new BoardScreen();
    Command *command = new OpenCommand(boardScreen);
    Invoker *invoker = new Invoker(command);
    invoker->call();
    delete command;
    delete invoker;

    command = new CreateCommand(boardScreen);
    invoker = new Invoker(command);
    invoker->call();
    delete command;
    delete invoker;

    command = new EditCommand(boardScreen);
    invoker = new Invoker(command);
    invoker->call();
    delete command;
    delete invoker;

    return 0;
}

到了这里，关于《设计模式的艺术》笔记 - 命令模式的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 《设计模式的艺术》笔记 - 组合模式

            组合模式组合多个对象形成树形结构以表示具有“部分-整体”关系的层次结构。组合模式对单个对象（即叶子对象）和组合对象（即容器对象）的使用具有一致性，又可以称为“部分—整体”（Part-Whole）模式，它是一种对象结构型模式。 myclass.h myclass.cpp main.cpp  

    2024年01月19日
    浏览(38)

  • 《设计模式的艺术》笔记 - 状态模式

            状态模式允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。其别名为状态对象，状态模式是一种对象行为模式。 myclass.h myclass.cpp main.cpp         1. 封装了状态的转换规则。在状态模式中可以将状态的转换代码封装在环境类或者具体状

    2024年01月25日
    浏览(46)

  • 《设计模式的艺术》笔记 - 代理模式

            代理模式是给某一个对象提供一个代理，并由代理对象控制对原对象的引用。代理模式是一种对象结构型模式。 myclass.h myclass.cpp main.cpp         1. 代理模式能够协调调用者和被调用者，在一定程度上降低了系统的耦合度，满足迪米特法则。         2. 客户端可以

    2024年01月19日
    浏览(46)

  • 《设计模式的艺术》笔记 - 桥接模式

            桥接模式将抽象部分与其实现部分分离，使它们都可以独立地变化。它是一种对象结构型模式，又称为柄体模式或接口模式 myclass.h myclass.cpp main.cpp         1. 分离抽象接口及其实现部分。桥接模式使用“对象间的关联关系”解耦了抽象和实现之间固有的绑定关系，

    2024年01月18日
    浏览(45)

  • 《设计模式的艺术》笔记 - 享元模式

            享元模式运用共享技术有效地支持大量细粒度对象的复用。系统只使用少量的对象，而这些对象都很相似，状态变化很小，可以实现对象的多次复用。由于享元模式要求能够共享的对象必须是细粒度对象，因此它又称为轻量级模式，是一种对象结构型模式。 myclass.

    2024年01月19日
    浏览(32)

  • 《设计模式的艺术》笔记 - 迭代器模式

            迭代器模式提供一种方法来访问聚合对象，而不用暴露这个对象的内部表示，其别名为游标（Cursor）。迭代器模式是一种对象行为型模式。 myclass.h myclass.cpp main.cpp         1. 支持以不同的方式遍历一个聚合对象，在同一个聚合对象上可以定义多种遍历方式。在迭代

    2024年01月24日
    浏览(38)

  • 《设计模式的艺术》笔记 - 单例模式

            单例模式优点是可以确保系统中只存在单个对象实例，缺点是不便扩展，一定程度上违背单一原则，既提供业务方法，又提供创建对象方法         在类加载的时候就创建好对象，获取对象时直接返回即可         在类加载的时候没有创建对象，第一次获取对象

    2024年02月02日
    浏览(32)

  • 《设计模式的艺术》笔记 - 工厂方法模式

            在简单工厂模式中，当系统中需要引入新的产品时，由于静态工厂方法通过所传入的参数的不同来创建不同的产品，这必定要修改工厂类的源代码，将违背开闭原则。因此，工厂方法模式应运而生。工厂方法模式是定义一个用于创建对象的接口，让子类决定将哪一个

    2024年01月23日
    浏览(37)

  • 《设计模式的艺术》笔记 - 抽象工厂模式

            提供了一个创建一系列相关或相互依赖的对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，它是一种对象创建型模式。         在抽象工厂模式中，每个具体工厂都提供了多个工厂方法用于产生多种不同类型的产品，这些产品构成了一个产品族。

    2024年01月16日
    浏览(29)

  • 《设计模式的艺术》笔记 - 建造者模式

            建造者模式将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。建造这模式是一种对象创建型模式。 myclass.h myclass.cpp main.cpp         优点：         1. 在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建

    2024年01月16日
    浏览(31)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包