django 緩存、中間件、信號、CSRF 詳解

時間 2019-12-12

標籤 django 緩存中間件信號 csrf 詳解欄目 Python 简体版

原文原文鏈接

中間件

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

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

與mange.py在同一目錄下的文件夾 wupeiqi/middleware下的auth.py文件中的Authentication類java

中間件中能夠定義四個方法，分別是：python

process_request(self,request) 接受request以後肯定所執行的view以前
process_view(self, request, callback, callback_args, callback_kwargs) 執行全部view以前須要執行這句
process_template_response(self,request,response) 包含render方法的才用這句
process_exception(self, request, exception) view拋出異常
process_response(self, request, response) view 執行以後

以上方法的返回值能夠是None和HttpResonse對象，若是是None，則繼續按照django定義的規則向下執行，若是是HttpResonse對象，則直接將該對象返回給用戶。mysql

自定義中間件

一、建立中間件類jquery

class Testmiddle(object):
    def process_request(self,request):
        print('Testmiddle process_request')
    def process_view(self, request, callback, callback_args, callback_kwargs):
        print('Testmiddle process_view')
    def process_exception(self, request, exception):
        pass
    def process_response(self, request, response):
        print('Testmiddle process_response')
        return response
    
class Nextmiddle(object):
    def process_request(self,request):
        print('Nextmiddle process_request')
    def process_view(self, request, callback, callback_args, callback_kwargs):
        print('Nextmiddle process_view')
    def process_exception(self, request, exception):
        pass
    def process_response(self, request, response):
        print('Nextmiddle process_response')
        return response

2.二、註冊中間件ajax

MIDDLEWARE_CLASSES = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
   # 'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.auth.middleware.SessionAuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    'middleware.middle.Testmiddle',
    'middleware.middle.Nextmiddle',
]

2.三、測試使用url和viewssql

from app01 import views
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^index/$', views.index),

]

def index(request):
    print 'This app01 Views.index'
    return HttpResponse('OK')

2.四、查看輸出結果：數據庫

'''
Testmiddle process_request
Nextmiddle process_request
Testmiddle process_view
Nextmiddle process_view
This app01 Views.index
Nextmiddle process_response
Testmiddle process_response
'''

從輸出結果能夠看出：django

他是先執行Testmiddle 的request 方法又執行了Nextmiddle的 process_request方法。。。。

2.五、原理：

當請求進來了到達中間件

去settings裏面找到MIDDLEWARE_CLASSES，MIDDLEWARE_CLASSES是一個元組

有4個列表：

process_request_lsit = []
process_view_list = []
process_response_list = []
而後他循環MIDDLEWARE_CLASSES這個類：
for 類 in MIDDLEWARE_CLASSES：
　　obj = 類()
　　if obj裏有process_request方法：
　　　　process_request_lsit.append(obj.process_request)

而後循環後後執行：

for i in process_request_list:
　　i() #加括號執行方法

for i in process_view_list:
    i() 
    ............

三、中間件的流程梳理

首先看下自定義的中間件中的process_response方法他是有返回值的其餘的是沒有返回值的。這個return response是什麼呢？

這個response就是我們自定義的views.index返回的結果！

def process_response(self, request, response):
        print( 'Testmiddle process_response')
        return response

若是在其餘的沒有返回值得，僅有process_response有返回值得話他的請求流程是這樣的：

可是若是在process_request或者process_view又返回值得話那麼流程就徹底不同了！

舉例：若是有m1和m2兩個中間件,若是我在m1中的request方法中設置了，若是訪問爲1.1.1.1那麼返回要一個404，那麼他的訪問流程是這樣的：

process_exception 何時觸發呢？我們定義的views.index出錯的時候他就會捕捉到而後執行我們定義的process_exception方法以下圖：

緩存

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

舉個例子來講：若是訪問量比較大的時候，有不少相同的操做好比：有時候請求的數據好比訪問同一條數據，或者同一個頁面的時候，實際上是不必的。

Django支持，mysql，Redis、Memecache、文件的方式作緩存，而且能夠設置超時時間。

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

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

