Cookie et session Django

Un cookie est un fichier texte stocké sur l'ordinateur client et conserve diverses informations de suivi.

L'identification des utilisateurs qui reviennent implique trois étapes :

  • Le script serveur envoie un ensemble de cookies au navigateur. Par exemple : nom, âge, ou numéro d'identification, etc.
  • Le navigateur stocke ces informations sur l'ordinateur local pour une utilisation future.
  • La prochaine fois que le navigateur envoie une requête au serveur web, le navigateur envoie ces informations de cookie au serveur, et le serveur utilise ces informations pour identifier l'utilisateur.

HTTP est un protocole « sans état », ce qui signifie que chaque fois qu'un client récupère une page web, le client ouvre une connexion distincte au serveur web, et le serveur ne conserve automatiquement aucun enregistrement des requêtes précédentes du client.

Cependant, il existe encore les trois façons suivantes de maintenir la session entre le client web et le serveur web :

Cookies

Un serveur web peut attribuer un ID de session unique sous forme de cookie à chaque client web, et pour les requêtes ultérieures du client, le cookie reçu peut être utilisé pour l'identifier.

Dans le développement web, la session est utilisée pour le suivi de session, et la session repose sur la technologie des cookies au niveau sous-jacent.

Syntaxe des cookies dans Django

Définir un cookie :

rep.set_cookie(key,value,...) 
rep.set_signed_cookie(key,value,salt='加密盐',...)

Obtenir un cookie :

request.COOKIES.get(key)

Supprimer le cookie :

rep =HttpResponse || render || redirect 
rep.delete_cookie(key)

Créer des applications et des modèles

models.py

class UserInfo(models.Model):
    username = models.CharField(max_length=32)
    password = models.CharField(max_length=64)

urls.py

