使用责任链模式优雅地处理请求

简介：

本文将介绍责任链模式的概念、应用场景，并通过一个具体的例子，演示如何实现责任链模式，帮助您更好地理解和应用这种设计模式。

责任链模式的应用场景

责任链模式适用于以下场景：

• 有多个对象可以处理一个请求，但是具体由哪个对象处理，取决于运行时的条件。
• 在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。
• 应用需要动态地指定处理请求的对象集合。

如何实现责任链

责任链模式（Chain of Responsibility）是一种行为设计模式，它允许多个对象来处理一个请求，将这些对象连接成一条链，并沿着这条链传递请求，直到某个处理程序处理它为止。下面是一个简单的责任链模式实现：

步骤

• 定义处理请求的接口或抽象类：创建一个接口或抽象类，定义处理请求的方法，以及设置下一个处理器的方法。这将作为责任链中各个处理器的基类。

• 创建具体处理器类：根据需求创建不同的具体处理器类，这些类需要继承自抽象处理器类（或实现处理请求的接口）。在具体处理器类中，实现处理请求的逻辑。如果当前处理器无法处理请求，则将请求传递给下一个处理器。

• 构建责任链：在客户端或应用程序中，实例化各个具体处理器类，并将它们连接起来形成责任链。通常，这是通过在一个处理器中设置对下一个处理器的引用来实现的。

• 提交请求：客户端向责任链的第一个处理器提交请求。处理器将根据其职责处理请求，并在适当的时候将请求传递给下一个处理器。请求沿着责任链传递，直到找到合适的处理器或到达责任链的末端。

• 处理请求：处理器在责任链上执行逻辑操作，处理请求并生成相应的结果。根据实际需求，处理器可以返回处理结果，或者将结果传递给下一个处理器进行进一步处理。

代码示例

我们将创建一个请假审批系统，其中有三个审批人：组长、经理和总监。请假请求将沿着责任链传递，直到找到合适的审批人为止。

首先，创建一个处理请求的抽象类 LeaveRequestHandler：

public abstract class LeaveRequestHandler {
    protected LeaveRequestHandler nextHandler;

    public void setNextHandler(LeaveRequestHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public abstract void handleRequest(LeaveRequest request);
}

class LeaveRequest {
    private final String employeeName;
    private final int days;

    public LeaveRequest(String employeeName, int days) {
        this.employeeName = employeeName;
        this.days = days;
    }

    public String getEmployeeName() {
        return employeeName;
    }

    public int getDays() {
        return days;
    }
}

接下来，创建具体的处理器类：TeamLeader、Manager 和 Director：

public class TeamLeader extends LeaveRequestHandler {
    @Override
    public void handleRequest(LeaveRequest request) {
        if (request.getDays() <= 3) {
            System.out.println("组长审批：" + request.getEmployeeName() + " 的请假，天数：" + request.getDays() + "天。");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        } else {
            System.out.println("没有找到合适的审批人。");
        }
    }
}

public class Manager extends LeaveRequestHandler {
    @Override
    public void handleRequest(LeaveRequest request) {
        if (request.getDays() > 3 && request.getDays() <= 10) {
            System.out.println("经理审批：" + request.getEmployeeName() + " 的请假，天数：" + request.getDays() + "天。");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        } else {
            System.out.println("没有找到合适的审批人。");
        }
    }
}

public class Director extends LeaveRequestHandler {
    @Override
    public void handleRequest(LeaveRequest request) {
        if (request.getDays() > 10) {
            System.out.println("总监审批：" + request.getEmployeeName() + " 的请假，天数：" + request.getDays() + "天。");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        } else {
            System.out.println("没有找到合适的审批人。");
        }
    }
}

创建一个 Client 类来测试责任链模式：

public class Client {
    public static void main(String[] args) {
        LeaveRequestHandler teamLeader = new TeamLeader();
        LeaveRequestHandler manager = new Manager();
        LeaveRequestHandler director = new Director();

        teamLeader.setNextHandler(manager);
        manager.setNextHandler(director);

        LeaveRequest request1 = new LeaveRequest("张三", 2);
        LeaveRequest request2 = new LeaveRequest("李四", 5);
        LeaveRequest request3 = new LeaveRequest("王五", 12);

        teamLeader.handleRequest(request1);
        teamLeader.handleRequest(request2);
        teamLeader.handleRequest(request3);
    }
}

运行 Client 类的 main 方法，您将看到以下输出：

组长审批：张三 的请假，天数：2天。
经理审批：李四 的请假，天数：5天。
总监审批：王五 的请假，天数：12天。

总结

在这个示例中，我们创建了三个具体的处理器：TeamLeader、Manager 和 Director。组长可以处理最多 3 天的请假请求，经理可以处理 3 到 10 天的请假请求，总监可以处理超过 10 天的请假请求。处理器之间形成了一个责任链。

我们创建了三个请假请求，分别请假 2 天、5 天和 12 天。这些请求将被传递给组长。组长处理不了的请求将被传递给下一个处理器，即经理。经理处理不了的请求将被传递给总监。

以上。