Java设计模式之责任链模式

原创

刺槐儿

发布于 2024-02-04 21:06:53

4390

1. 什么是责任链模式？

责任链模式是一种行为设计模式，用于将请求的发送者和接收者解耦，并将多个处理器对象组合成一条链，依次处理请求。在责任链模式中，每个处理器对象都包含了处理请求的逻辑，并将请求传递给下一个处理器对象，直到请求被处理完成或到达链的末尾。责任链模式允许请求的发送者不需要知道请求的接收者是谁，而请求的接收者也不需要知道请求的发送者是谁，从而实现了请求的分发、处理和传递。

2. 责任链模式的结构

在Java中，责任链模式包含以下几个关键组件：

Handler（处理器）：定义一个处理器接口，其中包含处理请求的方法以及设置下一个处理器的方法。
ConcreteHandler（具体处理器）：实现处理器接口，并具体实现处理请求的逻辑，同时设置下一个处理器的引用。

3. 责任链模式的工作原理

在责任链模式中，每个处理器对象都包含了处理请求的逻辑，并将请求传递给下一个处理器对象，直到请求被处理完成或到达链的末尾。当一个处理器对象无法处理请求时，会将请求传递给下一个处理器对象，直到有处理器对象能够处理请求或者请求到达链的末尾。责任链模式允许请求的发送者不需要知道请求的接收者是谁，而请求的接收者也不需要知道请求的发送者是谁，从而实现了请求的分发、处理和传递。

4. 责任链模式的实现步骤

在Java中，实现责任链模式通常包括以下步骤：

定义处理器接口（Handler）：定义一个处理器接口，其中包含处理请求的方法以及设置下一个处理器的方法。
创建具体处理器类（ConcreteHandler）：实现处理器接口，并具体实现处理请求的逻辑，同时设置下一个处理器的引用。
构建责任链：将多个具体处理器对象按照一定的顺序组合成一条链。
使用责任链模式：根据具体业务需求，创建具体处理器对象，并将它们组合成一条链，在客户端代码中使用责任链模式处理请求。

5. 案例说明

接下来通过一个简单的例子来演示责任链模式的实现。假设我们有一个报销审批系统，其中包含了多个审批人，按照报销金额大小依次进行审批。

首先，我们定义处理器接口：

// Handler: Approver
public interface Approver {
    void processRequest(Expense expense);
    void setNextApprover(Approver nextApprover);
}

然后，创建具体处理器类：

// ConcreteHandler: TeamLeader
public class TeamLeader implements Approver {
    private Approver nextApprover;
    @Override
    public void processRequest(Expense expense) {
        if (expense.getAmount() <= 100) {
            System.println("Team leader approved the expense of $" + expense.getAmount());
        } else if (nextApprover != null) {
            nextApprover.processRequest(expense);
        } else {
            System.out.println("No one can approve the expense of $" + expense.getAmount());
        }
    }
    @Override
    public void setNextApprover(Approver nextApprover) {
        this.nextApprover = nextApprover;
    }
}

// ConcreteHandler: Manager
public class Manager implements Approver {
    private Approver nextApprover;
    @Override
    public void processRequest(Expense expense) {
        if (expense.getAmount() <= 1000) {
            System.out.println("Manager approved the expense of $" + expense.getAmount());
        } else if (nextApprover != null) {
            nextApprover.processRequest(expense);
        } else {
            System.out.println("No one can approve the expense of $" + expense.getAmount());
        }
    }
    @Override
    public void setNextApprover(Approver nextApprover) {
        this.nextApprover = nextApprover;
    }
}

// ConcreteHandler: FinancialManager
public class FinancialManager implements Approver {
    private Approver nextApprover;
    @Override
    public void processRequest(Expense expense) {
        if (expense.getAmount() <= 5000) {
            System.out.println("Financial manager approved the expense of $" + expense.getAmount());
        } else if (nextApprover != null) {
            nextApprover.processRequest(expense);
        } else {
            System.out.println("No one can approve the expense of $" + expense.getAmount());
        }
    }
    @Override
    public void setNextApprover(Approver nextApprover) {
        this.nextApprover = nextApprover;
    }
}

接下来，创建一个包含处理器对象的责任链：

// Client
public class Client {
    public static void main(String[] args) {
        Approver teamLeader = new TeamLeader();
        Approver manager = new Manager();
        Approver financialManager = new FinancialManager();

        // Build the chain of responsibility
        teamLeader.setNextApprover(manager);
        manager.setNextApprover(financialManager);

        // Test the chain
        Expense expense1 = new Expense(80);
        Expense expense2 = new Expense(800);
        Expense expense3 = new Expense(5000);
        Expense expense4 = new Expense(10000);

        teamLeader.processRequest(expense1);
        teamLeader.processRequest(expense2);
        teamLeader.processRequest(expense3);
        teamLeader.processRequest(expense4);
    }
}

在客户端代码中，我们创建了三个具体处理器对象（TeamLeader、Manager、FinancialManager），并将它们按照审批级别顺序组成了一条责任链。然后，我们创建了四个报销申请对象，并分别提交给责任链中的第一个处理器对象进行处理。处理结果将会依次传递给下一个处理器对象，直到找到合适的处理者或者到达责任链的末尾。

6. 责任链模式的优缺点

优点：

降低耦合度：责任链模式将请求的发送者和接收者解耦，使得处理器对象之间的关系更加灵活，从而降低了系统的耦合度。
灵活性和可扩展性：责任链模式允许动态地调整责任链的结构和顺序，从而提高了系统的灵活性和可扩展性。
简化对象：责任链模式将每个处理器对象的责任分散到多个对象中，使得每个对象的职责更加清晰明确，从而简化了对象的设计和实现。

缺点：

请求处理不确定性：责任链模式的处理顺序是不确定的，可能会导致请求被多个处理器对象处理或者没有处理，从而降低了系统的可控性。
性能影响：责任链模式需要遍历整个责任链来寻找合适的处理器对象，可能会影响系统的性能。

7. 使用场景

责任链模式适用于以下场景：

多个对象可以处理同一个请求：当一个请求可能由多个对象进行处理时，可以使用责任链模式将这些处理对象组合成一条链。
请求的发送者和接收者需要解耦：当请求的发送者和接收者之间存在紧耦合关系时，可以使用责任链模式将它们解耦，从而提高系统的灵活性。
动态地调整请求的处理顺序：当需要动态地调整请求的处理顺序时，可以使用责任链模式动态地添加、移除或调整处理器对象，从而提高系统的灵活性和可扩展性。

总结

责任链模式是一种非常有用的设计模式，可以帮助我们实现请求的分发、处理和传递。在Java中，责任链模式被广泛应用于各种领域，如权限验证、日志记录和异常处理等。合理地应用责任链模式可以使系统更加灵活、可扩展，并且更易于理解和维护。然而，在使用责任链模式时，需要注意设计好责任链的结构和顺序，避免出现请求处理不确定或性能影响的问题，从而保证模式的正确应用和系统的稳定性。

我正在参与2024腾讯技术创作特训营第五期有奖征文，快来和我瓜分大奖！

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

2024腾讯·技术创作特训营第五期

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

2024腾讯·技术创作特训营第五期

登录后参与评论

0 条评论

热度