职责链模式(Chain of Responsibility)

@@@模式定义：
使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。
将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

@@@练习示例: 
申请聚餐费用

@@@示例代码:
\pattern\Handler.java

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

package pattern;

/**
 * 定义职责对象的接口
 */
public abstract class Handler {
    /**
     * 持有下一个处理请求的对象
     */
	protected Handler successor = null;
	
	/**
	 * 设置下一个处理请求的对象
	 * @param successor 下一个处理请求的对象
	 */
	public void setSuccessor(Handler successor) {
		this.successor = successor;
	}
	
	/**
	 * 处理聚餐费用的申请
	 * @param user 申请人
	 * @param fee 申请的钱数
	 * @return 成功或失败的具体通知
	 */
	public abstract String handleFeeRequest(String user, double fee);
}

\pattern\ProjectManager.java
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

package pattern;

public class ProjectManager extends Handler {
	@Override
	public String handleFeeRequest(String user, double fee) {
		String str = "";
		// 项目经理的权限比较小，只能在500以内
		if (fee < 500) {
			// 为了测试，简单点，只同意小李的
			if ("小李".equals(user)) {
				str = "项目经理同意" + user + "聚餐费用" + fee + "元的请求";
			} else {
				// 其他人一律不同意
				str =  "项目经理不同意" + user + "聚餐费用" + fee + "元的请求";
			}
			
			return str;
		} else {
			// 超过500, 继续传递给级别更高的人处理
			if (this.successor != null) {
				return successor.handleFeeRequest(user, fee);
			}
		}
		
		return str;
	}
}

\pattern\DepManager.java
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

package pattern;

public class DepManager extends Handler {
	@Override
	public String handleFeeRequest(String user, double fee) {
		String str = "";
		// 部门经理的权限只能在1000以内
		if (fee < 1000) {
			// 为了测试，简单点，只同意小李的
			if ("小李".equals(user)) {
				str = "部门经理同意" + user + "聚餐费用" + fee + "元的请求";
			} else {
				// 其他人一律不同意
				str =  "部门经理不同意" + user + "聚餐费用" + fee + "元的请求";
			}
			
			return str;
		} else {
			// 超过1000, 继续传递给级别更高的人处理
			if (this.successor != null) {
				return successor.handleFeeRequest(user, fee);
			}
		}
		
		return str;
	}
}

\pattern\GeneralManager.java
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

package pattern;

public class GeneralManager extends Handler {
	@Override
	public String handleFeeRequest(String user, double fee) {
		String str = "";
		// 总经理的权限很大，只要请求到了这里，他都可以处理
		if (fee >= 1000) {
			// 为了测试，简单点，只同意小李的
			if ("小李".equals(user)) {
				str = "总经理同意" + user + "聚餐费用" + fee + "元的请求";
			} else {
				// 其他人一律不同意
				str =  "总经理不同意" + user + "聚餐费用" + fee + "元的请求";
			}
			
			return str;
		} else {
			// 如果还有后继的处理对象，继续传递
			if (this.successor != null) {
				return successor.handleFeeRequest(user, fee);
			}
		}
		
		return str;
	}
}

\user\Client.java
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

package user;

import pattern.DepManager;
import pattern.GeneralManager;
import pattern.Handler;
import pattern.ProjectManager;

public class Client {
	public static void main(String[] args) {
		// 先要组装职责链
        Handler h1 = new GeneralManager();
        Handler h2 = new DepManager();
        Handler h3 = new ProjectManager();
        h3.setSuccessor(h2);
        h2.setSuccessor(h1);
        
        // 开始测试
        String ret1 = h3.handleFeeRequest("小李", 300);
        System.out.println("the ret1=" + ret1);     
        String ret2 = h3.handleFeeRequest("小张", 300);
        System.out.println("the ret2=" + ret2);
        
        String ret3 = h3.handleFeeRequest("小李", 600);
        System.out.println("the ret3=" + ret3);     
        String ret4 = h3.handleFeeRequest("小张", 600);
        System.out.println("the ret4=" + ret4);
        
        String ret5 = h3.handleFeeRequest("小李", 1200);
        System.out.println("the ret5=" + ret5);     
        String ret6 = h3.handleFeeRequest("小张", 1200);
        System.out.println("the ret6=" + ret6);
	}
}

运行结果:
the ret1=项目经理同意小李聚餐费用300.0元的请求
the ret2=项目经理不同意小张聚餐费用300.0元的请求
the ret3=部门经理同意小李聚餐费用600.0元的请求
the ret4=部门经理不同意小张聚餐费用600.0元的请求
the ret5=总经理同意小李聚餐费用1200.0元的请求
the ret6=总经理不同意小张聚餐费用1200.0元的请求

@@@模式的实现:
定义的处理模板中持有下一个处理请求的对象，具体实现中根据实际情况传递处理。
有外部链和内部链的区别。

@@@模式的优点:
1) 请求者和接收者松散耦合；
2) 动态组合职责；

@@@模式的缺点:
1) 产生很多细粒度对象；
2) 请求不一定能被处理；

@@@模式的本质:
分离职责，动态组合。

@@@模式体现的设计原则:
LKP