1、定义
顾名思义,责任链模式(Chain of Responsibility Pattern)为请求创建了一个接收者对象的链。这种模式给予请求的类型,对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。
在这种模式中,通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求,那么它会把相同的请求传给下一个接收者,依此类推。
2、介绍
优点: 1、降低耦合度。它将请求的发送者和接收者解耦。 2、简化了对象。使得对象不需要知道链的结构。 3、增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序,允许动态地新增或者删除责任。 4、增加新的请求处理类很方便。
缺点: 1、不能保证请求一定被接收。 2、系统性能将受到一定影响,而且在进行代码调试时不太方便,可能会造成循环调用。 3、可能不容易观察运行时的特征,有碍于除错。
使用场景: 1、有多个对象可以处理同一个请求,具体哪个对象处理该请求由运行时刻自动确定。 2、在不明确指定接收者的情况下,向多个对象中的一个提交一个请求。 3、可动态指定一组对象处理请求。
3、源码
类关系图:
思路:1、IWomen作为请求者接口类,具体请求和请求标志位(寻找负责类)由CWomen实现。2、CHandler作为负责类的接口,根据具体请求标志位,判断是否请求当前负责者类,如果不是请求当前负责者类,则去询问下一个。
3.1、头文件
IWomen.h
#pragma once
#include <iostream>
using namespace std;
class IWomen
{
public:
IWomen(void)
{
}
virtual ~IWomen(void)
{
}
virtual int GetType() = 0;
virtual string GetRequest() = 0;
};
Women.h
#pragma once
#include "iwomen.h"
class CWomen :
public IWomen
{
public:
CWomen(int _type, string _request);
~CWomen(void);
int GetType();
string GetRequest();
private:
int m_type;
string m_request;
};
Handler.h
#pragma once
#include "IWomen.h"
class CHandler
{
public:
CHandler(int _level);
virtual ~CHandler(void);
void HandleMessage(IWomen *pwomen);
void SetNext(CHandler *phandler);
virtual void Response(IWomen *pwomen) = 0;
private:
int m_level;
CHandler *m_pNextHandler;
};
Father.h
#pragma once
#include "handler.h"
#include "IWomen.h"
class CFather :
public CHandler
{
public:
CFather(void);
~CFather(void);
void Response(IWomen *pwomen);
};
Husband.h
#pragma once
#include "handler.h"
#include "IWomen.h"
class CHusband :
public CHandler
{
public:
CHusband(void);
~CHusband(void);
void Response(IWomen *pwomen);
};
Son.h
#pragma once
#include "handler.h"
#include "IWomen.h"
class CSon :
public CHandler
{
public:
CSon(void);
~CSon(void);
void Response(IWomen *pwomen);
};
3.2、实现
Women.cpp
#include "Women.h"
CWomen::CWomen( int _type, string _request )
{
this->m_type = _type;
switch (this->m_type)
{
case 1:
this->m_request.append("女儿的请求是:");
this->m_request.append(_request);
break;
case 2:
this->m_request.append("妻子的请求是:");
this->m_request.append(_request);
break;
case 3:
this->m_request.append("母亲的请求是:");
this->m_request.append(_request);
break;
}
}
CWomen::~CWomen(void)
{
}
int CWomen::GetType()
{
return m_type;
}
string CWomen::GetRequest()
{
return m_request;
}
Handler.cpp
#include "Handler.h"
CHandler::CHandler(int _level) : m_level(_level)
{
m_pNextHandler = NULL;
}
CHandler::~CHandler(void)
{
}
void CHandler::HandleMessage(IWomen *pwomen)
{
if (pwomen->GetType() == this->m_level)
{
this->Response(pwomen);
}
else
{
if (this->m_pNextHandler != NULL)
this->m_pNextHandler->HandleMessage(pwomen);
else
cout << "----------没地方请示了,不做处理!----------" << endl;
}
}
void CHandler::SetNext(CHandler *phandler)
{
m_pNextHandler = phandler;
}
Father.cpp
#include "Father.h"
CFather::CFather(void) : CHandler(1)
{
}
CFather::~CFather(void)
{
}
void CFather::Response(IWomen *pwomen)
{
cout << "女儿向父亲请示:" << endl;
cout << pwomen->GetRequest().c_str() << endl;
cout << "父亲的答复是:同意" << endl;
}
Husband.cpp
#include "Husband.h"
#include <iostream>
using std::cout;
using std::endl;
CHusband::CHusband(void) : CHandler(2)
{
}
CHusband::~CHusband(void)
{
}
void CHusband::Response( IWomen *pwomen )
{
cout << "妻子向丈夫请示:" << endl;
cout << pwomen->GetRequest().c_str() << endl;
cout << "丈夫的答复是:同意" << endl;
}
Son.cpp
#include "Son.h"
#include <iostream>
using std::cout;
using std::endl;
CSon::CSon(void) : CHandler(3)
{
}
CSon::~CSon(void)
{
}
void CSon::Response( IWomen *pwomen )
{
cout << "母亲向儿子请示:" << endl;
cout << pwomen->GetRequest().c_str() << endl;
cout << "儿子的答复是:同意" << endl;
}
ChainofResponsibility.cpp
#include "IWomen.h"
#include "Women.h"
#include "Handler.h"
#include "Father.h"
#include "Husband.h"
#include "Son.h"
void DoNew()
{
cout << "----------使用模式后的处理方式----------" << endl;
//Handler.h, Handler.cpp, IWomen.h, Women.h, Women.cpp, Father.h, Father,cpp, Husband.h, Husband.cpp, Son.h, Son.cpp
IWomen *pwomen1 = new CWomen(1, "我要出去逛街");//女儿请求,标志为1
IWomen *pwomen2 = new CWomen(2, "我要出去吃饭");//妻子请求,标志为2
IWomen *pwomen3 = new CWomen(3, "我也要出去吃饭");//母亲请求,标志为2
IWomen *pwomen4 = new CWomen(4, "我也要出去逛街");
CHandler *pfather = new CFather();//指向子类对象CFather,负责标志为1的请求
CHandler *phusband = new CHusband();//指向子类对象CHusband,负责标志为2的请求
CHandler *pson = new CSon();//指向子类对象CSon,负责标志为3的请求
//指定自己的下一个请求者。
pfather->SetNext(phusband);
phusband->SetNext(pson);
pfather->HandleMessage(pwomen1);
pfather->HandleMessage(pwomen2);
pfather->HandleMessage(pwomen3);
pfather->HandleMessage(pwomen4);
delete pfather;
delete phusband;
delete pson;
delete pwomen1;
delete pwomen2;
delete pwomen3;
delete pwomen4;
}
int main()
{
//要实现逻辑判断,即女性的请求先发送到父亲类,父亲类一看是自己要处理的,就回应进行处理。如果女儿已经出嫁了,那就把这个请求转发到女婿类来处理。依此类推,形成了一个责任链。
DoNew();
return 0;
}
4、结果
参考文献:《菜鸟教程》 https://blog.csdn.net/phiall/article/details/52199659博客