设计模式-职责链

说起职责链模式，其实非常像AOP - 面向切面编程。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的降低，提高程序的可重用性，同时提高了开发的效率。

职责链.png

举个栗子看看（例子来源于《JavaScript设计模式与开发实践》）。
根据订单等级来确定如何购买手机

orderType：订单分为3级。第1级别在定金支付情况下可获得100元优惠券；第2级别在定金支付情况下可获得50元优惠券；第三级别没有优惠券
pay：是否支付定金
stock：通过普通渠道购买手机的库存量。对于已经获得优惠券的用户，不受该限制。

先用一段简单的流程代码阐述下需求：

function order(orderType, pay, stock) {
  if (orderType === 1) {
    if (pay === true) {
      console.log("500元定金预购，得到100元优惠券！");
    } else {
      if (stock > 0) {
        console.log("普通购买，无优惠券！");
      } else {
        console.log("库存不足！");
      }
    }
  } else if (orderType === 2) {
    if (pay === true) {
      console.log("200元定金预购，得到50元优惠券！");
    } else {
      if (stock > 0) {
        console.log("普通购买，无优惠券！");
      } else {
        console.log("库存不足！");
      }
    }
  } else {
    if (stock > 0) {
      console.log("普通购买，无优惠券！");
    } else {
      console.log("库存不足！");
    }
  }
}

order(1, true, 10);  // 500元定金预购，得到100元优惠券！
order(2, true, 10); // 200元定金预购，得到50元优惠券！
order(3, true, 10); // 普通购买，无优惠券！
order(3, true, 0); // 库存不足！

代码写得很清楚，就是有点“老太太的裹脚布，又臭又长”的感觉。而且不少分支的返回值是一样的，导致重复代码也比较多。

那看看如何重构吧？

第一步：抽象出订单对象

需求中一共有三种订单类型：

var order500 = function (orderType, pay, stock) {
  if (orderType === 1 && pay === true) {
    console.log("500元定金预购，得到100元优惠券！");
  } else {
     order200(orderType, pay, stock);
  }
};

var order200 = function (orderType, pay, stock) {
  if (orderType === 2 && pay === true) {
    console.log("200元定金预购，得到50元优惠券！");
  } else {
    orderNormal(orderType, pay, stock);
  }
};

var orderNormal = function (orderType, pay, stock) {
  if (stock > 0) {
    console.log("普通购买，无优惠券！");
  } else {
    console.log("库存不足！");
  }
};

当order500不满足时，进入order200处理；当order200不满足时，进入orderNormal处理。
看起来不错，但是有个问题，如果中间要插入个order300呢？那是不是order500需要改动？
这样就不符合“面向修改关闭，面向扩展开放”的原则了。orderXXX订单对象应该是一个稳定的内聚对象。

所以，我们需要将order500->order200->orderNormal的链式关系抽离出来，用专门的Chain处理。

第二步：改造订单对象，抽象出流程对象

先改造一下上面的订单对象，去掉订单类型之间的关系，统一返回nextHandler字符串代表流程交接。

var order500 = function (orderType, pay, stock) {
  if (orderType === 1 && pay === true) {
    console.log("500元定金预购，得到100元优惠券！");
  } else {
     return "nextHandler";
  }
};

var order200 = function (orderType, pay, stock) {
  if (orderType === 2 && pay === true) {
    console.log("200元定金预购，得到50元优惠券！");
  } else {
    return "nextHandler";
  }
};

var orderNormal = function (orderType, pay, stock) {
  if (stock > 0) {
    console.log("普通购买，无优惠券！");
  } else {
    console.log("库存不足！");
  }
};

然后写一个处理流程的函数，假设我们希望如下调用（这只是一种调用方式，还可以有其他链式调用，比如order500.after(order200).after(orderNormal)）：

var order = new Chain(order500, order200, orderNormal);

那么意味着Chain的构造函数的入参就是流程节点的定义，可以这么写（这只是一种解法，欢迎写出更多解法）：

function loop(fns, self, args) {
  if (fns.length === 0) {
    console.log("缺少Handler");
    return;
  }
  var copyFns = Array.prototype.slice.call(fns);
  var res = copyFns.shift().apply(self, args);
  if (res === "nextHandler") {
    return loop(copyFns, self, args);
  } else {
    return res;
  }
}

function Chain() {
  var fns = Array.prototype.slice.call(arguments);

  return function () {
    return loop(fns, this, arguments);
  };
}

利用递归将构造函数里面的所有处理节点按照条件遍历。我们可以测试一下。

var order = new Chain(order500, order200, orderNormal);
order(1, true, 10);
order(2, true, 10);
order(3, true, 10);
order(3, true, 0);
var order2 = new Chain();
order2(1, true, 10);

// 打印值
500元定金预购，得到100元优惠券！
200元定金预购，得到50元优惠券！
普通购买，无优惠券！
库存不足！
缺少Handler

小结

职责链中的节点数量，和顺序都是可以变化的，所以重点就是将节点从流程中独立出来，两者可以动态组合。

节点类型一定要完全一样吗？不一定。只要符合“鸭子原则”，出入参一致，那么各个节点是可以处理完全不同的事情。