from django.contrib import admin
from django.urls import path
from cookie import views
url = [
    path('admin/', admin.site.urls),
    path('login/', views.login),
    path('index/', views.index),
    path('logout/', views.logout),
    path('order/', views.order)

views.py

def login(request):
    if request.method == "GET":
        return render(request, "login.html")
    username = request.POST.get("username")
    password = request.POST.get("pwd")

    user_obj = models.UserInfo.objects.filter(username=username, password=password).first()
    print(user_obj.username)

    if not user_obj:
        return redirect("/login/")
    else:
        rep = redirect("/index/")
        rep.set_cookie("is_login", True)
        return rep
       
def index(request):
    print(request.COOKIES.get('is_login'))
    status = request.COOKIES.get('is_login') # Lorsque le navigateur envoie une autre requête, déterminez si le cookie qu'il transporte est le cookie défini dans la réponse lors d'une connexion réussie.
    if not status:
        return redirect('/login/')
    return render(request, "index.html")


def logout(request):
    rep = redirect('/login/')
    rep.delete_cookie("is_login")
    return rep # Exécuter après avoir cliqué sur déconnexion, supprimer le cookie, ne plus enregistrer l'état de l'utilisateur et rediriger vers la page de connexion
   
def order(request):
    print(request.COOKIES.get('is_login'))
    status = request.COOKIES.get('is_login')
    if not status:
        return redirect('/login/')
    return render(request, "order.html")

Ce qui suit crée trois fichiers de modèle : login.html, index.html, order.html.

login.html

<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Titre</title> </head> <body> <h3>Connexion utilisateur</h3> <form action="" method="post"> {% csrf_token %} <p>Nom d'utilisateur :<input type="text" name="username"></p> <p>Mot de passe :<input type="password" name="pwd"></p> <input type="submit"> </form> </body> </html>

index.html

<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Titre</title> </head> <body> <h2>page d'accueil...</h2> <a href="/logout/">Déconnexion</a> </body> </html>

order.html

<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Titre</title> </head> <body> <h2>page de commande...</h2> <a href="/logout/">Déconnexion</a> </body> </html>

Le résultat de l'exécution est affiché dans la figure ci-dessous :

Session (paires clé-valeur stockées côté serveur)

Lorsque le serveur est en cours d'exécution, il peut créer un objet de session dédié pour le navigateur de chaque utilisateur. Comme la session est exclusive au navigateur de l'utilisateur, lorsque les utilisateurs accèdent aux ressources web du serveur, ils peuvent stocker leurs données respectives dans leurs propres sessions. Lorsque les utilisateurs accèdent ensuite à d'autres ressources web sur le serveur, ces autres ressources web récupèrent les données dans les sessions respectives des utilisateurs pour les servir.

Fonctionnement

  • a. Le navigateur demande d'abord la page de connexion.

  • b. Lorsque le navigateur saisit le compte et le mot de passe pour la deuxième requête, si la saisie est correcte, le serveur répond au navigateur avec une page d'index et un cookie dont la clé est sessionid et la valeur est une chaîne aléatoire, c'est-à-dire set_cookie("sessionid", random_string).

  • c. En interne, le serveur stocke un enregistrement dans la table django.session.

    Il y a trois champs dans la table django.session.

    • session_key : stocke la chaîne aléatoire, c'est-à-dire la valeur correspondant à la clé sessionid du cookie envoyé au navigateur.
    • session_data : stocke les informations utilisateur, c'est-à-dire plusieurs request.session["key"]=value, et il s'agit de texte chiffré.
    • expire_date : stocke la date d'expiration de cet enregistrement (14 jours par défaut).

  • d. Lorsque le navigateur demande d'autres ressources pour la troisième fois, il transporte le cookie : {sessionid: random_string}. Le serveur récupère les données de l'utilisateur dans la table django.session en fonction de la chaîne aléatoire pour que l'utilisateur puisse les utiliser (c'est-à-dire en conservant l'état).

Remarque :La table django.session stocke des informations sur le navigateur, et non des informations sur chaque utilisateur. Par conséquent, les requêtes de plusieurs utilisateurs utilisant le même navigateur n'enregistrent qu'un seul enregistrement (le dernier écrase le précédent), et seules les requêtes provenant de plusieurs navigateurs enregistrent plusieurs enregistrements.

Les cookies compensent le caractère sans état de HTTP, permettant au serveur de savoir « qui » est la personne. Cependant, les cookies sont stockés dans le navigateur sous forme de texte, ce qui est moins sécurisé, et la taille maximale prise en charge n'est que de 4096 octets. Par conséquent, utilisez les cookies uniquement pour identifier les différents utilisateurs, puis stockez les informations privées et le texte dépassant 4096 octets dans la session correspondante.

paramètres de session :

request.session["key"] = value

Étapes d'exécution :

  • a. Générer une chaîne aléatoire
  • b. Enregistrer la chaîne aléatoire et les paires clé-valeur définies dans les champs session_key et session_data de la table django_session.
  • c. Définitiondu cookie : set_cookie("sessionid", chaîne aléatoire)Répondre au navigateur

Récupération de session :

request.session.get('key')

Étapes d'exécution :

  • a. Obtenir la valeur de la clé sessionid à partir du cookie, c'est-à-dire la chaîne aléatoire.
  • b. Filtrer l'enregistrement de la table django_session en fonction de la chaîne aléatoire.
  • c. Récupérer les données dans le champ session_data.

Suppression de session : supprimer l'enregistrement entier (y compris les trois champs session_key, session_data, expire_date) :

request.session.flush()

Supprimer l'une des paires clé-valeur dans session_data :

del request.session["key"]

Étapes d'exécution :

  • a. Obtenir la valeur de la clé sessionid à partir du cookie, c'est-à-dire la chaîne aléatoire.
  • b. Filtrer l'enregistrement de la table django_session en fonction de la chaîne aléatoire.
  • c. Supprimer les enregistrements filtrés

Exemple

Créer la route :

urls.py

from session import views as session_views

url = [
    path('session_login/', session_views.login),
    path('s_index/', session_views.s_index),
    path('s_logout/', session_views.s_logout),
]

Créer une fonction de vue :

views.py

def login(request):
    if request.method == "GET":
        return render(request, "login.html")
    username = request.POST.get("username")
    password = request.POST.get("pwd")

    user_obj = models.UserInfo.objects.filter(username=username, password=password).first()
    print(user_obj.username)

    if not user_obj:
        return redirect("/session_login/")
    else:
        request.session['is_login'] = True
        request.session['user1'] = username
        return redirect("/s_index/")


def s_index(request):
    status = request.session.get('is_login')
    if not status:
        return redirect('/session_login/')
    return render(request, "s_index.html")


def s_logout(request):
   # del request.session["is_login"] # Supprimer un ensemble de paires clé-valeur dans session_data
    request.session.flush() # Supprimer un enregistrement incluant (session_key session_data expire_date) trois champs
    return redirect('/session_login/')

Fichier de modèle :

s_index.html

<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Titre</title> </head> <body> <h2>page session_index... {{ request.session.user1 }}</h2> <a href="/s_logout/">Déconnexion</a> </body> </html>

Le résultat de l'exécution est affiché dans la figure ci-dessous :

autres extensions