What do you know about decorators and their use as…

Decorators in Python are syntactic sugar for higher-order functions. They allow wrapping one function with another without changing its structure.

Example of a simple decorator:

def my_decorator(func):
    def wrapper():
        print("Something before calling the function.")
        func()
        print("Something after calling the function.")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

# Calling say_hello() actually calls the wrapper() function
# It executes code before and after calling say_hello()

Using decorators to implement middleware:

Middleware is a layer that processes requests and responses, situated between the web server and the application itself. In the context of Python frameworks (such as Django, Flask), middleware can perform tasks such as:

Authentication and authorization processing.
Logging requests.
Caching.
Error handling.
Modifying requests or responses.

Decorators are well-suited for creating middleware components that can be applied to individual view functions or classes.

Example of using a decorator for middleware (simplified):

def authentication_required(view_func):
    def wrapped_view(request, *args, **kwargs):
        if not request.user.is_authenticated:
            # Redirect to login page or return an error
            return HttpResponseForbidden("Authentication required")
        return view_func(request, *args, **kwargs)
    return wrapped_view

# In Django:
# @authentication_required
# def my_protected_view(request):
#    # Logic of the protected view
#    pass

# In Flask:
# @app.route('/protected')
# @authentication_required
# def protected_route():
#    # Logic of the protected route
#    pass

In more complex frameworks, middleware is often implemented as classes that implement a specific interface or inherit from a base middleware class. Nonetheless, the core principle remains the same — intercepting and modifying request/response processing. Decorators can be used to apply these middleware classes to functions or methods.

Advantages of using decorators for middleware:

Code cleanliness: Middleware logic is separated from the main function logic, making the code more readable.
Reusability: A single decorator can be applied to many functions or methods.
Composability: Multiple decorators can be stacked to create a chain of handlers.

Disadvantages:

It may be less flexible than class-based middleware, especially for complex scenarios.
The order of decorator application matters.

What do you know about decorators and their use as middleware?