一、配置

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

b、內存

  # 此緩存將內容保存至內存的變量中
    # 配置：
        CACHES = {
            'default': {
                'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
                'LOCATION': 'unique-snowflake',
            }
        }

    # 注：其餘配置同開發調試版本

c、文件

  # 此緩存將內容保存至文件
    # 配置：

        CACHES = {
            'default': {
                'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
                'LOCATION': '/var/tmp/django_cache',
            }
        }
    # 注：其餘配置同開發調試版本

d、數據庫

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

    # 配置：
        CACHES = {
            'default': {
                'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
                'LOCATION': 'my_cache_table', # 數據庫表
            }
        }

    # 注：執行建立表命令 python manage.py createcachetable

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

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

二、應用

a. 全站使用

 使用中間件，通過一系列的認證等操做，若是內容在緩存中存在，則使用FetchFromCacheMiddleware獲取內容並返回給用戶，當返回給用戶以前，判斷緩存中是否已經存在，若是不存在則UpdateCacheMiddleware會將緩存保存至緩存，從而實現全站緩存

    MIDDLEWARE = [
        'django.middleware.cache.UpdateCacheMiddleware',
        # 其餘中間件...
        'django.middleware.cache.FetchFromCacheMiddleware',
    ]

    CACHE_MIDDLEWARE_ALIAS = ""
    CACHE_MIDDLEWARE_SECONDS = ""
    CACHE_MIDDLEWARE_KEY_PREFIX = ""

b. 單獨視圖緩存

方式一：
from django.views.decorators.cache import cache_page

# #這裏設置的是 60秒 * 15 ,15分鐘以後
@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)),
]

c、局部視圖使用

  a. 引入TemplateTag

        {% load cache %}

    b. 使用緩存

        {% cache 5000 緩存key %}
            緩存內容
        {% endcache %}

信號

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

1.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          # 建立數據庫鏈接時，自動觸發

對於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 callback(sender, **kwargs):
        print("xxoo_callback")
        print(sender,kwargs)

    xxoo.connect(callback)
    # xxxoo指上述導入的模塊函數的內容

裝飾器信號（局部信號註冊）

from django.core.signals import request_finished
##傳入信號參數
from django.dispatch import receiver

receiver #調用這個方法，傳入信號參數
@receiver(request_finished)
def my_callback(sender, **kwargs):
    print("Request finished!")

二、自定義信號

a.定義信號（通常放在__init__文件中）

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

#providing_args=["toppings", "size"] 這是傳入參數能夠隨便改，觸發時對應上就能夠

b. 註冊信號

def callback(sender, **kwargs):
    print("callback")
    print(sender,kwargs)
 
###callback  這個函數名是固定的不能夠改

pizza_done.connect(callback)

c. 觸發信號

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

##sender 調用者

因爲內置信號的觸發者已經集成到Django中，因此其會自動調用，而對於自定義信號則須要開發者在任意位置觸發。

小案例

settings.py   ##裝在mysql

DATABASES = {
    'default': {
    'ENGINE': 'django.db.backends.mysql',
    'NAME':'day824',
    'USER': 'root',
    'PASSWORD': '*****',
    'HOST': '',
    'PORT': '',
    }
}



models.py

from django.db import models

class UserInfo(models.Model):  ##建立表
    name =models.CharField(max_length=64) #

# python manage.py makemigrations
# python manage.py migrate




__init__裏面導入

import pymysql
pymysql.install_as_MySQLdb()


django.py 下面的__init__方法  ，每次初始化progect時執行信號的註冊，

from django.db.models.signals import pre_save, post_save #導入信號
每次執行modal操做前pre_save 執行後 post_save 


##sender 調用者
def callback(sender,**kwargs):  ##modal對象保存前執行這個函數，
    print('pre_save_callback')
    print(sender,kwargs)

def callback1(sender, **kwargs):  ##modal對象保存後執行這個函數，
    print('poost_save_callback')
    print(sender,kwargs)

pre_save.connect(callback)  #調用函數
post_save.connect(callback) #調用函數


views.py

