Django基础知识整理（四）--Cookie-Session-类视图-中间件

最新推荐文章于 2024-04-21 15:37:50 发布

冰履踏青云

最新推荐文章于 2024-04-21 15:37:50 发布

阅读量991

点赞数

分类专栏： Django 文章标签： Django请求响应视图中间件

本文为博主原创文章，未经博主允许不得转载。

本文链接：https://blog.csdn.net/weixin_44327634/article/details/112881440

版权

Django 专栏收录该内容

10 篇文章 7 订阅

订阅专栏

Cookie

1.什么是Cookie

Cookie，有时也用其复数形式Cookies，指某些网站为了辨别用户身份、进行session跟踪而储存在用户本地终端上的数据（通常经过加密）。

Cookie最早是网景公司的前雇员Lou Montulli在1993年3月的发明。Cookie是由服务器端生成，发送给User-Agent（一般是浏览器），浏览器会将Cookie的key/value保存到某个目录下的文本文件内，下次请求同一网站时就发送该Cookie给服务器（前提是浏览器设置为启用cookie）。Cookie名称和值可以由服务器端开发自己定义，这样服务器可以知道该用户是否是合法用户以及是否需要重新登录等。服务器可以利用Cookies包含信息的任意性来筛选并经常性维护这些信息，以判断在HTTP传输中的状态。

Cookie是存储在浏览器中的一段纯文本信息，建议不要存储敏感信息如密码，因为电脑上的浏览器可能被其它人使用。

2.Cookie的特点

Cookie以键值对的格式进行信息的存储。
Cookie基于域名安全，不同域名的Cookie是不能互相访问的，如访问json.cn时向浏览器中写了Cookie信息，使用同一浏览器访问baidu.com时，无法访问到json.cn写的Cookie信息。
当浏览器请求某网站时，会将浏览器存储的跟网站相关的所有Cookie信息提交给网站服务器。

3.设置Cookie

可以通过HttpResponse对象中的set_cookie方法来设置cookie。

HttpResponse.set_cookie(cookie名, value=cookie值, max_age=cookie有效期)

max_age 单位为秒，默认为None。如果是临时cookie，可将max_age设置为None。

def demo_view(request):
    response = HttpResponse('cookie测试')
    response.set_cookie('django1', 'python1')  # 临时cookie，关闭浏览器再次访问路由不存在
    response.set_cookie('django2', 'python2', max_age=3600)  # 有效期一小时
    return response

在这里插入图片描述

4.读取Cookie

可以通过HttpRequest对象的COOKIES属性来读取本次请求携带的cookie值。request.COOKIES为字典类型。

def demo_view1(request):
    cookie1 = request.COOKIES.get('django1')
    print(cookie1)
    return HttpResponse('OK')

将它的路由设置成空即首页，再次访问http://127.0.0.1:8000/user/cook/

在这里插入图片描述

Session

1. 启用Session

Django项目默认启用Session。

可以在settings.py文件中查看，如图所示
在这里插入图片描述
所以如需禁用session，直接将上图中的session中间件注释掉即可。

2.Session的存储方式

在settings.py文件中，可以设置session数据的存储方式，一般来说有三种存储方式：数据库、本地缓存、混合存储。

2.1 数据库

存储在数据库中，如下设置可以写，也可以不写，这是默认存储方式。

SESSION_ENGINE='django.contrib.sessions.backends.db'

如果存储在数据库中，需要在项INSTALLED_APPS中安装Session应用。
在这里插入图片描述

以上都是在django创建时自带的，无需自己配置

在这里插入图片描述
默认用的就是sqlite3数据库文件。

2.2 本地缓存

存储在本机内存中，如果丢失则不能找回，比数据库的方式读写更快。一般都用redis。

SESSION_ENGINE='django.contrib.sessions.backends.cache'

2.3 混合存储

优先从本机内存中存取，如果没有则从数据库中存取。

SESSION_ENGINE='django.contrib.sessions.backends.cached_db'

本地缓存示例

这里介绍在redis中保存session，需要引入第三方扩展，我们可以使用django-redis来解决。
安装好redis数据库之后：
1）安装扩展

pip install django-redis

2）配置

在settings.py文件中做如下设置

CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379/1",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
        }
    }
}
SESSION_ENGINE = "django.contrib.sessions.backends.cache"
SESSION_CACHE_ALIAS = "default"

3.Session操作

