设计模式之——责任链模式

责任链模式(Chain of Responsibility)是一种行为型设计模式,它将请求的发送者和接收者解耦,形成一个处理请求的链条。每个接收者都有机会处理请求,直到请求被处理完成或者到达链条的末尾。

责任链模式主要解决的问题是将请求的发送者和接收者解耦,避免请求发送者与接收者之间的紧耦合关系。它可以使多个对象都有机会处理请求,从而灵活地组织和处理复杂的业务逻辑。

需要使用责任链模式的时候,通常有以下情况:

  1. 当有多个对象可以处理同一个请求时,并且具体由哪个对象处理请求在运行时决定。
  2. 当希望动态地组合和切换对象处理请求时,可以通过改变链条的顺序或者增加/移除链条中的处理者来实现。

假设你是一个团队的经理,你的团队需要向公司申请一笔经费。按照责任链模式,你首先会审查申请,如果金额超过你的审批权限,你会将申请转交给更高层级的领导,直到找到合适的领导来批准申请。在这个过程中,每个领导都有机会审批申请,直到申请被批准或者到达最高层级的领导。

责任链模式的优点包括:

  1. 解耦发送者和接收者:发送者不需要知道谁将会处理请求,而接收者也不需要知道请求的发送者是谁,从而实现解耦。
  2. 灵活性和可扩展性:可以动态地组合和切换处理者的顺序,增加或删除处理者,从而灵活地处理不同的请求。
  3. 可维护性:每个处理者只关注自己的责任范围,使得代码更加清晰、可读、可维护。

责任链模式也有一些缺点:

  1. 请求可能无法被处理:如果没有合适的处理者来处理请求,请求可能会到达链条的末尾而无法得到处理。
  2. 性能影响:由于请求需要在整个链条上传递,可能会对性能产生一定的影响。

适合使用责任链模式的场景包括:

  1. 当有多个对象可以处理同一请求,且具体由哪个对象处理在运行时确定时,可以使用责任链模式。
  2. 当希望动态地组合和切换对象来处理请求时,可以使用责任链模式。

下面是一个简单的代码示例,展示了责任链模式的使用:

// Request 类表示请求
class Request {
    private String content;
    private int amount;

    public Request(String content, int amount) {
        this.content = content;
        this.amount = amount;
    }

    public String getContent() {
        return content;
    }

    public int getAmount() {
        return amount;
    }
}

// Handler 抽象类表示处理者
abstract class Handler {
    protected Handler successor;

    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    public abstract void handleRequest(Request request);
}

// Manager 类表示经理
class Manager extends Handler {
    private int approvalLimit;

    public Manager(int approvalLimit) {
        this.approvalLimit = approvalLimit;
    }

    @Override
    public void handleRequest(Request request) {
        if (request.getAmount() <= approvalLimit) {
            System.out.println("Manager approves the request: " + request.getContent());
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

// Director 类表示主管
class Director extends Handler {
    private int approvalLimit;

   public Director(int approvalLimit) {
        this.approvalLimit = approvalLimit;
    }

    @Override
    public void handleRequest(Request request) {
        if (request.getAmount() <= approvalLimit) {
            System.out.println("Director approves the request: " + request.getContent());
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

// CEO 类表示首席执行官
class CEO extends Handler {
    @Override
    public void handleRequest(Request request) {
        System.out.println("CEO approves the request: " + request.getContent());
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Handler manager = new Manager(1000);
        Handler director = new Director(5000);
        Handler ceo = new CEO();

        manager.setSuccessor(director);
        director.setSuccessor(ceo);

        Request request1 = new Request("Expense reimbursement", 800);
        Request request2 = new Request("Project budget", 3000);
        Request request3 = new Request("New hire request", 10000);

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

在上面的示例中,我们使用责任链模式来处理不同的请求。

每个处理者(Manager、Director、CEO)都有一个审批限额,当请求的金额小于等于审批限额时,当前处理者可以处理请求;

否则,请求会传递给下一个处理者。

最终,请求会被合适的处理者处理或者到达链条的末尾。

通过使用责任链模式,我们可以灵活地组合和切换处理者的顺序,同时解耦了请求的发送者和接收者。

这样,我们可以动态地调整责任链,实现不同的处理逻辑,提高代码的灵活性和可维护性。

需要注意的是,责任链模式并不是要求所有请求都能被处理,而是将请求的处理分散到不同的处理者中,以提高灵活性和可扩展性。

posted @   苹果V  阅读(13)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· 一个费力不讨好的项目,让我损失了近一半的绩效!
· 清华大学推出第四讲使用 DeepSeek + DeepResearch 让科研像聊天一样简单!
· 实操Deepseek接入个人知识库
· CSnakes vs Python.NET:高效嵌入与灵活互通的跨语言方案对比
· Plotly.NET 一个为 .NET 打造的强大开源交互式图表库
点击右上角即可分享
微信分享提示