Java责任链案例

本文目录导读：

1. 完整案例：请假审批系统
2. 进阶：Lambda表达式简化版
3. 关键要点

我来为你展示一个完整的Java责任链模式案例，以请假审批系统为例：

完整案例：请假审批系统

基础抽象类（处理器）

// 请假请求类
public class LeaveRequest {
    private String employeeName;
    private int leaveDays;
    private String reason;
    public LeaveRequest(String employeeName, int leaveDays, String reason) {
        this.employeeName = employeeName;
        this.leaveDays = leaveDays;
        this.reason = reason;
    }
    // getter/setter
    public String getEmployeeName() {
        return employeeName;
    }
    public int getLeaveDays() {
        return leaveDays;
    }
    public String getReason() {
        return reason;
    }
    @Override
    public String toString() {
        return "请假申请[员工=" + employeeName + ", 天数=" + leaveDays + 
               ", 原因=" + reason + "]";
    }
}

抽象处理器类

// 审批处理器抽象类
public abstract class Approver {
    protected Approver nextApprover;  // 下一个审批人
    protected String name;            // 审批人姓名
    public Approver(String name) {
        this.name = name;
    }
    // 设置下一个审批人
    public void setNextApprover(Approver nextApprover) {
        this.nextApprover = nextApprover;
    }
    // 获取下一个审批人
    public Approver getNextApprover() {
        return nextApprover;
    }
    // 审批方法（抽象方法，由具体实现类实现）
    public abstract void approve(LeaveRequest request);
    // 传递给下一个审批人
    protected void forwardToNext(LeaveRequest request) {
        if (nextApprover != null) {
            System.out.println(name + " 无法审批，转交给 " + nextApprover.name);
            nextApprover.approve(request);
        } else {
            System.out.println("没有更高审批人，申请被拒绝");
        }
    }
}

具体处理器实现类

// 部门经理（可审批3天以内的请假）
public class DepartmentManager extends Approver {
    public DepartmentManager(String name) {
        super(name);
    }
    @Override
    public void approve(LeaveRequest request) {
        if (request.getLeaveDays() <= 3) {
            System.out.println("部门经理 " + name + " 审批通过：" + request);
        } else {
            System.out.println("部门经理 " + name + " 审批不通过（请假天数超过3天）");
            forwardToNext(request);
        }
    }
}
// 总监（可审批7天以内的请假）
public class Director extends Approver {
    public Director(String name) {
        super(name);
    }
    @Override
    public void approve(LeaveRequest request) {
        if (request.getLeaveDays() <= 7) {
            System.out.println("总监 " + name + " 审批通过：" + request);
        } else {
            System.out.println("总监 " + name + " 审批不通过（请假天数超过7天）");
            forwardToNext(request);
        }
    }
}
// 总经理（可审批15天以内的请假）
public class GeneralManager extends Approver {
    public GeneralManager(String name) {
        super(name);
    }
    @Override
    public void approve(LeaveRequest request) {
        if (request.getLeaveDays() <= 15) {
            System.out.println("总经理 " + name + " 审批通过：" + request);
        } else {
            System.out.println("总经理 " + name + " 审批不通过（请假天数超过15天）");
            forwardToNext(request);
        }
    }
}
// 董事会（可审批30天以内的请假）
public class Board extends Approver {
    public Board(String name) {
        super(name);
    }
    @Override
    public void approve(LeaveRequest request) {
        if (request.getLeaveDays() <= 30) {
            System.out.println("董事会 " + name + " 审批通过：" + request);
        } else {
            System.out.println("董事会 " + name + " 审批拒绝：" + request);
            System.out.println("请假天数过长，申请被拒绝");
        }
    }
}

链的组装和使用

public class ResponsibilityChainDemo {
    public static void main(String[] args) {
        // 创建审批链
        Approver departmentManager = new DepartmentManager("张经理");
        Approver director = new Director("李总监");
        Approver generalManager = new GeneralManager("王总");
        Approver board = new Board("董事会");
        // 组装责任链
        departmentManager.setNextApprover(director);
        director.setNextApprover(generalManager);
        generalManager.setNextApprover(board);
        System.out.println("========== 责任链模式-请假审批系统 ==========\n");
        // 测试不同的请假申请
        System.out.println("【场景1】请假2天");
        LeaveRequest request1 = new LeaveRequest("张三", 2, "家中有事");
        departmentManager.approve(request1);
        System.out.println("\n【场景2】请假5天");
        LeaveRequest request2 = new LeaveRequest("李四", 5, "结婚");
        departmentManager.approve(request2);
        System.out.println("\n【场景3】请假10天");
        LeaveRequest request3 = new LeaveRequest("王五", 10, "出国旅游");
        departmentManager.approve(request3);
        System.out.println("\n【场景4】请假20天");
        LeaveRequest request4 = new LeaveRequest("赵六", 20, "项目间歇期休息");
        departmentManager.approve(request4);
        System.out.println("\n【场景5】请假35天");
        LeaveRequest request5 = new LeaveRequest("钱七", 35, "长期休假");
        departmentManager.approve(request5);
    }
}

