Chain Of Responsibility (职责链模式)

转载请注明来源：http://blog.csdn.net/xiaojimanman/article/details/17315849

自己对于下定义的能力真的很弱，至于定义，直接问度娘即可，自己就先简单说一下职责链的目的吧，即通过给予多个对象处理请求的机会，以解除请求的发送者与接收者之间的耦合。

对于上面说的目的，自己举个简单的例子，在大学生活中，我们会经常和学校各种部分去打交道，办理各种繁琐的事务，各种繁琐的程序，看着都让人心烦。现在我们假设有这样的一个部门（接口），学生将所有要处理的事务全部交与它，由它去分配每个事务（请求）由哪个部门（class）去处理，这样是不是就简化了学生的操作步骤了，即使哪一天学校的组织架构发生了改变，也不需要通知所有的学生，只需要告诉这个部门（接口）就可以完成组织架构重组（系统升级），极大的提升了各部门之间的效率。

不知道对上面的目的是不是有了理解，下面再举个例子来说明下职责链模式到底是什么？

前段时间有一部热播的电视剧《我是特种兵之火凤凰》，里面有这样一个片段，大概就是雷神将一个引燃的炸药包交给一个队员，要求她将这个炸药包在手里放3秒，然后将它交给下一位队员，在即将引爆的时候，把它扔到前面的水池之中。这就可以看成一个简单的职责链，雷神就相当有我们前面说的那个部门（接口），由他点燃炸药包（接收请求），然后将它（request）分配给职责链上的队员（class），我们并不知道将会由谁去处理这个炸药包（request），但是一定会有处理结果反馈的。所以说职责链（Chain Of Responsibility）就是一系列的类（Class）试图处理一个请求（Request），这些类之间是松散的耦合，唯一的共同点就是他们之间传递的Request，来了一个请求，A类先处理，如果A没有权限或者不能处理，就把它交给B类，如果B类也没有权限或者不能处理，就把它交给C类，依次类推，直到请求被处理或者到了这个职责链（Chain Of Responsibility）的末端。这就像一条链条（Chain）一样，一节一节的传递下去。

说了这么多，简单的举个具体的实例来说明下。

首先创建职责链的基类，来确定职责链上的每个节点的一些基本属性和方法。

 /**  
 *@Description:  职责链的基类   
 */ 
package cn.lulei.cof.base;  
  
abstract class MonitorBase {
	private String levelStr;
	private MonitorBase nextMonitor;

	protected String getLevelStr() {
		return levelStr;
	}

	protected void setLevelStr(String levelStr) {
		this.levelStr = levelStr;
	}

	protected void setNextMonitor(MonitorBase nextMonitor) {
		this.nextMonitor = nextMonitor;
	}
	
	protected MonitorBase getNextMonitor() {
		return nextMonitor;
	}
	
	/**
	 * @param levelStr
	 * @Date:2013-10-27  
	 * @Author:lulei  
	 * @Description: 处理请求
	 */
	abstract protected void doRequest(String levelStr);
}

接着依次创建职责链上的每个处理节点，实现doRequest(String levelStr)函数。（班级、学院、学校）

班级

 /**  
 *@Description:  班级权限处理类  
 */ 
package cn.lulei.cof.base;

class MonitorClass extends MonitorBase{

	@Override
	protected void doRequest(String levelStr) {
		if (levelStr.equals(getLevelStr())) {
			System.out.println("班级权限类处理了请求");
		} else if (getNextMonitor() != null){
			getNextMonitor().doRequest(levelStr);
		} else {
			System.out.println("已经到了职责链末端，请求未有人处理！");
		}
	}
}

学院

 /**  
 *@Description: 学院权限处理类 
 */
package cn.lulei.cof.base;  
  
class MonitorAcademy extends MonitorBase{

	@Override
	protected void doRequest(String levelStr) {
		if (levelStr.equals(getLevelStr())) {
			System.out.println("学院权限类处理了请求");
		} else if (getNextMonitor() != null){
			getNextMonitor().doRequest(levelStr);
		} else {
			System.out.println("已经到了职责链末端，请求未有人处理！");
		}
	}
}

学校

 /**  
 *@Description:   学校权限处理类  
 */ 
package cn.lulei.cof.base; 
  
class MonitorSchool extends MonitorBase{

	@Override
	protected void doRequest(String levelStr) {
		if (levelStr.equals(getLevelStr())) {
			System.out.println("学校权限类处理了请求");
		} else if (getNextMonitor() != null){
			getNextMonitor().doRequest(levelStr);
		} else {
			System.out.println("已经到了职责链末端，请求未有人处理！");
		}
	}
}

现在每个节点都已经创建好了，就需要找一个链条把这些节点串联起来，并为外部提供服务接口。

 /**  
 *@Description: 职责链提供外部服务类    
 */ 
package cn.lulei.cof.base;  
  
public class MonitorService {
	
	private MonitorClass monitorClass;
	private MonitorAcademy monitorAcademy;
	private MonitorSchool monitorSchool;
	private MonitorBase firstMonitor;
	
	public MonitorService() {
		init();
	}
	
	public void doRequest(String levelStr) {
		firstMonitor.doRequest(levelStr);
	}
	
	/**
	 * @Date:2013-10-27  
	 * @Author:lulei  
	 * @Description: 创建职责链
	 */
	private void init(){
		monitorClass = new MonitorClass();
		monitorAcademy = new MonitorAcademy();
		monitorSchool = new MonitorSchool();
		
		monitorClass.setLevelStr("class");
		monitorAcademy.setLevelStr("academy");
		monitorSchool.setLevelStr("school");
		monitorClass.setNextMonitor(monitorAcademy);
		monitorAcademy.setNextMonitor(monitorSchool);
		firstMonitor = monitorClass;
	}

	public static void main(String[] args) {
		MonitorService monitorService = new MonitorService();
		monitorService.doRequest("academy");
		monitorService.doRequest("class");
		monitorService.doRequest("adaf");
		monitorService.doRequest("school");
	}

}

自己就稍微偷一下懒，就直接在服务类直接写测试了，这样一个完整的职责链就已经完成了。看一下上面的main函数执行的一个结果。

在使用职责链模式时，客户端不必事先知道对象集合中的哪一个对象可提供自己需要的服务，当客户端发出调用请求的后，该请求就会沿着职责链转发请求，直到找到提供该服务的对象或者职责链末端为止，这样就极大的降低了客户端与服务器之间的耦合度。当然实际运用的职责链模式要比上面的例子复杂的多，剩下的就需要在日常的学习生活中不断的去挖掘程序之美