说起职责链模式，其实非常像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
小结
职责链中的节点数量，和顺序都是可以变化的，所以重点就是将节点从流程中独立出来，两者可以动态组合。
节点类型一定要完全一样吗？不一定。只要符合“鸭子原则”，出入参一致，那么各个节点是可以处理完全不同的事情。
网友评论