django之cookie和session

title: django之cookie和session #标题tags: #标签
date: 2022-01-09
categories: python # 分类

会话跟踪

先来了解一下什么是会话！可以把会话理解为客户端与服务器之间的一次会晤，在一次会晤中可能会包含多次请求和响应。例如你给10086打个电话，你就是客户端，而10086服务人员就是服务器了。从双方接通电话那一刻起，会话就开始了，到某一方挂断电话表示会话结束。在通话过程中，你会向10086发出多个请求，那么这多个请求都在一个会话中。 客户向某一服务器发出第一个请求开始，会话就开始了，直到客户关闭了浏览器会话结束。

在一个会话的多个请求中共享数据，这就是会话跟踪技术。例如在一个会话中的请求如下：

• 请求银行主页；
• 请求登录（请求参数是用户名和密码）；
• 请求转账（请求参数与转账相关的数据）；
• 请求信用卡还款（请求参数与还款相关的数据）。

在这上会话中当前用户信息必须在这个会话中共享的，因为登录的是张三，那么在转账和还款时一定是相对张三的转账和还款！这就说明我们必须在一个会话过程中有共享数据的能力。而web中这种能力的实现就要依靠cookie和session

cookie

Cookie简介

Cookie的由来

都知道HTTP协议是无状态的。无状态的意思是每次请求都是独立的，它的执行情况和结果与前面的请求和之后的请求都无直接关系，它不会受前面的请求响应情况直接影响，也不会直接影响后面的请求响应情况。一句有意思的话来描述就是人生只如初见，对服务器来说，每次的请求都是全新的。

状态可以理解为客户端和服务器在某次会话中产生的数据，那无状态的就以为这些数据不会被保留。会话中产生的数据又是我们需要保存的，也就是说要“保持状态”。因此Cookie就是在这样一个场景下诞生。

并且还有一个问题就是，你登陆我的网站的时候，我没法确定你是不是登陆了，之前学的django中，虽然写了很多页面，但是用户不用登陆都是可以看所有网页的，只要他知道网址就行，但是我们为了自己的安全机制，我们要做验证，访问哪一个网址，都要验证用户的身份，但是还有保证什么呢，用户登陆过之后，还要保证登陆了的用户不需要再重复登陆，就能够访问我网站的其他的网址的页面，对不对，但是http无状态啊，怎么保证这个事情呢？此时就要找cookie了。

什么是Cookie

首先来讲，cookie是浏览器的技术，Cookie具体指的是一段小信息，它是服务器发送出来存储在浏 览器上的一组组键值对，可以理解为服务端给客户端的一个小甜点，下次访问服务器时浏览器会自动携带这些键值对，以便服务器提取有用信息。

Cookie的原理

cookie的工作原理是：浏览器访问服务端，带着一个空的cookie，然后由服务器产生内容，浏览器收到相应后保存在本地；当浏览器再次访问时，浏览器会自动带上Cookie，这样服务器就能通过Cookie的内容来判断这个是“谁”了。

查看Cookie

查看方法如下：

Cookie图解

Cookie规范

• Cookie大小上限为4KB；
• 一个服务器最多在客户端浏览器上保存20个Cookie；
• 一个浏览器最多保存300个Cookie，因为一个浏览器可以访问多个服务器。
  　　　　
  上面的数据只是HTTP的Cookie规范，但在浏览器大战的今天，一些浏览器为了打败对手，为了展现自己的能力起见，可能对Cookie规范“扩展”了一些，例如每个Cookie的大小为8KB，最多可保存500个Cookie等！但也不会出现把你硬盘占满的可能！
  注意，不同浏览器之间是不共享Cookie的。也就是说在你使用IE访问服务器时，服务器会把Cookie发给IE，然后由IE保存起来，当你在使用FireFox访问服务器时，不可能把IE保存的Cookie发送给服务器。

Cookie与HTTP头

