设计模式之-责任链模式，快速掌握责任链模式，通俗易懂的讲解责任链模式以及它的使用场景

系列文章目录

设计模式之-6大设计原则简单易懂的理解以及它们的适用场景和代码示列
设计模式之-单列设计模式，5种单例设计模式使用场景以及它们的优缺点
设计模式之-3种常见的工厂模式简单工厂模式、工厂方法模式和抽象工厂模式，每一种模式的概念、使用场景和优缺点。
设计模式之模板方法模式，通俗易懂快速理解，以及模板方法模式的使用场景
设计模式之-建造者模式通俗易懂理解，以及建造者模式的使用场景和示列代码
设计模式之-代理模式，快速掌握理解代理模式，以及代理模式的使用场景
设计模式之-原型模式，快速掌握原型模式，通俗易懂的理解原型模式以及使用场景
设计模式之-中介者模式，快速掌握中介者模式，通俗易懂的讲解中介者模式以及它的使用场景
设计模式之-责任链模式，快速掌握责任链模式，通俗易懂的讲解责任链模式以及它的使用场景
设计模式之-装饰模式，快速掌握装饰模式，通俗易懂的讲解装饰模式以及它的使用场景
设计模式之-适配器模式，快速掌握适配器模式，通俗易懂的讲解适配器模式以及它的使用场景

---

---

一、快速理解责任链模式

责任链模式是一种行为型设计模式，它将请求的发送者和接收者解耦，使多个对象都有机会处理请求。每个接收者都包含对下一个接收者的引用，形成一个链条，当请求从链条的头部开始传递时，每个接收者都有机会处理请求，直到有一个接收者能够处理为止。

在现实生活中，责任链模式的例子可以是请假审批流程。假设有多个层级的审批人员，每个人都有不同的审批权限。当员工提交请假申请时，请求会从最高层级的审批人员开始传递，如果一个审批人员无法处理请求，则将请求传递给下一个审批人员，直到有人能够处理为止。

二、责任链模式使用场景

1. 当有多个对象可以处理同一个请求时，可以使用责任链模式。每个对象都有机会处理请求，但处理者不需要知道请求的发送者和后续处理者。
2. 当需要动态指定处理请求的对象时，可以使用责任链模式。可以根据特定条件来决定请求的传递顺序或跳过某些处理者。

三、代码示例

下面是一个通俗易懂的责任链模式示例代码，以请假审批为场景：

// 抽象处理者：审批人
abstract class Approver {
    protected Approver nextApprover;

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

    public abstract void approveLeave(int days);
}

// 具体处理者：主管
class Supervisor extends Approver {
    @Override
    public void approveLeave(int days) {
        if (days <= 2) {
            System.out.println("主管批准了请假申请");
        } else {
            if (nextApprover != null) {
                nextApprover.approveLeave(days);
            } else {
                System.out.println("没有人能够处理该请假申请");
            }
        }
    }
}

// 具体处理者：经理
class Manager extends Approver {
    @Override
    public void approveLeave(int days) {
        if (days <= 5) {
            System.out.println("经理批准了请假申请");
        } else {
            if (nextApprover != null) {
                nextApprover.approveLeave(days);
            } else {
                System.out.println("没有人能够处理该请假申请");
            }
        }
    }
}

// 具体处理者：CEO
class CEO extends Approver {
    @Override
    public void approveLeave(int days) {
        if (days <= 7) {
            System.out.println("CEO批准了请假申请");
        } else {
            System.out.println("没有人能够处理该请假申请");
        }
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        Approver supervisor = new Supervisor();
        Approver manager = new Manager();
        Approver ceo = new CEO();

        supervisor.setNextApprover(manager);
        manager.setNextApprover(ceo);

        supervisor.approveLeave(3); // 主管批准了请假申请
        supervisor.approveLeave(6); // CEO批准了请假申请
        supervisor.approveLeave(9); // 没有人能够处理该请假申请
    }
}

在上面的示例中，Approver是抽象处理者，定义了处理请假申请的方法和下一个处理者的引用。Supervisor、Manager和CEO是具体处理者，分别实现了抽象处理者的处理请假申请方法，并在其中判断是否能够处理请求，如果不能处理则将请求传递给下一个处理者。

在客户端代码中，首先创建了主管、经理和CEO对象，并设置它们的下一个处理者。然后调用主管的approveLeave方法来发起请假申请，该方法会根据请假天数判断是否能够处理请求，如果不能处理则会将请求传递给下一个处理者。最后，根据不同的请假天数，输出不同的处理结果。

