设计模式（一）-责任链模式（Chain of Responsibility）

学习设计模式之前我们先来看一个这样的生活问题。申请聚餐费用。



这个我们平时的java怎么实现呢，看代码

public class FeeRequest {
/**
* 提交聚餐费用申请给项目经理
* @param user 申请人
* @param fee 申请费用
* @return 成功或失败的具体通知
*/
public String requestToProjectManager(String user,double fee){
String str = "";
if(fee < 500){
//项目经理的权限比较小，只能在500以内
str = this.projectHandle(user, fee);
}else if(fee < 1000){
//部门经理的权限只能在1000以内
str = this.depManagerHandle(user, fee);
}else if(fee >= 1000){
//总经理的权限很大，只要请求到了这里，他都可以处理
str = this.generalManagerHandle(user, fee);
}
return str;
}

/**
* 项目经理审批费用申请，参数、返回值和上面是一样的，省略了
*/
private String projectHandle(String user, double fee) {
String str = "";
//为了测试，简单点，只同意小李的
if("小李".equals(user)){
str = "项目经理同意"+user+"聚餐费用"+fee+"元的请求";
}else{
//其他人一律不同意
str = "项目经理不同意"+user+"聚餐费用"+fee+"元的请求";
}
return str;
}

/**
* 部门经理审批费用申请，参数、返回值和上面是一样的，省略了
*/
private String depManagerHandle(String user, double fee) {
String str = "";
//为了测试，简单点，只同意小李申请的
if("小李".equals(user)){
str = "部门经理同意"+user+"聚餐费用"+fee+"元的请求";
}else{
//其他人一律不同意
str= "部门经理不同意"+user+"聚餐费用"+fee+"元的请求";
}
return str;
}
/**
* 总经理审批费用申请，参数、返回值和上面是一样的，省略了
*/
private String generalManagerHandle(String user, double fee)
{
String str = "";

//为了测试，简单点，只同意小李的
if("小李".equals(user)){
str = "总经理同意"+user+"聚餐费用"+fee+"元的请求";
}else{
//其他人一律不同意
str = "总经理不同意"+user+"聚餐费用"+fee+"元的请求";
}
return str;
}

}

测试代码

public class Client {
public static void main(String[] args) {
FeeRequest request = new FeeRequest();

//开始测试
String ret1 = request.requestToProjectManager("小李", 300);
System.out.println("the ret1="+ret1);
String ret2 = request.requestToProjectManager("小张", 300);
System.out.println("the ret2="+ret2);

String ret3 = request.requestToProjectManager("小李", 600);
System.out.println("the ret3="+ret3);
String ret4 = request.requestToProjectManager("小张", 600);
System.out.println("the ret4="+ret4);

String ret5 = request.requestToProjectManager("小李", 1200);
System.out.println("the ret5="+ret5);
String ret6 = request.requestToProjectManager("小张", 1200);
System.out.println("the ret6="+ret6);
}
}

经典的if else，是不是看的很亲切，这估计也是我们平时的做法，但是这样接受者多一个就要改很多.

在软件构建过程中，一个请求可能被多个对象处理，但是每个请求在运行时只能有一个接受者，如果显式指定，将必不可少地带来请求发送者与接受者的紧耦合。

如何使请求的发送者不需要指定具体的接受者？让请求的接受者自己在运行时决定来处理请求，从而使两者解耦。这就出现了我们的责任链设计模式。

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

——《设计模式》GoF

下面看看责任链设计模式





下面我们来看看通过责任链设计模式实现的代码。

Handler.java

/**
* 定义职责对象的接口
*/
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);
}

ProjectManager.java

public class ProjectManager extends Handler{
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;
}
}

DepManager.java

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

GeneralManager.java

public class GeneralManager extends Handler{
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;
}
}

Client.java

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

在这里实现的代码中，我们通过successor制定下的一个责任人，这就产生我们的责任链设计模式。

别以为我们没有见到过，学过struts2的都知道。filter chain ，interceptor chain，一个filter交给下一个，一个interceptor交给下一个。



下面再放一张责任链设计模式的序列图。

假如员工直接上司为小组长，小组长直接上司项目经理，项目经理直接上司部门经理，部门经理直接上司总经理。公司规定请假审批如下：

请假时间为t,时间单位day，简写d： t< 0.5d，小组长审批； t>=0.5d,t<2,项目经理审批；

t>=2,t<5部门经理审批； t>=5总经理审批； 审批时序图如下



大概就这样，不懂可留言讨论。