Cookie是通过HTTP请求和响应头在客户端和服务器端传递的：

• Cookie：请求头，客户端发送给服务器端；
• 格式：Cookie: a=A; b=B; c=C。即多个Cookie用分号离开； Set-Cookie：响应头，服务器端发送给客户端；
• 一个Cookie对象一个Set-Cookie： Set-Cookie: a=A Set-Cookie: b=B Set-Cookie: c=C

Cookie的覆盖

如果服务器端发送重复的Cookie，那么会覆盖原有的Cookie，例如客户端的第一个请求服务器端发送的Cookie是：Set-Cookie: a=A；第二请求服务器端发送的是：Set-Cookie: a=AA，那么客户端只留下一个Cookie，即：a=AA。

django中操作Cookie

获取cookie

request.COOKIES['key']
request.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None)
'''
参数：
default: 默认值
salt: 加密盐
max_age: 后台控制过期时间
'''

设置Cookie

rep = HttpResponse(...)
rep ＝ render(request, ...)
rep.set_cookie(key,value,...)
rep.set_signed_cookie(key,value,salt='加密盐', max_age=None, ...)
'''
参数：
key：键
value：值
max_age=None, 超时时间（这个cookie生效多少秒）
expires=None, 超时时间日期(有效期到expires指定的时间日期，比如此值为2022/1/15，那么到这个日期，cookie就失效了)
path='/'：Cookie生效的路径，/ 表示根路径，特殊的：根路径的cookie可以被任何url的页面访问
domain=None：Cookie生效的域名
secure=False：只能https传输
httponly=False：只能http协议传输，无法被JavaScript获取（不是绝对，底层抓包可以获取到也可以被覆盖）
'''

set_cookie方法源码

class HttpResponseBase:
        def set_cookie(self, key,                 键
        　　　　　　　　　　　　 value='',            值
        　　　　　　　　　　　　 max_age=None,        超长时间 ,有效事件，max_age=20意思是这个cookie20秒后就消失了，默认时长是2周,这个是以秒为单位的
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　cookie需要延续的时间（以秒为单位）
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　如果参数是\ None`` ，这个cookie会延续到浏览器关闭为止。
        　　　　　　　　　　　　 expires=None,        超长时间，值是一个datetime类型的时间日期对象，到这个日期就失效的意思，用的不多
       　　　　　　　　　　　　　　　　　　　　　　　　　　expires默认None ,cookie失效的实际日期/时间。 
    　　　　　　　　　　　　　　　　　　　　　　　　　　　　
        　　　　　　　　　　　　 path='/',           Cookie生效的路径，就是访问哪个路径可以得到cookie，'/'是所有路径都能获得cookie
                                                 浏览器只会把cookie回传给带有该路径的页面，这样可以避免将
                                                 cookie传给站点中的其他的应用。
                                                 / 表示根路径，特殊的：根路径的cookie可以被任何url的页面访问
        　　　　　　　　　　　　 
                             domain=None,         Cookie生效的域名
                                                  你可用这个参数来构造一个跨站cookie。
                                                  如， domain=".example.com"
                                                  所构造的cookie对下面这些站点都是可读的：
                                                  www.example.com 、 www2.example.com 
        　　　　　　　　　　　　　　　　　　　　　　　　　和an.other.sub.domain.example.com 。
                                                  如果该参数设置为 None ，cookie只能由设置它的站点读取。
        　　　　　　　　　　　　 secure=False,        如果设置为 True ，浏览器将通过HTTPS来回传cookie。
        　　　　　　　　　　　　 httponly=False       只能http协议传输，无法被JavaScript获取
                                                 （不是绝对，底层抓包可以获取到也可以被覆盖）
        　　　　　　　　　　): pass

关于Cookie的demo

此文章中的项目代码已上传至Gitee。

注意：由于涉及到cookie和session，建议所有访问测试操作，打开浏览器的无痕模式进行验证，否则可能没有效果。

