【python】-- Django 中間件、緩存、信號

Django  中間件、緩存、信號

1、 Django  中間件

django 中的中間件（middleware），在django中，中間件其實就是一個類，在請求到來和結束後，django會根據本身的規則在合適的時機執行中間件中相應的方法。

在django項目的settings模塊中，有一個 MIDDLEWARE_CLASSES 變量，其中每個元素就是一箇中間件：

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

一、中間件中能夠定義四個方法：

process_request(self,request)   #每一個進入view視圖中請求都要通過這個函數
process_response(self, request, response) #每一個從view視圖中返回的response都會觸發這個函數
process_view(self, request, callback, callback_args, callback_kwargs) #通過路由映射找到view中對應的方法後，就會觸發這個函數,找不到就不會觸發
process_template_response(self,request,response) # 若是Views中的函數返回的對象中，具備render方法，這個函數纔會執行
process_exception(self, request, exception)  #若是對應的視圖中的函數出現異常，這個函數纔會執行

二、自定義中間件

與mange.py在同一層級下新建目錄Middle，在Middle新建m1.py（文件名稱隨意）：

一、在m1.py中定義三個中間件

class Foo: # render 方法用來觸發process_template_response函數
    def render(self): return HttpResponse("template_response") def test(request): print("窮") return Foo()

views.py

from django.utils.deprecation import MiddlewareMixin  # 自定義中間件都須要繼承這個類

# 定義中間件Row1
class Row1(MiddlewareMixin): def process_request(self,request):  # 全部通過中間件Row1的request都會打印001
        print('request——001') # request這個參數是請求的request, view_func指定的視圖中對應的函數, view_func_args路由系統中的位置參數, view_func_kwargs路由系統中的關鍵字參數
    def process_view(self, request, view_func, view_func_args, view_func_kwargs): print('view1') def process_response(self, request, response):  # 全部通過中間件Row1的response 都會打印001
        print('response——001') return response from django.shortcuts import HttpResponse # 定義中間件Row2
class Row2(MiddlewareMixin): def process_request(self,request): print('request——002') # 若是不想讓request進入view視圖函數中，能夠在自定義中間件中直接return返回。
        # 終止以後就不會通過row3的response，會直接從row2 response返回, 這個特性是1.7以後纔有的。1.7之前會通過row3的response以後再進行返回。
        # return HttpResponse('終止')

    def process_view(self, request, view_func, view_func_args, view_func_kwargs): print('view2') def process_response(self, request, response): print('response——002') return response # 定義中間件Row3
class Row3(MiddlewareMixin): def process_request(self,request): print('request——003') def process_view(self, request, view_func, view_func_args, view_func_kwargs): print('view2') def process_response(self, request, response): print('response——003') return response # 這個函數的觸發條件就是若是對應的視圖中的函數出現異常，這個函數纔會執行
    def process_exception(self, request, exception): if isinstance(exception,ValueError): return HttpResponse('出現異常》。。') # 若是Views中的函數返回的對象中，具備render方法，這個函數纔會執行，像redirect,HttpResponse 都不會觸犯這個函數
    def process_template_response(self,request,response): print('-----------------------') return response

二、註冊中間件：

在settings文件中的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',
    'Middle.m1.Row1',
    'Middle.m1.Row2',
    'Middle.m1.Row3',
]

三、中間件request、response狀態流程示意圖：

 

 

2、Django  緩存

因爲Django是動態網站，全部每次請求均會去數據進行相應的操做，當程序訪問量大時，耗時必然會更加明顯，最簡單解決方式是使用：緩存，緩存將一個某個views的返回值保存至內存或者memcache中，5分鐘內再有人來訪問時，則再也不去執行view中的操做，而是直接從內存或者Redis中以前緩存的內容拿到，並返回，Django是目前僅有自帶緩存的框架。

Django中提供了7種緩存方式：

• 開發調試
• 內存
• 文件
• 數據庫
• Memcache緩存（python-memcached模塊）
• Memcache緩存（pylibmc模塊）
• Redis緩存

1、緩存配置方式

一、配置

a、開發調試

