JAVA的23种设计模式之责任链模式

责任链模式：

       将能够处理同一请求的对象连接成一条链，所提交的请求沿着链传递，链上的对象逐个判断是否有能力处理该请求。 如果能则处理，如果不能则传递给链上的下一个对象。

场景：

•     打牌时候，轮流出牌。
•     接力赛跑
•     大学中，奖学金审批
•     公司中，公文审批

公司里面，请假条的审批过程:

•     如果请假天数小于3天，主任审批 
•     如果请假天数大于等于3天小于10天。经理审批
•     如果大于等于10天，小于30天，总经理审批
•     如果大于等于30天，提示拒绝。

链表方式定义职责链

链表方式实现职责链
    通过集合数组生成职责链更加实用。实际上，很多项目种，每个具体的Handler并不是由开发团队定义的。而是项目上线后由外部单位追加的所以实用链表方式定义COR链就很困难

 

就拿上面举的例子：员工请假的例子来

创建请假的基本信息：

package cn.fllday.chain;


/**
 * 封装请假的基本信息
 * @author gssznb
 *
 */
public class LeaveRequest {

	private String name;
	
	private int leaveDays;
	
	private String reason;

	public LeaveRequest() {
		super();
	}

	public LeaveRequest(String name, int leaveDays, String reason) {
		super();
		this.name = name;
		this.leaveDays = leaveDays;
		this.reason = reason;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getLeaveDays() {
		return leaveDays;
	}

	public void setLeaveDays(int leaveDays) {
		this.leaveDays = leaveDays;
	}

	public String getReason() {
		return reason;
	}

	public void setReason(String reason) {
		this.reason = reason;
	}

	@Override
	public String toString() {
		return "LeaveRequest [name=" + name + ", leaveDays=" + leaveDays + ", reason=" + reason + "]";
	}
}

常见一个领导的抽象类。

package cn.fllday.chain;

/**
 * 创建一个领导的抽象类
 * 所有的能够审批假条的领导都要实现这个类
 * @author gssznb
 *
 */
public abstract class Leader {

	protected String name;  // 提供给子类使用的 所以实用protected
	protected Leader nextLeader;  // 责任链上的后继对象

	public Leader(String name) {
		super();
		this.name = name;
	}

	// 设置责任链的后继对象
	public void setNextLeader(Leader nextLeader) {
		this.nextLeader = nextLeader;
	}
	
	public abstract void handlerRequest(LeaveRequest request);
}

创建三个领导者。 实现审批流程。

package cn.fllday.chain;

public class Manager2 extends Leader {

	public Manager2(String name) {
		super(name);
	}
	
	@Override
	public void handlerRequest(LeaveRequest request) {
		if (request.getLeaveDays() < 3) {
			System.out.println("员工：" + request.getName() + "请假，天数：" + request.getLeaveDays());
			System.out.println("经理:"+this.name+"审批通过");
		}else {
			if (this.nextLeader !=null) {
				this.nextLeader.handlerRequest(request);
			}
		}
	}

}



package cn.fllday.chain;

public class Manager extends Leader {

	public Manager(String name) {
		super(name);
	}
	
	@Override
	public void handlerRequest(LeaveRequest request) {
		if (request.getLeaveDays() < 10) {
			System.out.println("员工：" + request.getName() + "请假，天数：" + request.getLeaveDays());
			System.out.println("经理:"+this.name+"审批通过");
		}else {
			if (this.nextLeader !=null) {
				this.nextLeader.handlerRequest(request);
			}
		}
	}

}

package cn.fllday.chain;

public class Director extends Leader {

	public Director(String name) {
		super(name);
	}
	
	@Override
	public void handlerRequest(LeaveRequest request) {
		if (request.getLeaveDays() < 30) {
			System.out.println("员工：" + request.getName() + "请假，天数：" + request.getLeaveDays());
			System.out.println("总经理:"+this.name+"审批通过");
		}else {
			System.out.println("你是不是不想干了？" + this.name);
		}
	}

}

通过Client.java来调用。

执行顺序是可以通过客户端调用者来手动设置的。

package cn.fllday.chain;

public class Client {

	public static void main(String[] args) {
		Leader c = new Director("张4");
		Leader b = new Manager("张三");
		Leader a = new Manager2("张5");
		a.setNextLeader(b);
		b.setNextLeader(c);
		LeaveRequest leave = new LeaveRequest();
		leave.setName("TOM");
		leave.setLeaveDays(2);
		leave.setReason("回老家");
		a.handlerRequest(leave);
	}
	
}

通过 setLeaveDays 分别设置 2 天 9天 20天 100天来测试责任链的效果

执行结果：

两天：
员工：TOM请假，天数：2
经理:张5审批通过


九天：
员工：TOM请假，天数：9
经理:张三审批通过

二十天：
员工：TOM请假，天数：20
总经理:张4审批通过

一百天：
你是不是不想干了？张4

开发中的场景：

•     JAVA中，异常机制就就是一种责任链模式，一个try可以对应多个catch，当第一个catch 不匹配类型，则自动跳到第二个      catch
•     JavaScript语言中，事件的冒泡和捕获机制，JAVA语言中事件的处理采用观察者模式
•     Servlet开发中，过滤器的链式处理
•     Struts2中，拦截器的调用也是典型的责任链模式