设置Cookie

# urls.py文件
from django.urls import path
from app01 import views
urlpatterns = [
    #    path('admin/', admin.site.urls),
    path('index/', views.index, name='index'),
    path('home/', views.home, name='home'),
]
# views.py文件的视图函数
def index(request):
    # 定义响应头，HttpResponse或render方法都可以
    ret = HttpResponse('ok!!!')
    # 通过set_cookie方法，给响应头设置cookie
    ret.set_cookie('k1', 'v1')
    return ret

现在来请求下这个页面，看看Cookie是否设置成功了。如下：

获取Cookie

上面设置了Cookie，那么在访问这个项目的其他路径时，也会携带上上面那个页面给设置的Cookie，除非清空浏览器缓存，获取Cookie的代码如下：

def home(request):
    print(request.COOKIES)    # 打印结果：{'k1': 'v1'}
    return render(request,'home.html')   # home.html页面自定义即可

浏览器上查看请求头中的cookie：

好，现在我们来试下，如何通过cookie来判断用户是否登录，以便进行相应的处理：

# views.py文件内容
# index视图函数作为登录功能的，逻辑可以自定义，比如登录成功，就设置cookie，失败，就不设置
# 我这里没写判断逻辑，只要访问，就给设置cookie
def index(request):
    # 定义响应头，HttpResponse、redirect或render方法都可以
    ret = HttpResponse('ok!!!')
    # 通过set_cookie方法，给响应头设置cookie
    ret.set_cookie('k1', 'v1')
    return ret
def home(request):
    print(request.COOKIES)  # 打印结果：{'k1': 'v1'}
    # 尝试获取cookie值，如果cookie等于某个值，则说明处于登录状态，返回home.html页面
    # 反之，则表示未登录，需要进行登录
    is_login = request.COOKIES.get('k1')
    if is_login == 'v1':
        return render(request, 'home.html')  # home.html页面自定义即可
    else:
        return HttpResponse('未登录!!!')

效果如下（需要清除浏览器中的cookie）：

可以看到，直接访问home页面，是未被设置Cookie的，现在来访问下index页面（index的视图函数会给设置相应的Cookie），然后再访问下home页面，效果如下：

1、访问index

2、再次访问home

可以看到这次没有再显示未登录了，而是直接访问到了home页面，这是因为我们访问了index，被设置了cookie，这样，再请求这个网站的其他页面时，就会携带上保存的Cookie。

通过cookie来做个简单的登录认证功能

urls.py文件

from django.urls import path
from app01 import views
urlpatterns = [
    #    path('admin/', admin.site.urls),
    path('index/', views.index, name='index'),
    path('newindex/', views.newindex, name='newindex'),
    path('home/', views.home, name='home'),
    path('login/', views.Login.as_view(), name='login'),
]

views.py文件

from django.shortcuts import render, redirect, HttpResponse
from django.views import View
from django.http import JsonResponse
# Create your views here.
# 定义一个装饰器，用于处理登录成功或失败的后续操作
def is_login(f):
    '''
    装饰器功能描述：获取请求中的Cookie，根据值来判断是否处于登录状态
    如果已登录，则执行具体函数
    如果未登录，则重定向到登录页面
    '''
    def inner(request, *args, **kwargs):
        is_login = request.COOKIES.get('is_login')
        print(is_login, type(is_login))
        if is_login == 'True':
            ret = f(request, *args, **kwargs)
            return ret
        else:
            return redirect('login')
    return inner
# 增加装饰器is_login
@is_login
def home(request):
    return render(request, 'home.html')
@is_login
def newindex(request):
    return render(request, 'newindex.html')
