Django cookie y session

Las cookies son archivos de texto almacenados en la computadora del cliente y contienen diversa información de seguimiento.

Reconocer a un usuario que regresa incluye tres pasos:

  • El script del servidor envía un conjunto de cookies al navegador. Por ejemplo: nombre, edad o número de identificación, etc.
  • El navegador almacena esta información en la computadora local para uso futuro.
  • Cuando el navegador envía cualquier solicitud al servidor web la próxima vez, el navegador envía la información de estas cookies al servidor, y el servidor la utilizará para identificar al usuario.

HTTP es un protocolo "sin estado", lo que significa que cada vez que el cliente recupera una página web, el cliente abre una conexión separada al servidor web, y el servidor automáticamente no conserva ningún registro de las solicitudes anteriores del cliente.

Pero aún existen las siguientes tres formas de mantener la sesión (session) entre el cliente web y el servidor web:

Cookies

Un servidor web puede asignar un ID de sesión (session) único como cookie para cada cliente web, y para las solicitudes posteriores del cliente se puede utilizar la cookie recibida para identificarlo.

En el desarrollo web, se utiliza session para realizar el seguimiento de sesión; session depende internamente de la tecnología de cookies.

Sintaxis de Cookie en Django

Establecer cookie:

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

Obtener cookie:

request.COOKIES.get(key)

Eliminar cookie:

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

Crear aplicación y modelo

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') # Al recibir la nueva solicitud del navegador, juzgar si la cookie que lleva el navegador es la cookie de respuesta al inicio de sesión exitoso
    if not status:
        return redirect('/login/')
    return render(request, "index.html")


def logout(request):
    rep = redirect('/login/')
    rep.delete_cookie("is_login")
    return rep # Se ejecuta al hacer clic en cerrar sesión, elimina la cookie, ya no guarda el estado del usuario y redirige a la página de inicio de sesión
   
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")

A continuación, cree tres archivos de plantilla: login.html, index.html, order.html.

login.html

<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> <h3>Inicio de sesión de usuario</h3> <form action="" method="post"> {% csrf_token %} <p>Nombre de usuario:<input type="text" name="username"></p> <p>Contraseña:<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>Title</title> </head> <body> <h2>Página index...</h2> <a href="/logout/">Cerrar sesión</a> </body> </html>

order.html

<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> <h2>Página order...</h2> <a href="/logout/">Cerrar sesión</a> </body> </html>

El resultado de la ejecución se muestra en la siguiente figura:

Session (pares clave-valor guardados en el servidor)

Durante la ejecución, el servidor puede crear un objeto session exclusivo para el navegador de cada usuario. Dado que la session es exclusiva del navegador del usuario, cuando el usuario accede a los recursos web del servidor, puede colocar sus propios datos en su propia session. Cuando el usuario vuelve a acceder a otros recursos web del servidor, estos otros recursos web extraen los datos de la session del usuario para brindarle servicio.

Principio de funcionamiento

  • a. El navegador solicita por primera vez la página de inicio de sesión login.

  • b. El navegador envía una segunda solicitud con la cuenta y la contraseña. Si son correctas, el servidor responde al navegador con una página index y una cookie cuya clave es sessionid y cuyo valor es una cadena aleatoria, es decir, set_cookie("sessionid", cadena_aleatoria).

  • c. Internamente, el servidor registra un dato en la tabla django.session.

    La tabla django.session tiene tres campos.

    • session_key: almacena la cadena aleatoria, es decir, el valor correspondiente a la clave sessionid de la cookie respondida al navegador.
    • session_data: almacena la información del usuario, es decir, múltiples request.session["key"]=value, y está cifrada.
    • expire_date: almacena el tiempo de expiración de ese registro (14 días por defecto).
  • d. Cuando el navegador solicita por tercera vez otros recursos, lleva la cookie: {sessionid: cadena_aleatoria}. El servidor obtiene los datos del usuario desde la tabla django.session según esa cadena aleatoria para que estén disponibles (es decir, se guarda el estado).

Nota:La tabla django.session guarda información del navegador, no información de cada usuario. Por lo tanto, múltiples solicitudes de usuarios desde el mismo navegador solo guardan un registro (el posterior sobrescribe al anterior); solo las solicitudes de varios navegadores guardan múltiples registros.

Las cookies compensan la falta de estado de HTTP, permitiendo que el servidor sepa "quién" es la persona que llega. Sin embargo, las cookies se guardan en el navegador en forma de texto, tienen una seguridad deficiente y admiten un máximo de 4096 bytes. Por lo tanto, solo se utilizan las cookies para identificar a los distintos usuarios, y luego en la session correspondiente se guarda información privada y texto que supere los 4096 bytes.

Configuración de session:

request.session["key"] = value

Pasos de ejecución:

  • a. Generar una cadena aleatoria
  • b. Guardar la cadena aleatoria y los pares clave-valor configurados en session_key y session_data de la tabla django_session
  • c. Configurarcookie: set_cookie("sessionid", cadena_aleatoria)Responder al navegador

Obtener session:

request.session.get('key')

Pasos de ejecución:

  • a. Obtener de la cookie el valor de la clave sessionid, es decir, la cadena aleatoria.
  • b. Filtrar el registro de la tabla django_session según la cadena aleatoria.
  • c. Extraer los datos del campo session_data.

Eliminación de session: eliminar todo el registro (incluidos los tres campos session_key, session_data, expire_date):

request.session.flush()

Eliminar uno de los pares clave-valor en session_data:

del request.session["key"]

Pasos de ejecución:

  • a. Obtener de la cookie el valor de la clave sessionid, es decir, la cadena aleatoria
  • b. Filtrar el registro de la tabla django_session según la cadena aleatoria
  • c. Eliminar el registro filtrado

Ejemplo

Crear rutas:

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),
]

Crear funciones de vista:

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"] # Eliminar un par clave-valor en session_data
    request.session.flush() # Eliminar un registro completo, incluidos los tres campos (session_key, session_data, expire_date)
    return redirect('/session_login/')

Archivo de plantilla:

s_index.html

<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> <h2>Página session_index... {{ request.session.user1 }}</h2> <a href="/s_logout/">Cerrar sesión</a> </body> </html>

El resultado de la ejecución se muestra en la siguiente figura:

Otras extensiones