Chain of Responsibility Pattern

The Chain of Responsibility Pattern is a behavioral design pattern that allows an object to pass a request along a chain of potential handlers until one of them handles the request. This pattern decouples the sender and receiver of a request and promotes a more flexible design.

• **Handler**: An interface for handling requests.
• **ConcreteHandler**: Implements the Handler interface and handles requests.
• **Client**: Initiates the request and sends it to the chain of handlers.
• **Chain**: A sequence of handlers that can process requests.

The request is sent to the first handler in the chain. If the handler can process the request, it does so; otherwise, it forwards the request to the next handler in the chain until a handler processes the request or the end of the chain is reached.

graph TD;
    A[Client] --> B[Handler1]
    B -->|Can Handle| C[Handler2]
    C -->|Cannot Handle| D[Handler3]
    D -->|Final Handler| E[End]
            

Here is a simple implementation in Python:

class Handler:
    def set_next(self, handler):
        self.next_handler = handler
        return handler

    def handle(self, request):
        if self.next_handler:
            return self.next_handler.handle(request)
        return None

class ConcreteHandlerA(Handler):
    def handle(self, request):
        if request == "A":
            return "Handler A handled the request."
        else:
            return super().handle(request)

class ConcreteHandlerB(Handler):
    def handle(self, request):
        if request == "B":
            return "Handler B handled the request."
        else:
            return super().handle(request)

client = ConcreteHandlerA()
handler_b = ConcreteHandlerB()
client.set_next(handler_b)

print(client.handle("A"))  # Output: Handler A handled the request.
print(client.handle("B"))  # Output: Handler B handled the request.
print(client.handle("C"))  # Output: None
            

• Keep the chain flexible by allowing handlers to be added or removed.
• Ensure each handler is responsible for a specific type of request.
• Document the chain structure and responsibilities clearly.