通过HttpRequest对象的session属性进行会话的读写操作。

1）以键值对的格式写session。

request.session['键']=值

2）根据键读取值。

request.session.get('键',默认值)

3）清除所有session，在存储中删除值部分。

request.session.clear()

4）清除session数据，在存储中删除session的整条数据。

request.session.flush()

5）删除session中的指定键及值，在存储中只删除某个键及对应的值。

del request.session['键']

6）设置session的有效期

request.session.set_expiry(value)

如果value是一个整数，session将在value秒没有活动后过期。
如果value为0，那么用户session的Cookie将在用户的浏览器关闭时过期。
如果value为None，那么session有效期将采用系统默认值，默认为两周，可以通过在settings.py中设置SESSION_COOKIE_AGE来设置全局默认值。

类视图

1. 类视图引入

以函数的方式定义的视图称为函数视图，函数视图便于理解。但是遇到一个视图对应的路径提供了多种不同HTTP请求方式的支持时，便需要在一个函数中编写不同的业务逻辑，代码可读性与复用性都不佳。

在Django中也可以使用类来定义一个视图，称为类视图。
使用类视图可以将视图对应的不同请求方式以类中的不同方法来区别定义。如下所示:

from django.views.generic import View

class RegisterView(View):
    """类视图：处理注册"""

    def get(self, request):
        """处理GET请求，返回注册页面"""
       return HttpResponse('get请求返回注册页面')

    def post(self, request):
        """处理POST请求，实现注册逻辑"""
        return HttpResponse('post这里实现注册逻辑')

类视图的好处：

1.代码可读性好
2.类视图相对于函数视图有更高的复用性，如果其他地方需要用到某个类视图的某个特定逻辑，直接继承该类视图即可.

2. 类视图使用

定义类视图需要继承自Django提供的父类View，可使用from django.views import View或者from django.views.generic.base import View 导入，配置路由时，使用类视图的as_view()方法来添加。

urlpatterns = [
    # 视图函数：注册
    # url(r'^register/$', views.register, name='register'),
    # 类视图：注册
    url(r'^register/$', views.RegisterView.as_view(), name='register'),
]

3. 类视图原理

点开from django.views import View或者from django.views.generic.base import View
里面导入的view可以查看其底层逻辑的实现：

 @classonlymethod
    def as_view(cls, **initkwargs):
        """
        Main entry point for a request-response process.
        """
        ...省略代码...

        def view(request, *args, **kwargs):
            self = cls(**initkwargs)
            if hasattr(self, 'get') and not hasattr(self, 'head'):
                self.head = self.get
            self.request = request
            self.args = args
            self.kwargs = kwargs
            # 调用dispatch方法，按照不同请求方式调用不同请求方法
            return self.dispatch(request, *args, **kwargs)

        ...省略代码...

        # 返回真正的函数视图
        return view


    def dispatch(self, request, *args, **kwargs):
        # Try to dispatch to the right method; if a method doesn't exist,
        # defer to the error handler. Also defer to the error handler if the
        # request method isn't on the approved list.
        if request.method.lower() in self.http_method_names:
            handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
        else:
            handler = self.http_method_not_allowed
        return handler(request, *args, **kwargs)

4. 为类视图添加装饰器（了解即可）

为类视图添加装饰器，可以使用两种方法:在URL配置中装饰和在类视图中装饰。
为了理解方便，我们先来定义一个为函数视图准备的装饰器（在设计装饰器时基本都以函数视图作为考虑的被装饰对象），及一个要被装饰的类视图。

def my_decorator(func):
    def wrapper(request, *args, **kwargs):
        print('自定义装饰器被调用了')
        print('请求路径%s' % request.path)
        return func(request, *args, **kwargs)
    return wrapper

class DemoView(View):
    def get(self, request):
        print('get方法')
        return HttpResponse('ok')

    def post(self, request):
        print('post方法')
        return HttpResponse('ok')

在URL配置中装饰：

urlpatterns = [
    url(r'^demo/$', my_decorate(DemoView.as_view()))
]

此种方式会为类视图中的所有请求方法都加上装饰器行为（因为是在视图入口处，分发请求方式前）。这种方式最简单，但因装饰行为被放置到了url配置中，单看视图的时候无法知道此视图还被添加了装饰器，不利于代码的完整性，不建议使用。

