设计模式之责任链模式

设计模式是前人、大牛等在实际编程中对遇到的问题解决方案的抽象，也就是每一个设计模式都在编程实例中有体现。

1.责任链模式在编程中的小体现，看下面的情况：

(1)if else if ....

if(a<12){
    ...
}
else if (a<25){
    ...
}
else if(a<67){
    ...
}
else{
    ...
}

(2)switch case

switch(a)
{
    case 1:     ;break;
    case 2:     ;break;
    case 3:     ;break;
    default:    
}

(3)链表next

typedef struct node
{
    int value;
    struct node *next;
}TreeNode;

 上面的三种情况中，共同特点就是必须依次扫描每个分支进行判断，找到对应的分支进行处理。(C++、Java中switch也是要遍历每个分支的)

2.责任链模式的定义

　　责任链模式是一种对象的行为模式。在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。

　　责任链模式的重点在“链”上，有一条链去处理相似的请求在链中决定由谁去处理这个请求，并返回相应的结果。

　　在1中的3个例子中，第一个if、switch、Tree root节点就相当于“链的入口”，当每个分支都要进行复杂的业务逻辑处理时，使用责任链模式比较好。

3.责任链模式简单实例

　　设计模式是不分语言的。虽然Java提供特有机制对应的关键字，如clone(原型模式)、Observable(观察者模式)等。但是其他语言也可以实现这些，只可能是机制不同而已。

 责任链模式C++实例代码:

(1)Handler类是其他具体处理类A、B、D类的父类，提供抽象，公共代码。

(2)代码建立责任链A->B->D。(责任链末尾必须是默认处理类，也即switch中的default部分)

#include<iostream>
using namespace std;
class Handler{  ///处理类抽象
public:
    Handler(int _value):value(_value){} ///设置自身能够处理的编号
    virtual ~Handler(){}
    void setNextHandler(Handler *_nextHandler){ ///设置后继处理者
        this->nextHandler=_nextHandler;
    }
    virtual void putHandlerMesg(int _value)=0;  ///处理者实现进行具体的处理过程

    int value;
    Handler *nextHandler;
};

class A:public Handler{ ///处理类A
public:
    A(int _value):Handler(_value){};
    ~A(){};
    void putHandlerMesg(int _value){
        cout<<"A handler this command："<<_value<<endl;
    }
};

class B:public Handler{ ///处理类A
public:
    B(int _value):Handler(_value){};
    ~B(){};
    void putHandlerMesg(int _value){
        cout<<"B handler this command："<<_value<<endl;
    }
};

class D:public Handler{ ///默认处理类D，位于链尾部，当其他处理者不能处理时使用
public:
    D(int _value):Handler(_value){};
    void putHandlerMesg(int _value){
        cout<<"default handler:"<<_value<<endl;
    }
    ~D(){};
};

int MainHandle(int handlerValue,Handler *a){    ///Main函数进行处理建立的责任链
    Handler *tmp=a;
    while(1){
        if(tmp->value == handlerValue){
            tmp->putHandlerMesg(handlerValue);
            break;
        }
        else if(tmp->value == 0)
        {
            tmp->putHandlerMesg(handlerValue);
            break;
        }
        else{
            tmp=tmp->nextHandler;
        }
    }
}

int main(){
    ///建立处理链，a(1)->b(2)->d(0,default)
    Handler *a=new A(1);
    Handler *b=new B(2);
    Handler *d=new D(0);
    a->setNextHandler(b);
    b->setNextHandler(d);

    ///处理的两个例子
    MainHandle(2,a);
    MainHandle(4,a);
    delete(a);
    delete(b);
    delete(d);
}

 4.责任链模式的优缺点

4.1责任链模式的优点

　　实现了请求者与处理者代码分离：发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任。提高系统的灵活性和可扩展行。

4.2责任链模式的缺点

　　每次都是从链头开始：这也正是链表的缺点。你也许会想到一种貌似不错的解决方案，比如使用hash映射，将要处理的请求id与处理类对象关联，但是这样系统损失了可扩展性。