class Login(View):
    def get(self, request):
        return render(request, 'login.html')
    def post(self, request):
        '''
        提取请求头中的用户名和密码，来判断是否和后端数据一致，
        如果一致，则给响应头设置cookie： is_login=True
        否则提示登录失败！
        '''
        username = request.POST.get('uname')
        passwd = request.POST.get('pwd')
        if username == 'ljz' and passwd == '123.com':
            ret = redirect('newindex')
            ret.set_cookie('is_login', True)
            return ret
        else:
            return HttpResponse('登录失败!!!')

前端html页面

<!--            login.html页面                         -->

{% load static %}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登录页面</title>
</head>
<body>

<h1>请登录</h1>
<form action="{% url 'login' %}" method="post">
    {% csrf_token %}
    用户名：<input type="text" name="uname">
    密码：<input type="password" name="pwd">
    <input type="submit" value="登录">
</form>


</body>
</html>


<!--            home.html页面                         -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<h1>hello world!!!</h1>
<a href="/newindex/">这是index页面</a>

</body>
</html>



<!--            newindex.html页面                         -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>你好，new index</h1>
<a href="/home/">这是home页面</a>
</body>
</html>

demo效果

上述demo的效果如下：

1、在没有登录之前，访问home或newindex，都会跳转到login页面：

2、在login页面登录失败，会返回“登录失败!!!”，如下：

3、登录成功一次后，被设置了cookie，之后请求home或者newindex都会携带服务端给设置的cookie，所以也就可以正常访问，如下：

session

Session是服务器端技术，利用这个技术，服务器在运行时可以 为每一个用户的浏览器创建一个其独享的session对象，由于 session为用户浏览器独享，所以用户在访问服务器的web资源时 ，可以把各自的数据放在各自的session中，当用户再去访问该服务器中的其它web资源时，其它web资源再从用户各自的session中 取出数据为用户服务。

Cookie虽然在一定程度上解决了“保持状态”的需求，但是由于Cookie本身最大支持4096字节，以及Cookie本身保存在客户端，可能被拦截或窃取，因此就需要有一种新的东西，它能支持更多的字节，并且他保存在服务器，有较高的安全性。这就是Session。

问题来了，基于HTTP协议的无状态特征，服务器根本就不知道访问者是“谁”。那么上述的Cookie就起到桥接的作用。

我们可以给每个客户端的Cookie分配一个唯一的id，这样用户在访问时，通过Cookie，服务器就知道来的人是“谁”。然后我们再根据不同的Cookie的id，在服务器上保存一段时间的私密资料，如“账号密码”等等。

总结而言：Cookie弥补了HTTP无状态的不足，让服务器知道来的人是“谁”；但是Cookie以文本的形式保存在本地，自身安全性较差；所以我们就通过Cookie识别不同的用户，对应的在Session里保存私密的信息以及超过4096字节的文本。

另外，上面所说的Cookie和Session其实是共通性的东西，不限于语言和框架。

django通过session实现登录认证

注意：session默认是保存在数据库中的，你需要在开始前配置下你的数据库。我这里用的是本地的MySQL作为后端数据库的。如果你使用django给你提供的默认数据库：sqlite，那么只需要执行下面两条指令即可：

# 不同的django版本可能下面的命令有略微差异。
$ makemigrations
$ migrate

好，现在来看看我是如何配置django连接本地mysql数据库的：

# settings.py配置文件找到
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

# 改为：
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',  # 指定mysql数据库引擎
        'NAME': 'session_test',  # 要连接的数据库名称（需要自行提前手动创建好）
        'USER': 'root',  # 连接数据库的用户
        'PASSWORD': '123.com',  # 用户密码
        'HOST': '127.0.0.1',  # 数据库地址
        'PORT': 3306  # 数据库连接端口
    }
}


# settings的同级目录下的__init__.py文件配置如下：
import pymysql
pymysql.install_as_MySQLdb()


# 运行manage.py指令：
# 不同的django版本可能下面的命令有略微差异。
$ makemigrations
$ migrate

