Concepts fondamentaux de Django : ORM, Sessions, et Cookies

1.1 Opérations de base

L'ORM établit une correspondance entre les objets de votre code et les tables de votre base de données. Cette abstraction permet de manipuler des données comme des objets Python, ce qui améliore considérablement l'efficacité du développement au détriment d'une légère perte de performance potentielle lors de l'exécution des requêtes SQL générées.

Les étapes clés pour utiliser l'ORM dans Django sont :

• Configuration de la base de données : Modifiez le fichier settings.py pour spécifier les détails de votre connexion à la base de données.
• Enregistrement de l'application : Ajoutez le nom de votre application dans la liste INSTALLED_APPS dans settings.py.
• Définition des modèles : Créez des classes dans le fichier models.py de votre application pour représenter vos tables de base de données.
• Exécution des commandes de migration :
  • python manage.py makemigrations : Génère les fichiers de migration basés sur les modifications de vos modèles.
  • python manage.py migrate : Applique les migrations à la base de données en exécutant le SQL correspondant.

1.2 Connexion à la base de données

La configuration de la base de données se fait dans settings.py. Voici des exemples pour SQLite et MySQL :

DATABASES = {
   'default': {
       'ENGINE': 'django.db.backends.sqlite3',
       'NAME': BASE_DIR / 'db.sqlite3',
   }
}
       

DATABASES = {
   'default': {
       'ENGINE': 'django.db.backends.mysql',
       'NAME': 'nom_base_de_donnees',
       'USER': 'utilisateur',
       'PASSWORD': 'mot_de_passe',
       'HOST': '127.0.0.1',
       'PORT': 3306,
   }
}
       

Connexion à MySQL :

Pour utiliser MySQL, vous devez installer le connecteur approprié (pymysql ou mysqlclient) et configurer votre projet.

• Installation : pip install pymysql ou pip install mysqlclient.

• Configuration (pour pymysql, dans le fichier __init__.py de votre projet) : ```python

  import pymysql pymysql.install_as_MySQLdb()

Autres bases de données :

Django supporte d'autres SGBD comme PostgreSQL et Oracle, nécessitant l'installation de bibliothèques supplémentaires (ex: psycopg2 pour PostgreSQL).

1.3 Pool de connexions

Django ne fournit pas de pool de connexions intégré. Des bibliothèques tierces comme django-db-connection-pool peuvent être utilisées pour gérer un pool de connexions afin d'améliorer les performances lors d'accès fréquents à la base de données.

# Installation
pip install django-db-connection-pool

# Configuration dans settings.py
DATABASES = {
   "default": {
       'ENGINE': 'dj_db_conn_pool.backends.mysql', # Ou le backend approprié
       'NAME': 'nom_base_de_donnees',
       'USER': 'utilisateur',
       'PASSWORD': 'mot_de_passe',
       'HOST': '127.0.0.1',
       'PORT': 3306,
       'POOL_OPTIONS': {
           'POOL_SIZE': 10,
           'MAX_OVERFLOW': 10,
           'RECYCLE': 24 * 60 * 60,
           'TIMEOUT': 30,
       }
   }
}
       

1.4 Gestion de bases de données multiples

Django permet de configurer et d'utiliser plusieurs bases de données au sein d'un même projet.

1.4.1 Répartition lecture/écriture

Il est possible de diriger les opérations de lecture vers une base de données (ex: une réplique) et les opérations d'écriture vers une autre (la base principale).

• Configuration des bases de données dans settings.py avec des alias distincts (ex: default et bak).
• Application des migrations spécifiques : python manage.py migrate --database=default et python manage.py migrate --database=bak.
• Utilisation explicite : .objects.using("default")... pour l'écriture, .objects.using("bak")... pour la lecture.
• Pour simplifier, un DATABASE_ROUTER peut être configuré dans settings.py pour diriger automatiquement les requêtes.

1.4.2 Distribution par application

Différentes applications peuvent être associées à différentes bases de données. Les migrations doivent être appliquées explicitement par application et par base de données.

# Exemple dans une vue
from app01 import models as models_app1
from app02 import models as models_app2

def ma_vue(request):
   # Opérations sur app01 (base 'default')
   donnees_app1 = models_app1.MonModele.objects.all()

   # Opérations sur app02 (base 'bak')
   donnees_app2 = models_app2.AutreModele.objects.using('bak').all()
   return HttpResponse("Vue exécutée")
       

1.4.3 Distribution au sein d'une même application

Même pour les modèles d'une seule application, il est possible de les répartir sur différentes bases de données en utilisant la méthode .using() ou via un DATABASE_ROUTER.

1.4.4 Considérations importantes

• Évitez les jointures entre des tables situées dans des bases de données différentes, car Django ne les supporte pas nativement. Regroupez autant que possible les tables liées dans la même base de données.
• La répartition des tables sur plusieurs bases de données est utile pour gérer de grands volumes de données et améliorer la scalabilité.

1.5 Relations entre tables

Django ORM supporte nativement les relations un-à-un, un-à-plusieurs et plusieurs-à-plusieurs.

• Un-à-plusieurs : Géré avec ForeignKey.
• Plusieurs-à-plusieurs : Géré avec ManyToManyField. Django crée une table intermédiaire pour gérer cette relation.
• Un-à-un : Géré avec OneToOneField, similaire à ForeignKey mais avec une contrainte d'unicité.

Exemple de relation plusieurs-à-plusieurs avec une table entermédiaire personnalisée :

class Garcon(models.Model):
   nom = models.CharField(max_length=32, unique=True)

class Fille(models.Model):
   nom = models.CharField(max_length=32, unique=True)

class RelationGarconFille(models.Model):
   garcon_id = models.ForeignKey(Garcon, on_delete=models.CASCADE)
   fille_id = models.ForeignKey(Fille, on_delete=models.CASCADE)
   lieu = models.CharField(max_length=32)
       

2. Sessions et Cookies

Django fournit des mécenismes robustes pour gérer les sessions utilisateur et les cookies, essentiels pour maintenir l'état entre les requêtes HTTP.

2.1 Cookies

Les cookies sont de petits morceaux de données stockés sur le navigateur du client. Ils sont couramment utilisés pour stocker des informations d'identification, des préférences utilisateur ou des identifiants de session.

• Envoi de cookies : Utilisez response.set_cookie('nom_cookie', 'valeur_cookie', max_age=3600).
• Lecture de cookies : Accédez aux cookies via request.COOKIES.get('nom_cookie').
• Suppression de cookies : Utilisez response.delete_cookie('nom_cookie').

2.2 Sessions

Le framework de session de Django permet de stocker des données côté serveur associées à un utilisateur spécifique, généralement identifié par un cookie de session unique.

• Activation : Assurez-vous que 'django.contrib.sessions' est dans INSTALLED_APPS et que les MIDDLEWARE nécessaires (SessionMiddleware) sont activés.
• Stockage : Les données de session peuvent être stockées dans la base de données (par défaut), dans des fichiers ou dans un cache comme Redis ou Memcached pour de meilleures performances. La configuration se fait dans settings.py (SESSION_ENGINE).
• Utilisation :
  • Pour définir une donnée de session : request.session['cle'] = 'valeur'.
  • Pour lire une donnée de session : request.session.get('cle').
  • Pour supprimer une donnée : del request.session['cle'].
  • Pour vider toute la session : request.session.flush().
• Expiration : La durée de vie d'une session peut être configurée via SESSION_COOKIE_AGE et SESSION_EXPIRE_AT_BROWSER_CLOSE.

L'utilisation combinée de l'ORM, des sessions et des cookies permet de construire des applications web dynamiques et interactives.