【设计模式】之二十三种设计模式--责任链模式

责任链模式

Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request.Chain the receiving objects and pass the request along the chain until an object handles it.
(使多个对象都有机会处理请求,从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链,并沿着这条链传递该请求,直到有对象处理它为止。)

通用类图

Handler抽象类，责任链上的抽象类
ConcreteHandler实现类，责任链上的具体实现类，继承Handler抽象类

通用源码

//Handler抽象类
class Handler {
private:
    Handler *nextHandler = NULL;
public:
    //每个处理者都必须对请求作出处理
    Response HandleMessage(Request *request) {
        Response *response = null;
        //判断是否是自己的处理级别
        if(getHandlerLevel() == request->getRequestLevel()) {
            response = echo(request);
        }else {
            //不属于自己的处理级别，判断是否有下一个处理中
            if(nextHandler != NULL) {
                response = nextHandler->HandleMessage(request);
            }else {
                //没有适当的处理者，业务自行处理
            }
        }
        return response;
    }
    //设置下一个处理者
    void setNext(Handler *h) {
        nextHandler = h;
    }
protected:
    //每个处理者的级别
    virtual Level getHandlerLevel() = 0;
    //每个处理者实现的处理任务
    virtual Response echo(Request *request) = 0;
};
//具体处理者类
class ConcreteHandler1 : public Handler {
protected:
    //定义自己的处理逻辑
    virtual Response echo(Request *request) {
        //完成处理逻辑
        return NULL:
    }
    //定义自己的处理级别
    virtual Level getHandlerLevel() {
        //设置处理级别
        return NULL;
    }
};
class ConcreteHandler2 : public Handler {
protected:
    //定义自己的处理逻辑
    virtual Response echo(Request *request) {
        //完成处理逻辑
        return NULL:
    }
    //定义自己的处理级别
    virtual Level getHandlerLevel() {
        //设置处理级别
        return NULL;
    }
};
class ConcreteHandler3 : public Handler {
protected:
    //定义自己的处理逻辑
    virtual Response echo(Request *request) {
        //完成处理逻辑
        return NULL:
    }
    //定义自己的处理级别
    virtual Level getHandlerLevel() {
        //设置处理级别
        return NULL;
    }
};
//上面处理涉及到的类
//Level 定义一个请求和处理等级
class Level {
};
//Request 封装请求
class Request {
public:
    Level getRequestLevel() {
        return NULL:
    }
};
//Response 封装链中返回的结果
class Response {
};

优点

将请求和处理分开，将处理者和请求这解耦提高系统的灵活性；

缺点

每个请求都会遍历责任链，性能大打折扣
调试的时候逻辑较复杂

注意事项

控制责任链的节点数量，避免出现超长链，设置最大节点数量。

示例代码

#include <iostream>
#include <string>

using namespace std;

void input(const string &s) {
    cout << s << endl;
}

class IWomen {
public:
    virtual int getType() = 0;
    virtual string getRequest() = 0;
};

class Women : public IWomen {
private:
    int type;
    string request;
public:
    Women(int t, string r) {
        type = t;
        switch(t) {
            case 1: request = "daughter's req: " + r; break;
            case 2: request = "wife's req: " + r; break;
            case 3: request = "mother's req: " + r; break;
        }
    }
    virtual int getType() {
        return type;
    }
    virtual string getRequest() {
        return request;
    }
};

class IHandler {
private:
    const static int F_L_REQ = 1;
    const static int H_L_REQ = 2;
    const static int S_L_REQ = 3;
    int level;
    IHandler *nextHandler = NULL;
public:
    IHandler(int l) : level(l) { }
    void HandleMessage(IWomen *women) {
        if(women->getType() == level) {
            response(women);
        }else {
            if(nextHandler == NULL) {
                input("error");
            }else {
                nextHandler->HandleMessage(women);
            }
        }
    }
    void setNext(IHandler *h) {nextHandler = h;}
    virtual void response(IWomen *women) = 0;
};

class Father : public IHandler{
public:
    Father() : IHandler(1) { }
    virtual void response(IWomen *women) {
        input(women->getRequest());
        input("father's answer: agree.");
    }
};

class Husband : public IHandler{
public:
    Husband() : IHandler(2) { }
    virtual void response(IWomen *women) {
        input(women->getRequest());
        input("husband's answer: agree.");
    }
};

class Son : public IHandler{
public:
    Son() : IHandler(3) { }
    virtual void response(IWomen *women) {
        input(women->getRequest());
        input("son's answer: agree.");
    }
};

int main() {
    string s = "go out";
    Women women1(1,s);
    Women women2(2,s);
    Women women3(3,s);
    IHandler *father = new Father();
    IHandler *husband = new Husband();
    IHandler *son = new Son();
    father->setNext(husband);
    husband->setNext(son);
    father->HandleMessage(&women1);
    husband->HandleMessage(&women2);
    son->HandleMessage(&women3);
    delete father;
    delete husband;
    delete son;
    return 0;
}