Django Comprendre le nouveau style du middleware Django 1.10


Exemple

Django 1.10 a introduit un nouveau style de middleware où process_request et process_response sont fusionnés.

Dans ce nouveau style, un middleware est un appelant qui renvoie un autre appelable . Eh bien, en réalité, le premier est une usine de middleware et le second est le véritable middleware .

La fabrique de middleware prend comme argument unique le middleware suivant dans la pile des middlewares, ou la vue elle-même lorsque le bas de la pile est atteint.

Le middleware prend la requête en argument unique et retourne toujours un HttpResponse .

Le meilleur exemple pour illustrer le fonctionnement de nouveaux middlewares est probablement de montrer comment créer un middleware à compatibilité descendante:

class MyMiddleware:

    def __init__(self, next_layer=None):
        """We allow next_layer to be None because old-style middlewares
        won't accept any argument.
        """
        self.get_response = next_layer

    def process_request(self, request):
        """Let's handle old-style request processing here, as usual."""
        # Do something with request
        # Probably return None
        # Or return an HttpResponse in some cases

    def process_response(self, request, response):
        """Let's handle old-style response processing here, as usual."""
        # Do something with response, possibly using request.
        return response

    def __call__(self, request):
        """Handle new-style middleware here."""
        response = self.process_request(request)
        if response is None:
            # If process_request returned None, we must call the next middleware or
            # the view. Note that here, we are sure that self.get_response is not
            # None because this method is executed only in new-style middlewares.
            response = self.get_response(request)
        response = self.process_response(request, response)
        return response