责任链模式（Chain of Responsibility）

点滴~

已于 2024-08-09 15:51:46 修改

阅读量859

点赞数 22

文章标签：责任链模式

于 2024-08-02 13:48:35 首次发布

本文链接：https://blog.csdn.net/oqkdws/article/details/140870543

版权

责任链模式（Chain of Responsibility）是一种行为型设计模式，其主要目的是通过为请求创建一个对象链来避免请求的发送者和接收者之间的耦合关系。在这种模式下，多个对象都有机会处理这个请求，它们被连接成一条链，请求则沿着这条链传递，直到有一个对象能够处理它为止。以下是对责任链模式的详细解析：

定义

责任链模式将请求的发送者和接收者解耦，使得多个对象都有机会处理这个请求，并且将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

结构

在责任链模式中，通常包含以下几个角色：

处理者（Handler）：声明了所有具体处理者的通用接口。该接口通常仅包含单个方法用于请求处理，但有时其还会包含一个设置链上下个处理者的方法。
具体处理者（Concrete Handlers）：包含处理请求的实际代码。每个处理者接收到请求后，都必须决定是否进行处理，以及是否沿着链传递请求。
客户端（Client）：可根据程序逻辑一次性或者动态地生成链，并将请求发送给链上的任意处理者。

工作流程

创建链：客户端创建链中的各个处理者对象，并设置它们之间的引用关系。
发送请求：客户端将请求发送给链中的第一个处理者。
处理请求：处理者接收到请求后，首先检查自己是否能够处理该请求。如果能够处理，则处理它；如果不能处理，则将该请求传递给链中的下一个处理者。
传递请求：这个过程会一直进行下去，直到有一个处理者能够处理该请求为止。

优点

降低耦合度：将请求的发送者和接收者解耦，提高了系统的灵活性和可扩展性。
增强了对象之间的协作：通过链式传递请求，使得多个对象可以共同参与请求的处理过程。
动态改变处理者：可以在运行时动态地改变处理者的顺序或添加新的处理者，从而改变请求的处理流程。

应用场景

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

当有多个对象可以处理一个请求，并且你需要在运行时动态地确定哪个对象处理该请求时。
当你想在不明确指定接收者的情况下，向多个对象中的一个传递请求时。
当处理请求的顺序在运行时可能发生变化时。

示例

以下是一个简单的责任链模式示例，模拟了一个公司处理员工请假请求的过程：

抽象处理者（Handler）：定义一个能够处理请假请求的接口。
具体处理者（ProjectManager, DepartmentHead）：分别表示项目经理和部门经理，它们能够处理特定天数范围内的请假请求。
客户端（Client）：创建处理者链，并发送请假请求。

在这个示例中，客户端将请假请求发送给项目经理（链的第一个处理者）。项目经理首先检查自己是否能够处理该请求（即请假天数是否在其审批权限范围内）。如果能够处理，则直接处理；如果不能处理，则将该请求传递给部门经理（链的下一个处理者）。部门经理继续这个过程，直到请求被处理或传递到链的末尾。

责任链模式是一种非常有用的设计模式，它可以帮助我们构建灵活且可扩展的系统。通过避免请求的发送者和接收者之间的直接耦合，我们可以更容易地添加新的处理者或修改现有处理者的顺序，从而满足不断变化的业务需求。

在Java中实现责任链模式来模拟公司处理员工请假请求的过程，我们需要定义几个类：LeaveRequest（请假请求类），Handler（处理者接口），以及具体的处理者类（如ProjectManager和DepartmentHead）。下面是一个简单的实现示例：

首先，我们定义请假请求类LeaveRequest：

public class LeaveRequest {  
    private int numberOfDays;  
    private String employeeName;  
  
    public LeaveRequest(int numberOfDays, String employeeName) {  
        this.numberOfDays = numberOfDays;  
        this.employeeName = employeeName;  
    }  
  
    public int getNumberOfDays() {  
        return numberOfDays;  
    }  
  
    public String getEmployeeName() {  
        return employeeName;  
    }  
  
    @Override  
    public String toString() {  
        return "LeaveRequest{" +  
                "numberOfDays=" + numberOfDays +  
                ", employeeName='" + employeeName + '\'' +  
                '}';  
    }  
}

然后，定义处理者接口Handler：

public interface Handler {  
    // 处理请假请求的方法  
    void handleRequest(LeaveRequest leaveRequest);  
    // 设置下一个处理者  
    void setNextHandler(Handler handler);  
}

接下来，定义具体的处理者类，如ProjectManager和DepartmentHead：

public class ProjectManager implements Handler {  
    private Handler nextHandler;  
  
    @Override  
    public void handleRequest(LeaveRequest leaveRequest) {  
        if (leaveRequest.getNumberOfDays() <= 3) {  
            System.out.println("Project Manager approved the leave request for " + leaveRequest.getEmployeeName());  
        } else {  
            if (nextHandler != null) {  
                nextHandler.handleRequest(leaveRequest);  
            } else {  
                System.out.println("Leave request cannot be approved by anyone.");  
            }  
        }  
    }  
  
    @Override  
    public void setNextHandler(Handler handler) {  
        this.nextHandler = handler;  
    }  
}  
  
public class DepartmentHead implements Handler {  
    private Handler nextHandler;  
  
    @Override  
    public void handleRequest(LeaveRequest leaveRequest) {  
        if (leaveRequest.getNumberOfDays() <= 7) {  
            System.out.println("Department Head approved the leave request for " + leaveRequest.getEmployeeName());  
        } else {  
            if (nextHandler != null) {  
                nextHandler.handleRequest(leaveRequest);  
            } else {  
                System.out.println("Leave request cannot be approved by anyone.");  
            }  
        }  
    }  
  
    @Override  
    public void setNextHandler(Handler handler) {  
        this.nextHandler = handler;  
    }  
}

最后，我们编写一个客户端类来测试这个责任链：

public class ChainPatternDemo {  
    private static Handler getChain() {  
        // 创建责任链  
        Handler projectManager = new ProjectManager();  
        Handler departmentHead = new DepartmentHead();  
  
        // 设置链的顺序  
        projectManager.setNextHandler(departmentHead);  
  
        return projectManager;  
    }  
  
    public static void main(String[] args) {  
        // 创建请求  
        LeaveRequest request1 = new LeaveRequest(2, "John Doe");  
        LeaveRequest request2 = new LeaveRequest(5, "Jane Smith");  
        LeaveRequest request3 = new LeaveRequest(10, "Alice Johnson");  
  
        // 获取链的入口  
        Handler handler = getChain();  
  
        // 发送请求  
        handler.handleRequest(request1);  
        handler.handleRequest(request2);  
        handler.handleRequest(request3);  
    }  
}

在这个例子中，我们创建了一个责任链，其中ProjectManager是链的第一个处理者，它负责处理3天或更少的请假请求。如果请求天数超过3天，则它会将请求传递给链中的下一个处理者——DepartmentHead。DepartmentHead可以处理最多7天的请假请求。如果请求天数超过7天，并且链中没有更多的处理者，则会打印一条消息表示请假请求无法被批准。

运行ChainPatternDemo类将演示责任链如何工作。