Chain of Responsibility(职责链设计模式)

声明：本博文篇幅短，适合review。

一、概念

       使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理他为止。

二、模式结构图

class Handle
{
public:
	virtual ~Handle();
	virtual void handleRequest() = 0;
	void setSuccessor(Handle* succ){
		_succ = succ;
	}
protected:
	Handle(){
		_succ = NULL;
	}
	Handle(Handle* succ){
		_succ = succ;
	}
private:
	Handle* _succ;
};

class ConcreteHandleA : public Handle {
public:
	ConcreteHandleA(Handle* succ) : _succ(succ) {}
	void handleRequest()
	{
		if (_succ)
		{
			cout<<"ConcreteHandleA to Next....."<<endl;
			_succ->handleRequest();
		}
		else
		{
			cout<<"ConcreteHandleA I deal with it..."<<endl;
		}
	}
};

class ConcreteHandleB : public Handle {
public:
	ConcreteHandleB(Handle* succ) : _succ(succ) {}
	void handleRequest()
	{
		if (_succ)
		{
			cout<<"ConcreteHandleB to Next....."<<endl;
			_succ->handleRequest();
		}
		else
		{
			cout<<"ConcreteHandleB I deal with it..."<<endl;
		}
	}
};

void main(){
	Handle* h1 = new ConcreteHandleA();
	Handle* h2 = new ConcreteHandleB();
	h1->setSuccessor(h2);
	h1->handleRequest();
}

三、例子

class Manager
{
public:
	virtual ~Manager();
	virtual void dismiss() = 0;
	void SetSuccessor(Manager* mng){
		_mng = mng;
	}
protected:
	Manager(){
		_mng = NULL;
	}
	Manager(Manager* mng){
		_mng = mng;
	}
private:
	Manager* _mng;
};

class ZhuGuan : public Manager {
public:
	ZhuGuan(Manager* mng) : _mng(mng) {}
	void dismiss(int power)
	{
		if (power > 10)
		{
			cout<<"ZhuGuan dismiss!"<<endl;
		}
		else
		{
			if (_mng){
				cout<<"ZhuGuan give it to next one"<<endl;
				_mng->dissmiss(power);
			}else{
				cout<<"ZhuGuan no power!"<<endl;
			}
		}
	}
};

class JinLi : public Manager {
public:
	JinLi(Manager* mng) : _mng(mng) {}
	void dismiss(int power)
	{
		if (power > 10)
		{
			cout<<"JinLi dismiss!"<<endl;
		}
		else
		{
			if (_mng){
				cout<<"JinLi give it to next one"<<endl;
				_mng->dissmiss(power);
			}else{
				cout<<"JinLi no power!"<<endl;
			}
		}
	}
};

class ZongCai : public Manager {
public:
	ZongCai(Manager* mng) : _mng(mng) {}
	void dismiss(int power)
	{
		if (power > 10)
		{
			cout<<"ZongCai dismiss!"<<endl;
		}
		else
		{
			if (_mng){
				cout<<"ZongCai give it to next one"<<endl;
				_mng->dissmiss(power);
			}else{
				cout<<"ZongCai no power!"<<endl;
			}
		}
	}
};

void main(){
	Manager* m1 = new ZhuGuan();
	Manager* m2 = new JinLi();
	Manager* m3 = new ZongCai();
	
	m1->SetSuccessor(m2);
	m2->SetSuccessor(m3);
	
	m1->dismiss(8);
	m1->dismiss(11);
}

四、优缺点

       1、优点

             a、降低了耦合性，请求的发送者完全不必知道该请求会被哪个应答对象处理。

             b、增强了系统的可扩展性。

       2、缺点

          a、职责链的建立的合理性要靠客户端来保证，增加了程序的复杂性，也有可能由于职责链导致出错。