2021年10月9日-设计模式之责任链模式

作为学生会某部门干事，现在需要递交经费申请请求。经费如果数额不大的话就由部长审批，如果数额较大需找主席审批，如果数额很大需找辅导员审批。

我们可以选择 if 语句来解决这个问题，首先我们自己根据数额判断一下应该找谁审批，然后把这个请求给他。

不过，问题来了，如果申请人我不知道数额标准怎么办。比如你不能要求每个去政府机构办事的公民都熟读办事标准吧！所以能不能将请求和处理请求之间解耦呢(+_+)?

现在我们使用责任链模式重新解决这个问题。申请人我直接吧请求给部长或者主席或者辅导员，至于谁来处理我不关心，因为这是他们的事。

• Handler 抽象处理者，声明了处理请求的方法。里面聚合了另一个处理者，众多处理者就形成了处理链

抽象处理者类：

public abstract class Approver {
    protected Approver approver;

    public void setApprover(Approver approver) {
        this.approver = approver;
    }

    abstract public void processRequest(PurchaseRequest request);
}

具体的处理者：

public class Chairman extends Approver{
    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getPrice() >= 200 && request.getPrice() < 300) {
            System.out.println("主席处理请求：" + request);
        } else {
            super.approver.processRequest(request);
        }
    }
}

public class Counsellor extends Approver {
    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getPrice() >= 0 && request.getPrice() < 100) {
            System.out.println("辅导员处理请求：" + request);
        } else {
            super.approver.processRequest(request);
        }
    }
}

public class Minister extends Approver {
    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getPrice() >= 100 && request.getPrice() < 200) {
            System.out.println("部长处理请求：" + request);
        } else {
            super.approver.processRequest(request);
        }
    }
}

public class ViceMinister extends Approver{
    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getPrice() >= 0 && request.getPrice() < 100) {
            System.out.println("副部长处理请求：" + request);
        } else {
            super.approver.processRequest(request);
        }
    }
}

请求类

public class PurchaseRequest {
    private int id;
    private float price;

    public PurchaseRequest(int id, float price) {
        this.id = id;
        this.price = price;
    }

    public int getId() {
        return id;
    }

    public float getPrice() {
        return price;
    }

    @Override
    public String toString() {
        return "PurchaseRequest{" +
                "id=" + id +
                ", price=" + price +
                '}';
    }
}

测试类

public class DutyChainTest {
    public static void main(String[] args) {
        ViceMinister viceMinister = new ViceMinister();
        Minister minister = new Minister();
        Chairman chairman = new Chairman();
        Counsellor counsellor = new Counsellor();
        // 形成一个环
        viceMinister.setApprover(minister);
        minister.setApprover(chairman);
        chairman.setApprover(counsellor);
        counsellor.setApprover(viceMinister);

        PurchaseRequest request = new PurchaseRequest(1, 250);
        viceMinister.processRequest(request);
    }
}

优点：

• 请求和处理分开，实现解耦

缺点：

• 当链比较长时，性能会受到影响，所以新增节点时需要判断链的节点是否过多
• 调试不方便

应用场景：

• 有多个对象可以处理一个请求时