L'architecture MVT de Django expliquée

Vous vous interrogez sur les différences entre les architectures MVT et MVC ? Vous ne savez pas ce que signifient ces termes ? Découvrez-le ici.

Le framework Web Django possède une architecture modèle-vue-modèle (MVT), ce qui en fait le seul framework dont vous aurez besoin pour créer un site Web ou une application Web complète. Ce framework Python vous permet de créer des modèles qui génèrent des bases de données et restituent des modèles HTML dynamiques à l'interface utilisateur à l'aide de vues.

La puissance de Django n’est pas un secret ; c'est rapide, fiable, évolutif et sécurisé. La fiabilité, ainsi que l'évolutivité de ce logiciel, reposent sur son architecture MVT. Et dans cet article, vous apprendrez exactement comment fonctionne l’architecture MVT de Django.

Quel est le modèle de Django ?

Le modèle de l'architecture MVT de Django définit la structure et le comportement des données que vous souhaitez stocker via votre site Web. Chaque modèle Django que vous créez génère une table de base de données correspondante, où chaque attribut du modèle devient un champ dans la table.

En poursuivant la configuration de notre article d'introduction sur Django, vous pouvez créer un modèle pour les vendeurs. Un vendeur peut avoir un modèle de vendeur contenant des informations personnelles, telles qu'un nom et des coordonnées, ainsi qu'un modèle associé pour les articles vendus par chaque vendeur.

L'exemple de structure de fichier de projet Django existant

mysite/
 mysite/
   _pycache_
   _init_.py
   asgi.py
   settings.py
   urls.py
   wsgi.py
 sellers/
   migration
   _init_.py
   admin.py
   apps.py
   models.py
   test.py
   views.py
 db.sqlite3
 manage.py

Création de modèles Django

Si vous regardez sous la section des applications des vendeurs dans la structure de fichiers ci-dessus, vous verrez un fichier appelé models.py. C’est ici que vous créerez tous vos modèles Django pour la section vendeurs de votre site Web. Chaque modèle que vous créez sera une sous-classe de l'API Model de Django, c'est pourquoi chaque fichier models.py généré par Django a une importation de modèles par défaut.

Le fichier models.py

From django.db import models

# Create your models here.

class Seller(models.Model):
first_name = models.CharField(max_length=30)
last_name = models.CharField(max_length=30)
contact_number = models.CharField(max_length=30)

class Product(models.Model):
seller = models.ForeignKey(Seller, on_delete=models.CASCADE)
item_name = models.CharField(max_length=100)
item_qantity = models.IntegerField()
item_price = models.DecimalField(max_digits=9, decimal_places=2)
item_description = models.TextField()

Le code ci-dessus est une copie du contenu mis à jour du fichier model.py. Le fichier crée désormais deux modèles : Vendeur et Produit. Ces modèles partagent une relation un-à-plusieurs, dans laquelle un vendeur peut proposer plusieurs produits en vente. Ainsi, le modèle Product possède une clé étrangère du vendeur et un attribut on_delete défini sur models.CASCADE, ce qui signifie que lorsque vous supprimez un vendeur, vous supprimerez automatiquement tous les produits qui ont cette clé primaire comme clé étrangère.

Avant de pouvoir utiliser un modèle que vous créez, vous devrez indiquer à Django où le trouver. Pour ce faire, vous devrez accéder au fichier settings.py et insérer le nom du module qui contient le fichier models.py dans le INSTALLED_APP.

Dans l'exemple de projet de cet article, le fichier models.py se trouve dans le module des vendeurs. Par conséquent, la section INSTALLED_APP mise à jour se lira comme suit :

INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'sellers',
]

Avec le code ci-dessus, les modèles de l'application des vendeurs sont désormais visibles sur le site Django, et vous pouvez désormais passer aux migrations.

Effectuer des migrations est important car ce processus est un moyen de diffuser les modifications que vous apportez dans vos modèles au schéma de base de données correspondant. Ainsi, chaque fois que vous apportez des modifications à votre modèle, vous devrez effectuer le processus de migration, qui comporte deux étapes.

La première étape consiste à effectuer des migrations, qui est une commande qui crée des migrations basées sur les modifications détectées dans le fichier models.py. Pour démarrer le processus de migration, vous devrez ouvrir votre terminal, accéder au répertoire contenant votre projet Django et lancer le serveur à l'aide de la commande suivante :

python manage.py runserver

Le serveur étant exécuté dans un terminal, ouvrez un nouveau terminal et entrez la commande suivante :

python manage.py makemigrations

Après exécution, le terminal produira le résultat suivant :

Migrations for 'sellers':
sellers\migrations\0001_initial.py
- Create model Seller
- Create model Product

Le résultat ci-dessus indique clairement que vous disposez désormais de migrations pour deux modèles : le vendeur et le produit. Maintenant, si vous accédez au dossier de migration dans le module de vos vendeurs, vous verrez qu'il contient désormais un nouveau fichier appelé 0001_initial.py. Dans ce fichier, vous trouverez les migrations que vous venez de créer.

