责任链模式详解,c++实现
责任链模式
定义:使多个对象都有机会处理请求,避免请求的发送者和接受者的耦合关系,将处理对象连成链,并沿着这条链传递该请求,直到有对象处理它为止。
重点在于“链”,由一条链处理相似的请求,在链中决定谁来处理这个请求,适合用于处理有等级限制的需求时。
通用类图
处理者Handler的三个职责:
1.定义一个请求的处理等级判断方法handle()用于判断处理还是推向下一级,这应该是处理者唯一对外开放的方法,应该用final修饰使其不被更改,因在基类中确定了等级判断函数,故也用到了模板模式。
2.定义一个链的编排方法setNext()用于设置“链”的下一级。
3.定义自己的处理等级,定义对请求的解决方法echo()。
优点:
将请求和处理分开,请求者不必知道谁处理,处理者不用知道谁请求的,两者解耦,提高系统的灵活性。
缺点:
很明显的两点,一是性能,每个请求都是从头遍历到尾,如果链条很长就很不方便;二是调试不便,判断处理等级时运用了递归方式,逻辑复杂,递归带来的时间与内存损耗会因链条的加长而显著提升。
注意事项:
因缺点显著,故最应重视控制链条节点的数量,一般可以在基类中设置一个最大节点数,在setNext()方法中判断是否超过了阈值,超过了则不允许建立该链,避免无意识的破坏系统性能。
c++代码示例
//需求类,是待处理的类
class request
{
public:
request(string& Data, const int& HandlerLevel)
{
mstrData = Data;
miHandlerLevel = HandlerLevel;
cout << "任务已创建,处理等级为" << miHandlerLevel << endl;
}
int getHandlerLevel()
{
return miHandlerLevel;
}
void setHandlerLevel(int &HandlerLevel)
{
miHandlerLevel = HandlerLevel;
}
string getData()
{
return mstrData;
}
protected:
int miHandlerLevel;
string mstrData;
};
//处理类的基类,确定处理等级,用子类实现处理需求的具体方式
class handler
{
public:
handler(const int& handlerLevel) :miHandlerLevel(handlerLevel), mNext(nullptr)
{
}
void Judge_Handle(request* Request)
{
if (getHandlerLevel() == Request->getHandlerLevel())
{
handle(Request);
}
else if(mNext != nullptr)
{
cout << "该等级无法处理,递交至下一位" << endl;
mNext->Judge_Handle(Request);
}
else
{
cout << "该命令无法被处理" << endl;
}
}
void setNext(handler* Handler)
{
mNext = Handler;
}
protected:
virtual void handle(request* Request)
{
}
int getHandlerLevel()
{
return miHandlerLevel;
}
handler* mNext;
int miHandlerLevel;
};
class employee :public handler
{
public:
employee(const int& handlerLevel):handler(handlerLevel)
{
cout << "处理人员已创建,等级为" << miHandlerLevel << endl;
}
protected:
virtual void handle(request* Resquest)
{
cout << Resquest->getData() << "处理等级为" << Resquest->getHandlerLevel() << ",已被" << getHandlerLevel() << "等级处理人员处理" << endl;
}
};
//测试函数
void func()
{
//确定等级
const int LEVEL1 = 1;
const int LEVEL2 = 2;
const int LEVEL3 = 3;
const int LEVEL4 = 4;
//组合处理链
handler* Handler1 = new employee(LEVEL1);
handler* Handler2 = new employee(LEVEL2);
handler* Handler3 = new employee(LEVEL3);
Handler1->setNext(Handler2);
Handler2->setNext(Handler3);
//生成不同等级的需求需求
string data = "mission1";
request* Request1 = new request(data, LEVEL1);
data = "mission2";
request* Request2 = new request(data, LEVEL2);
data = "mission3";
request* Request3 = new request(data, LEVEL3);
data = "mission4";
request* Request4 = new request(data, LEVEL4);
//只需要让处理链的第一位处理所有任务即可
Handler1->Judge_Handle(Request1);
Handler1->Judge_Handle(Request2);
Handler1->Judge_Handle(Request3);
Handler1->Judge_Handle(Request4);
}
int main()
{
func();
return 0;
}