职责链模式----C++实现

职责链模式

定义：

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

适用性：

1、  有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。

2、  想着不明确指定接收者的情况下，向多个对象中的一个提交请求。

3、  可处理一个请求的对象集合应被动态指定。

 

 

优点：

1、  降低了耦合度

2、  增加了给对象指派职责的灵活性。

 

结构：

实现：

 

//请求级别

enum REQUESTLEVEL

{

       NORMAL = 0,

       ABOVE_NORMAL,

       HIGH

};

//请求类

class Request

{

public:

       Request(string name,int level):m_name(name),m_level(level)

       {  }

       intGetRequestLevel()

       {

              returnm_level;

       }

 

       string GetRequestName()

       {

              returnm_name;

       }

protected:

private:

       string m_name;

       int     m_level;

};

//处理请求的抽象父类

class Handler

{

public:

       virtual void HandleRequest(Request *pRequest) {};

       virtual void SetSuccessor(Handler *phandler){}

protected:

       Handler  *m_pSuccessor;

};

//处理请求的具体类

class ConcreteHandler1:public Handler

{

public:

       ConcreteHandler1(intlevel):m_level(level){}

        void HandleRequest(Request *pRequest)

        {

               if (pRequest&& pRequest->GetRequestLevel() == m_level)

               {

                      cout<<"ConcreteHandler1handle  request :"<<pRequest->GetRequestName()<<endl;

               }

               else if(m_pSuccessor)

               {

                      m_pSuccessor->HandleRequest(pRequest);

               }

        };

        void SetSuccessor(Handler *phandler)

        {

               m_pSuccessor = phandler;

        }

protected:

private:

       int  m_level;     //每个具体类都有对应的可以处理的请求级别

};

 

 

class ConcreteHandler2:public Handler

{

public:

       ConcreteHandler2(intlevel):m_level(level){}

       voidHandleRequest(Request *pRequest)

       {

              if(pRequest && pRequest->GetRequestLevel() == m_level)

              {

                     cout<<"ConcreteHandler2 handle  request :"<<pRequest->GetRequestName()<<endl;

              }

              elseif(m_pSuccessor)

              {

                     m_pSuccessor->HandleRequest(pRequest);

              }

       };

       voidSetSuccessor(Handler *phandler)

       {

              m_pSuccessor = phandler;

       }

protected:

private:

       int  m_level;

};

 

 

class ConcreteHandler3:public Handler

{

public:

       ConcreteHandler3(intlevel):m_level(level){}

       voidHandleRequest(Request *pRequest)

       {

              if(pRequest && pRequest->GetRequestLevel() == m_level)

              {

                     cout<<"ConcreteHandler3 handle  request :"<<pRequest->GetRequestName()<<endl;

              }

              elseif(m_pSuccessor)

              {

                     m_pSuccessor->HandleRequest(pRequest);

              }

       };

       voidSetSuccessor(Handler *phandler)

       {

              m_pSuccessor = phandler;

       }

protected:

private:

       int  m_level;

};

 

       Handler *ph1 = newConcreteHandler1(NORMAL);

       Handler *ph2 = newConcreteHandler2(ABOVE_NORMAL);

       Handler *ph3 = newConcreteHandler3(HIGH);

       Request *pr1 = newRequest("请求1",NORMAL );

       Request *pr2 = newRequest("请求2",ABOVE_NORMAL );

       Request *pr3 = newRequest("请求3",HIGH );

       ph1->SetSuccessor(ph2);

       ph2->SetSuccessor(ph3);

       ph1->HandleRequest(pr1);

       ph1->HandleRequest(pr2);

       ph1->HandleRequest(pr3);