# 此爲開始調試用，實際內部不作任何操做
    # 配置：
        CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.dummy.DummyCache',     # 引擎
                'TIMEOUT': 300,                                               # 緩存超時時間（默認300，None表示永不過時，0表示當即過時）
                'OPTIONS':{ 'MAX_ENTRIES': 300,                                       # 最大緩存個數（默認300）
                    'CULL_FREQUENCY': 3,                                      # 緩存到達最大個數以後，剔除緩存個數的比例，即：1/CULL_FREQUENCY（默認3）
 }, 'KEY_PREFIX': '',                                             # 緩存key的前綴（默認空）
                'VERSION': 1,                                                 # 緩存key的版本（默認1）
                'KEY_FUNCTION' 函數名                                          # 生成key的函數（默認函數會生成爲：【前綴:版本:key】）
 } } # 自定義key
    def default_key_func(key, key_prefix, version): """ Default function to generate keys. Constructs the key used by all other methods. By default it prepends the `key_prefix'. KEY_FUNCTION can be used to specify an alternate function with custom key making behavior. """
        return '%s:%s:%s' % (key_prefix, version, key) def get_key_func(key_func): """ Function to decide which key function to use. Defaults to ``default_key_func``. """
        if key_func is not None: if callable(key_func): return key_func else: return import_string(key_func) return default_key_func

View Code

b、內存

# 此緩存將內容保存至內存的變量中
    # 配置：
        CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache', 'LOCATION': 'unique-snowflake',  #變量值要惟一
 } } # 注：其餘配置同開發調試版本

View Code

c、文件

# 此緩存將內容保存至文件
    # 配置：
 CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache', 'LOCATION': '/var/tmp/django_cache', } } # 注：其餘配置同開發調試版本

View Code

d、數據庫

# 此緩存將內容保存至數據庫

    # 配置：
        CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.db.DatabaseCache', 'LOCATION': 'my_cache_table', # 數據庫表
 } } # 注：執行建立表命令 python manage.py createcachetable

View Code

e、Memcache緩存（python-memcached模塊）

# 此緩存使用python-memcached模塊鏈接memcache
 CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache', 'LOCATION': '127.0.0.1:11211', } } CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache', 'LOCATION': 'unix:/tmp/memcached.sock', } } CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache', 'LOCATION': [ '172.19.26.240:11211', '172.19.26.242:11211', ] } }

View Code

f、Memcache緩存（pylibmc模塊）

# 此緩存使用pylibmc模塊鏈接memcache
 CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache', 'LOCATION': '127.0.0.1:11211', } } CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache', 'LOCATION': '/tmp/memcached.sock', } } CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache', 'LOCATION': [ '172.19.26.240:11211', '172.19.26.242:11211', ] } }

View Code

g. Redis緩存（依賴：pip3 install django-redis）

CACHES = { "default": { "BACKEND": "django_redis.cache.RedisCache", "LOCATION": "redis://127.0.0.1:6379", "OPTIONS": { "CLIENT_CLASS": "django_redis.client.DefaultClient", "CONNECTION_POOL_KWARGS": {"max_connections": 100} # "PASSWORD": "密碼",
 } } }

View Code

from django_redis import get_redis_connection conn = get_redis_connection("default")

視圖種鏈接並操做

二、緩存的三種方式：

 使用中間件，通過一系列的認證等操做，若是內容在緩存中存在，則使用FetchFromCacheMiddleware獲取內容並返回給用戶，當返回給用戶以前，判斷緩存中是否已經存在，若是不存在則UpdateCacheMiddleware會將緩存保存至緩存，從而實現全站緩存 MIDDLEWARE = [ 'django.middleware.cache.UpdateCacheMiddleware',   #這個要設置在最上層，通過全部中間件的response認證以後再把緩存內容返回給用戶
        # 其餘中間件...
        'django.middleware.cache.FetchFromCacheMiddleware',    #這個中間件要設置在全部中間件最下層,好比若是設置CSRF中間件前，request請求不用經過csrf認證就能拿到返回
 ] CACHE_MIDDLEWARE_ALIAS = "" CACHE_MIDDLEWARE_SECONDS = "" CACHE_MIDDLEWARE_KEY_PREFIX = ""

全局設置緩存

 方式一： from django.views.decorators.cache import cache_page @cache_page(60 * 15)   #經過裝飾器，單位是秒
        def my_view(request): ... 方式二： from django.views.decorators.cache import cache_page urlpatterns = [ url(r'^foo/([0-9]{1,2})/$', cache_page(60 * 15)(my_view)), ]

單獨視圖緩存

 a. 引入TemplateTag {% load cache %} b. 使用緩存 {% cache 5000 緩存key %}  # 時間以秒爲單位，緩存key自定義
 緩存內容 {% endcache %}