在类视图中装饰：
在类视图中使用为函数视图准备的装饰器时，不能直接添加装饰器，需要使用method_decorator将其转换为适用于类视图方法的装饰器。

method_decorator装饰器使用name参数指明被装饰的方法

# 为全部请求方法添加装饰器
@method_decorator(my_decorator, name='dispatch')
class DemoView(View):
    def get(self, request):
        print('get方法')
        return HttpResponse('ok')

    def post(self, request):
        print('post方法')
        return HttpResponse('ok')


# 为特定请求方法添加装饰器
@method_decorator(my_decorator, name='get')
class DemoView(View):
    def get(self, request):
        print('get方法')
        return HttpResponse('ok')

    def post(self, request):
        print('post方法')
        return HttpResponse('ok')

如果需要为类视图的多个方法添加装饰器，但又不是所有的方法（为所有方法添加装饰器参考上面例子），可以直接在需要添加装饰器的方法上使用method_decorator，如下所示：

from django.utils.decorators import method_decorator

# 为特定请求方法添加装饰器
class DemoView(View):

    @method_decorator(my_decorator)  # 为get方法添加了装饰器
    def get(self, request):
        print('get方法')
        return HttpResponse('ok')

    @method_decorator(my_decorator)  # 为post方法添加了装饰器
    def post(self, request):
        print('post方法')
        return HttpResponse('ok')

    def put(self, request):  # 没有为put方法添加装饰器
        print('put方法')
        return HttpResponse('ok')

中间件

Django中的中间件是一个轻量级、底层的插件系统，可以介入Django的请求和响应处理过程，修改Django的输入或输出。中间件的设计为开发者提供了一种无侵入式的开发方式，增强了Django框架的健壮性。

我们可以使用中间件，在Django处理视图的不同阶段对输入或输出进行干预。

1.中间件的定义方法

定义一个中间件工厂函数，然后返回一个可以被调用的中间件。

中间件工厂函数需要接收一个可以调用的get_response对象。

返回的中间件也是一个可以被调用的对象，并且像视图一样需要接收一个request对象参数，返回一个response对象。

def simple_middleware(get_response):
    # 此处编写的代码仅在Django第一次配置和初始化的时候执行一次。

    def middleware(request):
        # 此处编写的代码会在每个请求处理视图前被调用。

        response = get_response(request)

        # 此处编写的代码会在每个请求处理视图之后被调用。

        return response

    return middleware

例如，在users应用中新建一个middleware.py文件：

def my_middleware(get_response):
    print('init初始化被调用')
    def middleware(request):
        print('request请求前被调用')
        response = get_response(request)
        print('response响应后被调用')
        return response
    return middleware

定义好中间件后，需要在settings.py 文件中添加注册中间件

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    # 'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    'users.middleware.my_middleware',  # 添加中间件
]

定义一个视图进行测试

def demo_view(request):
    print('view 视图被调用')
    return HttpResponse('OK')

在这里插入图片描述

2.执行流程

在这里插入图片描述

3. 多个中间件的执行顺序

在请求视图被处理前，中间件由上至下依次执行
在请求视图被处理后，中间件由下至上依次执行

在这里插入图片描述
示例：

定义两个中间件

def my_middleware(get_response):
    print('init初始化被调用')
    def middleware(request):
        print('request请求前被调用')
        response = get_response(request)
        print('response响应后被调用')
        return response
    return middleware

def my_middleware2(get_response):
    print('init2初始化被调用')
    def middleware(request):
        print('request2请求前被调用')
        response = get_response(request)
        print('response2响应后被调用')
        return response
    return middleware

注册添加两个中间件:

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    # 'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    'users.middleware.my_middleware',  # 添加
    'users.middleware.my_middleware2',  # 添加
]

执行结果:
在这里插入图片描述

冰履踏青云

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Django基础知识整理（四）--Cookie-Session-类视图-中间件

文章目录Cookie1.什么是Cookie2.Cookie的特点3.设置Cookie4.读取CookieSession1. 启用Session2.Session的存储方式2.1 数据库2.2 本地缓存2.3 混合存储本地缓存示例3.Session操作类视图1. 类视图引入2. 类视图使用3. 类视图原理4. 为类视图添加装饰器（了解即可）中间件1.中间件的定义方法2.执行流程3. 多个中间件的执行顺序Cookie1.什么是CookieCookie，有时也用其复数形式Cookies，指某些网站为了辨别用
复制链接

扫一扫