1. 意图
使多个对象都有机会处理请求. 从而避免请求的发送者/接收者之间的耦合关系.这些对象将连成一条链.并沿着链传递该请求. 直到有个对象处理它.
2. 动机
3. 适用性
有多个对象可以处理一个请求.具体是哪个对象处理请求要在运行时确定.需要在不明确指定接收者的情况下.向多个对象中的一个提交一个请求.可处理一个请求的对象的集合需要被动态指定.
4. 结构
5. 参与者
Handler
----定义一个处理请求的接口.
----(可选) 实现后继链.
ConcreteHandler
----具体处理者.处理它所负责的请求.
----可访问它的后继者.
----如果可处理该请求.就处理之.否则将请求转发给它的后继者.
Client
----向链上的具体处理者对象提交请求.
6.实例
公司的管理者一共有三级,总经理、总监、经理,如果一个员工要求加薪,应该向主管的经理申请,如果加薪的数量在经理的职权内,那么经理可以直接批准,否则将申请上交给总监。总监的处理方式也一样,总经理可以处理所有请求。这就是典型的职责链模式,请求的处理形成了一条链,直到有一个对象处理请求。给出这个例子的UML图。
代码的实现比较简单,如下所示:
//抽象管理者
class Manager
{
protected:
Manager *m_manager;
string m_name;
public:
Manager(Manager *manager, string name):m_manager(manager), m_name(name){}
virtual void DealWithRequest(string name, int num) {}
};
//经理
class CommonManager: public Manager
{
public:
CommonManager(Manager *manager, string name):Manager(manager,name) {}
void DealWithRequest(string name, int num)
{
if(num < 500) //经理职权之内
{
cout<<"经理"<<m_name<<"批准"<<name<<"加薪"<<num<<"元"<<endl<<endl;
}
else
{
cout<<"经理"<<m_name<<"无法处理,交由总监处理"<<endl;
m_manager->DealWithRequest(name, num);
}
}
};
//总监
class Majordomo: public Manager
{
public:
Majordomo(Manager *manager, string name):Manager(manager,name) {}
void DealWithRequest(string name, int num)
{
if(num < 1000) //总监职权之内
{
cout<<"总监"<<m_name<<"批准"<<name<<"加薪"<<num<<"元"<<endl<<endl;
}
else
{
cout<<"总监"<<m_name<<"无法处理,交由总经理处理"<<endl;
m_manager->DealWithRequest(name, num);
}
}
};
//总经理
class GeneralManager: public Manager
{
public:
GeneralManager(Manager *manager, string name):Manager(manager,name) {}
void DealWithRequest(string name, int num) //总经理可以处理所有请求
{
cout<<"总经理"<<m_name<<"批准"<<name<<"加薪"<<num<<"元"<<endl<<endl;
}
};
客户调用方式为:
//测试案例
int main()
{
Manager *general = new GeneralManager(NULL, "A"); //设置上级,总经理没有上级
Manager *majordomo = new Majordomo(general, "B"); //设置上级
Manager *common = new CommonManager(majordomo, "C"); //设置上级
common->DealWithRequest("D",300); //员工D要求加薪
common->DealWithRequest("E", 600);
common->DealWithRequest("F", 1000);
delete common; delete majordomo; delete general;
return 0;
}
7.实例2
main(),客户
IWomen,发出请求者接口
CWomen,请求者实现类
CHandler,处理请求抽象类
CFather,处理请求实现类,责任链之一
CHusband,处理请求实现类,责任链之二
CSon,处理请求实现类,责任链之三
说明:CHandler抽象类负责聚合责任链之中的其它处理对象,用SetNext来建立这个责任链。HandleMessage在处理请求时,会判断是否是自己要处理的请求,如果是则直接处理。如果不是,则查找下一个责任链上的处理对象,找到了则由下一个处理。
//IWomen.h
#pragma once
#include <iostream>
using std::string;
class IWomen
{
public:
IWomen(void)
{
}
virtual ~IWomen(void)
{
}
virtual int GetType() = 0;
virtual string GetRequest() = 0;
};
//Women.h
#pragma once
#include "iwomen.h"
#include <iostream>
using std::string;
class CWomen :
public IWomen
{
public:
CWomen(int _type, string _request);
~CWomen(void);
int GetType();
string GetRequest();
private:
int m_type;
string m_request;
};
//Women.cpp
#include "StdAfx.h"
#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.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;
};
//Handler.cpp
#include "StdAfx.h"
#include "Handler.h"
#include <iostream>
using std::cout;
using std::endl;
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.h
#pragma once
#include "handler.h"
#include "IWomen.h"
class CFather :
public CHandler
{
public:
CFather(void);
~CFather(void);
void Response(IWomen *pwomen);
};
//Father.cpp
#include "StdAfx.h"
#include "Father.h"
#include <iostream>
using std::cout;
using std::endl;
CFather::CFather(void) : CHandler(1)
{
}
CFather::~CFather(void)
{
}
void CFather::Response( IWomen *pwomen )
{
cout << "女儿向父亲请示:" << endl;
cout << pwomen->GetRequest().c_str() << endl;
cout << "父亲的答复是:同意" << endl;
}
//Husband.h
#pragma once
#include "handler.h"
#include "IWomen.h"
class CHusband :
public CHandler
{
public:
CHusband(void);
~CHusband(void);
void Response(IWomen *pwomen);
};
//Husband.cpp
#include "StdAfx.h"
#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.h
#pragma once
#include "handler.h"
#include "IWomen.h"
class CSon :
public CHandler
{
public:
CSon(void);
~CSon(void);
void Response(IWomen *pwomen);
};
//Son.cpp
#include "StdAfx.h"
#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 "stdafx.h"
#include "INormalWomen.h"
#include "NormalWomen.h"
#include "INormalHandler.h"
#include "NormalFather.h"
#include "NormalHusband.h"
#include "NormalSon.h"
#include "IWomen.h"
#include "Women.h"
#include "Handler.h"
#include "Father.h"
#include "Husband.h"
#include "Son.h"
#include <iostream>
using std::cout;
using std::endl;
void DoIt()
{
cout << "----------原来的处理方式----------" << endl;
//INormalWomen.h, NormalWomen.h, INormalHandler.h, NormalFather.h, NormalHusband.h, NormalSon.h
INormalWomen *pwomen = new CNormalWomen(1, "我要出去逛街");
INormalHandler *pfather = new CNormalFather();
INormalHandler *phusband = new CNormalHusband();
INormalHandler *pson = new CNormalSon();
if (pwomen->GetType() == 1)
{
cout << "女儿向父亲请示:" << endl;
pfather->HandleMessage(pwomen);
}
else if (pwomen->GetType() == 2)
{
cout << "妻子向丈夫请示:" << endl;
phusband->HandleMessage(pwomen);
}
else if (pwomen->GetType() == 3)
{
cout << "母亲向儿子请示:" << endl;
pson->HandleMessage(pwomen);
}
else
{
//什么也不做
}
delete pwomen;
delete pfather;
delete phusband;
delete pson;
}
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, "我要出去逛街");
IWomen *pwomen2 = new CWomen(2, "我要出去吃饭");
IWomen *pwomen3 = new CWomen(3, "我也要出去吃饭");
IWomen *pwomen4 = new CWomen(4, "我也要出去逛街");
CHandler *pfather = new CFather();
CHandler *phusband = new CHusband();
CHandler *pson = new CSon();
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 _tmain(int argc, _TCHAR* argv[])
{
//反面
DoIt();
//要实现逻辑判断,即女性的请求先发送到父亲类,父亲类一看是自己要处理的,就回应进行处理。如果女儿已经出嫁了,那就把这个请求转发到女婿类来处理。依此类推,形成了一个责任链。
DoNew();
return 0;
}