C++设计模式——职责链模式

最新推荐文章于 2024-09-03 00:00:00 发布

CoderAldrich

最新推荐文章于 2024-09-03 00:00:00 发布

阅读量1.2k

点赞数 5

分类专栏：设计模式

设计模式专栏收录该内容

25 篇文章

订阅专栏

职责链模式允许多个对象有机会处理请求，避免发送者和接收者直接耦合。通过链式结构，请求沿链传递，直到被某对象处理。适用于运行时刻自动确定处理请求的对象。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

什么是职责链模式？

在GOF的《设计模式:可复用面向对象软件的基础》一书中对职责链模式是这样说的：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，直到有一个对象处理它为止；如下图：

对于每个角色，他们都有他们的职责；当我提交了休假申请时，项目经理需要判断，看看自己能否处理，如果休假超过了2个小时，那么项目经理就不能处理了；项目经理将这个请求提交到项目主管，项目主管判断部门经理在不在，如果部门经理在，项目主管就不能处理了；最后，我的休假申请就到了部门经理那里了，由他亲自审批。可以很明显的看到，项目经理、项目主管和部门经理都有可能处理我的休假申请，我的请求沿着这条链一直走下去，直到有人处理了我的请求。

UML类图

Handler：定义了一个处理请求的接口；其它类如果需要处理相同的请求，可以实现该接口就好了；
ConcreteHandler：处理它所负责的请求，如果可处理该请求，就处理掉这个请求；否则将该请求转发给它的下一个可以处理该请求的对象，所以它必须能访问它的下一个可以处理同样请求的对象；
Client：向处理对象提出具体的请求。

当客户提交一个请求时，请求沿着一条链传递，直至有一个ConcreteHandler对象负责处理它。

使用场合

有多个的对象可以处理一个请求，由哪个对象处理该请求是在运行时刻自动确定的；
如果想在不明确指定接收者的情况下，向多个对象中的一个提交一个请求；
可以处理一个请求的对象集合应被动态指定。

代码实现

#include <iostream>
using namespace std;

#define SAFE_DELETE(p) if (p) { delete p; p = NULL; }

class HolidayRequest
{
public:
     HolidayRequest(int hour) : m_iHour(hour){}
     int GetHour() { return m_iHour; }
private:
     int m_iHour;
};

// The holiday request handler interface
class Manager
{
public:
     virtual bool HandleRequest(HolidayRequest *pRequest) = 0;
};

// Project manager
class PM : public Manager
{
public:
     PM(Manager *handler) : m_pHandler(handler){}
     bool HandleRequest(HolidayRequest *pRequest)
     {
          if (pRequest->GetHour() <= 2 || m_pHandler == NULL)
          {
               cout<<"PM said:OK."<<endl;
               return true;
          }
          return m_pHandler->HandleRequest(pRequest);
     }
private:
     Manager *m_pHandler;
};

// Department manager
class DM : public Manager
{
public:
     DM(Manager *handler) : m_pHandler(handler){}
     bool HandleRequest(HolidayRequest *pRequest)
     {
          cout<<"DM said:OK."<<endl;
          return true;
     }

     // The department manager is in?
     bool IsIn()
     {
          return true;
     }
private:
     Manager *m_pHandler;
};

// Project supervisor
class PS : public Manager
{
public:
     PS(Manager *handler) : m_pHandler(handler){}
     bool HandleRequest(HolidayRequest *pRequest)
     {
          DM *pDM = dynamic_cast<DM *>(m_pHandler);
          if (pDM != NULL)
          {
               if (pDM->IsIn())
               {
                    return pDM->HandleRequest(pRequest);
               }
          }
          cout<<"PS said:OK."<<endl;
          return true;
     }
private:
     Manager *m_pHandler;
};
int main()
{
     DM *pDM = new DM(NULL);
     PS *pPS = new PS(pDM);
     PM *pPM = new PM(pPS);
     HolidayRequest *pHolidayRequest = new HolidayRequest(10);
     pPM->HandleRequest(pHolidayRequest);
     SAFE_DELETE(pHolidayRequest);

     pHolidayRequest = new HolidayRequest(2);
     pPM->HandleRequest(pHolidayRequest);

     SAFE_DELETE(pDM);
     SAFE_DELETE(pPS);
     SAFE_DELETE(pPM);
     SAFE_DELETE(pHolidayRequest);
}

优缺点

降低耦合度；职责链模式使得一个对象不用知道是哪一个对象处理它的请求。对象仅需要知道该请求会被正确的处理。接收者和发送者都没有对方的明确的信息，且链中的对象不需要知道链的结构；
增强了给对象指派职责的灵活性；当在对象中分派职责时，职责链给你更多的灵活性。你可以通过在运行时对该链进行动态的增加或修改来增加或改变处理一个请求的那些职责；
不保证被接受，既然一个请求没有明确的接收者，那么就不能保证它一定会被处理；该请求可能一直到链的末端都得不到处理。一个请求也可能因该链没有被正确配置而得不到处理。

总结

职责链模式在实现时，需要处理好它的后继者的问题，就是说，如果我不处理这个请求，那么我将把这个请求发给谁去处理呢？同时，职责链模式在实现时，它的链的形状并不是由职责链本身建立和维护的，而是由客户进行创建的，由客户指定每一个处理者的后继者是谁。这就大大的提高了职责链的灵活性。在实际中，我们也可以将职责链模式与组合模式相结合，一个构件的父构件可以作为它的后继者。