精华内容
参与话题
问答
  • [设计模式]Command命令模式

    千次阅读 2013-01-04 21:38:50
    command命令模式 Command模式通过将请求封装到一个对象(Command)中,并将请求的接收者存放到具体的ConcreteCommand类中的(reciver)中,从而实现调用操作的对象和操作的具体实现之间的解耦。 解析:Command模式...

    command命令模式

    Command模式通过将请求封装到一个对象(Command)中,并将请求的接收者存放到具体的ConcreteCommand类中的(reciver)中,从而实现调用操作的对象和操作的具体实现之间的解耦。

    解析:Command模式的思想是把命令封装在一个类(Command)中,同时把接收对象也封装在一个类(Receive)中,由调用这个命令的类(Invoker)来调用。其实,如果弄清楚了Command模式的原理,就会发现其实它和注册回调函数的原理很相似,而在面向过程的设计中的回调函数其实和这里的Command类的作用是一致的。采用Command模式解耦了命令的发出者和命令的执行者。

    小demo

    command.h

    #ifndef COMMAND_H
    #define COMMAND_H
    
    class Command
    {
    public:
    	virtual ~Command() {}
    	virtual void Execute() = 0;
    };
    
    class Receiver
    {
    public:
    	void Action();
    };
    
    class Invoker
    {
    public:
    	Invoker(Command *pCommand);
    	~Invoker();
    	void Invoke();
    private:
    	Command *m_pCommand;
    };
    
    class ConcreateComand	: public Command
    {
    public:
    	ConcreateComand(Receiver* pReceiver);
    	virtual ~ConcreateComand();
    	virtual void Execute();
    private:
    	Receiver* m_pReceiver;
    };
    
    #endif

    command.cpp

    #include "Command.h"
    #include <iostream>
    
    void Receiver::Action()
    {
    	std::cout << "Receiver Action\n";
    }
    
    Invoker::Invoker(Command *pCommand)	: m_pCommand(pCommand)
    {
    }
    
    Invoker::~Invoker()
    {
    	delete m_pCommand;
    	m_pCommand = NULL;
    }
    
    void Invoker::Invoke()
    {
    	if (NULL != m_pCommand)
    	{
    		m_pCommand->Execute();
    	}
    }
    
    ConcreateComand::ConcreateComand(Receiver* pReceiver): m_pReceiver(pReceiver)
    {
    }

    main.cpp

    #include "Command.h"
    #include <stdlib.h>
    
    int main()
    {
    	Receiver* pReceiver = new Receiver();
    	Command*  pCommand  = new ConcreateComand(pReceiver);
    	Invoker*  pInvoker  = new Invoker(pCommand);
    
    	pInvoker->Invoke();
    	delete pInvoker;
    	system("pause");
    	return 0;
    }

    Command模式的思想非常简单,但是Command模式也十分常见,并且威力不小。实际上,command模式关键就是提供一个抽象的command类,并将执行操作封装到command类接口中,command类中一般就只是一些接口的集合,并不包含任何的数据属性。好处有:

    • command模式将调用操作的对象和知道如何实现该操作的对象解耦在command的结构图中,Invoker对象根本就不知道具体的是哪个对象在处理Excute操作(当然要知道是Command类别的对象,也仅此而已)。
    • 在command要增加新的处理操作对象很容易,我们可以通过创建新的继承自command的子类来实现这一点。
    • command模式可以和memento模式结合起来,支持取消的操作。

    实现方式

    1. 声明仅有一个执行方法的命令接口。
    2. 抽取请求并使之成为实现命令接口的具体命令类。 每个类都必须有一组成员变量来保存请求参数和对于实际接收者对象的引用。 所有这些变量的数值都必须通过命令构造函数进行初始化。
    3. 找到担任发送者职责的类。 在这些类中添加保存命令的成员变量。 发送者只能通过命令接口与其命令进行交互。 发送者自身通常并不创建命令对象, 而是通过客户端代码获取。
    4. 修改发送者使其执行命令, 而非直接将请求发送给接收者。
    5. 客户端必须按照以下顺序来初始化对象:
    • 创建接收者。
    • 创建命令, 如有需要可将其关联至接收者。
    • 创建发送者并将其与特定命令关联。

    请求发送者与接收者解耦——命令模式

    与其他模式的关系

    责任链模式、 命令模式、 中介者模式和观察者模式用于处理请求发送者和接收者之间的不同连接方式:

    • 责任链按照顺序将请求动态传递给一系列的潜在接收者,直至其中一名接收者对请求进行处理。
    • 命令在发送者和请求者之间建立单向连接。
    • 中介者清除了发送者和请求者之间的直接连接, 强制它们通过一个中介对象进行间接沟通。
    • 观察者允许接收者动态地订阅或取消接收请求。

    责任链的管理者可使用命令模式实现。

    • 在这种情况下,可以对由请求代表的同一个上下文对象执行许多不同的操作。
    • 还有另外一种实现方式, 那就是请求自身就是一个命令对象。 在这种情况下, 可以对由一系列不同上下文连接而成的链执行相同的操作。

    你可以同时使用命令和备忘录模式来实现 “撤销”。 在这种情况下, 命令用于对目标对象执行各种不同的操作,备忘录用来保存一条命令执行前该对象的状态。

    命令和策略模式看上去很像,因为两者都能通过某些行为来参数化对象。 但是, 它们的意图有非常大的不同。

    • 你可以使用命令来将任何操作转换为对象。 操作的参数将成为对象的成员变量。 你可以通过转换来延迟操作的执行、将操作放入队列、保存历史命令或者向远程服务发送命令等。
    • 另一方面, 策略通常可用于描述完成某件事的不同方式,让你能够在同一个上下文类中切换算法。

    原型模式可用于保存命令的历史记录。

    你可以将访问者模式视为命令模式的加强版本,其对象可对不同类的多种对象执行操作。

    展开全文
  • [C++设计模式] command 命令模式

    千次阅读 2015-07-20 10:35:58
    在软件系统中,“行为请求者”与“行为实现者”通常呈现一种“紧耦合”。但在某些场合,比如要对...这就是命令模式Command Pattern)。 在OOP中,一切都是对象,将请求封装成对象,符合OOP的设计思想,当将客户的单

    在软件系统中,“行为请求者”与“行为实现者”通常呈现一种“紧耦合”。但在某些场合,比如要对行为进行“记录、撤销/重做、事务”等处理,这种无法抵御变化的紧耦合是不合适的。在这种情况下,如何将“行为请求者”与“行为实现者”解耦?将一组行为抽象为对象,实现二者之间的松耦合。这就是命令模式(Command Pattern)。

    在OOP中,一切都是对象,将请求封装成对象,符合OOP的设计思想,当将客户的单个请求封装成对象以后,我们就可以对这个请求存储更多的信息,使请求拥有更多的能力;命令模式同样能够把请求发送者和接收者解耦,使得命令发送者不用去关心请求将以何种方式被处理。


    Command:
    定义命令的接口,声明执行的方法。
    ConcreteCommand:
    命令接口实现对象,是“虚”的实现;通常会持有接收者,并调用接收者的功能来完成命令要执行的操作。
    Receiver:
    接收者,真正执行命令的对象。任何类都可能成为一个接收者,只要它能够实现命令要求实现的相应功能。
    Invoker:
    要求命令对象执行请求,通常会持有命令对象,可以持有很多的命令对象。这个是客户端真正触发命令并要求命令执行相应操作的地方,也就是说相当于使用命令对象的入口。
    Client:
    创建具体的命令对象,并且设置命令对象的接收者。注意这个不是我们常规意义上的客户端,而是在组装命令对象和接收者,或许,把这个Client称为装配者会更好理解,因为真正使用命令的客户端是从Invoker来触发执行。

    1.命令模式的本质是对命令进行封装,将发出命令的责任和执行命令的责任分割开。
    2.每一个命令都是一个操作:请求的一方发出请求,要求执行一个操作;接收的一方收到请求,并执行操作。
    3.命令模式允许请求的一方和接收的一方独立开来,使得请求的一方不必知道接收请求的一方的接口,更不必知道请求是怎么被接收,以及操作是否被执行、何时被执行,以及是怎么被执行的。
    4.命令模式使请求本身成为一个对象,这个对象和其他对象一样可以被存储和传递。
    5.命令模式的关键在于引入了抽象命令接口,且发送者针对抽象命令接口编程,只有实现了抽象命令接口的具体命令才能与接收者相关联。

    class Receiver
    {
    public:
         void Action()
         {
              cout<<"Receiver->Action"<<endl;
         }
    };
    
    class Command
    {
    public:
         virtual void Execute() = 0;
    };
    
    class ConcreteCommand : public Command
    {
    public:
         ConcreteCommand(Receiver *pReceiver) : m_pReceiver(pReceiver){}
         void Execute()
         {
              m_pReceiver->Action();
         }
    private:
         Receiver *m_pReceiver;
    };
    
    class Invoker
    {
    public:
         Invoker(Command *pCommand) : m_pCommand(pCommand){}
         void Invoke()
         {
              m_pCommand->Execute();
         }
    private:
         Command *m_pCommand;
    };
    
    int main()
    {
         Receiver *pReceiver = new Receiver();
         Command *pCommand = new ConcreteCommand(pReceiver);
         Invoker *pInvoker = new Invoker(pCommand);
         pInvoker->Invoke();
         SAFE_DELETE(pInvoker);
         SAFE_DELETE(pCommand);
         SAFE_DELETE(pReceiver);
         return 0;
    }


    展开全文
  • 设计模式(20)-Command 命令模式

    千次阅读 2017-07-02 22:45:21
    将一个请求封装为一个对象,从而可用不同的请求对客户进行参数化; 对请求排队或记录请求日志,以及支持可取消的操作。

    将一个请求封装为一个对象,从而可用不同的请求对客户进行参数化;

    对请求排队或记录请求日志,以及支持可取消的操作。


    展开全文
  •  我的描述1、模式理解我觉得命令模式可以从以下几点进行理解:1)分离框架和应用逻辑在GOF《设计模式》动机部分,描述了用户界面框架中按钮和菜单这样的对象,这些对象执行操作以对用户请求进行响应,但是由于这些...
     
    
    官方描述
    将一个请求封装成一个对象,从而使你可用不同的请求对客户进行参数化,对请求排队或记录请求日志,以及支持可撤销的操作。
     
    我的描述
    1、模式理解
    我觉得命令模式可以从以下几点进行理解:
    1)分离框架和应用逻辑
    在GOF《设计模式》动机部分,描述了用户界面框架中按钮和菜单这样的对象,这些对象执行操作以对用户请求进行响应,但是由于这些对象属于工具箱的一部分,所以在实际的被用户使用之前,根本不能确定执行的操作内容,操作内容属于具体应用的一部分。为了在界面框架和基于该框架的应用之间协调的工作,并提供灵活的可扩展性,采用Command命令模式,该模式把操作内容从按钮和菜单项中分离出来,并通过定义一个抽象的Command类型来进行衔接,这样具体应用程序就可以通过实现具体的Command子类,来对应用程序中按钮和菜单项的操作任务进行灵活的定制。
    在Struts框架中,框架通过Action类来封装请求操作,通过这种封装,使多变的请求逻辑和稳定的框架进行了分离,从而既实现了框架的完整性,又增强了框架使用的可扩展和可定制性。
    在基于Struts的开发中,我们通过实现具体的Action子类来执行具体的请求操作,对于复杂的J2EE Web系统,我们仍然可以对系统进行分层处理,在业务层再创建具体的业务处理对象(比如Session Bean Facade或业务处理JavaBean Manager),子Action通过调用业务处理对象(对应Receiver)完成请求操作。
     
    2)增强可扩展性和可切换性
    即使不是在框架中,我们仍然可以采用Command命令模式,将请求从调用对象中分离出来,并进行包装,这样通过定义抽象的Command类型,及实现具体的不同子类,从而可以灵活的用具体Command对象对系统进行配置,当需要新的请求处理方式时,可以简单的再定义新的Command子类,并用其装配系统,从而实现很好的可扩展性;
    同时因为各Command子类具有兼容的接口,所以系统可以在运行时根据需要对所使用的Command对象进行切换。
     
    3)集中与请求密切相关的内容
    有些时候,一些附加的操作很有必要,比如请求的撤销操作,排队以及日志记录操作等等,如果没有将Command分离出来,而是把请求操作放到象按钮或菜单对象内部,那么再增加这些附加的操作,必然会使得按钮/菜单这些对象变得极其的复杂,从而不便于实现和维护。
    Command模式的采用,将请求从业务对象中分离出来,进行独立的封装,这样对于与请求密切相关的内容,就可以集中放到Command对象内部,从而简化业务对象的设计。
     
     
    2、Command模式与其它模式的关系
    1)和Adapter模式的关系
    在GOF《设计模式》实现部分中,谈到Command的智能程度,一种极端是它只确定一个接收者和执行该请求的动作;另一种极端是它实现所有的功能,根本不需要额外的接收者对象。对于第一种极端,我觉得它起到了一种Adapter适配器的作用,它在客户端和实现者之间建立了一种协调的关系,而这和Adapter模式的核心区别就是意图不同,Adapter模式侧重于提供一种结构上的协调,Command模式则侧重于将请求从业务对象中分离。
     
    2)和Composite模式的关系
    当需要对Command对象进行组合,以构造宏命令时,组合的对象仍然是一种Command类型,当用户调用该组合Command对象的执行操作时,组合Command相应调用所含的各个Command成员执行操作。
     
    3)和Memento模式的关系
    当需要提供请求的撤销操作时,在请求执行之前需要把请求所操作的对象状态进行保存,以备撤销是使用,这是可以采用Memento备忘录模式进行对象内部状态地存储。
     
    3、备注
    1)Command模式的结构图
     
     
    2)Command模式参与者描述
     
    1、客户(Client)角色:创建了一个具体命令(ConcreteCommand)对象并确定其接收者。
    2、命令(Command)角色:声明了一个给所有具体命令类的抽象接口。这是一个抽象角色。
    3、具体命令(ConcreteCommand)角色:定义一个接受者和行为之间的弱耦合;实现Execute()方法,负责调用接收考的相应操作。Execute()方法通常叫做执方法。
    4、请求者(Invoker)角色:负责调用命令对象执行请求,相关的方法叫做行动方法。
    5、接收者(Receiver)角色:负责具体实施和执行一个请求。任何一个类都可以成为接收者,实施和执行请求的方法叫做行动方法。
      
     
    4、参考资料
           GOF《设计模式——可复用面向对象软件的基础》
    展开全文
  • 命令,出现在计算机中,是早就有的事,最典型的DOS系统就是命令模式最好的示例,大家输入一条指令给系统,系统就会完成一种操作,记得最早接触电脑时就是在初中的时候,Dos系统,没有鼠标,那个时候会电脑的人很少,...
  • 浅学设计模式命令<command>模式

    千次阅读 2012-05-25 22:51:11
    概念 在软件系统中,“行为请求者”与“行为实现者”通常呈现一种“紧耦合”。但在某些场合,比如要对行为进行“记录、撤销/重做、...这就是命令模式Command Pattern)关系图:看下命令模式是有哪些角色来组成的吧。
  • 命令模式Command Pattern) 命令模式属于行为型模式,它尝试将一个请求封装成一个对象,从而使您可以用不同的请求对客户进行参数化。 在该设计模式中,请求以命令的形式包裹在对象中并传给调用对象。调用对象寻找...
  • 命令模式解决了应用程序中对象的职责以及它们之间的通信方式 类型 行为型 适用场景 请求调用者和请求接收者需要解耦,使得调用者和接收者不直接交互 需要抽象出等待执行的行为 优点 降低隅合 容易扩展新命令或者一...
  • Design Pattern Command 命令设计模式

    千次阅读 2014-07-27 07:47:10
    本设计模式就是利用不同的类包起不同的命令,达到使用什么命令就实现什么操作。 也可以进一步利用map和自己喜欢的命令词对接起来。 一个执行类实际上已经包含了所有需要的操作了,如: class SuperMaker { public...
  • Java 实现命令(Command)模式

    千次阅读 2014-10-13 11:28:52
    类图 public interface ICommand { void execute(); } public class ConcreteCommand implements ICommand { private Receiver receiver; ... public ConcreteCommand(Receiver receiver) { this.receiver = r
  • 命令模式--command模式

    千次阅读 2015-01-19 09:47:59
    首先来一个命令的接口: package mode.command; /** * * 定义一个命令接口,其中有一个抽象的执行方法,参数人命令接收器 * * */ public interface Command { public void execute(CommandReceiver ...
  • Java命令模式(Command)

    千次阅读 2019-04-08 23:21:52
    概述   将一个请求封装为一个对象...命令模式(Command)的参与者 序号 参与者 说明 1 Command 声明执行操作的接口 2 ConcreteCommand 将一个接收者对象绑定于一个动作, 调用接收者相应的操作,以实现Exe...
  • 设计模式之Command(命令模式)

    千次阅读 2012-01-04 11:09:02
    命令模式做一个总结,以便查阅。 一、什么是命令模式  1、命令模式的定义: 将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可撤销的操作。 2、...
  • 成功解决ERROR: Command errored out with exit status 1: command: 'f:\program files\python\python36\pyt 解决问题 Building wheel for av (setup.py) ... error ERROR: Command errored out with exit ...
  • Java模式 - Command(命令模式)

    千次阅读 2011-11-28 10:19:10
    [http://www.blogjava.net/supercrsky/articles/200497.html] [http://xuzhenqinandy.iteye.com/blog/206011] [http://www.linuxidc.com/Linux/2011-08/41686.htm] [http://www.360doc.com/content/06/1127/10/58
  • 设计模式之命令模式(Command)摘录

    千次阅读 2014-07-01 22:07:27
    设计模式之命令模式(Command)摘录!
  • java设计模式-命令模式

    万次阅读 2019-08-02 18:35:40
    java设计模式-命令模式 1 背景 & 定义 软件开发过程中,常常出现“方法请求者”与“方法实现者”间存在紧密耦合;不利于软件功能的扩展和维护;例如,想对行为进行“撤销、重做、记录”等处理就很不方便,命令...
  • 19.Command-命令模式

    2017-05-10 09:54:04
    Command 命令模式 命令模式: 将一个请求封装为一个对象,从而让我们可用不同的请求对客户进行参数化; 对请求排队或者记录请求日志,以及支持可撤销的操作。 命令模式是一种对象行为型模式,其别名为动作(Action...
  • 设计模式之七 命令模式Command Pattern)

    千次阅读 热门讨论 2012-12-28 15:17:11
    概述 ...下面我们来学习命令模式 目的  将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化,对请求排队或记录请求日志,以及支持可撤销的操作。   结构图  详细解析 Co
  • 命令模式(Command Pattern)标签: 设计模式初涉描述性文字本节讲解的是行为型设计模式种的:命令模式,该模式非常简单, 就是用于行为请求者与行为实现者的解耦,举个简单的例子, 摆地摊与开店的流程:(例子参考...
  • C++设计模式--命令模式(Command)

    千次阅读 2019-03-05 07:44:56
    命令模式的结构很简单,但是对于消除代码间的耦合却有着重要的影响。命令模式就是一个函数对象:一个作为对象的函数。通过将函数封装为对象,就能够以参数的额形式将其传递给其他函数或者对象,告诉它们在旅行请求的...
  • 23种设计模式之命令模式Command

    千次阅读 2011-06-05 13:30:00
    23种设计模式之命令模式Command命令模式是一种对象的行为型模式,类似于传统程序设计方法中的回调机制,它将一个请求封装为一个对象,从而使得可用不同的请求对客户进行参数化;对请求排队或者记录请求日志,...
  • 设计模式之命令模式---Command Pattern

    千次阅读 2016-08-06 10:37:34
    模式的定义命令模式是一个高内聚的模式,定义如下:Encapsulate a request as an object,thereby letting you parameterize clients with different requests,queue or log requests,and support undoable ...
  • 命令模式-Command

    2014-02-19 17:14:27
    命令模式(Command),将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可撤销的操作。 命令模式结构图: Commandod ,用来声明执行操作的接口 abstract class ...
  • 命令(command)模式

    2013-04-06 21:13:27
    命令模式是将请求(命令)封装为对象。以便于使用不同的请求(队列或者日志)来参数化其他对象。 命令模式把发出命令的责任(invoker)和执行命令的责任(receiver)分割开。 关于命令模式 1.命令模式将...
  • 命令Command模式

    2005-10-13 16:54:00
    命令模式又称为行动(Action)模式或交易(Transaction)模式。命令模式把一个请求或者操作封装到一个对象中。命令模式允许系统使用不同的请求把客户端参数化,对请求排队或者记录请求日志,可以提供命令的撤销和...
  • 命令模式Command),将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可撤消的操作。
  • 命令模式)的结构很简单,但对于消除代码间的耦合却有着重要的影响。
  • 设计模式学习--命令模式Command Pattern) 2013年6月18日  设计模式学习记录 题外话:不知道同志们,怎么看待设计模式这个东西的,以小巫现在的水平,还不能把设计模式能运用到实际开发当中去,自己面向oo...
  • Command模式是最让我疑惑的一个模式,我在阅读了很多代码后,才感觉隐约掌握其大概原理,我认为理解设计模式最主要是掌握起原理构造,这样才对自己实际编程有指导作用.Command模式实际上不是个很具体,规定很多的模式,...

空空如也

1 2 3 4 5 ... 20
收藏数 280,823
精华内容 112,329
关键字:

command