Detaillierte Erklärung von Cookies und Sitzungen in Python

Dieser Artikel bietet Ihnen eine detaillierte Erklärung von Cookies und Sitzungen in Python. Ich hoffe, dass er für Freunde hilfreich ist.

Cookie

1. Der Ursprung von Cookie

Jeder weiß, dass das HTTP-Protokoll zustandslos ist.

Zustandslos bedeutet, dass jede Anfrage unabhängig ist. Ihre Ausführung und Ergebnisse stehen in keinem direkten Zusammenhang mit der vorherigen Anfrage oder den nachfolgenden Anfragen Antworten anfordern.

Ein interessanter Satz, um es zu beschreiben: Das Leben ist so, als würde man es zum ersten Mal sehen. Für den Server ist jede Anfrage brandneu.

Zustand kann als die vom Client und Server in einer Sitzung generierten Daten verstanden werden, und zustandslos bedeutet, dass diese Daten nicht gespeichert werden. Die in der Sitzung generierten Daten müssen wir speichern, was bedeutet, dass wir den „Status aufrechterhalten“ müssen. Daher wurde Cookie in einem solchen Szenario geboren.

2. Was ist ein Cookie?

Cookie bezieht sich speziell auf eine Reihe von Schlüssel-Wert-Paaren, die vom Server gesendet und im Browser gespeichert werden Wenn Sie den Server das nächste Mal besuchen, überträgt der Server diese Schlüssel-Wert-Paare automatisch, damit der Server nützliche Informationen extrahieren kann.

3. Das Prinzip von Cookies

Das Funktionsprinzip von Cookies ist: Der Inhalt wird vom Server generiert und der Browser speichert ihn lokal, wenn der Browser ihn erneut besucht. Der Browser setzt automatisch ein Cookie, sodass der Server anhand des Inhalts des Cookies feststellen kann, „wer“ dies ist.

Betreiben von Cookies in Django

1. Cookie abrufen

request.COOKIES['key']
request.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None)

Parameter:

• Standard: Standardwert

• Salt: Verschlüsselungssalz

• max_age: Ablaufzeit der Hintergrundkontrolle

2. Cookie setzen

rep = HttpResponse(...)
rep ＝ render(request, ...)

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

Parameter:

• key, key

• value='', value

• max_age =Keine, Timeout-Zeitraum

• expires=Keine, Timeout-Zeitraum (IE erfordert einen Ablauf, also legen Sie ihn fest, falls noch nicht geschehen.)

• path='/', der Pfad, in dem das Cookie wirksam wird, / stellt den Root-Pfad dar, Besonderheit: Auf das Cookie des Root-Pfads kann von jeder URL-Seite aus zugegriffen werden

• domain= Keine, das Cookie wird wirksam. Domainname

• secure=False, https-Übertragung

• httponly=False kann nur per HTTP-Protokoll übertragen werden und nicht durch JavaScript abgerufen werden (nicht absolute, unterste Ebene. Das Paket kann abgerufen oder überschrieben werden)

3. Cookie löschen

def logout(request):
    rep = redirect("/login/")
    rep.delete_cookie("user")  # 删除用户浏览器上之前设置的usercookie值
    return rep

Sitzung

SitzungUrsprung

Obwohl Cookies die Notwendigkeit, den Status beizubehalten, bis zu einem gewissen Grad lösen, da das Cookie selbst maximal 4096 Bytes unterstützt und das Cookie selbst Wird auf dem Client gespeichert, kann es abgefangen oder gestohlen werden. Es besteht Bedarf an einer neuen Sache, die mehr Bytes unterstützen kann und mit höherer Sicherheit auf dem Server gespeichert wird. Das ist Sitzung.

Das Problem besteht darin, dass der Server aufgrund der zustandslosen Eigenschaften des HTTP-Protokolls überhaupt nicht weiß, „wer“ der Besucher ist. Dann übernimmt das oben genannte Cookie eine Brückenfunktion.

Wir können dem Cookie jedes Kunden eine eindeutige ID zuweisen, sodass der Server beim Besuch des Benutzers anhand des Cookies weiß, „wer“ der Besucher ist. Dann speichern wir private Informationen für einen bestimmten Zeitraum auf dem Server, basierend auf verschiedenen Cookie-IDs, wie zum Beispiel „Kontopasswort“ und so weiter.

Zusammenfassend: Cookies gleichen die Mängel der HTTP-Zustandslosigkeit aus, indem sie es dem Server ermöglichen, zu wissen, „wer“ die kommende Person ist. Cookies werden jedoch lokal in Textform gespeichert und ihre eigene Sicherheit ist schlecht Deshalb verwenden wir Cookies, um verschiedene Benutzer zu identifizieren und dementsprechend private Informationen und Texte mit mehr als 4096 Bytes in der Sitzung zu speichern.

Darüber hinaus sind die oben genannten Cookies und Sitzungen tatsächlich übliche Dinge und nicht auf Sprachen und Frameworks beschränkt.

Sitzungsbezogene Methoden in Django

# 获取、设置、删除Session中数据
request.session['k1']
request.session.get('k1',None)
request.session['k1'] = 123
request.session.setdefault('k1',123) # 存在则不设置
del request.session['k1']


# 所有 键、值、键值对
request.session.keys()
request.session.values()
request.session.items()
request.session.iterkeys()
request.session.itervalues()
request.session.iteritems()

# 会话session的key
request.session.session_key