def cache3(request):
    t = time.time()
    print('befo')
    UserInfo.objects.create(name='alex')
    print('afte')
    return render(request,'cache3.html',{'t':t})



執行結果：

befo 
pre_save_callback  ##調用執行前的結果
<class 'app1.models.UserInfo'> {'instance': <UserInfo: UserInfo object>, 'raw': False, 'using': 'default', 'update_fields': None, 'signal': <django.db.models.signals.ModelSignal object at 0x02B3C3B0>}
pre_save_callback##調用執行前的結果
<class 'app1.models.UserInfo'> {'instance': <UserInfo: UserInfo object>, 'raw': False, 'update_fields': None, 'signal': <django.db.models.signals.ModelSignal object at 0x02B3C410>, 'using': 'default', 'created': True}
afte

緩存文件小案例

urls.py  ##配置路由

from app1 import views
urlpatterns = [
    url(r'^cache3/',views.cache3),
]


先得配置 settings.py


CACHES ={
    'default':{
        'BACKEND':'django.core.cache.backends.filebased.FileBasedCache',
        'LOCATION':os.path.join(BASE_DIR,'file') ##緩存存放的位置
    }
}

 views.py

def cache3(request):
    t = time.time() #時間戳
    return render(request,'cache3.html',{'t':t}) 


cache3.html

{% load cache %}
{# 導入 cache #}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
{{ t }}
{#普通時間戳 #}
<hr />
{% cache 10 nnn %}
{#    緩存的數據 #}
    {{ t }}
{% endcache %}
</body>
</html>

跨站請求僞造

1、簡介

django爲用戶實現防止跨站請求僞造的功能，經過中間件 django.middleware.csrf.CsrfViewMiddleware 來完成。而對於django中設置防跨站請求僞造功能有分爲全局和局部。在表單應用中，必須加上證書才能夠訪問，{% csrf_token %}

全局：

　　中間件 django.middleware.csrf.CsrfViewMiddleware

局部：

注：這裏得導入模塊

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

@csrf_protect，爲當前函數強制設置防跨站請求僞造功能，即使settings中沒有設置全局中間件，傳入任何POST請求均可以經過。
@csrf_exempt，取消當前函數防跨站請求僞造功能，即使settings中設置了全局中間件，任何POST請求都不經過。

2、應用

一、普通表單

veiw中設置返回值：
　　return render_to_response('Account/Login.html',data,context_instance=RequestContext(request))　　
     或者
     return render(request, 'xxx.html', data)
  
html中設置Token:
　　{% csrf_token %}   //設置證書

二、Ajax

對於傳統的form，能夠經過表單的方式將token再次發送到服務端，而對於ajax的話，使用以下方式。

view.py

from django.template.context import RequestContext
#一般咱們用的都是render ，render能夠生成token字符串，
#render_to_response 沒法生成token字符串，導入RequestContext 就能夠生成token字符串
# Create your views here.
  
  
def test(request):
  
    if request.method == 'POST':
        print request.POST
        return HttpResponse('ok')
    return  render_to_response('app01/test.html',context_instance=RequestContext(request))

text.html

<!DOCTYPE html>
<html>
<head lang="en">
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
    {% csrf_token %}
  
    <input type="button" onclick="Do();"  value="Do it"/>
  
    <script src="/static/plugin/jquery/jquery-1.8.0.js"></script>
    <script src="/static/plugin/jquery/jquery.cookie.js"></script>
    <script type="text/javascript">
        var csrftoken = $.cookie('csrftoken');
  
        function csrfSafeMethod(method) {
            // these HTTP methods do not require CSRF protection
            return (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method));
        }
        $.ajaxSetup({
            beforeSend: function(xhr, settings) {
                if (!csrfSafeMethod(settings.type) && !this.crossDomain) {
                    xhr.setRequestHeader("X-CSRFToken", csrftoken);
                }
            }
        });
        function Do(){
  
            $.ajax({
                url:"/app01/test/",
                data:{id:1},
                type:'POST',
                success:function(data){
                    console.log(data);
                }
            });
  
        }
    </script>
</body>
</html>