运行结果

========== 责任链模式-请假审批系统 ==========
【场景1】请假2天
部门经理 张经理 审批通过：请假申请[员工=张三, 天数=2, 原因=家中有事]
【场景2】请假5天
部门经理 张经理 审批不通过（请假天数超过3天）
部门经理 张经理 无法审批，转交给 李总监
总监 李总监 审批通过：请假申请[员工=李四, 天数=5, 原因=结婚]
【场景3】请假10天
部门经理 张经理 审批不通过（请假天数超过3天）
部门经理 张经理 无法审批，转交给 李总监
总监 李总监 审批不通过（请假天数超过7天）
总监 李总监 无法审批，转交给 王总
总经理 王总 审批通过：请假申请[员工=王五, 天数=10, 原因=出国旅游]
【场景4】请假20天
部门经理 张经理 审批不通过（请假天数超过3天）
部门经理 张经理 无法审批，转交给 李总监
总监 李总监 审批不通过（请假天数超过7天）
总监 李总监 无法审批，转交给 王总
总经理 王总 审批不通过（请假天数超过15天）
总经理 王总 无法审批，转交给 董事会
董事会 董事会 审批通过：请假申请[员工=赵六, 天数=20, 原因=项目间歇期休息]
【场景5】请假35天
部门经理 张经理 审批不通过（请假天数超过3天）
部门经理 张经理 无法审批，转交给 李总监
总监 李总监 审批不通过（请假天数超过7天）
总监 李总监 无法审批，转交给 王总
总经理 王总 审批不通过（请假天数超过15天）
总经理 王总 无法审批，转交给 董事会
董事会 董事会 审批拒绝：请假申请[员工=钱七, 天数=35, 原因=长期休假]
请假天数过长，申请被拒绝

进阶：Lambda表达式简化版

import java.util.function.Function;
// 函数式接口版责任链
public class LambdaChainDemo {
    // 定义处理器函数式接口
    @FunctionalInterface
    interface Processor {
        boolean process(LeaveRequest request);
    }
    public static void main(String[] args) {
        // 创建审批处理器链
        Processor departmentManager = request -> {
            if (request.getLeaveDays() <= 3) {
                System.out.println("部门经理审批通过：" + request);
                return true;
            }
            return false;
        };
        Processor director = request -> {
            if (request.getLeaveDays() <= 7) {
                System.out.println("总监审批通过：" + request);
                return true;
            }
            return false;
        };
        Processor generalManager = request -> {
            if (request.getLeaveDays() <= 15) {
                System.out.println("总经理审批通过：" + request);
                return true;
            }
            return false;
        };
        Processor board = request -> {
            System.out.println("董事会最终审批：" + request);
            return request.getLeaveDays() <= 30;
        };
        // 组合责任链
        Processor chain = request -> {
            if (departmentManager.process(request)) return true;
            if (director.process(request)) return true;
            if (generalManager.process(request)) return true;
            return board.process(request);
        };
        // 模拟请求
        LeaveRequest req = new LeaveRequest("小明", 8, "家里有事");
        chain.process(req);
    }
}

关键要点

角色划分

• Handler（抽象处理器）：定义处理请求的接口
• ConcreteHandler（具体处理器）：实现具体的处理逻辑
• Client（客户端）：构建责任链并发送请求

优点

✅ 降低耦合度（请求者与处理者解耦） ✅ 增强灵活性（可以动态改变链成员或调整顺序） ✅ 增强可扩展性（新增处理器类很方便）

缺点

⚠️ 请求可能不被处理 ⚠️ 调试比较困难（需要追踪整个链） ⚠️ 可能影响性能（链过长时）

适用场景

• 多个对象可以处理同一请求
• 需要动态指定处理顺序
• 请求处理者不明确时

这个案例展示了责任链模式的经典用法,可以根据实际需求进行灵活调整！