What design pattern is used in middleware?

In middleware, the Chain of Responsibility design pattern is often used. This pattern allows requests to be passed along a chain of handlers, where each handler decides whether to process the request or pass it further. In the context of middleware, this is convenient for sequential processing of requests and responses, such as authentication, logging, error handling, etc.

Example in Python (simplified):

class Middleware:
    def __init__(self, next_middleware=None):
        self.next = next_middleware

    def handle(self, request):
        # process request
        if self.next:
            return self.next.handle(request)
        return None

class AuthMiddleware(Middleware):
    def handle(self, request):
        if not request.get('user'):
            return 'Unauthorized'
        return super().handle(request)

class LoggingMiddleware(Middleware):
    def handle(self, request):
        print(f"Request: {request}")
        return super().handle(request)

# Creating the chain
middleware = AuthMiddleware(LoggingMiddleware())
response = middleware.handle({'user': 'Alice'})