Django Cookie und Session

Ein Cookie ist eine Textdatei, die auf dem Computer des Clients gespeichert wird und verschiedene Tracking-Informationen enthält.

Das Identifizieren wiederkehrender Benutzer umfasst drei Schritte:

  • Das Server-Skript sendet eine Reihe von Cookies an den Browser. Zum Beispiel: Name, Alter oder Identifikationsnummer usw.
  • Der Browser speichert diese Informationen zur späteren Verwendung auf dem lokalen Computer.
  • Wenn der Browser das nächste Mal eine Anfrage an den Webserver sendet, sendet der Browser diese Cookie-Informationen an den Server, und der Server verwendet diese Informationen, um den Benutzer zu identifizieren.

HTTP ist ein "zustandsloses" Protokoll, was bedeutet, dass jedes Mal, wenn ein Client eine Webseite abruft, der Client eine separate Verbindung zum Webserver öffnet und der Server automatisch keine Aufzeichnung früherer Client-Anfragen behält.

Es gibt jedoch noch die folgenden drei Möglichkeiten, die Sitzung zwischen dem Webclient und dem Webserver aufrechtzuerhalten:

Cookies

Ein Webserver kann jedem Webclient eine eindeutige Sitzungs-ID als Cookie zuweisen, und für die nachfolgenden Anfragen des Clients kann das empfangene Cookie verwendet werden, um ihn zu identifizieren.

In der Webentwicklung wird Session zur Sitzungsverfolgung verwendet, und Session stützt sich auf der zugrunde liegenden Ebene auf die Cookie-Technologie.

Cookie-Syntax in Django

Cookie setzen:

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

Cookie abrufen:

request.COOKIES.get(key)

Cookie löschen:

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

