深入了解Java设计模式之职责链模式

职责链模式是一种行为型设计模式，它允许你将请求沿着处理者链进行发送，直到其中一个处理者处理该请求。职责链模式常用于请求的处理流程较为复杂，有多个处理器时的情况。

定义

职责链模式为请求创建了一个接受者对象的链，给予请求的类型，对请求的发送者和接收者进行解耦。职责链模式将请求的发送者和接收者分离开来，只要在链上得到处理，就完成了一次请求的处理过程。

适用场景

职责链模式通常用于以下情况：
- 有多个对象可以处理请求，但不确定哪个对象处理
- 想要在不明确请求处理初始点的情况下，将请求的发送者和处理者解耦
- 有多个请求处理者，但不想明确请求接收者的情况下，向所有处理者发出请求

实现方法

职责链模式由多个处理者组成的链。每个处理者都包含处理请求的方法和下一个处理者的引用。如果当前处理者无法处理请求，它将从链上移除并将请求传递给下一个处理者。在请求到达最后一个处理者时，请求将不再被处理。因此，职责链的长度要视情况而定。

职责链模式的组件如下：
- 请求类：定义请求的结构
- 抽象处理者类：定义处理请求的接口和抽象处理方法
- 具体处理者类：实现抽象处理者接口和抽象处理方法，如果能够处理该种请求，则进行处理；否则，将请求转发给下一个处理者。

示例

下面是一个简单的职责链模式示例，如果请求的金额小于一万，则由CEO审批；如果大于等于一万小于一百万，则由CFO审批；如果大于等于一百万，则由BU主管审批。

请求类

请求类定义请求的结构，包括请求类型和请求金额。

public class Request {
    private String type;
    private double amount;

    public Request(String type, double amount) {
        this.type = type;
        this.amount = amount;
    }

    public String getType() {
        return type;
    }

    public double getAmount() {
        return amount;
    }
}

抽象处理者类

抽象处理者类定义处理请求的接口和抽象处理方法，同时持有下一个处理者的引用。

public abstract class Approver {
    protected Approver nextApprover;

    public void setNextApprover(Approver nextApprover) {
        this.nextApprover = nextApprover;
    }

    public abstract void processRequest(Request request);
}

具体处理者类

具体处理者类实现抽象处理者接口和抽象处理方法，如果能够处理该种请求，则进行处理；否则，将请求转发给下一个处理者。

public class CEO extends Approver {
    @Override
    public void processRequest(Request request) {
        if (request.getType().equals("purchase") && request.getAmount() < 10000) {
            System.out.println("CEO approved the request: " + request.getType() + ", Amount: " + request.getAmount());
        } else if (nextApprover != null) {
            nextApprover.processRequest(request);
        } else {
            System.out.println("No one can handle the request!");
        }
    }
}

public class CFO extends Approver {
    @Override
    public void processRequest(Request request) {
        if (request.getType().equals("purchase") && request.getAmount() >= 10000 && request.getAmount() < 1000000) {
            System.out.println("CFO approved the request: " + request.getType() + ", Amount: " + request.getAmount());
        } else if (nextApprover != null) {
            nextApprover.processRequest(request);
        } else {
            System.out.println("No one can handle the request!");
        }
    }
}

public class BUManager extends Approver {
    @Override
    public void processRequest(Request request) {
        if (request.getType().equals("purchase") && request.getAmount() >= 1000000) {
            System.out.println("BU Manager approved the request: " + request.getType() + ", Amount: " + request.getAmount());
        } else if (nextApprover != null) {
            nextApprover.processRequest(request);
        } else {
            System.out.println("No one can handle the request!");
        }
    }
}

调用示例

下面是一个调用职责链模式的示例：

public class ChainOfResponsibilityExample {
    public static void main(String[] args) {
        Approver ceo = new CEO();
        Approver cfo = new CFO();
        Approver buManager = new BUManager();
        ceo.setNextApprover(cfo);
        cfo.setNextApprover(buManager);

        Request request1 = new Request("purchase", 5000);
        ceo.processRequest(request1);

        Request request2 = new Request("purchase", 50000);
        ceo.processRequest(request2);

        Request request3 = new Request("purchase", 1000000);
        ceo.processRequest(request3);

        Request request4 = new Request("unknown", 1000000);
        ceo.processRequest(request4);
    }
}

输出结果如下：

CEO approved the request: purchase, Amount: 5000.0
CFO approved the request: purchase, Amount: 50000.0
BU Manager approved the request: purchase, Amount: 1000000.0
No one can handle the request!

总结

职责链模式是一种行为型设计模式，它可以创建一个请求处理链，使用了对象之间的链接来逐步递增处理请求，旨在拆分职责，降低耦合度，增加代码的灵活性和可扩展性。职责链模式非常适用于请求的处理流程比较复杂，有多个处理器时的情况。