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

最新推荐文章于 2024-11-03 23:39:20 发布
最新推荐文章于 2024-11-03 23:39:20 发布
阅读量914 收藏 6
点赞数 7
分类专栏： 设计模式 文章标签： 设计模式 笔记 命令模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuweiping5247/article/details/135696086
版权
本文详细介绍了命令模式的概念、实现方式，包括命令抽象类、具体命令类、接收者、调用者以及命令队列的扩展。同时探讨了该模式的优点、缺点，适用场景及一个实际练习案例，展示了如何在IT项目中应用命令模式来降低系统耦合和实现灵活的操作控制。
摘要由CSDN通过智能技术生成

介绍

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

实现

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

#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;
}

vfdn
关注
专栏目录
设计模式学习笔记（一）（黑马程序员）
hexinqiong的博客
05-06 1031
设计模式学习笔记（一）（黑马程序员） 1、设计模式概述 1.1 软件设计模式的产生背景 ​ "设计模式"最初并不是出现在软件设计中，而是被用于建筑领域的设计中。 ​ 1977年美国著名建筑大师、加利福尼亚大学伯克利分校环境结构中心主任克里斯托夫·亚历山大（Christopher Alexander）在他的著作《建筑模式语言：城镇、建筑、构造》中描述了一些常见的建筑设计问题，并提出了 253 种关于对城镇、邻里、住宅、花园和房间等进行设计的基本模式。 ​ 1990年软件工程界开始研讨设计模式的话题，后来
设计模式--介绍
turbolove的博客
09-20 1950
​ 设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。
计算机笔记--【Java设计模式】
qq_40720821的博客
05-17 1278
设计模式
23种设计模式 - 个人笔记(一)
知行
02-05 1144
1 认识设计模式 1.1 什么是设计模式 所谓设计模式，就是对经常出现的软件设计问题的成熟解决方案。 很多人把设计模式想象成非常高深的概念，实际上设计模式仅仅是对特定问题的一种惯性思维。笔者见过一些学员喜欢抱着一本设计模式的书研究，以期成为一个“高手”，实际上设计模式的理解必须以足够的代码积累量作为基础，最好是经历过某种痛苦，或者正在经历一种苦痛，就会对设计模式有较深的感受。 1.2 设计模式的目的 编写软件的过程中，程序员面临着来自耦合性、内聚性以及可维护性、可扩展性、重用性、灵活性等多方面的挑
黑马程序员 Java设计模式学习笔记（一）
qq_38196449的博客
01-14 1232
类图(Class diagram)是显示了模型的静态结构，特别是模型中存在的类、类的内部结构以及它们与其他类的关系等。类图不显示暂时性的信息。类图是面向对象建模的主要组成部分。
java设计模式笔记
penanut的博客
04-20 1507
根据黑马程序员的课程资料整理所得，仅用于学习使用，如有侵权，请联系删除。 1，设计模式概述 1.1 软件设计模式的产生背景 "设计模式"最初并不是出现在软件设计中，而是被用于建筑领域的设计中。 1977年美国著名建筑大师、加利福尼亚大学伯克利分校环境结构中心主任克里斯托夫·亚历山大（Christopher Alexander）在他的著作《建筑模式语言：城镇、建筑、构造》中描述了一些常见的建筑设计问题，并提出了 253 种关于对城镇、邻里、住宅、花园和房间等进行设计的基本模式。 1990年软件工程界开始研讨设
《设计模式的艺术》读书笔记
qq_40586164的博客
11-09 2363
面向对象设计原则 表1 7种常用的面向对象设计原则 设计原则名称 定 义 使用频率 单一职责原则(Single Responsibility Principle, SRP) 一个类只负责一个功能领域中的相应职责 ★★★★☆ 开闭原则(Open-Closed Principle, OCP) 软件实体应对扩展开放，而对修改关闭 ★★★★★ 里氏代换原则(Liskov Substitution Principle, LSP) 所有引用基类对象的地方能够透明地使用其子类的对象 ★★★★★
设计模式学习笔记
ai_0922的博客
04-28 1333
设计模式 面向对象的编程，并不是类也多越好，类的划分是为了封装，但分类的基础是抽象，具有相同属性的功能和队形的抽象集合才是类 如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化可能会削弱或者抑制这个类完成其他职责的能力。这种耦合会导致脆弱的设计，当变化发生时，设计会遭受到意想不到的破坏。 软件设计真正要做的许多内容，就是发现职责并把那些职责相互分离 如果你能够想到多余一个...
Java设计模式
m0_51970364的博客
06-09 572
概述 软件设计模式（Software Design Pattern），又称设计模式，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。它描述了在软件设计过程中的一些不断重复发生的问题，以及该问题的解决方案。 也就是说，它是解决特定问题的一系列套路，是历来 代码设计经验的总结，具有一定的普遍性，可以反复使用。 UML类图 统一建模语言（Unified Modeling Language，UML）是用来设计软件的可视化建模语言。它的特点是简单、统一、图形化、能表达软件设计中的动态与静态信息。
《设计模式：可复用面向对象软件的基础》——引言（笔记）
weixin_46949627的博客
10-08 889
《设计模式：可复用面向对象软件的基础》 引言部分笔记
设计模式学习笔记总结
yawen的博客
09-17 174
设计模式七大原则 单一职责原则 对于一个类应该只负责一项职责。 接口隔离 客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小接口上。 依赖倒转 高层模块不应该依赖底层模块，两者都应该依赖其抽象 抽象不应该依赖细节，细节应该依赖抽象 依赖倒转的核心是面向接口编程 依赖倒转原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定得多。以抽象为基础搭建的架构比以细节为基础的架构要稳定得多。在java中，抽象指的是接口或抽象类，细节上实现类 使用接口或者抽象类的目的是制定好规范，而不涉及
大话设计模式读书笔记之简单工厂模式（Java版）
2020-10-28
02-28 275
书中人物两位：小菜和大鸟 故事从一份题目开始：请用C++、Java、C#任意一种面向对象语言实现一个计算器控制台程序，要求输入两个数和运算符号，得到结果。 小菜第一次答题，代码如下： import java.util.Scanner; public class SimpleFactoryModel { public static void main(String[] args) { ...
图解设计模式在Spring框架中的实现读书笔记
资源摘要信息:"本书是关于设计模式与Spring框架结合的学习笔记，作者通过图解的方式对设计模式进行了深入阐述，并结合Spring框架的具体实现进行了示例演示。设计模式作为软件工程中解决特定问题的模板和经验总结，...
远程控制项目第二天
最新发布
zhj18679130613的博客
11-03 121
所有有关网络编程的项目，最基础的框架就是那些固定的流程，Socket，bind，listen，accept，然后我需要的就是在此基础上进行完善和优化，然后再Windows网络编程中，在socket前首先需要初始化 Winsock 库。
设计模式概述
小林的博客
10-30 404
直到1995 年，艾瑞克·伽马（ErichGamma）、理査德·海尔姆（Richard Helm）、拉尔夫·约翰森（Ralph Johnson）、约翰·威利斯迪斯（John Vlissides）等 4 位作者合作出版了《设计模式：可复用面向对象软件的基础》一书，在此书中收录了 23 个设计模式，这是设计模式领域里程碑的事件，导致了软件设计模式的突破。GoF（四人组）书中提供了模板方法、策略、命令、职责链、状态、观察者、中介者、迭代器、访问者、备忘录、解释器等 11 种行为型模式。
【Java】设计模式——单例设计模式
啊松同学的博客
11-02 569
单例设计模式介绍
微服务设计模式 - 发布订阅模式（Publisher Subscriber Pattern）
2404_88048702的博客
11-02 840
发布-订阅模式是实现松耦合系统的强大工具，在云计算和分布式系统中应用广泛。通过使用如RabbitMQ的消息中间件，我们可以很容易地在Spring Boot项目中实现这一模式。通过本文的示例，我们展示了如何利用配置消费者行为，并通过Spring Boot注解进行订阅，从而实现发布-订阅模式的精细化控制和一个完整的发布-订阅模式。这种模式不仅提高了系统的扩展性和灵活性，还大大简化了开发过程中的依赖管理。
设计模式——外观模式
chuliling0446的博客
10-30 1057
这些是实现具体功能的类，它们组成了一个子系统。子系统类之间可能存在复杂的交互和依赖关系，这些关系对于客户端来说可能是难以理解和操作的。外观类是外观模式的核心，它知道哪些子系统类负责哪些功能，并将客户端的请求转发给相应的子系统类来处理。外观类提供了一个简化的接口，隐藏了子系统类的复杂性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

vfdn

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值