配置好后端数据库后，现在来看下django是如何操作session的（这里我只贴视图函数中的部分代码，要想看其他的，可以移步项目地址）：

# views.py文件部分内容

class Session_Login(View):
    def get(self, request):
        return render(request, 'session_login.html')

    def post(self, request):
        '''
        提取请求头中的用户名和密码，来判断是否和后端数据一致，
        如果一致，则给响应头设置cookie： is_login=True
        否则提示登录失败！
        '''
        _username = request.POST.get('uname')
        _passwd = request.POST.get('pwd')

        if _username == 'ljz' and _passwd == '123.com':
            '''
            session不和cookie一样，通过响应对象来设置，
            session直接通过request来设置
            '''
            request.session['is_login'] = True
            request.session['username'] = 'lvjianzhao'
            '''
            上面两句话做了以下几件事：
            1、生成session_id：随机字符串
            2、在cookie里面加上了一个键值对，session_id:fjiiejfeifeijfejf
            3、将用户设置的数据进行加密，并保存到了django_session表中
            session_key：就是生成的session_id;
            session_data: 就是用户数据加密后的字符串：
            '''
            return redirect('session_home')
        else:
            return HttpResponse('登录失败!!!')


# 定义一个装饰器，用于处理登录成功或失败的后续操作
def session_is_login(f):
    '''
    装饰器功能描述：获取请求中的Session，根据值来判断是否处于登录状态
    如果已登录，则执行具体函数
    如果未登录，则重定向到登录页面
    '''

    def inner(request, *args, **kwargs):
        print(request.session)  # 打印结果：<django.contrib.sessions.backends.db.SessionStore object at 0x000001EA2C466D90>
        _is_login = request.session.get('is_login')
        '''
        上面获取key的操作，django做了以下几件事：
        1、从cookie里面拿出来sessionid:xxxxx这个随机字符串
        2、去django_session表中查询到对应的数据
        3、反解密获取到的数据，并获取用户需要的数据
        '''
        print(_is_login, type(_is_login))  # 打印结果：True <class 'bool'>(获取的结果True是布尔值)
        if _is_login:
            ret = f(request, *args, **kwargs)
            return ret
        else:
            return redirect('session_login')

    return inner


@session_is_login
def session_home(request):
    return render(request, 'home.html')

现在访问Session_Login视图函数并登录成功看看：

可以看到，登录成功后，会被设置了一个session：sessionid:"e0al3gtpek2q7dnvi3b6byx3i4e38xpr"，而代码中通过request.session方法设置的那两个键值对却没有传给客户端，这是因为django把他保存在了后端，只需要通过客户端提供的sessionid就可以从后端查出来，如下：

# 客户端的sessionid以session_key字段保存在数据库中，
# session_data就是我们通过`request.session`方法设置的那两个键值对
mysql> select * from  django_session where session_key = 'e0al3gtpek2q7dnvi3b6byx3i4e38xpr'\G
*************************** 1. row ***************************
 session_key: e0al3gtpek2q7dnvi3b6byx3i4e38xpr
session_data: eyJpc19sb2dpbiI6dHJ1ZSwidXNlcm5hbWUiOiJsdmppYW56aGFvIn0:1n6jc1:a0TAWdeD6yQxCgrTDgbLwJitLrbddocQdt2o93AIQXo
 expire_date: 2022-01-24 01:36:41.904081
1 row in set (0.00 sec)

退出登录功能

如果想要增加“退出登录”的按钮，只需要：

1、增加urls.py路由：

urlpatterns = [
    ............
    path('logout/', views.logout, name='logout'),
    ............
]

2、定义相应的视图函数：

def logout(request):
    request.session.flush()         # 只需要这一句话，就会删除客户端的cookie及服务端session表中的记录
    return redirect('session_login')

3、前端页面增加退出按钮：

<div>
    <a href="/logout/">退出</a>
</div>

django中操作session

