《设计模式》学习笔记——命令模式

        命令模式（Command Pattern）是一种数据驱动的设计模式，它属于行为型模式。 请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令。

意图：
    将一个请求封装成一个对象，从而使您可以用不同的请求对客户进行参数化。
主要解决：
    在软件系统中，行为请求者与行为实现者通常是一种紧耦合的关系.
    但某些场合，比如需要对行为进行记录、撤销或重做、事务等处理时，这种无法抵御变化的紧耦合的设计就不太合适。
何时使用：
    在某些场合，比如要对行为进行"记录、撤销/重做、事务"等处理，这种无法抵御变化的紧耦合是不合适的。
    在这种情况下，如何将"行为请求者"与"行为实现者"解耦？将一组行为抽象为对象，可以实现二者之间的松耦合。
如何解决：
    通过调用者调用接受者执行命令，顺序：调用者→接受者→命令。
关键代码：
    定义三个角色：
    1、received 真正的命令执行对象 
    2、Command 
    3、invoker 使用命令对象的入口
应用实例：
    struts 1 中的 action 核心控制器 ActionServlet 只有一个.
    相当于 Invoker，而模型层的类会随着不同的应用有不同的模型类，相当于具体的 Command。
优点： 
    1、降低了系统耦合度。 
    2、新的命令可以很容易添加到系统中去。
缺点：
    使用命令模式可能会导致某些系统有过多的具体命令类。
使用场景：
    认为是命令的地方都可以使用命令模式，比如： 
                                            1、GUI 中每一个按钮都是一条命令。
                                            2、模拟 CMD。
注意事项：
    系统需要支持命令的撤销(Undo)操作和恢复(Redo)操作，也可以考虑使用命令模式，见命令模式的扩展。

CommandPattern.h

#pragma once
#include<iostream>
#include<string>
#include<list>

class Docter
{
public:
	void treat_eye()
	{
		std::cout << "Docter treat_eye()" << std::endl;
	}
	void treat_nose()
	{
		std::cout << "Docter treat_nose()" << std::endl;
	}

private:
protected:
};

// 抽象命令类
class CommandPattern
{
public:
	CommandPattern() {};
	~CommandPattern() {};
	virtual void docterTreat() = 0;			// 抽象接口
};

// 命令类
class CommandDocterTreatEye:public CommandPattern
{
public:
	CommandDocterTreatEye(Docter* docter):m_docter(docter){};	// 传入参数，也叫注入参数
	~CommandDocterTreatEye() {};
	virtual void docterTreat()									// 抽象接口实现
	{
		docterTreatEye();										// 实际调用
	}		
private:
	Docter * m_docter;			// 更好的方法是传入Docter类的纯虚基类做为一层接口，然后利用多态思想解耦和
	void docterTreatEye() { m_docter->treat_eye(); }			
protected:
};

// 命令类
class CommandDocterTreatNose :public CommandPattern
{
public:
	CommandDocterTreatNose(Docter* docter) :m_docter(docter) {};	// 传入参数，也叫注入参数
	~CommandDocterTreatNose() {};

	virtual void docterTreat()									// 抽象接口实现
	{
		docterTreatNose();										// 实际调用
	}	
private:
	Docter * m_docter;			// 更好的方法是传入Docter类的纯虚基类做为一层接口，然后利用多态思想解耦和
	void docterTreatNose() { m_docter->treat_nose(); }			// 实际调用
protected:
};

// 护士类,命令的发起者
class BeautyNurse
{
public:
	BeautyNurse(CommandPattern * commandpattern): m_commandpattern(commandpattern){}
	~BeautyNurse() {}

	void SubmitteCase()			// 案例提交，下达命令
	{
		m_commandpattern->docterTreat();		// 让医生治疗
	}
private:
	CommandPattern * m_commandpattern;			// 能够采集命令
protected:
};

// 护士长类,命令的批量发起者
class AdvHeadNurse
{
public:
	AdvHeadNurse()
	{
		m_commandPatternList.clear();			// 初始状态清空列表
	}
	~AdvHeadNurse() {}

	void setCommend(CommandPattern * command)
	{
		m_commandPatternList.push_back(command);	// 向列表添加命令
	}
	void SubmitteCase()			// 案例提交，下达命令
	{
		for (auto it = m_commandPatternList.begin(); it != m_commandPatternList.end(); it++)
			(*it)->docterTreat();

	}
private:
	std::list<CommandPattern *> m_commandPatternList;// 能够采集一批命令
protected:
};

 

CommandPattern.cpp

#include "CommandPattern.h"

 

mainTest.cpp

#include<iostream>
#include<string>
#include "CommandPattern.h"

int mainTest1(void)
{
	// 建立一个医生对象
	Docter* docter = new Docter;
	// 建立一个命令对象
	CommandPattern* commandPattern = new CommandDocterTreatNose(docter);	// 通过构造注入一个对象
	// 执行
	commandPattern->docterTreat();
	// 执行结束，删除对象
	delete commandPattern;

	// 建立一个新命令对象
	commandPattern = new CommandDocterTreatEye(docter);		// 通过构造注入另一个对象
	// 执行
	commandPattern->docterTreat();
	// 执行结束，删除对象
	delete commandPattern;
	// 删除对象
	delete docter;
	return 0;
}

int mainTest2()
{
	

	// 建立一个医生对象
	Docter* docter = new Docter;
	// 建立一个命令对象
	//CommandPattern* commandPattern = new CommandDocterTreatNose(docter);	// 通过构造注入一个对象		
	CommandPattern* commandPattern = new CommandDocterTreatEye(docter);		// 通过构造注入一个对象		
	BeautyNurse* beautynurse = new BeautyNurse(commandPattern);				// 建立一个护士对象，命令传达者
	beautynurse->SubmitteCase();											// 护士提交案例，传达命令

	// 执行结束，删除对象
	delete beautynurse;
	// 执行结束，删除对象
	delete commandPattern;
	// 删除对象
	delete docter;


	system("pause");
	return 0;
}

int main()
{
	//mainTest1();
	//mainTest2();

	// 建立一个医生对象
	Docter* docter = new Docter;
	// 建立一个命令对象
	CommandPattern* commandPattern1 = new CommandDocterTreatNose(docter);	// 通过构造注入一个对象		
	CommandPattern* commandPattern2 = new CommandDocterTreatEye(docter);	// 通过构造注入一个对象	
	// 建立一个护士长对象
	AdvHeadNurse* advHeadNurse = new AdvHeadNurse();						// 建立一个护士对象，命令传达者
	// 插入命令									插入命令可以修改扩展添加对可变参数的支持，能够更加友好
	advHeadNurse->setCommend(commandPattern1);
	advHeadNurse->setCommend(commandPattern2);
	// 批量传达命令
	advHeadNurse->SubmitteCase();											// 护士提交案例，传达命令

	// 执行结束，删除对象						
	delete advHeadNurse;
	// 执行结束，删除对象
	delete commandPattern2;
	// 执行结束，删除对象
	delete commandPattern1;
	// 删除对象
	delete docter;


	system("pause");
	return 0;
}