# 将所有Session失效日期小于当前日期的数据删除
request.session.clear_expired()

# 检查会话session的key在数据库中是否存在
request.session.exists("session_key")

# 删除当前会话的所有Session数据
request.session.delete()
　　
# 删除当前的会话数据并删除会话的Cookie。
request.session.flush() 
    这用于确保前面的会话数据不可以再次被用户的浏览器访问
    例如，django.contrib.auth.logout() 函数中就会调用它。

# 设置会话Session和Cookie的超时时间
request.session.set_expiry(value)
    * 如果value是个整数，session会在些秒数后失效。
    * 如果value是个datatime或timedelta，session就会在这个时间后失效。
    * 如果value是0,用户关闭浏览器session就会失效。
    * 如果value是None,session会依赖全局session失效策略。

1. Sitzungsprozessanalyse

2. Sitzungskonfiguration in Django

Django unterstützt standardmäßig Sitzungen und stellt Entwicklern intern fünf Sitzungstypen zur Verfügung.

1. 数据库Session
SESSION_ENGINE = 'django.contrib.sessions.backends.db'   # 引擎（默认）

2. 缓存Session
SESSION_ENGINE = 'django.contrib.sessions.backends.cache'  # 引擎
SESSION_CACHE_ALIAS = 'default'                            # 使用的缓存别名（默认内存缓存，也可以是memcache），此处别名依赖缓存的设置

3. 文件Session
SESSION_ENGINE = 'django.contrib.sessions.backends.file'    # 引擎
SESSION_FILE_PATH = None                                    # 缓存文件路径，如果为None，则使用tempfile模块获取一个临时地址tempfile.gettempdir() 

4. 缓存+数据库
SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db'        # 引擎

5. 加密Cookie Session
SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies'   # 引擎

其他公用设置项：
SESSION_COOKIE_NAME ＝ "sessionid"                       # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串（默认）
SESSION_COOKIE_PATH ＝ "/"                               # Session的cookie保存的路径（默认）
SESSION_COOKIE_DOMAIN = None                             # Session的cookie保存的域名（默认）
SESSION_COOKIE_SECURE = False                            # 是否Https传输cookie（默认）
SESSION_COOKIE_HTTPONLY = True                           # 是否Session的cookie只支持http传输（默认）
SESSION_COOKIE_AGE = 1209600                             # Session的cookie失效日期（2周）（默认）
SESSION_EXPIRE_AT_BROWSER_CLOSE = False                  # 是否关闭浏览器使得Session过期（默认）
SESSION_SAVE_EVERY_REQUEST = False                       # 是否每次请求都保存Session，默认修改之后才保存（默认）

Django中Session相关设置

Django中Session相关设置

Sitzungsbezogene Einstellungen in Django

3. Decorator bezogen auf CBV

Anmeldeansicht implementiert von CBV

class LoginView(View):

    def get(self, request):
        """
        处理GET请求
        """
        return render(request, 'login.html')

    def post(self, request):
        """
        处理POST请求 
        """
        user = request.POST.get('user')
        pwd = request.POST.get('pwd')
        if user == 'alex' and pwd == "alex1234":
            next_url = request.GET.get("next")
            # 生成随机字符串
            # 写浏览器cookie -> session_id: 随机字符串
            # 写到服务端session：
            # {
            #     "随机字符串": {'user':'alex'}
            # }
            request.session['user'] = user
            if next_url:
                return redirect(next_url)
            else:
                return redirect('/index/')
        return render(request, 'login.html')

Zu verwenden Bei unserem check_login-Dekorator oben in der CBV-Ansicht gibt es drei Möglichkeiten:

von django.utils.decorators import method_decorator

1. Get in der CBV-Ansicht hinzufügen Oder auf der Post-Methode

from django.utils.decorators import method_decorator


class HomeView(View):

    def dispatch(self, request, *args, **kwargs):
        return super(HomeView, self).dispatch(request, *args, **kwargs)

    def get(self, request):
        return render(request, "home.html")
    
    @method_decorator(check_login)
    def post(self, request):
        print("Home View POST method...")
        return redirect("/index/")

2. Fügen Sie es zur Versandmethode hinzu

from django.utils.decorators import method_decorator


class HomeView(View):

    @method_decorator(check_login)
    def dispatch(self, request, *args, **kwargs):
        return super(HomeView, self).dispatch(request, *args, **kwargs)

    def get(self, request):
        return render(request, "home.html")

    def post(self, request):
        print("Home View POST method...")
        return redirect("/index/")

Da die Versandmethode zuerst in CBV ausgeführt wird, entspricht das Schreiben sowohl dem get als auch dem Post-Methoden fügen eine Anmeldebestätigung hinzu.

3. Fügen Sie es direkt zur Ansichtsklasse hinzu, aber method_decorator muss den Namensschlüsselwortparameter übergeben

Wenn sowohl die Get-Methode als auch die Post-Methode eine Anmeldebestätigung erfordern, schreiben Sie zwei ein Dekorateur.

from django.utils.decorators import method_decorator

@method_decorator(check_login, name="get")
@method_decorator(check_login, name="post")
class HomeView(View):

    def dispatch(self, request, *args, **kwargs):
        return super(HomeView, self).dispatch(request, *args, **kwargs)

    def get(self, request):
        return render(request, "home.html")

    def post(self, request):
        print("Home View POST method...")
        return redirect("/index/")

Das obige ist der detaillierte Inhalt vonDetaillierte Erklärung von Cookies und Sitzungen in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!