23种设计模式中的责任链模式

允许多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个处理器处理该请求为止。

责任链模式是一种处理请求的模式。它让多个处理器都有机会处理请求，直到其中某个处理成功为止。责任链模式把多个请求连成一条链，让请求在这条链上传递。

在实际场景中，财务审批就是一个责任链模式。

我们来看看如何实现责任链模式。

我们创建抽象类Approver ，然后创建4种不同级别的审核者，都扩展了Approver 。每个审核者都会比较自己的审核额度，如果有权限审核就直接审核通过，否则，将不审核，直接把请求传递给下一个审核者。

创建抽象审批者。

// 抽象审批者
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 abstract void processRequest(PurchaseRequest request);
}

创建扩展了该抽象审批者的具体类。

// 部门经理 - 可以审批不超过5000元的采购
public class DepartmentManager extends Approver {
    public DepartmentManager(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getAmount() <= 5000) {
            System.out.printf("部门经理 %s 审批了采购单: %s, 金额: %.2f元\n", 
                              name, request.getPurpose(), request.getAmount());
        } else if (nextApprover != null) {
            nextApprover.processRequest(request);
        }
    }
}

// 总监 - 可以审批不超过20000元的采购
public class Director extends Approver {
    public Director(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getAmount() <= 20000) {
            System.out.printf("总监 %s 审批了采购单: %s, 金额: %.2f元\n", 
                              name, request.getPurpose(), request.getAmount());
        } else if (nextApprover != null) {
            nextApprover.processRequest(request);
        }
    }
}

// 副总裁 - 可以审批不超过100000元的采购
public class VicePresident extends Approver {
    public VicePresident(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getAmount() <= 100000) {
            System.out.printf("副总裁 %s 审批了采购单: %s, 金额: %.2f元\n", 
                              name, request.getPurpose(), request.getAmount());
        } else if (nextApprover != null) {
            nextApprover.processRequest(request);
        }
    }
}

// 总裁 - 可以审批任何金额的采购
public class President extends Approver {
    public President(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest request) {
        System.out.printf("总裁 %s 审批了采购单: %s, 金额: %.2f元\n", 
                          name, request.getPurpose(), request.getAmount());
    }
}

采购请求类。

// 采购请求
public class PurchaseRequest {
    private double amount;  // 采购金额
    private String purpose; // 采购目的

    public PurchaseRequest(double amount, String purpose) {
        this.amount = amount;
        this.purpose = purpose;
    }

    public double getAmount() {
        return amount;
    }

    public String getPurpose() {
        return purpose;
    }
}

测试示例。

public class PurchaseApprovalDemo {
    public static void main(String[] args) {
        // 创建审批人
        Approver manager = new DepartmentManager("张经理");
        Approver director = new Director("李总监");
        Approver vp = new VicePresident("王副总裁");
        Approver president = new President("赵总裁");

        // 设置责任链
        manager.setNextApprover(director);
        director.setNextApprover(vp);
        vp.setNextApprover(president);

        // 创建采购请求
        PurchaseRequest request1 = new PurchaseRequest(4500, "购买办公用品");
        PurchaseRequest request2 = new PurchaseRequest(12000, "团队建设活动");
        PurchaseRequest request3 = new PurchaseRequest(50000, "服务器设备升级");
        PurchaseRequest request4 = new PurchaseRequest(150000, "新办公室装修");

        // 处理采购请求
        System.out.println("===== 采购审批流程开始 =====");
        manager.processRequest(request1);
        manager.processRequest(request2);
        manager.processRequest(request3);
        manager.processRequest(request4);
        System.out.println("===== 采购审批流程结束 =====");
    }
}

这种模式在实际业务中非常常见，如工作流审批、客户服务请求处理、异常处理流程等。

总结

责任链模式是一种把一个或多个处理器组合在一起，依次处理请求的模式。

责任链模式的优势是添加新的处理器或调整处理器顺序非常容易。