1.行为模式-责任链模式 责任链模式 应用场景

责任链模式（Chain of Responsibility Pattern）

定义

责任链模式是一种行为型设计模式，它允许多个对象有机会处理请求，避免请求的发送者与接收者之间的耦合关系。将这些接收者连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。

核心思想

责任链模式的核心思想是将请求的处理分发给多个对象，但发送者不需要知道哪个对象最终会处理请求。每个对象都包含对下一个处理对象的引用，这样请求沿着链逐步传递，直到找到能够处理请求的对象。

组成部分

1. Handler（处理者）：定义了处理请求的接口，并包含一个指向下一个处理者的引用。
2. ConcreteHandler（具体处理者）：实现 Handler 接口，负责处理特定的请求。如果不能处理请求，它将请求转发给下一个处理者。
3. Client（客户端）：创建处理者链，并将请求发送给链的起始节点。

类图示例

   +--------------------+
  |      Handler        |
  +--------------------+
  | + setNext(handler)  |
  | + handleRequest()   |
  +--------------------+
           |
           v
  +--------------------+    +--------------------+
  | ConcreteHandlerA    |    | ConcreteHandlerB    |
  +--------------------+    +--------------------+
  | + handleRequest()   |    | + handleRequest()   |
  +--------------------+    +--------------------+
           |                      |
           v                      v
        (Next)                 (Next)

类图解释

• Handler（处理者）：定义了一个 handleRequest() 方法，用于处理请求，同时持有对下一个处理者的引用。
• ConcreteHandlerA/B（具体处理者）：实现了 Handler 接口，负责处理请求或将请求传递给下一个处理者。

代码示例

以下是责任链模式的简单实现代码：

// 处理者接口
abstract class Handler {
    protected Handler nextHandler;

    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public abstract void handleRequest(String request);
}

// 具体处理者A
class ConcreteHandlerA extends Handler {
    @Override
    public void handleRequest(String request) {
        if (request.equals("A")) {
            System.out.println("ConcreteHandlerA handled request: " + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

// 具体处理者B
class ConcreteHandlerB extends Handler {
    @Override
    public void handleRequest(String request) {
        if (request.equals("B")) {
            System.out.println("ConcreteHandlerB handled request: " + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();

        handlerA.setNextHandler(handlerB);  // 设置责任链

        handlerA.handleRequest("A");  // 由HandlerA处理
        handlerA.handleRequest("B");  // 由HandlerB处理
        handlerA.handleRequest("C");  // 无法处理
    }
}

代码解释

1. Handler 类：抽象类定义了 handleRequest() 方法，处理请求并包含对下一个处理者的引用。
2. ConcreteHandlerA/B：实现 Handler 接口，处理具体的请求。如果当前处理者无法处理请求，则将请求传递给下一个处理者。
3. Client：客户端创建了责任链（ConcreteHandlerA -> ConcreteHandlerB），并将请求发送到链的起始节点。

优点

1. 解耦请求的发送者和接收者：责任链模式将请求的发送者和处理者解耦，客户端不需要知道哪个处理者会处理请求。
2. 灵活的链结构：可以动态地添加或移除处理者，灵活组装责任链。
3. 简化请求对象：请求对象不需要包含处理逻辑，只负责将请求传递给责任链。

缺点

1. 可能导致请求未被处理：如果链条中的所有处理者都不能处理请求，可能会导致请求没有得到处理。
2. 性能问题：链条过长时，请求的传递可能会影响系统性能。

适用场景

1. 多对象可处理同一请求：有多个对象可以处理同一个请求，但具体由哪个对象处理由运行时动态决定。
2. 动态职责链：需要动态地构造职责链并灵活改变职责链结构时，适合使用责任链模式。
3. 不希望显式指定处理者：客户端不希望指定处理者，而希望处理者自己确定是否处理请求。

总结

责任链模式通过让多个对象组成一条链，来实现对请求的灵活处理。它可以避免请求发送者与处理者之间的紧耦合，提供了系统的灵活性。然而，需要注意责任链的合理设计，以避免请求未被处理或性能问题。