当前位置：首页 > news >正文

Java 设计模式：责任链模式详解

news 来源：原创 2025/6/17 2:34:12

Java 设计模式：责任链模式详解

责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，它通过将请求沿着一条处理链传递，直到某个对象处理它为止，避免了请求发送者和接收者之间的直接耦合。本文将详细介绍责任链模式的定义、实现方式及其在 Java 中的应用。

1. 什么是责任链模式？

责任链模式的核心思想是：将多个处理对象组成一条链，请求沿着这条链传递，每个处理对象都有机会处理请求或将其传递给下一个对象。这种模式适用于需要动态分配职责或按顺序处理请求的场景。

模式结构

抽象处理者（Handler）：定义处理请求的接口，通常包含一个指向下一个处理者的引用。
具体处理者（Concrete Handler）：实现抽象处理者，决定是否处理请求，并可将请求传递给链中的下一个对象。
客户端（Client）：发起请求并将其发送到责任链的起点。

2. 实现责任链模式

以下是一个简单的 Java 示例，模拟一个请假审批流程：员工提交请假请求，根据天数不同，由不同级别的管理者审批。

2.1 定义抽象处理者

public abstract class LeaveHandler {
    protected LeaveHandler nextHandler; // 指向下一个处理者

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

    // 处理请假请求
    public abstract void handleRequest(LeaveRequest request);
}

2.2 定义具体处理者

小组长（TeamLeader）：处理 1-3 天的请假。
经理（Manager）：处理 3-7 天的请假。
总监（Director）：处理 7 天以上的请假。

public class TeamLeader extends LeaveHandler {
    @Override
    public void handleRequest(LeaveRequest request) {
        if (request.getDays() <= 3) {
            System.out.println("小组长批准了 " + request.getName() + " 的 " + request.getDays() + " 天请假");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request); // 传递给下一个处理者
        } else {
            System.out.println("无人能处理该请求");
        }
    }
}

public class Manager extends LeaveHandler {
    @Override
    public void handleRequest(LeaveRequest request) {
        if (request.getDays() <= 7) {
            System.out.println("经理批准了 " + request.getName() + " 的 " + request.getDays() + " 天请假");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        } else {
            System.out.println("无人能处理该请求");
        }
    }
}

public class Director extends LeaveHandler {
    @Override
    public void handleRequest(LeaveRequest request) {
        if (request.getDays() > 7) {
            System.out.println("总监批准了 " + request.getName() + " 的 " + request.getDays() + " 天请假");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        } else {
            System.out.println("无人能处理该请求");
        }
    }
}

2.3 定义请求类

public class LeaveRequest {
    private String name; // 请假人姓名
    private int days;    // 请假天数

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

    public String getName() {
        return name;
    }

    public int getDays() {
        return days;
    }
}

2.4 客户端使用

public class Client {
    public static void main(String[] args) {
        // 创建处理者
        LeaveHandler teamLeader = new TeamLeader();
        LeaveHandler manager = new Manager();
        LeaveHandler director = new Director();

        // 构建责任链
        teamLeader.setNextHandler(manager);
        manager.setNextHandler(director);

        // 提交请假请求
        LeaveRequest request1 = new LeaveRequest("张三", 2);
        LeaveRequest request2 = new LeaveRequest("李四", 5);
        LeaveRequest request3 = new LeaveRequest("王五", 10);

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

输出结果

小组长批准了 张三 的 2 天请假
经理批准了 李四 的 5 天请假
总监批准了 王五 的 10 天请假

3. 责任链模式的优点与缺点

优点

解耦请求与处理：请求发送者无需知道具体由谁处理，降低了耦合度。
灵活性强：可以动态调整链的结构，添加或删除处理者。
职责分明：每个处理者只关注自己负责的部分，符合单一职责原则。

缺点

请求可能未被处理：如果链中没有合适的处理者，请求可能被忽略。
性能开销：链过长时，请求需要逐级传递，可能影响性能。

4. 实际应用场景

责任链模式在 Java 中有许多实际应用，以下是几个典型场景：

Servlet 过滤器：在 Java Web 开发中，FilterChain 使用责任链模式，多个过滤器按顺序处理 HTTP 请求。
日志框架：如 SLF4J 或 Log4j，日志级别通过责任链分发到不同处理器。
审批流程：如本文示例的请假审批，适用于多级审核的业务逻辑。

示例：Servlet Filter 中的责任链

public class AuthFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) {
        // 权限校验
        System.out.println("AuthFilter: 检查用户权限");
        // 传递给下一个过滤器
        chain.doFilter(request, response);
    }
}