设计模式(c++)笔记之二十一（Chain of Responsibility模式）

最新推荐文章于 2020-05-07 18:05:18 发布

热血枫叶

最新推荐文章于 2020-05-07 18:05:18 发布

阅读量1.9k

点赞数

分类专栏：设计模式(C++) 设计模式(c++)笔记文章标签：设计模式 c++

本文链接：https://blog.csdn.net/rexuefengye/article/details/13017003

版权

设计模式(C++) 同时被 2 个专栏收录

23 篇文章 3 订阅

订阅专栏

设计模式(c++)笔记

23 篇文章 11 订阅

订阅专栏

一、描述:

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

Chain of Responsibility 模式典型的结构图为:

Chain of Responsibility模式中ConcreteHandler将自己的后继对象(向下传递消息的对象)记录在自己的后继表中,当一个请求到来时,ConcreteHandler 会先检查看自己有没有匹配的处理程序,如果有就自己处理,否则传递给它的后继。当然这里示例程序中为了简化,ConcreteHandler 只是简单的检查看自己有没有后继,有的话将请求传递给后继进行处理,没有的话就自己处理。

二、实例:

中国古代对妇女制定了“三从四德”的道德规范,“三从”是指“未嫁从父、既嫁从夫、夫死从子”,也就是说一个女性,在没有结婚的时候要听从于父亲,结了婚后听从于丈夫,丈夫死了还要听儿子的,举个例子来说,一个女的要出去逛街,同样这样的一个请求,在她没有出嫁前她必须征得父亲的同意,出嫁之后必须获得丈夫的许可,那丈夫死了怎么办?一般都是男的比女的死的早,还要问问儿子是否允许自己出去逛街,估计你下边马上要问要是没有儿子怎么办?请示小叔子、侄子等等,在父系社会中,妇女只占从属地位,现在想想中国的妇女还是比较悲惨的,逛个街还要请示来请示去,而且作为父亲、丈夫、儿子只有两种选择:要不承担起责任来告诉她允许或不允许逛街,要不就让她请示下一个人,这是整个社会体系的约束,应用到我们项目中就是业务规则,那我们来看怎么把“三从”通过我们的程序来实现,需求很简单:通过程序描述一下古代妇女的“三从”制度,好我们先看类图:

main()，客户

IWomen，发出请求者接口

CWomen，请求者实现类

CHandler，处理请求抽象类

CFather，处理请求实现类，责任链之一

CHusband，处理请求实现类，责任链之二

CSon，处理请求实现类，责任链之三

说明：CHandler抽象类负责聚合责任链之中的其它处理对象，用SetNext来建立这个责任链。HandleMessage在处理请求时，会判断是否是自己要处理的请求，如果是则直接处理。如果不是，则查找下一个责任链上的处理对象，找到了则由下一个处理。

我的工程目录:

发出请求者接口:IWomen类

IWomen.h

#ifndef __Chain_of_Responsibility__IWomen__
#define __Chain_of_Responsibility__IWomen__

#include <iostream>
using std::string;
class IWomen
{
public:
    IWomen(void)
    {
    }
    virtual ~IWomen(void)
    {
    }
    //获得个人状况
    virtual int GetType() = 0;
    
    //获得个人请示,你要干什么?出去逛街?约会?还是看电影
    virtual string GetRequest() = 0;
};


#endif /* defined(__Chain_of_Responsibility__IWomen__) */

请求者实现类:CWomen类

CWomen.h

#ifndef __Chain_of_Responsibility__Women__
#define __Chain_of_Responsibility__Women__

#include <iostream>
#include "IWomen.h"
using std::string;

class CWomen :
public IWomen
{
public:
    CWomen(int _type, string _request);
    ~CWomen(void);
    int GetType();       //获得自己的状况
    string GetRequest(); //获得妇女的请求
private:
    /* 1---未出嫁;2---出嫁;3---夫死*/
    int m_type;
    
    //妇女的请示
    string m_request;
};

#endif /* defined(__Chain_of_Responsibility__Women__) */

CWomen.cpp

#include "Women.h"

CWomen::CWomen( int _type, string _request )
{
    this->m_type = _type;
    switch (this->m_type)
    {
        case 1:
            this->m_request.append("女儿的请求是：");
            this->m_request.append(_request);
            break;
        case 2:
            this->m_request.append("妻子的请求是：");
            this->m_request.append(_request);
            break;
        case 3:
            this->m_request.append("母亲的请求是：");
            this->m_request.append(_request);
            break;
    }
}

CWomen::~CWomen(void)
{
}

int CWomen::GetType()
{
    return m_type;
}

string CWomen::GetRequest()
{
    return m_request;
}

处理请求抽象类: CHandler类

CHandler.h

#ifndef __Chain_of_Responsibility__Handler__
#define __Chain_of_Responsibility__Handler__

#include <iostream>
#include "IWomen.h"

class CHandler
{
public:
    CHandler(int _level);
    virtual ~CHandler(void);
    void HandleMessage(IWomen *pwomen); 
    void SetNext(CHandler *phandler);
    virtual void Response(IWomen *pwomen) = 0;
private:
    int m_level;               //能处理的级别
    CHandler *m_pNextHandler;  //责任传递,下一个人责任人是谁
};

#endif /* defined(__Chain_of_Responsibility__Handler__) */

CHandler.cpp

#include "Handler.h"

using std::cout;
using std::endl;

//每个类都要说明一下自己能处理哪些请求
CHandler::CHandler(int _level ) : m_level(_level)
{
    m_pNextHandler = NULL;
}
CHandler::~CHandler(void)
{
}

