一Djano的中间件

1 中间件的概念

中间件顾名思义，是介于request与respose处理之间的一道处理过程，相对比较轻量级，并且全局上改变django的输入与输出。因为改变是全局，
所有需要谨慎使用，用不好会影响到性能

2 自定义中间件

中间件中一般有四个方法：
   process_request
   process_view
   process_exception
   process_response

当用户发起请求的时候依次讲过所有的中间件，这个时候的请求时process_request,最后到达views的函数中,views函数处理后，在依次穿过中间件，
这个时候process_response最后返回给请求者
我们自己定义一个中间件首先需要定义一个类再继承MiddlewareMixin

  1. from django.utils.deprecation import MiddlewareMixin
  2.  
  3. class CustomerMiddleware1(MiddlewareMixin):
  4.      def process_request(self, request):
  5.            print('CustomerMiddleware process_request1.....')
  6.  
  7.      def process_response(self, request, response):
  8.           print("中间件....返回1”）
  9.           return response
  10.  
  11.  class CustomerMiddleware2(MiddlewareMixin):
  12.        def process_request(self, request):
  13.            print('CustomerMiddleware process_request2.....')
  14.  
  15.        def process_response(self, request, response):
  16.            print("中间件....返回2”）
  17.            return response
  18.  
  19.  执行顺序：
  20.   CustomerMiddleware process_request
  21.   CustomerMiddleware process_request2.....
  22.   Index
  23.   中间件....返回2
  24.   中间件....返回1

3  process_view

当最后一个中间的process_request到达路由映射之后,返回到中间件1的process_view, 然后依次往下到达views函数
最后通过process_responese依次返回到达用户

  1. from django.utils.deprecation import MiddlewareMixin
  2. from django.shortcuts import HttpResponse
  3.  
  4. class Md1(MiddlewareMixin)
  5.  
  6.     def process_request(self,request)：
  7.            print("Md1请求")
  8.            # return HttpResponse("MD1中断")
  9.  
  10.     def process_response(self,request, response)
  11.            print("MD1返回")
  12.            return response
  13.  
  14.     def process_view(self, request, callback, callback_args, callback_kwargs)
  15.            # callback 要执行的那个视图函数
  16.            # callback_args  函数的参数
  17.            print("Md1view")
  18.  
  19. Class Md2(MiddlewareMixin)
  20.             def process_request(self, request)
  21.                 print("Md2请求")
  22.                 return HttpResponse("Md2中断")
  23.  
  24.             def process_response(self, request, response)
  25.                 print("Md2返回")
  26.                 return response
  27.  
  28.             def process_view(self, request, callback, callback_args, callback_kwargs)
  29.                 print("Md2view")
  30.

4  process_exception

如果在执行视图函数中出现错误，会依次走process_exception

  1. from django.utils.deprecation import MiddlewareMixin
  2.  from django.shortcuts import HttpResponse
  3.  
  4. class Md1(MiddlewareMixin)
  5.  
  6.     def process_request(self,request)：
  7.             print("Md1请求")
  8.             # return HttpResponse("MD1中断")
  9.  
  10.     def process_response(self,request, response)
  11.             print("MD1返回")
  12.             return response
  13.  
  14.     def process_view(self, request, callback, callback_args, callback_kwargs)
  15.            print("Md1view")
  16.  
  17.     def process_exception(self, exception):
  18.           print("md1 process_exception")
  19.  
  20. Class Md2(MiddlewareMixin)
  21.     def process_request(self, request)
  22.           print("Md2请求")
  23.           return HttpResponse("Md2中断")
  24.  
  25.     def process_response(self, request, response)
  26.           print("Md2返回")
  27.           return response
  28.  
  29.     def process_view(self, request, callback, callback_args, callback_kwargs)
  30.           print("Md2view")
  31.  
  32.     def process_exception(self, exception):
  33.           print("md2 process_exception")

二 缓存

由于Django是动态网站，所以每次请求均会去数据库进行响应的操作，当程序访问量大时，耗时必然会更加明显。使用缓存讲一个或某个view的返回值保存在内存或者memcache中，5分钟内有人来访问时则不再去执行view中的操作，而是直接从
内存或者redis之类的缓存中拿到内容并返回
Django中提供了6中缓存方式
    1 开发调试
    2 内存
    3 文件
    4 数据库
    5 Memcache缓存(python-memcached模块)
    6 Memcache缓存(pylibmc模块)

1 开发测试

此为开始调试用，实际内部不做任何操作

  1.  CACHES = {
  2.             'default': {
  3.                 'BACKEND': 'django.core.cache.backends.dummy.DummyCache',     # 引擎
  4.                 'TIMEOUT': 300,                                               # 缓存超时时间（默认300，None表示永不过期，0表示立即过期）
  5.                 'OPTIONS':{
  6.                     'MAX_ENTRIES': 300,                                       # 最大缓存个数（默认300）
  7.                     'CULL_FREQUENCY': 3,                                      # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
  8.                 },
  9.                 'KEY_PREFIX': '',                                             # 缓存key的前缀（默认空）
  10.                 'VERSION': 1,                                                 # 缓存key的版本（默认1）
  11.                 'KEY_FUNCTION' 函数名                                          # 生成key的函数（默认函数会生成为：【前缀:版本:key】）
  12.             }
  13.         }

配置

自定义key

  1. def default_key_func(key, key_prefix, version):
  2.             """
  3.             Default function to generate keys.
  4.  
  5.             Constructs the key used by all other methods. By default it prepends
  6.             the `key_prefix'. KEY_FUNCTION can be used to specify an alternate
  7.             function with custom key making behavior.
  8.             """
  9.             return '%s:%s:%s' % (key_prefix, version, key)
  10.  
  11. def get_key_func(key_func):
  12.             """
  13.             Function to decide which key function to use.
  14.  
  15.             Defaults to ``default_key_func``.
  16.             """
  17.             if key_func is not None:
  18.                 if callable(key_func):
  19.                     return key_func
  20.                 else:
  21.                     return import_string(key_func)
  22.             return default_key_func

2 内存

此缓存将内容保存至内存的变量中

  1. CACHES = {
  2.             'default': {
  3.                     'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
  4.                     'LOCATION': 'unique-snowflake',
  5.                 }
  6.             }

配置

注：其他配置同开发调试版本

3 文件

此缓存将内容保存至文件

  1.     CACHES = {
  2.             'default': {
  3.                     'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
  4.                     'LOCATION': '/var/tmp/django_cache',
  5.                 }
  6.             }
  7.     # 注：其他配置同开发调试版本

配置

4 数据库

此缓存将内容保存至数据库

  1.     CACHES = {
  2.             'default': {
  3.                     'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
  4.                     'LOCATION': 'my_cache_table', # 数据库表
  5.                 }
  6.             }
  7.      注：执行创建表命令 python manage.py createcachetable

配置

5 Memcache缓存（python-memcached模块）

此缓存使用python-memcached模块连接memcache

  1. ACHES = {
  2.             'default': {
  3.                 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
  4.                 'LOCATION': '127.0.0.1:11211',
  5.             }
  6.         }
  7.  
  8.         CACHES = {
  9.             'default': {
  10.                 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
  11.                 'LOCATION': 'unix:/tmp/memcached.sock',
  12.             }
  13.         }   
  14.  
  15.         CACHES = {
  16.             'default': {
  17.                 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
  18.                 'LOCATION': [
  19.                     '172.19.26.240:11211',
  20.                     '172.19.26.242:11211',
  21.                 ]
  22.             }
  23.         }

配置

6  Memcache缓存（pylibmc模块）

此缓存使用pylibmc模块连接memcache

  1.             CACHES = {
  2.                 'default': {
  3.                     'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
  4.                     'LOCATION': '127.0.0.1:11211',
  5.                 }
  6.             }
  7.  
  8.             CACHES = {
  9.                 'default': {
  10.                     'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
  11.                     'LOCATION': '/tmp/memcached.sock',
  12.                 }
  13.             }   
  14.  
  15.             CACHES = {
  16.                 'default': {
  17.                     'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
  18.                     'LOCATION': [
  19.                         '172.19.26.240:11211',
  20.                         '172.19.26.242:11211',
  21.                     ]
  22.                 }
  23.             }

配置

三 信号量

Django中提供了“信号调度”，用于在框架执行操作时解耦。通俗来讲，就是一些动作发生的时候，信号允许特定的发送者去提醒一些接受者。

1 Django内置信号

  1.  Model signals
  2.      pre_init                    # django的modal执行其构造方法前，自动触发
  3.      post_init                   # django的modal执行其构造方法后，自动触发
  4.      pre_save                    # django的modal对象保存前，自动触发
  5.      post_save                   # django的modal对象保存后，自动触发
  6.      pre_delete                  # django的modal对象删除前，自动触发
  7.      post_delete                 # django的modal对象删除后，自动触发
  8.      m2m_changed                 # django的modal中使用m2m字段操作第三张表（add,remove,clear）前后，自动触发
  9.      class_prepared              # 程序启动时，检测已注册的app中modal类，对于每一个类，自动触发
  10.  Management signals
  11.      pre_migrate                 # 执行migrate命令前，自动触发
  12.      post_migrate                # 执行migrate命令后，自动触发
  13.  Request/response signals
  14.      request_started             # 请求到来前，自动触发
  15.      request_finished            # 请求结束后，自动触发
  16.      got_request_exception       # 请求异常后，自动触发
  17.  Test signals
  18.      setting_changed             # 使用test测试修改配置文件时，自动触发
  19.      template_rendered           # 使用test测试渲染模板时，自动触发
  20.  Database Wrappers
  21.      connection_created          # 创建数据库连接时，自动触发

对于Django内置的信号，仅需注册指定信号，当程序执行相应操作时，自动触发注册函数：

  1.     from django.core.signals import request_finished
  2.     from django.core.signals import request_started
  3.     from django.core.signals import got_request_exception
  4.  
  5.     from django.db.models.signals import class_prepared
  6.     from django.db.models.signals import pre_init, post_init
  7.     from django.db.models.signals import pre_save, post_save
  8.     from django.db.models.signals import pre_delete, post_delete
  9.     from django.db.models.signals import m2m_changed
  10.     from django.db.models.signals import pre_migrate, post_migrate
  11.  
  12.     from django.test.signals import setting_changed
  13.     from django.test.signals import template_rendered
  14.  
  15.     from django.db.backends.signals import connection_created
  16.  
  17.     def callback(sender, **kwargs):
  18.         print("xxoo_callback")
  19.         print(sender,kwargs)
  20.  
  21.     xxoo.connect(callback)
  22.     # xxoo指上述导入的内容
  1. from django.core.signals import request_finished
  2. from django.dispatch import receiver
  3.  
  4. @receiver(request_finished)
  5. def my_callback(sender, **kwargs):
  6.     print("Request finished!")

2 自定义信号

a. 定义信号

  1.  import django.dispatch
  2.  pizza_done = django.dispatch.Signal(providing_args=["toppings", "size"])

b. 注册信号

  1.  def callback(sender, **kwargs):
  2.      print("callback")
  3.      print(sender,kwargs)
  4.  
  5.  pizza_done.connect(callback)

c. 触发信号

  1.  from 路径 import pizza_done
  2.  pizza_done.send(sender='seven',toppings=123, size=456)

四 CBV

我们之前往往在django中将一个路径对应到一个视图函数执行，这种模型简称为FBV。那么如果要使用到类的方式那么就要使用到CBV了
使用CBV是在django url控制器添加一条 path('login/', views.Login.as_view()), # 调用的Login 类下的as_view方法

它的原理: 在进入视图之前添加装饰器

  • 全部请求: 在进入dispatch方法之前
  • 特定请求: 在特定视图上用 @方法
  • 注意: 必须要使用method_decorator(my_decorator), 不能直接加my_decorator

1 使用CBV写一个登录认证

  1. # 注意每个类继承views.View, 父类下的dispatch会根据http的不同方法执行类下的方法
  2. from django views.View
  3. class Login(views.View):
  4.     msg = ''
  5.  
  6.     def get(self, request, *args, **kwargs):
  7.          return render(request,'login.html', {"msg": self.msg})
  8.  
  9.     def post(self, request, *args, **kwargs):
  10.         username = request.POST.get('username')
  11.         password = request.POST.get('password')
  12.         print(username, password)
  13.         user_obj = UserInfo.objects.filter(username=username, password=password).first()
  14.         print(user_obj)
  15.         if user_obj:
  16.                 request.session['is_login'] = True
  17.                 request.session['username'] = username
  18.                 return render(request, "index.html", {'username': username})
  19.         self.msg = '用户名或密码错误'
  20.         return render(request, 'login.html', {'msg': self.msg})

2 给类加装饰器

首先导入django的装饰器工具 from django.utils.decorators import method_decorator

  1. 自己写的装饰：
  2. def login_require(func):
  3.     def inner(req, *args, **kwargs):
  4.         is_login = req.session.get('is_login')
  5.         print(is_login)
  6.         username = req.session.get('username')
  7.         if is_login:
  8.             return func(req, username, *args, **kwargs)
  9.         return redirect('/login/')
  10.     return inner
  11.  
  12. 给index的get方法添加装饰器
  13. class Index(views.View):
  14.     @method_decorator(login_require)
  15.     def get(self, request, username, *args, **kwargs):
  16.             print(username)
  17.             return render(request, 'index.html', {'username': username})

3 父类的dispatch方法

如果要是想在父类的方法执行之前，先执行某个自定义的功能，可以通过继承dispatch方法实现

  1. class Order(views.View):
  2.     def dispatch(self, request, *args, **kwargs):
  3.             is_login = request.session.get('is_login')
  4.             print(is_login)
  5.             username = request.session.get('username')
  6.             if is_login:
  7.                 ret = super(Order, self).dispatch(request, *args, **kwargs)
  8.                 return ret
  9.             else:
  10.                 return redirect('/login/')
  11.  
  12.     def get(self, request, *args, **kwargs):
  13.             return render(request, 'Order.html')
  14.  
  15. #补充：如果多个类需要在执行get或post等方法执行额外功能，可以在每个类的dispatch方法前面加一个装饰器
  16. class Buy(views.View):
  17.         @method_decorator(login_require)
  18.         def dispatch(self, request, *args, **kwargs):
  19.             ret = super(Buy,self).dispatch(request, *args, **kwargs)
  20.             return ret

4 method_decorator装饰器还支持使用name参数指明被装饰的方法

  1. # 为全部请求方法添加装饰器
  2. @method_decorator(my_decorator, name='dispatch')
  3. class DemoView(View):
  4.     def get(self, request):
  5.         print('get方法')
  6.         return HttpResponse('ok')
  7.  
  8.     def post(self, request):
  9.         print('post方法')
  10.         return HttpResponse('ok')
  11.  
  12. # 为特定请求方法添加装饰器
  13. @method_decorator(my_decorator, name='get')
  14. class DemoView(View):
  15.     def get(self, request):
  16.         print('get方法')
  17.         return HttpResponse('ok')
  18.  
  19.     def post(self, request):
  20.         print('post方法')
  21.         return HttpResponse('ok')

WEB框架Django之中间件/缓存/CBV/信号的更多相关文章

  1. Django组件补充(缓存，信号，序列化)

    Django组件补充(缓存,信号,序列化) Django的缓存机制 1.1 缓存介绍 1.缓存的简介 在动态网站中,用户所有的请求,服务器都会去数据库中进行相应的增,删,查,改,渲染模板,执行业务逻辑 ...

  2. Django学习之缓存和信号

    Django学习之缓存和信号   一 缓存 由于Django是动态网站,所有每次请求均会去数据进行相应的操作,当程序访问量大时,耗时必然会更加明显,最简单解决方式是使用:缓存,缓存将一个某个views ...

  3. python运维开发(十七)----jQuery续(示例)web框架django

    内容目录: jQuery示例 前端插件 web框架 Django框架 jQuery示例 dom事件绑定,dom绑定在form表单提交按钮地方都会绑定一个onclick事件,所有查看网站的人都能看到代码 ...

  4. Web框架——Django笔记

    Web框架--Django笔记 MVC和MTV MVC:Model.View.Controller MTV:Model.Template.View Django--MTV 1.创建Django程序   ...

  5. Python3.5学习十八 Python之Web框架 Django

    Python之Web框架: 本质:Socket 引用wsgiref创建web框架 根据web框架创建过程优化所得: 分目录管理 模板单独目录 执行不同函数单独存入一个方法py文件 Web框架的两种形式 ...

  6. python web框架 Django进阶

    django 进阶 基础中,一些操作都是手动创建连接的非主流操作,这样显得太low,当然也是为了熟悉这个框架! 实际中,django自带连接数据库和创建app的机制,同时还有更完善的路由系统机制.既然 ...

  7. web框架---django

    15:31:14一.web框架1.框架:即framework,特指为解决一个开放性问题而设计的具有一定约束性的支撑结构,使用框架可以帮你快速开发特定的系统,简单地说,就是你用别人搭建好的舞台来做表演. ...

  8. python三大web框架Django,Flask,Flask，Python几种主流框架，13个Python web框架比较，2018年Python web五大主流框架

    Python几种主流框架 从GitHub中整理出的15个最受欢迎的Python开源框架.这些框架包括事件I/O,OLAP,Web开发,高性能网络通信,测试,爬虫等. Django: Python We ...

  9. WEB框架-Django框架学习-预备知识

    今日份整理,终于开始整个阶段学习的后期了,今日开始学习Django的框架,加油,你是最胖的! 1.web基础知识 1.1 web应用 Web应用程序是一种可以通过Web访问的应用程序,程序的最大好处是 ...

随机推荐

  1. vue项目插入视频-mp4

    1. v.vue文件: <template> <div> <div class="contain"> <my-video :sources ...

  2. MOSS 2007 错误0x80040E14解决

    今天公司内网莫名的出现错误,只能新建列表条目,不能创建网站,到后来列表条目也不能创建了,一直报0x80040E14错误.于是Google一把,搜索这个错误号,然后在apearce 的Blog找到了原因 ...

  3. iOS 两个页面之间的跳转

    -------->-------->-------->-------->-------->-------->-------->   以上完成页面one跳到页面 ...

  4. Oracle Oracle数据库 迁移到 SQL Server上

    原地址:https://blog.csdn.net/LongtengGensSupreme/article/details/81355181

  5. Python之路 - 网络编程初识

    Python之路 - 网络编程初识 前言

  6. rsync sersync搭建

    目标服务器 192.168.100.47 源服务器    192.168.100.46 目标服务器配置 [root@node01 nodejs]# cat /etc/rsyncd.conf #日志文件 ...

  7. reids遇到问题

    今天重启爬虫服务器在连接redis数据库时突然报错:MISCONF Redis is configured to save RDB snapshots, but it is currently not ...

  8. console.log() 字体颜色

    console.log("%c%s", "color: #fff; background: #20B2AA; font-size: 24px;", " ...

  9. 12.13java过关测试

    库存物资管理系统: 1.首先建两个数据表,一个pass用于商品的增删改查,一个passd记录商品的出库与入库信息: 2.建两个实体类,用来传递商品与单据的信息 3.在添加与删除时,填写入库或者出库单据 ...

  10. day10 文件处理指针使用 函数基本使用

    一:文件指针 强调:只有t模式下read(n),n代表字符个数,除此之外都是以字节为单位 with open('a.txt',mode='rt',encoding='utf-8') as f: #文本 ...