1. 职责链模式（Chain of Responsibility Pattern）是一种行为型设计模式，它通过将一个请求的发送者和接收者解耦，使多个对象都有机会处理这个请求。将这些对象串成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。 2. 适用场景： - 当多个对象可以处理同一请求，并且具体哪个对象处理该请求是在运行时确定时，可以使用职责链模式。 - 当希望由多个对象都有机会处理请求，而不是仅有一个确定的处理者时，可以使用职责链模式。 - 当需要在不明确接收者的情况下，向多个对象中的一个提交一个请求时，可以使用职责链模式。 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 { public void handleRequest(int request) { if (request >= 0 && request < 10) { System.out.println("ConcreteHandlerA处理请求 " + request); } else if (successor != null) { successor.handleRequest(request); } } } // 具体处理者B class ConcreteHandlerB extends Handler { public void handleRequest(int request) { if (request >= 10 && request < 20) { System.out.println("ConcreteHandlerB处理请求 " + request); } else if (successor != null) { successor.handleRequest(request); } } } // 具体处理者C class ConcreteHandlerC extends Handler { public void handleRequest(int request) { if (request >= 20 && request < 30) { System.out.println("ConcreteHandlerC处理请求 " + request); } else if (successor != null) { successor.handleRequest(request); } } } // 测试代码 public class Main { public static void main(String[] args) { // 构建职责链 Handler handlerA = new ConcreteHandlerA(); Handler handlerB = new ConcreteHandlerB(); Handler handlerC = new ConcreteHandlerC(); handlerA.setSuccessor(handlerB); handlerB.setSuccessor(handlerC); // 发送请求 int[] requests = {5, 15, 25}; for (int request : requests) { handlerA.handleRequest(request); } } } 输出结果： ConcreteHandlerA处理请求 5 ConcreteHandlerB处理请求 15 ConcreteHandlerC处理请求 25 以上代码中，定义了抽象处理者（Handler）及其三个具体处理者（ConcreteHandlerA、ConcreteHandlerB和ConcreteHandlerC），每个具体处理者都有一个后继处理者（successor）。 在测试代码中，构建了一个职责链，并发送了三个不同的请求。根据请求的值，职责链中的处理者依次处理请求。请求的值小于10由ConcreteHandlerA处理，大于等于10小于20由ConcreteHandlerB处理，大于等于20小于30由ConcreteHandlerC处理。如果某个处理者不能处理请求，则将请求传递给下一个处理者，直到有处理者处理该请求或职责链结束。

职责链模式是一种行为设计模式，用于将请求的发送者和接收者解耦，每个接收者都包含了对请求的处理逻辑并能决定是否将请求继续传递到下一个接收者。 下面是使用Python实现职责链模式的完整样例代码： ```python class Handler: def __init__(self, successor=None): self.successor = successor def handle(self, request): handled = self._handle(request) if not handled and self.successor: self.successor.handle(request) def _handle(self, request): raise NotImplementedError('Must provide implementation in subclass') class ConcreteHandler1(Handler): def _handle(self, request): if 0 < request <= 10: print(f'Request {request} handled by ConcreteHandler1') return True return False class ConcreteHandler2(Handler): def _handle(self, request): if 10 < request <= 20: print(f'Request {request} handled by ConcreteHandler2') return True return False class ConcreteHandler3(Handler): def _handle(self, request): if 20 < request <= 30: print(f'Request {request} handled by ConcreteHandler3') return True return False class DefaultHandler(Handler): def _handle(self, request): print(f'End of chain, no handler for {request}') return True def main(): handler1 = ConcreteHandler1() handler2 = ConcreteHandler2() handler3 = ConcreteHandler3() default_handler = DefaultHandler() handler1.successor = handler2 handler2.successor = handler3 handler3.successor = default_handler requests = [1, 15, 25, 40] for request in requests: handler1.handle(request) if __name__ == '__main__': main() ``` 该代码定义了一个抽象基类`Handler`，所有具体处理器都需要继承它，并实现`_handle()`方法来处理请求。`Handler`类还包含了一个`handle()`方法，在该方法中它首先调用`_handle()`方法来处理请求，如果请求没有被处理并且当前处理器有后继处理器，则调用后继处理器的`handle()`方法，依次传递请求。 具体处理器类`ConcreteHandler1`、`ConcreteHandler2`和`ConcreteHandler3`分别处理范围在1-10、11-20和21-30之间的请求。`DefaultHandler`是一个默认处理器，在职责链的末尾，它会处理任意请求。 在`main()`函数中，我们创建了以上的处理器实例并设置好它们的后继处理器，然后创建一系列的请求进行测试。运行该代码后，输出结果为： ``` Request 1 handled by ConcreteHandler1 Request 15 handled by ConcreteHandler2 Request 25 handled by ConcreteHandler3 End of chain, no handler for 40 ``` 可以看到，对于不同范围内的请求，它们被正确地传递到了相应的处理器来处理。而对于超出全部范围的请求，被`DefaultHandler`默认处理器处理。