Using Python to Implement the Chain of Responsibility Pattern

The responsibility chain pattern is a behavior design pattern used to decouple the sender and receiver of a request, with each receiver containing the processing logic for the request and being able to decide whether to continue the request to the next recipient. The following is the complete sample code for implementing the responsibility chain pattern using 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() This code defines an abstract base class' Handler ', which all concrete processors need to inherit and implement`_ The handle () 'method is used to process the request` The 'Handler' class also includes a 'handle()' method, in which it first calls`_ The 'handle()' method is used to process the request. If the request has not been processed and the current processor has a successor processor, the 'handle()' method of the successor processor is called and the request is passed in sequence. The specific processor classes' ConcreteHandler1 ',' ConcreteHandler2 ', and' ConcreteHandler3 'handle requests in the range of 1-10, 11-20, and 21-30, respectively` DefaultHandler 'is a default processor that handles any request at the end of the responsibility chain. In the 'main()' function, we created the above processor instances and set their successor processors, then created a series of requests for testing. After running this code, the output result is: Request 1 handled by ConcreteHandler1 Request 15 handled by ConcreteHandler2 Request 25 handled by ConcreteHandler3 End of chain, no handler for 40 It can be seen that for requests within different scopes, they are correctly passed to the corresponding processors for processing. For requests that exceed the entire range, they are processed by the 'DefaultHandler' default processor.