责任链模式 详解

定义

是一种对象的行为模式，在责任链模式里，很多对象由每个对其下家的引用而连接起来形成的一条链，请求在这个链上传递，直到链上的某一个对象决定处理此请求，发出这个请求的客户端并不知道链上的哪一个对象最终会处理这个请求；

行为型模式

角色

• 抽象处理者角色（Handler）：定义处理请求的接口；
• 抽象处理者角色（ConcreteHandler）：具体处理者接到请求后，可以选择处理该请求或者传递给下家；

---

从网上找到的例图

---

适用场景

• 有多个对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定；
• 在不确定指定接收者的情况下，向多个对象中的一个提交一个请求；
• 处理一个请求的对象集合应被动态绑定；

---

例子

• 这个很像传递游戏，需要将东西传递个下一个人，只有在当音乐停止的时候才知道下个执行者是谁；

---

实现代码

/**
 * Created by George on 16/7/14.
 */
/**
 * Created by George on 16/7/15.
 */

var Levels = {
    smallBoss : 1,
    middleBoss : 2,
    bigBoss : 3
};

var AbstractRequest = function (content) {
    this.content = content;
    this.getContent = function () {
        return this.content;
    };
    this.getRequestLevel = function () {

    };
};

var Request01 = function (content) {
    this.content = content;
    AbstractRequest.call(this, content);
    this.getRequestLevel = function () {
        return Levels.smallBoss;
    };
};


var Request02 = function (content) {
    this.content = content;
    AbstractRequest.call(this, content);

    this.getRequestLevel = function () {
        return Levels.middleBoss;
    };
};

var Request03 = function (content) {
    this.content = content;
    AbstractRequest.call(this, content);

    this.getRequestLevel = function () {
        return Levels.bigBoss;
    };
};

var AbstractHandler = function () {
    // 下个责任处理者
    this.nextHandler = null;

    // 捕获具体请求，并将责任传递给下个责任处理者
    this.handleRequest = function (request) {
        // 层级相同
        if (this.getHandlerLevel() == request.getRequestLevel())
            this.handle(request);
        else {
            if (this.nextHandler != null) {
                console.log("当前处理者层级" + this.getHandlerLevel() + "\n" + "不足以处理请求" + request.getRequestLevel());

                // 递归
                this.nextHandler.handleRequest(request);
            }
            else {
                console.log("链上所有处理者都不能处理该请求");
            }
        }
    };

    // 设置责任链的下个处理者
    this.setNextHandler = function (nextHandler) {
        this.nextHandler = nextHandler;
    };

    // 获取当前处理者的级别
    this.getHandlerLevel = function () {

    };

    // 定义链中每个处理者具体的处理方式
    this.handle = function (request) {

    };
};

// 具体处理者1
var Handler01 = function () {

};
Handler01.prototype = new AbstractHandler();
Handler01.prototype.getHandlerLevel = function () {
    return Levels.smallBoss;
};
Handler01.prototype.handle = function (request) {
    console.log("small boss 处理" + request.getContent() + "\n");
};

// 具体处理者2
var Handler02 = function () {

};
Handler02.prototype = new AbstractHandler();
Handler02.prototype.getHandlerLevel = function () {
    return Levels.middleBoss;
};
Handler02.prototype.handle = function (request) {
    console.log("middle boss 处理" + request.getContent() + "\n");
};

// 具体处理者3
var Handler03 = function () {

};
Handler03.prototype = new AbstractHandler();
Handler03.prototype.getHandlerLevel = function () {
    return Levels.bigBoss;
};
Handler03.prototype.handle = function (request) {
    console.log("big boss 处理" + request.getContent() + "\n");
};

// 创建结点
var handler01 = new Handler01();
var handler02 = new Handler02();
var handler03 = new Handler03();

// 组装链
handler01.setNextHandler(handler02);
handler02.setNextHandler(handler03);

// 创建请求
var request01 = new Request01("请求1");
var request02 = new Request02("请求2");
var request03 = new Request03("请求3");

// 每次提交都要从链头开始遍历
handler01.handleRequest(request01);
handler01.handleRequest(request02);
handler01.handleRequest(request03);

实现结果：

这里面注意的是，设定处理的条件为其等级相同，也就是相互对应，不能越级处理，也不能低级处理；

---

优缺点

1. 降低耦合度，一个对象无需知道哪个对象处理其请求，对象仅知道该请求会被正确处理，接受者和发送者 都没有对方的明确的信息；
2. 简化对象的相互连接，仅仅需要保持一个指向其后继者的引用，而不需要保持他所有的候选者的引用；
3. 增强了给对象指派职责的灵活性，当在对象中分派职责时，职责链给你更多的灵活性，可以通过在运行时刻对该链进行动态的增加或者修改来增加或改变一个请求的职责，可以将这种机制和静态的特例化处理对象的继承机制结合起来使用；
4. 增加新的请求处理类方便；

注意的是
1. 对于每个请求都需要遍历职责链，当数量大了以后可能会有性能问题；
2. 不能保证请求一定会被接收；