Anwendungen und Modelle erstellen

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
urlpatterns = [
    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') # Wenn der Browser eine weitere Anfrage sendet, wird geprüft, ob das mitgeführte Cookie das bei erfolgreicher Anmeldung in der Antwort gesetzte Cookie ist.
    if not status:
        return redirect('/login/')
    return render(request, "index.html")


def logout(request):
    rep = redirect('/login/')
    rep.delete_cookie("is_login")
    return rep # Nach dem Klicken auf Logout ausführen, Cookie löschen, Benutzerstatus nicht mehr speichern und zur Anmeldeseite weiterleiten
   
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")

Im Folgenden werden drei Template-Dateien erstellt: login.html, index.html, order.html.

login.html

<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Titel</title> </head> <body> <h3>Benutzeranmeldung</h3> <form action="" method="post"> {% csrf_token %} <p>Benutzername:<input type="text" name="username"></p> <p>Passwort:<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>Titel</title> </head> <body> <h2>Indexseite...</h2> <a href="/logout/">Abmelden</a> </body> </html>

order.html

<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Titel</title> </head> <body> <h2>Bestellseite...</h2> <a href="/logout/">Abmelden</a> </body> </html>

Das Ausführungsergebnis ist in der folgenden Abbildung dargestellt:

Sitzung (auf der Serverseite gespeicherte Schlüssel-Wert-Paare)

Wenn der Server läuft, kann er für den Browser jedes Benutzers ein eigenes Sitzungsobjekt erstellen. Da die Sitzung exklusiv für den Browser des Benutzers ist, können Benutzer beim Zugriff auf die Webressourcen des Servers ihre jeweiligen Daten in ihren eigenen Sitzungen speichern. Wenn Benutzer anschließend auf andere Webressourcen auf dem Server zugreifen, rufen diese anderen Webressourcen Daten aus den jeweiligen Sitzungen der Benutzer ab, um die Benutzer zu bedienen.

Funktionsweise

  • a. Der Browser fordert zuerst die Anmeldeseite an.

  • b. Wenn der Browser bei der zweiten Anfrage das Konto und das Passwort eingibt und die Eingabe korrekt ist, antwortet der Server dem Browser mit einer Indexseite und einem Cookie, dessen Schlüssel sessionid und dessen Wert eine Zufallszeichenkette ist, d. h. set_cookie("sessionid", random_string).

  • c. Intern speichert der Server einen Datensatz in der Tabelle django.session.

    Es gibt drei Felder in der Tabelle django.session.

    • session_key: speichert die Zufallszeichenkette, d. h. den Wert, der dem Schlüssel sessionid des an den Browser gesendeten Cookies entspricht.
    • session_data: speichert Benutzerinformationen, d. h. mehrere request.session["key"]=value, und es handelt sich um Chiffretext.
    • expire_date: speichert die Ablaufzeit dieses Datensatzes (standardmäßig 14 Tage).

  • d. Wenn der Browser zum dritten Mal andere Ressourcen anfordert, trägt er das Cookie: {sessionid: random_string}. Der Server ruft die Daten des Benutzers anhand der Zufallszeichenkette aus der Tabelle django.session ab, damit der Benutzer sie verwenden kann (d. h. Zustandsspeicherung).

Hinweis:Die Tabelle django.session speichert Browserinformationen, nicht Informationen über jeden einzelnen Benutzer. Daher speichern Anfragen mehrerer Benutzer, die denselben Browser verwenden, nur einen Datensatz (der spätere überschreibt den früheren), und nur Anfragen von mehreren Browsern speichern mehrere Datensätze.

Cookies machen die Zustandslosigkeit von HTTP wett, indem sie dem Server mitteilen, „wer“ die Person ist. Cookies werden jedoch im Browser als Text gespeichert, was weniger sicher ist, und die maximal unterstützte Größe beträgt nur 4096 Bytes. Verwenden Sie Cookies daher nur zur Identifizierung verschiedener Benutzer und speichern Sie dann private Informationen und Text, der 4096 Bytes überschreitet, in der entsprechenden Session.

Session-Einstellungen:

request.session["key"] = value

Ausführungsschritte:

  • a. Eine Zufallszeichenfolge generieren
  • b. Die Zufallszeichenfolge und die festgelegten Schlüssel-Wert-Paare in session_key und session_data der Tabelle django_session speichern.
  • c. EinstellungenCookie: set_cookie("sessionid", Zufallszeichenfolge)Dem Browser antworten

Session abrufen:

request.session.get('key')

Ausführungsschritte:

  • a. Den Wert des Schlüssels sessionid aus dem Cookie abrufen, d. h. die Zufallszeichenfolge.
  • b. Den Datensatz anhand der Zufallszeichenfolge aus der Tabelle django_session herausfiltern.
  • c. Die Daten im Feld session_data abrufen.

Löschen der Session: den gesamten Datensatz löschen (einschließlich der drei Felder session_key, session_data, expire_date):

request.session.flush()

Eines der Schlüssel-Wert-Paare in session_data löschen:

del request.session["key"]

Ausführungsschritte:

  • a. Den Wert des Schlüssels sessionid aus dem Cookie abrufen, d. h. die Zufallszeichenfolge.
  • b. Den Datensatz anhand der Zufallszeichenfolge aus der Tabelle django_session herausfiltern.
  • c. Die gefilterten Datensätze löschen

Beispiel

Route erstellen:

urls.py

from session import views as session_views

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

Eine View-Funktion erstellen:

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"] # Löschen eines Satzes von Schlüssel-Wert-Paaren in session_data
    request.session.flush() # Lösche einen Datensatz einschließlich (session_key session_data expire_date) drei Felder
    return redirect('/session_login/')

Vorlagendatei:

s_index.html

<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Titel</title> </head> <body> <h2>session_index Seite... {{ request.session.user1 }}</h2> <a href="/s_logout/">Abmelden</a> </body> </html>

Das Ausführungsergebnis ist in der folgenden Abbildung dargestellt:

Weitere Erweiterungen