單獨模板緩存

三種緩存方式的優先級：若是三種緩存方式同時存在的話，全局設置緩存>單獨視圖緩存>單獨模板緩存, 優先級跟請求生命週期有關

三、文件緩存示例：

a、settings.py中配置

CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache', 'LOCATION': os.path.join(BASE_DIR,'cache')   #cache文件的保存路徑
 } }

b、templates下的html文本

{% load cache %}  #導入緩存模塊
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
    <h1>{{ ctime }}</h1>
    <h1>{{ ctime }}</h1> {% cache 10 k1 %}    #緩存10秒
        <h1>{{ ctime }}</h1> {% endcache %} </body>
</html>

cache.html

c、views.py中的函數

from django.views.decorators.cache import cache_page @cache_page(10)  #緩存10秒
def cache(request): import time ctime = time.time() return render(request, 'cache.html', {'ctime': ctime})

 更多Django緩存內容：點擊

 

3、Django 信號

Django中提供了「信號調度」，用於在框架執行操做時解耦。通俗來說，就是一些動做發生的時候，信號容許特定的發送者去提醒一些接受者。

一、Django內置信號

Model signals
    pre_init                    # django的modal執行其構造方法前，自動觸發
    post_init                   # django的modal執行其構造方法後，自動觸發
    pre_save                    # django的modal對象保存前，自動觸發
    post_save                   # django的modal對象保存後，自動觸發
    pre_delete                  # django的modal對象刪除前，自動觸發
    post_delete                 # django的modal對象刪除後，自動觸發
    m2m_changed                 # django的modal中使用m2m字段操做第三張表（add,remove,clear）先後，自動觸發
    class_prepared              # 程序啓動時，檢測已註冊的app中modal類，對於每個類，自動觸發
Management signals
    pre_migrate                 # 執行migrate命令前，自動觸發
    post_migrate                # 執行migrate命令後，自動觸發
Request/response signals
    request_started             # 請求到來前，自動觸發
    request_finished            # 請求結束後，自動觸發
    got_request_exception       # 請求異常後，自動觸發
Test signals
    setting_changed             # 使用test測試修改配置文件時，自動觸發
    template_rendered           # 使用test測試渲染模板時，自動觸發
Database Wrappers
    connection_created          # 建立數據庫鏈接時，自動觸發

內置信號的觸發示例：

a.建立信號觸發方式

在manage.py同級目錄下建立sg.py文件（路徑可自定義）

# Django 全部內置函數的導入方式
from django.core.signals import request_finished from django.core.signals import request_started from django.core.signals import got_request_exception from django.db.models.signals import class_prepared from django.db.models.signals import pre_init, post_init from django.db.models.signals import pre_save, post_save from django.db.models.signals import pre_delete, post_delete from django.db.models.signals import m2m_changed from django.db.models.signals import pre_migrate, post_migrate from django.test.signals import setting_changed from django.test.signals import template_rendered from django.db.backends.signals import connection_created # 自定義一個函數
def f1(sender, **kwargs): print("hello") # print(sender,kwargs)

# 內置信號關聯觸發函數
pre_save.connect(f1)

b.讓view中的函數觸發信號

須要在與工程同名的目錄下的__init__.py文件中導入剛剛建立的sg.py文件

import sg

c 、view.py中進行save操做：

def signal(reuqest):
    from app01 import models

    obj = models.UserInf(user='root')
    print('start')
    obj.save()

    obj = models.UserInf(user='root')
    obj.save()

    obj = models.UserInf(user='root')
    obj.save()

在每一個save操做後，信號都會觸發一次觸發函數，打印一次hello
# 輸出： 
start
hello
hello
hello

二、自定義信號

a.sg.py中自定義信號

import django.dispatch  # 導入自定義信號類

# pizza_done 信號名能夠自定義 providing_args=["toppings", "size"] 這個設置的是pizza_done信號的觸發條件
pizza_done = django.dispatch.Signal(providing_args=["toppings", "size"]) def f2(sender, **kwargs): print("f2_callback") print(sender, kwargs) # 自定義信號關聯觸發函數
pizza_done.connect(f2)

b.__init__.py文件

import sg

c 、view.py文件

from sg import pizza_done   #導入自定義信號

pizza_done.send(sender="kkk",toppings=123, size=456)  #sender 名字自定義 

return HttpResponse('ok')