设计模式学习笔记（十五）——Chain Of Responsibility职责链

十三、Chain Of Responsibility（职责链）

情景举例：

将对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

代码示例：

/* 所有链上对象的抽象父类
     
     

* 注意：私有成员函数中有个变量指向后继对象，并在构造函数中初始化这个对象
     
     

*/

typedef int Topic;

const Topic NO_HELP_TOPIC = -1;

class HelpHandler {

public:

    HelpHandler(HelpHandler* = 0, Topic = NO_HELP_TOPIC);

    virtual bool HasHelp();

    virtual void SetHandler(HelpHandler*, Topic);

    virtual void HandleHelp();

private:

    HelpHandler* _successor;

    Topic _topic;

};

/* 构造函数中初始化了后继对象
     
     

*/

HelpHandler::HelpHandler (

    HelpHandler* h, Topic t

) : _successor(h), _topic(t) { }

/*

*/

bool HelpHandler::HasHelp () {

    return _topic != NO_HELP_TOPIC;

}

/* 默认操作是调用后继者的操作

*/

void HelpHandler::HandleHelp () {

    if (_successor != 0) {

        _successor->HandleHelp();

    }

}

/* 这是个窗口组件的公共父类
     
     

*/

class Widget : public HelpHandler {

protected:

    Widget(Widget* parent, Topic t = NO_HELP_TOPIC);

private:

    Widget* _parent;

};

/* 注意：构造函数中做了两件事1、设置父类的后继者2、设置父结点

*/

Widget::Widget (Widget* w, Topic t) : HelpHandler(w, t) {

    _parent = w;

}

/* 构造函数中表明：这个类的后继者可以是任何Widget的子类
     
     

*/

class Button : public Widget {

public:

    Button(Widget* d, Topic t = NO_HELP_TOPIC);

    virtual void HandleHelp();

    // Widget operations that Button overrides...

};

Button::Button (Widget* h, Topic t) : Widget(h, t) { }

/* 如果自己不能搞定，那就交给顶层类处理（其实就是交给后继者处理）
     
     

*/

void Button::HandleHelp () {

    if (HasHelp()) {

        // offer help on the button

    } else {

        HelpHandler::HandleHelp();

    }

}

/* 

*/

class Dialog : public Widget {

public:

    Dialog(HelpHandler* h, Topic t = NO_HELP_TOPIC);

    virtual void HandleHelp();

    // Widget operations that Dialog overrides...

    // ...

};

/* 构造函数中表明：这个类的后继者可以是任何HelpHandler的子类
     
     

*/

Dialog::Dialog (HelpHandler* h,  Topic t) : Widget(0) {

    SetHandler(h, t);

}

/*

*/

void Dialog::HandleHelp () {

    if (HasHelp()) {

        // offer help on the dialog

    } else {

        HelpHandler::HandleHelp();

    }

}

/* 构造函数中表明：这个类没有后继者
     
     

*/

class Application : public HelpHandler {

public:

    Application(Topic t) : HelpHandler(0, t) { }

    virtual void HandleHelp();

    // application-specific operations...

};

/*

*/

void Application::HandleHelp () {

    // show a list of help topics

}

/* 主程序中动态定义了一条链Application->Dialog->Button

* 请求处理如果不能处理，则是从这条链反上来。
     
     

*/

void dummy () {

/*

*/

const Topic PRINT_TOPIC = 1;

const Topic PAPER_ORIENTATION_TOPIC = 2;

const Topic APPLICATION_TOPIC = 3;

Application* application = new Application(APPLICATION_TOPIC);

Dialog* dialog = new Dialog(application, PRINT_TOPIC);

Button* button = new Button(dialog, PAPER_ORIENTATION_TOPIC);

/*

*/

button->HandleHelp();

 

个人理解：

职责链模式的关键在于定义一个抽象父类，该父类保有一个指向下个对象（自身类）的指针，作为后继者（successor）。在其所有子类的构造时，必须要告知父类其后继者，让父类保存该指针。

在处理请求时，如果该子类不能处理，则沿着这个指针依次查询后继者，让后继者处理这个请求，直到请求被处理或者到达链末。