通过使用责任链模式，可以灵活地指定处理请求的对象，并且可以动态调整处理者的顺序或跳过某些处理者。责任链模式还可以将请求的发送者和接收者解耦，使得它们之间的依赖关系更加松散。

四、我们来听一个故事，加深一下理解

以下是一个故事，用来解释责任链模式的概念。

假设你是一名财务审批员工，你的工作是审批员工的报销申请。每个报销申请都需要经过一系列的审批流程，包括初审、部门经理审批和财务总监审批。如果一个审批人员无法批准该申请，那么申请会继续传递给下一个审批人员，直到得到最终的审批结果。

有一天，你收到了一份报销申请，金额较大，需要经过多个层级的审批。你首先对这份申请进行初审，如果金额超过你的审批权限，你会将申请转给部门经理进行审批。如果部门经理也无法批准该申请，申请会进一步传递给财务总监进行最后的审批。

这个过程中，每个审批人员都代表责任链中的一个节点，每个节点都有权力批准或转发申请。如果一个节点无法处理申请，责任就会被传递给下一个节点，直到有一个节点能够处理该申请或者责任链结束。

通过这个故事，我们可以将报销审批流程视为一个责任链，每个审批人员是责任链中的一个节点。责任链模式允许申请在责任链上流动，直到找到一个能够处理它的节点，从而简化了申请的处理过程，并且可以根据具体情况动态调整责任链的结构。

请注意，这个故事中只是一个简单的示例，实际的责任链可能包含更多的节点和复杂的逻辑，但核心思想是一致的：将请求沿着一个预定义的链路传递，直到被处理或者到达链的末尾。

以下是一个使用Java语言实现上述财务报销审批的责任链模式的示例代码：

// 请求类 - 报销申请
class ExpenseRequest {
    private double amount;

    public ExpenseRequest(double amount) {
        this.amount = amount;
    }

    public double getAmount() {
        return amount;
    }
}

// 抽象处理者 - 审批人员
abstract class Approver {
    protected Approver nextApprover;

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

    public abstract void processRequest(ExpenseRequest request);
}

// 具体处理者 - 初审人员
class FirstApprover extends Approver {
    private double approvalLimit = 1000.0;

    @Override
    public void processRequest(ExpenseRequest request) {
        if (request.getAmount() <= approvalLimit) {
            System.out.println("初审人员批准了报销申请");
        } else if (nextApprover != null) {
            nextApprover.processRequest(request);
        }
    }
}

// 具体处理者 - 部门经理
class ManagerApprover extends Approver {
    private double approvalLimit = 5000.0;

    @Override
    public void processRequest(ExpenseRequest request) {
        if (request.getAmount() <= approvalLimit) {
            System.out.println("部门经理批准了报销申请");
        } else if (nextApprover != null) {
            nextApprover.processRequest(request);
        }
    }
}

// 具体处理者 - 财务总监
class CFOApprover extends Approver {
    @Override
    public void processRequest(ExpenseRequest request) {
        System.out.println("财务总监批准了报销申请");
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        // 创建责任链上的各个节点
        Approver firstApprover = new FirstApprover();
        Approver managerApprover = new ManagerApprover();
        Approver cfoApprover = new CFOApprover();

        // 设置责任链的顺序
        firstApprover.setNextApprover(managerApprover);
        managerApprover.setNextApprover(cfoApprover);

        // 创建报销申请
        ExpenseRequest request1 = new ExpenseRequest(500.0);
        ExpenseRequest request2 = new ExpenseRequest(3000.0);
        ExpenseRequest request3 = new ExpenseRequest(8000.0);

        // 处理报销申请
        firstApprover.processRequest(request1);
        System.out.println("---");
        firstApprover.processRequest(request2);
        System.out.println("---");
        firstApprover.processRequest(request3);
    }
}

在上述代码中，我们定义了一个责任链模式的示例，其中包括请求类 ExpenseRequest 和抽象处理者 Approver，以及具体处理者 FirstApprover、ManagerApprover 和 CFOApprover。客户端代码通过创建各个处理者，并设置它们在责任链上的顺序，然后将请求传递给责任链的第一个处理者。

在处理请求时，每个处理者都会判断自己是否有权限批准该请求。如果有权限，则处理请求；如果没有权限，则将请求传递给责任链中的下一个处理者，直到有一个处理者能够处理该请求或者责任链结束。

在上面的示例中，我们创建了三个报销申请，并依次将它们传递给责任链的第一个处理者 FirstApprover。根据报销金额的不同，请求会被不同的处理者审批。最终，我们可以看到每个请求被正确地处理或转发，从而演示了责任链模式的使用。