设计模式 - 职责链模式

职责链模式，针对同一个请求，多个对象都有处理的机会，从而避免了请求的发送者与接收者之间的耦合关系。把多个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。



Handler，定义一个处理请求的抽象接口，该接口是HandleRequest()。该类内部维护一个Handler对象的指针，指向处理该请求的后续对象。

ConcreteHandle，具体的处理请求的类，继承自Handle，处理它所负责的请求，能够访问它的后继者。若ConcreteHandle可处理该请求，就处理，若不能处理，就将该请求转发给它的后继者。

职责链模式的基本使用代码如下：

typedef  int  Request;

//处理请求的抽象基类
class Handle
{
public:
Handle(Handle *pHandle) : m_pSuccessor(pHandle) {}
~Handle() {}

//处理请求
virtual void HandleRequest(Request req) = 0;

protected:
//处理请求的后续对象
Handle*		m_pSuccessor;
};

//处理请求的具体类A
class ConcreteHandleA : public Handle
{
public:
ConcreteHandleA(Handle *pHandle = NULL) : Handle(pHandle) {}
~ConcreteHandleA() {}

void HandleRequest(Request req)
{
if(req < 10)
{
printf("A处理请求：%d \n", req);
}
else
{
if(m_pSuccessor)
{
m_pSuccessor->HandleRequest(req);
}
}
}
};

//处理请求的具体类B
class ConcreteHandleB : public Handle
{
public:
ConcreteHandleB(Handle *pHandle = NULL) : Handle(pHandle) {}
~ConcreteHandleB() {}

void HandleRequest(Request req)
{
if(req < 20)
{
printf("B处理请求：%d \n", req);
}
else
{
if(m_pSuccessor)
{
m_pSuccessor->HandleRequest(req);
}
}
}
};

//处理请求的具体类C
class ConcreteHandleC : public Handle
{
public:
ConcreteHandleC(Handle *pHandle = NULL) : Handle(pHandle) {}
~ConcreteHandleC() {}

void HandleRequest(Request req)
{
if(req < 30)
{
printf("C处理请求：%d \n", req);
}
else
{
if(m_pSuccessor)
{
m_pSuccessor->HandleRequest(req);
}
}
}
};

//使用时的代码
int main()
{
//所有请求
Request  req[] = {3, 8, 15, 18, 24, 29, 35};

//C没有后继者
ConcreteHandleC *pC = new ConcreteHandleC();
//C作为B的后继者
ConcreteHandleB *pB = new ConcreteHandleB(pC);
//B作为A的后继者
ConcreteHandleA *pA = new ConcreteHandleA(pB);

for(int i = 0; i < sizeof(req) / sizeof(int); i++)
{
//从A对象开始处理请求
pA->HandleRequest( req[i] );
}
}

职责链模式把处理一个请求的对象以链的形式连在了一起，当客户提交一个请求时，请求是沿链传递的，直到有一个ConcreteHandle对象处理它为止。

职责链模式的好处：

职责链模式使得请求的接收者和发送者都没有对方的明确消息，在链中的对象自己也并不知道链的结构。职责链模式简化了对象的相互连接，它们仅需保持一个指向其后继者的引用，而不需保持它所有的候选后继者的引用。

在客户端来定义链的结构，我们可随时增加或修改处理一个请求的结构。增强了给对象指派职责的灵活性。

职责链模式的弊端：

一个请求有可能到了链的末端都得不到处理，或者因为没有正确配置而得不到处理。