Django & l’Architecture MVT

Django
Développement
Web
Comprendre le framework web Django et son architecture Model-View-Template (MVT) : cycle de requête HTTP, séparation des responsabilités et simulation interactive.

Django est un framework web open-source en Python de haut niveau qui encourage un développement rapide et une conception propre et pragmatique. Créé pour répondre aux exigences des rédactions de presse web (d’où sa philosophie “Batteries incluses”), Django prend en charge la sécurité, l’authentification, l’administration et l’accès aux données dès son installation.

Au cœur de la structure de tout projet Django se trouve l’architecture MVT (Model-View-Template).

🏛️ L’Analogie du Restaurant : Comprendre le MVT

Pour bien appréhender le rôle de chaque composant, imaginons le fonctionnement d’un restaurant haut de gamme :

1.0.1. Le Modèle (Model)

Le Garde-Manger & la Réserve

Le Model gère les données de l’application. Il s’interface avec la base de données via l’ORM (Object-Relational Mapping) sans qu’il ne soit nécessaire d’écrire du SQL brut.

  • Structure et types de données.
  • Règles de validation et relations (1-N, N-N).
  • Opérations CRUD (Create, Read, Update, Delete).
1.0.2. La Vue (View)

Le Chef Cuisinier

La View contient la logique métier. Elle reçoit la requête du client, interroge le Model pour récupérer les ingrédients (données), puis prépare le plat.

  • Traitement de la requête HTTP.
  • Appel des méthodes du Model.
  • Sélection du Template approprié et transmission du contexte.
1.0.3. Le Template (Template)

Le Dressage de l’Assiette

Le Template s’occupe de la présentation visuelle. C’est un fichier HTML enrichi du langage de gabarit Django (DTL) qui affiche dynamiquement les données reçues de la Vue.

  • Structure HTML / CSS.
  • Variables et filtres ({ article.titre }).
  • Structures de contrôle ({% for item in liste %}).

Dans le modèle traditionnel MVC (Model-View-Controller) :

  • Le Controller reçoit la requête et pilote la logique.
  • La View affiche l’interface utilisateur.

En Django MVT :

  • Le rôle du Controller est pris en charge par le framework Django lui-même (le routeur d’URL urls.py et le middleware d’aiguillage).
  • La View Django correspond en réalité au Controller du MVC (gestion de la logique métier).
  • Le Template Django correspond à la View du MVC (rendu visuel HTML).

🔄 Le Cycle de Requête HTTP dans Django

Chaque interaction d’un utilisateur avec une application Django suit un cheminement strict et prévisible :

[Navigateur Client] ──(1. HTTP Request)──> [urls.py (URL Dispatcher)]
                                                    │
                                             (2. Routing)
                                                    ▼
[HTML Response] <──(5. Render HTML)── [views.py (View Logic)]
                                        │          ▲
                               (3. Query)    (4. Data)
                                        ▼          │
                                [models.py (ORM / DB)]
  1. Acheminement (URL Dispatcher) : La requête arrive dans urls.py. Django compare l’URL demandée aux motifs déclarés (URL patterns).
  2. Exécution de la Vue : L’URL associée pointe vers une fonction ou une classe dans views.py.
  3. Accès aux Données (ORM) : La Vue communique avec models.py pour lire ou modifier la base de données.
  4. Combinaison avec le Template : La Vue injecte les données (le contexte) dans un fichier HTML dans templates/.
  5. Réponse HTTP : Django génère le code HTML final et le renvoie au navigateur client avec un code statut HTTP (ex: 200 OK).

⚡ Simulateur Interactif : Exécution d’une Requête MVT

Ajustez les paramètres de la requête HTTP ci-dessous pour observer la chaîne de traitement complète du MVT Django en temps réel :

Simulateur de Pipeline Django MVT
Paramètres de la Requête Client
Journal d’Acheminement HTTP & MVT

[HTTP Request] \({inp_django_method}** `\){inp_django_url}` (Auth: ${inp_django_auth ? “Utilisateur Authentifié” : “Anonyme”}**)

  1. urls.py ──> Match pattern path('articles/<int:id>/', article_detail_view)
  2. views.py ──> Execution de article_detail_view(request, id=${inp_django_id})
  3. models.py ──> Query ORM: Article.objects.get(pk=${inp_django_id})
  4. templates/detail.html ──> Rendu DTL avec context { "article_id": ${inp_django_id}, "user": "${inp_django_auth ? "Alice" : "Guest"}" }
  5. HTTP Response ──> Status ${inp_django_method === “GET” ? “200 OK” : (inp_django_auth ? “201 Created / 200 OK” : “403 Forbidden”)}

💻 Structure du Code en Action

Voici comment les trois éléments s’articulent concrètement dans un projet Django :

Le fichier d’aiguillage des routes d’accès à l’application.

# mysite/urls.py
from django.urls import path
from . import views

urlpatterns = [
    # Route qui capture un paramètre dynamique 'id'
    path('articles/<int:id>/', views.article_detail, name='article_detail'),
]

La définition de la structure de données sous forme de classes Python (django.db.models.Model).

# blog/models.py
from django.db import models

class Article(models.Model):
    titre = models.CharField(max_length=200)
    contenu = models.TextField()
    date_publication = models.DateTimeField(auto_now_add=True)
    publie = models.BooleanField(default=True)

    def __str__(self):
        return self.titre

La fonction de vue qui fait le lien entre la base de données et le rendu HTML.

# blog/views.py
from django.shortcuts import render, get_object_or_404
from .models import Article

def article_detail(request, id):
    # 1. Interrogation du Model via l'ORM Django
    article = get_object_or_404(Article, pk=id, publie=True)

    # 2. Préparation du contexte (dictionnaire de données)
    context = {
        'article': article,
        'titre_page': f"Article : {article.titre}"
    }

    # 3. Transmission au Template HTML pour rendu
    return render(request, 'blog/article_detail.html', context)

Le fichier de présentation utilisant la syntaxe du Django Template Language (DTL).

<!-- blog/templates/blog/article_detail.html -->
{% extends "base.html" %}

{% block content %}
  <article class="article-container">
    <h1>{{ article.titre }}</h1>
    <p class="meta">Publié le {{ article.date_publication|date:"d F Y" }}</p>

    <div class="body">
      {{ article.contenu|linebreaks }}
    </div>
  </article>
{% endblock %}

🛡️ Les Avantages Sécurité Intégrés du MVT Django

La séparation MVT alliée à la philosophie de Django offre une protection par défaut contre les vulnérabilités web majeures :

Anti-Injection SQL

L’ORM Django paramètre automatiquement toutes les requêtes en base de données. L’utilisation de Article.objects.filter(titre=saisie_utilisateur) élimine totalement le risque d’injection SQL.

Protection XSS Native

Le moteur de Template (DTL) échappe automatiquement tous les caractères HTML dangereux dans les variables ({ variable }). Un script injecté s’affichera sous forme de texte brut sans s’exécuter.

Protection CSRF

Django requiert le jeton {% csrf_token %} dans tous les formulaires soumis en POST. Toute requête inter-site non authentifiée par ce jeton est rejetée instantanément avec une erreur 403.

💡 En Résumé : Les Commandes Clés à Retenir
  • python manage.py makemigrations : Génère les scripts SQL de migration à partir des modifications du models.py.
  • python manage.py migrate : Applique les migrations en base de données.
  • python manage.py runserver : Lance le serveur de développement local sur http://127.0.0.1:8000/.