Are middlewares an implementation of the Decorator pattern?

Question

In Django, there is the idea of Middleware. It consists of changing the requests and passing it down to the next middleware and so on, and doing the reverse with the responses.

Are middlewares implementation of the design pattern Decorator? Are they a particular case of the decorator? What are the differences between them?

Also, what is the difference between the implementation of Decorator in Django and the GoF description of it?

score 10 · Accepted Answer · answered Oct 26 '19 at 02:45

Middleware and decorators are similar and can do the same job. They provide a means of inserting intermediary effects either before or after other effects downstream in the chain/stack.

A difference is that the middleware pipeline is computed using a reduction that presents the middleware with a simpler interface that hides the next middleware object in the chain. Rather it presents a next function that applies the message to that object using the correct interface (e.g. IHandler.handle).

Another difference is that it is easier to dynamically add/remove middleware because it exists in the middle of a container object (e.g. in an array) and the pipeline can be assembled on demand. A decorator is a stack of Russian dolls and its stack cannot so easily be rejiggered.

score 1 · Answer 2 · answered Feb 09 '18 at 00:15

Middlewares are not themselves decorators but it is possible to make decorators out of middlewares using a couple of built in functions in Django:

def decorator_from_middleware(middleware_class):
"""
Given a middleware class (not an instance), return a view decorator. This
lets you use middleware functionality on a per-view basis. The middleware
is created with no params passed.
"""
    return make_middleware_decorator(middleware_class)()

def decorator_from_middleware_with_args(middleware_class):
"""
Like decorator_from_middleware, but return a function
that accepts the arguments to be passed to the middleware_class.
Use like::

     cache_page = decorator_from_middleware_with_args(CacheMiddleware)
     # ...

     @cache_page(3600)
     def my_view(request):
         # ...
"""
    return make_middleware_decorator(middleware_class)

As you said, in Django they are not the same. But in a more broad sense (not in Django) are in general middlewares implementation of the decorator pattern? — thyago stall, Feb 09 '18 at 12:23
Yes, I think so. Ultimately middlewares modify the view/controller function and wrap it like an onion, which is what decorators do. — Kevin L., Feb 09 '18 at 14:04

Are middlewares an implementation of the Decorator pattern?

2 Answers2