//一个女性(女儿,妻子或者是母亲)要求逛街,你要处理这个请求
void CHandler::HandleMessage( IWomen *pwomen )
{
    if (pwomen->GetType() == this->m_level)
    {
        this->Response(pwomen);
    }
    else
    {
        if(this->m_pNextHandler != NULL)
            this->m_pNextHandler->HandleMessage(pwomen);
        else
            cout << "----------没地方请示了，不做处理！----------" << endl;
    }
}

/*
 * 如果你属于你处理的返回,你应该让她找下一个环节的人,比如
 * 女儿出嫁了,还向父亲请示是否可以逛街,那父亲就应该告诉女儿,应该找丈夫请示
 */
void CHandler::SetNext( CHandler *phandler )
{
    m_pNextHandler = phandler;
}

处理请求实现类，责任链之一(父亲)： CFather类

CFather.h

#ifndef __Chain_of_Responsibility__Father__
#define __Chain_of_Responsibility__Father__

#include <iostream>
#include "Handler.h"
#include "IWomen.h"

class CFather :
public CHandler
{
public:
    CFather(void);
    ~CFather(void);
    void Response(IWomen *pwomen);
};

#endif /* defined(__Chain_of_Responsibility__Father__) */

CFather.cpp

#include "Father.h"
using std::cout;
using std::endl;

CFather::CFather(void) : CHandler(1)
{
}
CFather::~CFather(void)
{
}

//父亲的答复
void CFather::Response( IWomen *pwomen )
{
    cout << "女儿向父亲请示：" << endl;
    cout << pwomen->GetRequest().c_str() << endl;
    cout << "父亲的答复是：同意" << endl;
}

处理请求实现类，责任链之二(丈夫): CHusband.h

CHusband.h

#ifndef __Chain_of_Responsibility__Husband__
#define __Chain_of_Responsibility__Husband__

#include <iostream>
#include "handler.h"
#include "IWomen.h"

class CHusband :
public CHandler
{
public:
    CHusband(void);
    ~CHusband(void);
    void Response(IWomen *pwomen);
};


#endif /* defined(__Chain_of_Responsibility__Husband__) */

CHusband.cpp

#include "Husband.h"
using std::cout;
using std::endl;

CHusband::CHusband(void) : CHandler(2)
{
}
CHusband::~CHusband(void)
{
}

//丈夫请示的答复
void CHusband::Response( IWomen *pwomen )
{
    cout << "妻子向丈夫请示：" << endl;
    cout << pwomen->GetRequest().c_str() << endl;
    cout << "丈夫的答复是：同意" << endl;
}

处理请求实现类，责任链之三(儿子):CSon类

CSon.h

#ifndef __Chain_of_Responsibility__Son__
#define __Chain_of_Responsibility__Son__

#include <iostream>
#include "handler.h"
#include "IWomen.h"

class CSon :
public CHandler
{
public:
    CSon(void);
    ~CSon(void);
    void Response(IWomen *pwomen);
};


#endif /* defined(__Chain_of_Responsibility__Son__) */

CSon.cpp

#include "Son.h"
using std::cout;
using std::endl;

CSon::CSon(void) : CHandler(3)
{
}
CSon::~CSon(void)
{
}

//儿子的答复
void CSon::Response( IWomen *pwomen )
{
    cout << "母亲向儿子请示：" << endl;
    cout << pwomen->GetRequest().c_str() << endl;
    cout << "儿子的答复是：同意" << endl;
}

客户:main

#include <iostream>
#include "IWomen.h"
#include "Women.h"
#include "Handler.h"
#include "Father.h"
#include "Husband.h"
#include "Son.h"

using std::cout;
using std::endl;

void DoNew()
{
    cout << "----------使用模式后的处理方式----------" << endl;
    //Handler.h, Handler.cpp, IWomen.h, Women.h, Women.cpp, Father.h, Father,cpp, Husband.h, Husband.cpp, Son.h, Son.cpp
    IWomen *pwomen1 = new CWomen(1, "我要出去逛街");    //女儿向父亲请示
    IWomen *pwomen2 = new CWomen(2, "我要出去吃饭");    //已婚少妇,请示丈夫
    IWomen *pwomen3 = new CWomen(3, "我也要出去吃饭");  //母亲请示儿子
    IWomen *pwomen4 = new CWomen(4, "我也要出去逛街");  //暂时啥也不做
    
    CHandler *pfather = new CFather();
    CHandler *phusband = new CHusband();
    CHandler *pson = new CSon();
    
    pfather->SetNext(phusband);
    phusband->SetNext(pson);
    
    pfather->HandleMessage(pwomen1);
    pfather->HandleMessage(pwomen2);
    pfather->HandleMessage(pwomen3);
    pfather->HandleMessage(pwomen4);
    
    delete pfather;
    delete phusband;
    delete pson;
    delete pwomen1;
    delete pwomen2;
    delete pwomen3;
    delete pwomen4;
}

int main(int argc, const char * argv[])
{

    //要实现逻辑判断，即女性的请求先发送到父亲类，父亲类一看是自己要处理的，就回应进行处理。如果女儿已经出嫁了，那就把这个请求转发到女婿类来处理。依此类推，形成了一个责任链。
    DoNew();
    // insert code here...
    std::cout << "Hello, World!\n";
    return 0;
}

结果如下:

参考文献：《设计模式之禅》，《GoF_23种设计模式解析》

参考博客: http://www.cnblogs.com/wanggary/archive/2011/04/20/2022988.html

热血枫叶

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
设计模式(c++)笔记之二十一（Chain of Responsibility模式）

一、描述: 概念：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。 Chain of Responsibility 模式典型的结构图为: Chain of Responsibi
复制链接

扫一扫