【设计模式】【行为型模式（Behavioral Patterns）】之责任链模式（Chain of Responsibility Pattern）

1. 设计模式原理说明

责任链模式（Chain of Responsibility Pattern） 是一种行为设计模式，它允许你将请求沿着处理者链进行发送。每个处理者都可以处理请求，或者将其传递给链上的下一个处理者。这种模式使得多个对象都有机会处理请求，而无需提前指定具体的处理者。这样可以减少请求发送者和接收者之间的耦合。

主要角色

Handler（抽象处理者）：定义了一个处理请求的接口，通常包含一个后继连接，用于指向下一个处理者。
ConcreteHandler（具体处理者）：实现了处理请求的方法，判断是否处理该请求，如果不能处理则将请求转发给下一个处理者。
Client（客户端）：创建处理者对象并组织成一条链，向链中的第一个处理者提交请求。

2. UML 类图及解释

UML 类图

+-----------------+
|    Handler      |
|-----------------|
| - successor: Handler |
| - setSuccessor(successor: Handler) |
| - handleRequest(request: Request) |
+-----------------+
           ^
           |
           |
           v
+-----------------+
| ConcreteHandlerA|
|-----------------|
| - handleRequest(request: Request) |
+-----------------+
           ^
           |
           |
           v
+-----------------+
| ConcreteHandlerB|
|-----------------|
| - handleRequest(request: Request) |
+-----------------+

类图解释

Handler：定义了处理请求的接口，包含一个后继连接（successor），用于指向下一个处理者。
ConcreteHandlerA 和 ConcreteHandlerB：实现了处理请求的方法，判断是否处理该请求，如果不能处理则将请求转发给下一个处理者。
Client：创建处理者对象并组织成一条链，向链中的第一个处理者提交请求。

3. 代码案例及逻辑详解

Java 代码案例

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

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

    public abstract void handleRequest(int request);
}

// 具体处理者 A
class ConcreteHandlerA extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request >= 0 && request < 10) {
            System.out.println("ConcreteHandlerA handled request " + request);
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

// 具体处理者 B
class ConcreteHandlerB extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request >= 10 && request < 20) {
            System.out.println("ConcreteHandlerB handled request " + request);
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

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

        handlerA.setSuccessor(handlerB);

        handlerA.handleRequest(5);  // 应由 ConcreteHandlerA 处理
        handlerA.handleRequest(15); // 应由 ConcreteHandlerB 处理
        handlerA.handleRequest(25); // 没有处理者可以处理
    }
}

C++ 代码案例

#include <iostream>

// 抽象处理者
class Handler {
protected:
    Handler* successor;
public:
    void setSuccessor(Handler* successor) {
        this->successor = successor;
    }
    virtual void handleRequest(int request) = 0;
};

// 具体处理者 A
class ConcreteHandlerA : public Handler {
public:
    void handleRequest(int request) override {
        if (request >= 0 && request < 10) {
            std::cout << "ConcreteHandlerA handled request " << request << std::endl;
        } else if (successor != nullptr) {
            successor->handleRequest(request);
        }
    }
};

// 具体处理者 B
class ConcreteHandlerB : public Handler {
public:
    void handleRequest(int request) override {
        if (request >= 10 && request < 20) {
            std::cout << "ConcreteHandlerB handled request " << request << std::endl;
        } else if (successor != nullptr) {
            successor->handleRequest(request);
        }
    }
};

// 客户端
int main() {
    Handler* handlerA = new ConcreteHandlerA();
    Handler* handlerB = new ConcreteHandlerB();

    handlerA->setSuccessor(handlerB);

    handlerA->handleRequest(5);  // 应由 ConcreteHandlerA 处理
    handlerA->handleRequest(15); // 应由 ConcreteHandlerB 处理
    handlerA->handleRequest(25); // 没有处理者可以处理

    delete handlerA;
    delete handlerB;
    return 0;
}

Python 代码案例

# 抽象处理者
class Handler:
    def __init__(self):
        self.successor = None

    def set_successor(self, successor):
        self.successor = successor

    def handle_request(self, request):
        pass

# 具体处理者 A
class ConcreteHandlerA(Handler):
    def handle_request(self, request):
        if 0 <= request < 10:
            print(f"ConcreteHandlerA handled request {request}")
        elif self.successor is not None:
            self.successor.handle_request(request)

# 具体处理者 B
class ConcreteHandlerB(Handler):
    def handle_request(self, request):
        if 10 <= request < 20:
            print(f"ConcreteHandlerB handled request {request}")
        elif self.successor is not None:
            self.successor.handle_request(request)

# 客户端
if __name__ == "__main__":
    handlerA = ConcreteHandlerA()
    handlerB = ConcreteHandlerB()

    handlerA.set_successor(handlerB)

    handlerA.handle_request(5)  # 应由 ConcreteHandlerA 处理
    handlerA.handle_request(15) # 应由 ConcreteHandlerB 处理
    handlerA.handle_request(25) # 没有处理者可以处理

Go 代码案例

package main

import (
	"fmt"
)

// 抽象处理者
type Handler interface {
	setSuccessor(successor Handler)
	handleRequest(request int)
}

// 具体处理者 A
type ConcreteHandlerA struct {
	successor Handler
}

func (h *ConcreteHandlerA) setSuccessor(successor Handler) {
	h.successor = successor
}

func (h *ConcreteHandlerA) handleRequest(request int) {
	if request >= 0 && request < 10 {
		fmt.Printf("ConcreteHandlerA handled request %d\n", request)
	} else if h.successor != nil {
		h.successor.handleRequest(request)
	}
}

// 具体处理者 B
type ConcreteHandlerB struct {
	successor Handler
}

func (h *ConcreteHandlerB) setSuccessor(successor Handler) {
	h.successor = successor
}

func (h *ConcreteHandlerB) handleRequest(request int) {
	if request >= 10 && request < 20 {
		fmt.Printf("ConcreteHandlerB handled request %d\n", request)
	} else if h.successor != nil {
		h.successor.handleRequest(request)
	}
}

// 客户端
func main() {
	handlerA := &ConcreteHandlerA{}
	handlerB := &ConcreteHandlerB{}

	handlerA.setSuccessor(handlerB)

	handlerA.handleRequest(5)  // 应由 ConcreteHandlerA 处理
	handlerA.handleRequest(15) // 应由 ConcreteHandlerB 处理
	handlerA.handleRequest(25) // 没有处理者可以处理
}

4. 总结

责任链模式 是一种行为设计模式，它允许你将请求沿着处理者链进行发送。每个处理者都可以处理请求，或者将其传递给链上的下一个处理者。这种模式使得多个对象都有机会处理请求，而无需提前指定具体的处理者。通过这种方式，可以减少请求发送者和接收者之间的耦合。

主要优点

解耦：请求的发送者和接收者之间没有直接的耦合关系，提高了系统的灵活性。
增强可扩展性：可以动态地增加或改变处理者的数量和顺序，而不会影响客户端。
支持多个处理者：多个处理者可以依次处理同一个请求，增加了系统的灵活性和可配置性。

主要缺点

调试困难：由于请求的处理过程是动态的，调试时可能难以跟踪请求的处理路径。
性能开销：如果链过长，可能会导致性能下降，尤其是在每个处理者都需要执行某些操作时。

适用场景

当一个请求需要被多个对象中的一个或多个处理时。
当处理者的选择需要在运行时动态决定时。
当需要在不明确指定接收者的情况下，向多个对象中的一个发送请求时。
当需要创建一个可灵活配置的处理流程时。