Le fichier 0001_initial.py

# Generated by Django 3.2.9 on 2022-02-26 16:06

from django.db import migrations, models
import django.db.models.deletion

class Migration(migrations.Migration):

initial = True

dependencies = [
]

operations = [
migrations.CreateModel(
name='Seller',
fields=[
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('first_name', models.CharField(max_length=30)),
('last_name', models.CharField(max_length=30)),
('contact_number', models.CharField(max_length=30)),
],
),
migrations.CreateModel(
name='Product',
fields=[
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('item_name', models.CharField(max_length=100)),
('item_qantity', models.IntegerField()),
('item_price', models.DecimalField(decimal_places=2, max_digits=9)),
('item_description', models.TextField()),
('seller', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='sellers.seller')),
],
),
]

Chaque fois que vous effectuez une nouvelle migration, le dossier de migration génère une nouvelle version de ce fichier.

La deuxième étape du processus de migration consiste à migrer enfin les modèles. Cela signifie que vous synchronisez l'état de la base de données avec le fichier models.py, en utilisant les migrations que vous venez de créer dans le fichier 0001_initial.py. Vous pouvez terminer ce processus (pendant que le serveur est toujours en cours d'exécution) avec la commande suivante :

python manage.py migrate

Qu'est-ce que le modèle de Django ?

Les modèles sont un moyen de générer dynamiquement du HTML pour votre projet Django. Chaque modèle Django possède l'extension .html et une combinaison de contenu statique et dynamique. Les modèles Django ont une syntaxe unique qui inclut de nouvelles façons de créer des variables et des balises dans un document HTML.

Créer un modèle Django

Pour introduire des modèles dans l'exemple de site Web de commerce électronique pour cet article, vous devrez créer un nouveau répertoire dans le module des vendeurs. Ce nouveau répertoire appelé « modèles » accueillera tous les documents HTML de l'application des vendeurs, à commencer par la page d'accueil.

Le fichier sellers_home.html

<!DOCTYPE html>
<html lang="en">
<head>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Sellers | E-commerce</title>
</head>
<body>
<h1>Welcome Sellers!</h1>
</body>
</html>

Après avoir créé vos modèles, vous devrez les rendre visibles à Django en ajoutant le répertoire de vos modèles à la section TEMPLATES du fichier settings.py . La section MODÈLES mise à jour ressemblera à ce qui suit :

TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [
# new code that points to the location of the templates
BASE_DIR / 'sellers' / 'templates'
],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]

Maintenant que Django sait où trouver les modèles du site Web, vous pouvez les afficher dans l'interface utilisateur à l'aide de la vue.

Quel est le point de vue de Django ?

La vue est la deuxième couche de l'architecture MVT de Django, un modèle est inutile à moins qu'une vue ne le restitue à l'interface utilisateur. La vue est chargée d'accepter les requêtes Web et de renvoyer les réponses appropriées (y compris les modèles). Dans sa forme la plus basique, la vue est une fonction Python, stockée dans le fichier view.py de votre projet Django.

Création d'une vue Django

Le fichier view.py se trouve dans le module vendeurs de l'exemple de projet Django. Lorsqu’un vendeur visite votre site Web, vous souhaiterez qu’il accède à la page d’accueil d’un vendeur. Vous créerez cette page d’accueil à l’aide d’un modèle HTML, un peu comme celui créé dans la section modèle ci-dessus.

Le fichier view.py

from django.shortcuts import render

def index(request):
return render(request, 'sellers_home.html')

La vue ci-dessus prend une requête et renvoie le modèle HTML des vendeurs. Ainsi, chaque fois qu'un utilisateur visite (ou demande) http://127.0.0.1:8000/sellers/, il verra la page d'accueil des vendeurs. C'est après avoir créé un fichier urls.py dans le module des vendeurs.

Le fichier urls.py des vendeurs

from django.urls import path
from . import views

urlpatterns = [
path('', views.index, name='index'),
]

Et incluez le chemin d'accès au fichier urls.py du module vendeurs dans le fichier urls.py situé dans le répertoire principal de Django.

Le fichier urls.py du site Web

from django.contrib import admin
from django.urls import include, path

urlpatterns = [
path('sellers/', include('sellers.urls')),
path('admin/', admin.site.urls),
]

Maintenant que la vue est configurée, vous pouvez vous assurer que le serveur Django est toujours en cours d'exécution et accéder à http://127.0.0.1:8000/sellers/ dans votre navigateur pour voir la page d'accueil des vendeurs.

La page d'accueil des vendeurs

Architecture MVT de Django et architecture MVC

L'architecture MVT de Django est assez différente de l'architecture MVC populaire.

La section modèle de l'architecture MVT fonctionne à peu près de la même manière que la vue de l'architecture MVC, tandis que la vue de l'architecture MVT affiche des qualités similaires à celles du contrôleur de l'architecture MVC. Cependant, les modèles des deux architectures fonctionnent de manière identique.