Intégration des données de requête dans Django avec un middleware personnalisé

Ce guide détaille la création d'un middleware Django pour centraliser la récupération des données de requête, qu'elles soient au format JSON, x-www-form-urlencoded ou multipart/form-data, et les rendre accessibles via request.data.

Mise en place du middleware

Pour implémenter cette fonctionnalité, suivez ces étapes :

  1. Créez un fichier Python dans l'une de vos applications Django pour héberger votre middleware personnalisé. Ce middleware doit hériter de MiddlewareMixin.
  2. Définissez la méthode process_request dans votre classe de middleware. Cette méthode sera responsable de l'analyse du corps de la requête et de l'assignation des données à l'attribut request.data.
  3. Enregistrez votre middleware personnalisé dans le fichier settings.py de votre projet en l'ajoutant à la liste MIDDLEWARE.

Implémentation du middleware (middlewares.py)

Le code suivant illustre comment un middleware peut gérer différents types de données de requête :


import json
from django.utils.deprecation import MiddlewareMixin

class ParseRequestData(MiddlewareMixin):
    def process_request(self, request):
        try:
            # Tente de décoder le corps de la requête comme JSON
            request.data = json.loads(request.body)
        except json.JSONDecodeError:
            # Si le décodage JSON échoue, utilise les données POST
            # Ceci gère les formats urlencoded et multipart/form-data
            request.data = request.POST.dict() if request.POST else {}
        except Exception:
            # Gère toute autre exception inattendue
            request.data = {}

Explication du comportement :

  • Si les données envoyées sont au format JSON, request.body les contient directement. La fonction json.loads les désérialise en un dictionnaire Python.
  • Si les données sont encodées en application/x-www-form-urlencoded ou multipart/form-data (comme lors d'une soumission de formulaire HTML classique ou d'une requête AJAX sans spécifier contentType: 'application/json'), la tentative de décodage JSON échouera. Dans ce cas, les données sont récupérées depuis request.POST et converties en dictionnaire.
  • Pour les autres types de requêtes ou en cas d'erreur, request.data sera initialisé comme un dictionnaire vide.

Configuration dans settings.py

Assurez-vous d'ajouter votre middleware à la liste MIDDLEWARE. L'ordre est important ; placez-le généralement après les middlewares de sécurité et d'authentification, mais avant ceux qui pourriaent dépendre de request.data.


# settings.py

MIDDLEWARE = [
    # ... autres middlewares
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    # Votre middleware personnalisé
    'your_app_name.middlewares.ParseRequestData',
    # ... autres middlewares
]

Exemple d'utilisation dans les vues (views.py)

Une fois le middleware configuré, vous pouvez accéder aux données de la requête via request.data dans vos vues.


from django.shortcuts import render
from django.http import HttpResponse

def process_data_view(request):
    if request.method == 'POST':
        print(f"Données POST brutes : {request.POST}")
        print(f"Corps de la requête brut : {request.body}")
        print(f"Données traitées via request.data : {request.data}")
        return HttpResponse("Données reçues avec succès !", status=200)
    
    # Pour les requêtes GET, request.data sera vide ou contiendra des paramètres GET si gérés différemment
    print(f"Données GET via request.data : {request.data}")
    return render(request, 'data_form.html')

Exemple de template HTML (data_form.html)

Ce template montre comment envoyer des données soit via un formulaire HTML classique, soit via une requête AJAX.



<html lang="fr">
<head>
    <meta charset="UTF-8">
    <title>Test Middleware Data</title>
    <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
</head>
<body>
    <h1>Soumission de données</h1>

    <!-- Formulaire HTML classique (envoie en urlencoded) -->
    <form id="form-html" method="post" action="">
        <p>
            Nom d'utilisateur : <input type="text" name="username_html" id="id_username_html">
        </p>
        <p>
            Mot de passe : <input type="password" name="password_html" id="id_password_html">
        </p>
        <button type="submit">Soumettre (Formulaire HTML)</button>
    </form>

    <hr>

    <!-- Bouton pour soumettre via AJAX (envoie en JSON) -->
    <p>
        Nom d'utilisateur : <input type="text" id="id_username_ajax">
    </p>
    <p>
        Mot de passe : <input type="password" id="id_password_ajax">
    </p>
    <button id="submit-ajax">Soumettre (AJAX JSON)</button>

    <script>
        $('#submit-ajax').click(function() {
            const userData = {
                username: $('#id_username_ajax').val(),
                password: $('#id_password_ajax').val()
            };
            $.ajax({
                url: '', // L'URL actuelle
                type: 'POST',
                contentType: 'application/json',
                data: JSON.stringify(userData),
                success: function(response) {
                    alert('Réponse AJAX : ' + response);
                },
                error: function(xhr, status, error) {
                    alert('Erreur AJAX : ' + error);
                }
            });
        });
    </script>
</body>
</html>

En configurant ce middleware, vous centralisez la gestion des formats de données entrants, simplifiant ainsi le code de vos vues et assurant une uniformité dans l'accès aux informations transmises par le client.

Étiquettes: Django middleware request JSON AJAX

Publié le 28 juin à 20h05

Étiquettes Populaires

©2026 L'Atelier Monstre