javascript设计模式15职责链模式

职责链模式定义： 使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。

在javascript开发中，职责链模式是最容易被忽视的模式之一。但实际上只要运用得到，职责链模式可以很好的帮助我们管理代码，降低发起请求的对象和处理请求的对象之间的耦合性。

最大优点：解耦了请求发送者和N个接收者之间的复杂关系。将大量的ifelse语句，重构为按链条一样，一个节点一个节点传递执行的方式

如下图：

 

// 职责链模式
var order500 = function(orderType, pay, stock){
	if(ordetType == 1 && pay == true){
		console.log('500定金预购')
	}else{
		return 'nextSuccessor'
	}
}

var order300 = function(orderType, pay, stock){
	if(orderType == 2 && pay == true){
		console.log('300定金预购')
	}else{
		return 'nextSuccessor'
	}
}

var orderNormal = function(orderType, pay, stock){
	if( stock >　0 ){
		console.log('普通购买')
	}else{
		console.log('库存不足')
	}
}

var Chain = function(fn){
	this.fn = fn ;
	this.successor = null;
}

Chain.prototype.setNextSuccessor = function(successor){
	return this.successor = successor
}

Chain.prototype.passRequest = function(){
	var ret = this.fn.apply(this, arguments)
	if(ret === "nextSuccessor"){
		return this.successor && this.successor.passRequest.apply(this.successor, arguments)
	}
	return ret;
}

var chainOrder500 = new Chain(order500)
var chainOrder300 = new Chain(order300)
var chainOrderNormal = new Chain(orderNormal)

chainOrder500.setNextSuccessor(chainOrder300)
chainOrder300.setNextSuccessor(chainOrderNormal)
chainOrder500.passRequest(1, true, 300)

//异步的职责链实现 (手动传递请求给职责链)
Chain.prototype.next = function(){
	return this.successor && this.successor.passRequest.apply(this.successor, arguments)
}

var fn1 = new Chain(function(){
	console.log(1)
	return 'nextSuccessor'
})

var fn2 = new Chain(functino(){
	console.log(2)
	var self = this;
	setTimeout(function(){
		self.next()
	},100)
})
var fn3 = new Chain(function(){
	console.log(3)
})

fn1.passRequest(fn2).setNextSuccessor(fn3)
fn1.passRequest()

//使用AOP实现职责链
Function.prototype.after = function(fn){
	var self = this
	return function(){
		var ret = self.apply(this, arguments)
		if(ret == 'nextSuccessor'){
			return fn.apply(this,arguments)
		}
		return ret;
	}
}

var order = order500.after(order200).after(orderNorma) // 动态织入
// 用AOP实现职责链既简单又巧妙，但这种把函数叠在一起的方式，同时也叠加了函数的作用域，如果链条太长的话，也会对性能产生比较大的影响