责任链设计模式的原理与实现

基本概念

当一个请求可能需要被多个对象处理时，我们可以将这些处理对象链成一条链，并在这条链上传递该请求，直到该请求被处理完毕，这种设计模式就叫做责任链设计模式。

原理与实现

场景模拟：

                 公司的报销流程如下：由员工在OA系统填写报销申请单，申请单提交给该员工的上一级审批，如果审核金额超出了该上级的审批范围，则由该上级审批后再继续提交给该上级的上级进行审批，以此类推，直到公司最高领导人，如果金额过于巨大则需召开董事会进行商议审批。

以上场景如果我们用责任链设计模式可以做如下设计

Approver.java

//审核者抽象对象，所有的审批者都继承于该对象
abstract class Approver {
//下一审批者
protected Approver nextApprover;

public void setNextApprover(Approver nextApprover){
this.nextApprover = nextApprover;
}

//根据业务需求处理请求
abstract public void processRequest(PurchaseRequest request);
}

//经理
class Manager extends Approver {
//设置审批金额上限
private final double APPROVE_LIMIT = 1000;

public void processRequest(PurchaseRequest request ) {
System.out.println("申请单已经转发给经理审批，请耐心等待！");
System.out.println("经理审批中.......");
System.out.println("你的申请单已经过经理的审批");
if( request.getMoney() <= APPROVE_LIMIT ){
System.out.println("恭喜你，该申请单顺利通过公司领导的审批");
}
else{
System.out.println("申请金额超出1000元，将自动转发给上一级继续审批");
if( nextApprover != null)
nextApprover.processRequest(request);
else
System.out.println("申请金额过于庞大，将对此召开董事会讨论。。。。。。");
}
}
}

//部门主管
class Director extends Approver {
private final double APPROVE_LIMIT = 10000;

public void processRequest(PurchaseRequest request ) {
System.out.println("申请单已经转发给部门总管审批，请耐心等待！");
System.out.println("部门总管审批中.......");
System.out.println("你的申请单已经过部门总管的审批");
if( request.getMoney() <= APPROVE_LIMIT ){
System.out.println("恭喜你，该申请单顺利通过公司领导的审批");
}
else{
System.out.println("申请金额超出10000元，将自动转发给上一级继续审批");
if( nextApprover != null)
nextApprover.processRequest(request);
else
System.out.println("申请金额过于庞大，将对此召开董事会讨论。。。。。。");
}
}
}

//董事长
class President extends Approver {
private final double APPROVE_LIMIT = 100000;

public void processRequest(PurchaseRequest request ) {
System.out.println("申请单已经转发给董事长审批，请耐心等待！");
System.out.println("董事长审批中.......");
System.out.println("你的申请单已经过董事长的审批");
if( request.getMoney() <= APPROVE_LIMIT ){
System.out.println("恭喜你，该申请单顺利通过公司领导的审批");
}
else{
System.out.println("申请金额超出100000元，将自动转发给上一级继续审批");
if( nextApprover != null)
nextApprover.processRequest(request);
else
System.out.println("申请金额过于庞大，将对此召开董事会讨论。。。。。。");
}
}
}

//报销请求
class PurchaseRequest {
private String name;
private int money;
private String description;

public PurchaseRequest(String name, int money, String description) {
super();
this.name = name;
this.money = money;
this.description = description;
}

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
}

ApproveTest.java  (测试类)

public class ApproveTest {
public static void main(String[] args){
Manager manager = new Manager();
Director director = new Director();
President president = new President();
//设置经理的上级是部门主管
manager.setNextApprover(director);
//设置部门主管的上级是董事长
director.setNextApprover(president);
try{
System.out.println("输入你要报销的金额：");
System.out.print(">");
int money = Integer.parseInt(new BufferedReader(new InputStreamReader(System.in)).readLine());
//假设该员工的直属上级是经理，则其报销单由经理开始审核
manager.processRequest(new PurchaseRequest("张三", money, "General"));
}catch(Exception e){
System.exit(1);
}
}
}

结果输出：

报销金额小于1000时候：

输入你要报销的金额：
>988
申请单已经转发给经理审批，请耐心等待！
经理审批中.......
你的申请单已经过经理的审批
恭喜你，该申请单顺利通过公司领导的审批

报销金额在1000到10000之间时：

输入你要报销的金额：
>9980
申请单已经转发给经理审批，请耐心等待！
经理审批中.......
你的申请单已经过经理的审批
申请金额超出1000元，将自动转发给上一级继续审批
申请单已经转发给部门总管审批，请耐心等待！
部门总管审批中.......
你的申请单已经过部门总管的审批
恭喜你，该申请单顺利通过公司领导的审批

申请金额大于100000时：

输入你要报销的金额：
>1000001
申请单已经转发给经理审批，请耐心等待！
经理审批中.......
你的申请单已经过经理的审批
申请金额超出1000元，将自动转发给上一级继续审批
申请单已经转发给部门总管审批，请耐心等待！
部门总管审批中.......
你的申请单已经过部门总管的审批
申请金额超出10000元，将自动转发给上一级继续审批
申请单已经转发给董事长审批，请耐心等待！
董事长审批中.......
你的申请单已经过董事长的审批
申请金额超出100000元，将自动转发给上一级继续审批
申请金额过于庞大，将对此召开董事会讨论。。。。。。

上面那个例子体现了责任链设计模式的基本设计思想，从上面的代码我们可以看出，责任链设计模式将每个处理请求的对象都当成链上的一个节点，这些对象（节点）中都有一个处理请求的方法，每个节点又可以设置它的下一节点，从而形成一条处理链，在本节点处理请求之后可以选择是否将请求继续传递给下一个节点进行处理。

用责任链设计模式解决该类问题至少有以下两个好处：

1、 请求发起者可以不用知道具体的请求处理者，从而实现了程序的松耦合

2、 可以自由改变链条节点顺序，从而灵活改变内部传递规则