Spring框架之责任链模式 (Chain of Responsibility Pattern)

news2024/11/14 12:50:45

责任链模式（Chain of Responsibility Pattern）详解

责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，旨在将请求的发送者和处理者解耦。它通过创建一条 处理请求的责任链，使得多个对象都有机会处理请求，从而避免了请求的发送者和处理者之间的紧耦合。责任链模式的核心思想是将请求沿着链传递，直到有一个对象处理它为止。

在责任链模式中，处理请求的对象（处理者）被组织成一个链条，链中的每个对象都负责对请求进行处理。如果当前对象不能处理请求，它将把请求传递给链中的下一个对象，直到请求被处理为止。

1. 责任链模式的定义

1.1 什么是责任链模式？

责任链模式通过将一系列的处理对象组成一条链，使得每个处理对象都有机会去处理请求。每个处理对象都包含指向下一个处理对象的引用，如果当前处理对象无法处理请求，它会将请求传递给链中的下一个对象，直到请求被某个处理对象处理为止。

1.2 责任链模式的关键思想

解耦请求发送者和请求处理者：请求的发送者并不直接知道具体由哪个处理者来处理请求，而是通过一条链来传递请求。
动态地调整请求的处理顺序：可以灵活地改变责任链中处理者的顺序，甚至可以动态地添加新的处理者。
每个处理者只关心自己能处理的请求：如果某个处理者无法处理请求，它将把请求传递给链中的下一个处理者。

2. 责任链模式的结构

责任链模式通常由以下角色构成：

Handler（处理者）：定义了一个接口或抽象类，声明了处理请求的方法，并持有对下一个处理者的引用。
ConcreteHandler（具体处理者）：实现了 Handler 接口，并定义了如何处理请求。如果当前处理者不能处理请求，它会将请求传递给链中的下一个处理者。
Client（客户端）：负责创建链并将请求传递给责任链的第一个处理者。

类图

    +------------------+        
    |    Handler       |        
    +------------------+        
    | + handleRequest()|        
    | + setNextHandler()|        
    +------------------+        
           ^                    
           |                    
    +------------------------+   
    | ConcreteHandlerA       |  
    +------------------------+  
    | + handleRequest()      |  
    | + setNextHandler()     |  
    +------------------------+   
           ^                    
           |                    
    +------------------------+   
    | ConcreteHandlerB       |  
    +------------------------+  
    | + handleRequest()      |  
    | + setNextHandler()     |  
    +------------------------+   
           ^                    
           |                    
    +------------------------+   
    | ConcreteHandlerC       |  
    +------------------------+  
    | + handleRequest()      |  
    | + setNextHandler()     |  
    +------------------------+

3. 责任链模式的实现

通过一个实际的例子来演示责任链模式的实现。假设我们有一个处理请求的系统，每个请求有一个不同的级别（如：低、中、高），我们希望根据请求的级别来选择处理它的处理者。

3.1 Java 示例代码

// 抽象处理者
abstract class Handler {
    protected Handler nextHandler;

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

    public abstract void handleRequest(int level);
}

// 具体处理者A
class ConcreteHandlerA extends Handler {
    @Override
    public void handleRequest(int level) {
        if (level <= 10) {
            System.out.println("ConcreteHandlerA处理请求，级别：" + level);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(level); // 转发请求
        }
    }
}

// 具体处理者B
class ConcreteHandlerB extends Handler {
    @Override
    public void handleRequest(int level) {
        if (level <= 20) {
            System.out.println("ConcreteHandlerB处理请求，级别：" + level);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(level); // 转发请求
        }
    }
}

// 具体处理者C
class ConcreteHandlerC extends Handler {
    @Override
    public void handleRequest(int level) {
        if (level <= 30) {
            System.out.println("ConcreteHandlerC处理请求，级别：" + level);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(level); // 转发请求
        }
    }
}

// 客户端代码
public class ChainOfResponsibilityPatternDemo {
    public static void main(String[] args) {
        // 创建责任链中的处理者
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();
        Handler handlerC = new ConcreteHandlerC();

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

        // 客户端发出请求
        System.out.println("请求级别为10：");
        handlerA.handleRequest(10); // 由A处理

        System.out.println("\n请求级别为15：");
        handlerA.handleRequest(15); // 由B处理

        System.out.println("\n请求级别为25：");
        handlerA.handleRequest(25); // 由C处理

        System.out.println("\n请求级别为35：");
        handlerA.handleRequest(35); // 没有处理者能处理该请求
    }
}

输出结果：

请求级别为10：
ConcreteHandlerA处理请求，级别：10

请求级别为15：
ConcreteHandlerB处理请求，级别：15

请求级别为25：
ConcreteHandlerC处理请求，级别：25

请求级别为35：
（无输出）

3.2 解释

ConcreteHandlerA 只能处理请求级别小于或等于 10 的请求。如果请求级别大于 10，它会将请求转发给 ConcreteHandlerB 处理。
ConcreteHandlerB 只能处理请求级别小于或等于 20 的请求，超过这个级别的请求会被转发给 ConcreteHandlerC。
ConcreteHandlerC 只能处理请求级别小于或等于 30 的请求。
如果请求级别超过 30，责任链中没有任何处理者可以处理此请求，系统将不会输出任何内容。

4. 责任链模式的应用场景

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

多个对象可以处理一个请求：当一个请求可以由多个对象中的任何一个对象来处理时，可以使用责任链模式来处理。例如：请求的处理依赖于请求的级别或类型。
请求处理者的顺序不确定：当请求处理的顺序可以灵活变化时，可以使用责任链模式。例如：日志记录系统中的不同日志级别处理器，日志处理器可以按优先级顺序链式连接。
请求的处理者不一定知道最终的处理者是谁：责任链模式通过将请求沿链传递，避免了请求发送者和处理者之间的紧耦合。
动态地为请求分配处理者：通过责任链模式，可以动态地改变请求的处理顺序，甚至添加新的处理者。