注意：这都是django提供的方法，其他的框架就需要框架自己关于cookie和session的方法了。

获取、设置、删除Session中数据

# 取值
request.session['k1'] 
# request.session这句是帮你从cookie里面将sessionid的值取出来，
# 将django-session表里面的对应sessionid的值的那条记录中的session-data字段的数据给你拿出来（并解密）,get方法就取出k1这个键对应的值
request.session.get('k1',None) 

# 设置值
request.session['k1'] = 123
request.session.setdefault('k1',123) # 设置默认值，存在值则不设置

#删除值
del request.session['k1']  # django-session表里面同步删除

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

会话session的key

session_key = request.session.session_key  # 获取sessionid的值

将所有Session失效日期小于当前日期的数据删除，将过期的删除

request.session.clear_expired()

检查会话session的key在数据库中是否存在

request.session.exists("session_key") #session_key就是那个sessionid的值

删除当前会话的所有Session数据

request.session.delete()

删除当前的会话数据并删除会话的Cookie

request.session.flush()  # 常用，清空所有cookie---删除session表里的这个会话的记录，
# 这用于确保前面的会话数据不可以再次被用户的浏览器访问，例如，django.contrib.auth.logout() 函数中就会调用它。

设置会话Session和Cookie的超时时间

request.session.set_expiry(value)
    '''
    - 如果value是个整数，session会在些秒数后失效。
    - 如果value是个datatime或timedelta，session就会在这个时间后失效。
    - 如果value是0,用户关闭浏览器session就会失效。
    - 如果value是None,session会依赖全局session失效策略。
    '''

修改session_name

django默认的session_cookie_name为sessionid，如下：

这个值是在全局配置文件中定义的，如下：

我们可以在自己项目的settings.py文件中去定义session的名字，如下：

然后浏览器就可以看到session的名字发生了变化（需要重新登录）：

django中关于session的配置

注意：这些配置都是可以往settins.py文件中定义的。

Django中默认支持Session，其内部提供了5种类型的Session供我们使用。

# 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，默认修改之后才保存（默认）

CBV中加装饰器

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 == 'ljz' and pwd == "ljz123":
            next_url = request.GET.get("next")
            # 生成随机字符串
            # 写浏览器cookie -> session_id: 随机字符串
            # 写到服务端session：
            # {
            #     "随机字符串": {'user':'ljz'}
            # }
            request.session['user'] = user
            if next_url:
                return redirect(next_url)
            else:
                return redirect('/index/')
        return render(request, 'login.html')

要在CBV视图中使用我们上面的session_is_login装饰器，有以下三种方式：

1、加在CBV视图的get或post方法上

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(session_is_login)
    def post(self, request):
        print("Home View POST method...")
        return redirect("/index/")

2、 加在dispatch方法上

因为CBV中首先执行的就是dispatch方法，所以这么写相当于给get和post方法都加上了登录校验。

from django.utils.decorators import method_decorator


class HomeView(View):


    @method_decorator(session_is_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/")

3、直接加在视图类上，但method_decorator必须传 name 关键字参数

如果get方法和post方法都需要登录校验的话就写两个装饰器。

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/")

CSRF Token相关装饰器

CSRF Token相关装饰器在CBV只能加到dispatch方法上，或者加在视图类上然后name参数指定为dispatch方法。

• csrf_protect：为当前函数强制设置防跨站请求伪造功能，即便settings中没有设置全局中间件。
• csrf_exempt：取消当前函数防跨站请求伪造功能，即便settings中设置了全局中间件。

from django.views.decorators.csrf import csrf_exempt, csrf_protect
from django.utils.decorators import method_decorator


class HomeView(View):

    @method_decorator(csrf_exempt)
    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/")

或者：

from django.views.decorators.csrf import csrf_exempt, csrf_protect
from django.utils.decorators import method_decorator


@method_decorator(csrf_exempt, name='dispatch')
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/")