Django學習筆記（15）——中間件

　　當Django處理一個Request的過程是首先通過中間件，然后再通過默認的URL方式進行的。我們可以在Middleware這個地方把所有Request攔截住，用我們自己的方式完成處理以后直接返回Response，因此了解中間件的構成是非常有必要的。

1，中間件的概念

　　一個完整的Django流程如下：

 

 

Django默認的Middleware如下：

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

　　每一個中間件都有具體的功能。中間件可以定義五個方法。

分析源碼

　　我們可以查看上面middleware 的源碼，我們首先導入security：

from django.middleware.security import SecurityMiddleware

　　我們查看源碼，會發現：

　　同樣，我們再查看一個：

from django.middleware.common import CommonMiddleware

　　我們查看源碼，會發現：

再來繼續：

from django.middleware.csrf import CsrfViewMiddleware

　　我們查看源碼，發現：

　　我們是不是發現了一個共同的特點。也就是都有process_request和process_response。但是並不是所有的中間件都有process_request，但是所有中間件都有process_response。而且我們在寫中間件的時候，在process_response一定要注意有返回值！！，process_request沒有！！，如果process_request有return值的時候，就不會執行后面的程序了（所以這里可以攔截）

from django.middleware.clickjacking import XFrameOptionsMiddleware

　　查看源碼：

 

　　我們從瀏覽器發出一個請求Request，得到一個響應后的內容HttpResponse，也就是說，每一個請求都是先通過中間件中的process_request函數，這個函數返回None 或者HttpResponse 對象，如果返回前者，繼續處理其他中間件，如果返回前者，繼續處理其他中間件，如果返回一個HttpResponse，就處理終止，返回到網頁上。

　　中間件不用集成任何類（可以繼承object），下面一個中間件大概的樣子：

class CommonMiddleware(object):
    def process_request(self, request):
        return None

    def process_response(self, request, response):
        return response

　　還有process_view，process_exception和process_template_response函數。

　　中間件顧名思義，是介於request 與 response處理之間的一道處理過程，相對比較輕量級，並且在全局上改變django的輸入與輸出。因為改變的是全局，所以需要謹慎實用，用不好會影響到性能。

Django中間層的定義

Middleware is a framework of hooks into Django’s request/response processing. 

It’s a light, low-level “plugin” system for globally altering Django’s input or output.

　　如果你想修改請求，例如被傳送到view中的HTTPRequest對象。或者你想修改view返回的HTTPResponse對象，這些都可以通過中間件來實現。

　　可能你想在view執行之前做一些操作，這種情況就可以用middleware來實現。

 

2，自定義中間件的方法

　　中間件一共有五個方法：

process_request（self, request）

process_view（self, request, callback, callback_args, callback_kwargs）

process_template_response()

process_exception(self, request, exception)

process_response(self, request, response)

　　

2.1  Request 預處理函數：process_request(self, request)

　　這個方法的調用時機在Django接收到request之后，但仍未解析URL以確定應當運行的視圖函數。Django向它傳入相應的Request對象，以便在方法中修改。

　　如果返回None，Django將繼續處理這個request，執行后續的中間件，然后調用相應的view。

　　如果返回HttpResponse對象，Django將不再執行任何除了process_response以外的其他的中間件以及相應的view，Django將立即返回該HttpResponse。

 

2.2  View預處理函數：process_view(self, request, callback, callback_args, callback_kwargs)

　　這個方法的調用時機在Django執行完request預處理函數並確定待執行的view（即callback參數）之后，但在view函數實際執行之前。

request：HttpRequest 對象。

callback：Django將調用的處理request的python函數. 這是實際的函數對象本身,
 而不是字符串表述的函數名。

args：將傳入view的位置參數列表，但不包括request參數(它通常是傳入view的第一個參數)。

kwargs：將傳入view的關鍵字參數字典。

　　process_view() 應當返回None或 HttpResponse 對象。如果返回 None， Django將繼續處理這個request ，執行后續的中間件， 然后調用相應的view。

如果返回 HttpResponse 對象，Django 將不再執行任何其它的中間件(不論種類)以及相應的view，Django將立即返回。

 

2.3  Template模板渲染函數：process_template_response()

　　默認不執行，只有在視圖函數的返回結果對象中有render方法才會執行，並把對象的render方法的返回值返回給用戶（注意不返回視圖函數的return的結果了，而是返回視圖函數return值（對象）中render方法的結果）

 

2.4  Exception后處理函數：process_exception(self, request, exception)

　　這個方法只有在request處理過程中出了問題並且view函數拋出了一個未捕獲的異常才會被調用。這個鈎子可以用來發送錯誤通知，將現場相關信息輸出到日志文件，或者甚至嘗試從錯誤中自動恢復。

　這個函數的參數除了一貫的request對象之外，還包括view函數拋出的實際的異常對象exception 。

　　process_exception() 應當返回None或HttpResponse對象。如果返回None，Django將用框架內置的異常處理機制繼續處理相應request。如果返回HttpResponse對象，Django將使用該response對象，而短路框架內置的異常處理機制。

 

2.5  Response 后處理函數：process_response(self, request, response)

　　這個方法的調用時機在 Django 執行 view 函數並生成 response 之后。

　　該處理器能修改response 的內容；一個常見的用途是內容壓縮，如gzip所請求的HTML頁面。

　　這個方法的參數相當直觀：request是request對象，而response則是從view中返回的response對象。

　　process_response() 必須返回 HttpResponse 對象. 這個 response 對象可以是傳入函數的那一個原始對象（通常已被修改），也可以是全新生成的。

 

3，  自定義中間件方法練習

3.1 自定義中間件方法應用1（關於process_request 和 process_response方法）

　　　　當用戶發起請求的時候會依次經過所有的中間件，這個時候的請求是process_request，最后到達views的函數中，views函數處理后，在依次穿過中間件，這個時候是process_response，最后返回給請求者。

　　上述截圖中的中間件都是django中的，我們也可以自己定義一個中間件，我們可以自己寫一個類，但是必須繼承MiddlewareMixin。

（為什么必須繼承MiddlewareMinxin？  當時是因為我們之前查看settings里面的中間件的情形，他們也是這樣定義的。既然都是中間件，我們就需要按照人家的語法來寫）

需要導入：

from django.utils.deprecation import MiddlewareMixin

　　

 

 在 views 中：

def index(request):

    print("view函數...")
    return HttpResponse("OK")

　　

在Mymiddlewares.py 中：

from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import HttpResponse

class Md1(MiddlewareMixin):

    def process_request(self,request):
        print("Md1請求")

    def process_response(self,request,response):
        print("Md1返回")
        return response

class Md2(MiddlewareMixin):

    def process_request(self,request):
        print("Md2請求")
        #return HttpResponse("Md2中斷")
    def process_response(self,request,response):
        print("Md2返回")
        return response

　　

結果：

Md1請求
Md2請求
view函數...
Md2返回
Md1返回

　　注意：如果當請求到達請求2的時候直接不符合條件返回，即return HTTPResponse（“Md2中斷”），程序將請求直接發給中間件2 返回，然后依次返回到請求者，結果如下：

　　返回Md2 中斷的頁面，后台打印如下：

Md1請求  
Md2請求  
Md2返回  
Md1返回

　　流程圖如下：

 

3.2 自定義中間件方法應用2（關於process_view 方法）

　　Mymiddlewares.py 修改如下：

from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import HttpResponse

class Md1(MiddlewareMixin):

    def process_request(self,request):
        print("Md1請求")
        #return HttpResponse("Md1中斷")
    def process_response(self,request,response):
        print("Md1返回")
        return response

    def process_view(self, request, callback, callback_args, callback_kwargs):
        print("Md1view")

class Md2(MiddlewareMixin):

    def process_request(self,request):
        print("Md2請求")
        # return HttpResponse("Md2中斷")
    def process_response(self,request,response):
        print("Md2返回")
        return response

    def process_view(self, request, callback, callback_args, callback_kwargs):
        print("Md2view")

　　細心的話，會發現我們增加了 process_view 函數。

　　views.py 視圖函數不用改，還是這樣：

def index(request):

    print("view函數...")
    return HttpResponse("OK")

　　我們運行程式，結果如下：

Md1請求
Md2請求
Md1view
Md2view
view函數...
Md2返回
Md1返回

　　下面繼續使用流程圖分析上面過程：

　　當最后一個中間的 process_request 到達路由關系映射之后，返回到中間件1的 process_view ，然后依次往下，到達 views 函數，最后通過 process_response 依次返回到達用戶。

　　那么這樣做有什么意義？

　　我們可以發現，process_view() 里面有很多的參數。

我們捋一遍過程。

　　首先，執行中間件1的process_request，然后執行中間件2的 process_request：

from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import HttpResponse

class Md1(MiddlewareMixin):

    def process_request(self,request):
        print("Md1請求")


class Md2(MiddlewareMixin):

    def process_request(self,request):
        print("Md2請求")

　　然后去urls.py 去找到 index() 函數：

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

　　然后返回中間件1的process_view 和中間件2的 process_view，將拿到的 views.index 傳到 callback，去執行process_view()。

from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import HttpResponse

class Md1(MiddlewareMixin):

    def process_view(self, request, callback, callback_args, callback_kwargs):
        print("Md1view")

class Md2(MiddlewareMixin):

    def process_view(self, request, callback, callback_args, callback_kwargs):
        print("Md2view")

　　我們也可以嘗試打印 callback這個視圖函數，可以看到其結果如下：

callback =============>

<function  index at 0x103338bf8>

　　而process_view中 callback_args 和 claaback_kwargs 是視圖函數的參數。

　　當執行完process_view的時候，就去視圖函數執行其函數，然后執行 process_response。

　　注意：process_view函數可以用來調用視圖函數，我們調用如下：

from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import HttpResponse

class Md1(MiddlewareMixin):

    def process_request(self,request):
        print("Md1請求")

    def process_response(self,request,response):
        print("Md1返回")
        return response

    def process_view(self, request, callback, callback_args, callback_kwargs):
        print("Md1 view")

class Md2(MiddlewareMixin):

    def process_request(self,request):
        print("Md2請求")

    def process_response(self,request,response):
        print("Md2返回")
        return response

    def process_view(self, request, callback, callback_args, callback_kwargs):
        print("Md2 view")
        return  HttpResponse("123")

　　結果如下：

Md1請求
Md2請求
Md1 views
Md2 views
Md2返回
Md1返回

　　但是請注意，頁面返回的是  ‘123’， 而不是我們視圖函數里面的 “OK”（為了怕大家混淆，我這里將index的視圖函數貼上）。

def index(request):

    return HttpResponse("OK")

　　如果要返回 OK 的話，怎么做呢？我們修改代碼如下：

class Md1(MiddlewareMixin):

    def process_request(self,request):
        print("Md1請求")
        #return HttpResponse("Md1中斷")
    def process_response(self,request,response):
        print("Md1返回")
        return response

    def process_view(self, request, callback, callback_args, callback_kwargs):

        # return HttpResponse("hello")

        response=callback(request,*callback_args,**callback_kwargs)
        return response

　　結果如下：

Md1請求
Md2請求
view函數...
Md2返回
Md1返回

　　注意：process_view 如果有返回值，會越過其他的 process_view 以及視圖函數，但是所有的 process_response都還會執行。

 

3.3 自定義中間件方法應用3（關於process_exception 方法）

 　　Mymiddlewares.py 修改如下：

class Md1(MiddlewareMixin):

    def process_request(self,request):
        print("Md1請求")

    def process_response(self,request,response):
        print("Md1返回")
        return response

    def process_view(self, request, callback, callback_args, callback_kwargs):

        # return HttpResponse("hello")

        # response=callback(request,*callback_args,**callback_kwargs)
        # return response
        print("md1 process_view...")

    def process_exception(self, request, exception):
        print("md1 process_exception...")



class Md2(MiddlewareMixin):

    def process_request(self,request):
        print("Md2請求")

    def process_response(self,request,response):
        print("Md2返回")
        return response

    def process_view(self, request, callback, callback_args, callback_kwargs):
        print("md2 process_view...")

    def process_exception(self, request, exception):
        print("md2 process_exception...")

　　結果如下：

Md1請求
Md2請求
md1 process_view...
md2 process_view...
view函數...
Md2返回
Md1返回

　　當沒有問題（異常）的時候，我們發現，和正常的執行沒有任何區別。

　　當views出錯的時候， process_exception才會執行，我們看報錯后的執行流程，如下：

　　下面我們來模擬一個錯誤，執行看流程：

我們給views.py 里面加一個簡單的錯誤，代碼如下：

def index(request):
    print("index  doing")
    james
    return HttpResponse("index  OK")

　　我們執行程式，發現其執行流程如下：

Md1請求
Md2請求
md1 process_view...
md2 process_view...
view函數...
md2 process_exception...
md1 process_exception...



Traceback (most recent call last):
  File "C:\Users\Administrator\AppData\Local\Programs\Python\Python37\lib\site-packages\django\core\handlers\exception.py", line 34,
in inner
    response = get_response(request)
  File "C:\Users\Administrator\AppData\Local\Programs\Python\Python37\lib\site-packages\django\core\handlers\base.py", line 126, in _
get_response
    response = self.process_exception_by_middleware(e, request)
  File "C:\Users\Administrator\AppData\Local\Programs\Python\Python37\lib\site-packages\django\core\handlers\base.py", line 124, in _
get_response
    response = wrapped_callback(request, *callback_args, **callback_kwargs)
  File "E:\backup\pycode\web開發\User_model\users\views.py", line 7, in index
    james
NameError: name 'james' is not defined


Md2返回 
Md1返回

　　並且前端調用如下（當然這是Django自帶默認的錯誤報錯程式）：

　　我們也可以自己設定報錯，我們將Mymiddlewares.py 修改如下：

class Md1(MiddlewareMixin):

    def process_request(self,request):
        print("Md1請求")

    def process_response(self,request,response):
        print("Md1返回")
        return response

    def process_view(self, request, callback, callback_args, callback_kwargs):

        # return HttpResponse("hello")

        # response=callback(request,*callback_args,**callback_kwargs)
        # return response
        print("md1 process_view...")

    def process_exception(self, request, exception):
        print("md1 process_exception...")



class Md2(MiddlewareMixin):

    def process_request(self,request):
        print("Md2請求")

    def process_response(self,request,response):
        print("Md2返回")
        return response

    def process_view(self, request, callback, callback_args, callback_kwargs):
        print("md2 process_view...")

    def process_exception(self, request, exception):
        print("md2 process_exception...")
        return HttpResponse(exception)

　　我們再執行程式，會發現前台是這樣的：

　　后台是這樣的：

Md1請求
Md2請求
md1 process_view...
md2 process_view...
view函數...
md2 process_exception...
Md2返回 
Md1返回

　　我們發現在執行中間件2的process_exception后，不會去執行中間件1 了。因為中間件2將錯誤處理完之后，直接去執行response了。

 

4，中間件應用場景

　　由於中間件工作在視圖函數執行前，執行后。所以適合所有的請求/一部分請求做批量處理

1，做IP訪問頻率限制

　　放在中間件類的列表中，阻止某些IP訪問了。

　　因為某些IP訪問服務器的頻率過高，所以進行攔截，比如限制每分鍾不能超過20次。

2，緩存

　　客戶端請求來了，中間件去緩存看看有沒有數據，有直接返回給用戶，沒有再去邏輯層，執行視圖函數。

 

3，URL訪問過濾

　　如果用戶訪問的是login視圖

　　如果訪問的是其他視圖（需要檢測是不是由session已經有了放行，沒有返回login），這樣就省的在多個視圖函數上寫裝飾器了！

　　那么如何寫呢？如下：

Django通過中間件實現登錄驗證DEMO

　　前提：中間件版的登錄驗證需要依靠session，所以數據庫中要有django_session表。

urls.py代碼：

from django.conf.urls import url
from django.contrib import admin
from app01 import views

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^login/$', views.login, name='login'),
    url(r'^index/$', views.index, name='index'),
    url(r'^home/$', views.home, name='home'),
]

　　

views.py代碼：

from django.shortcuts import render, HttpResponse, redirect

def index(request):
    return HttpResponse("this is index")

def home(request):
    return HttpResponse("this is home")

def login(request):
    if request.method == 'POST':
        user = request.POST.get("user")
        pwd = request.POST.get("pwd")

        if user == 'james' and pwd == '123':
            # 設置session
            request.session['user'] = user
            # 獲取跳到登錄頁面之前的URL
            next_url = request.GET.get('next')
            # 如果有，就跳轉到登錄之前的URL
            if next_url:
                return redirect(next_url)
            # 否則默認跳轉到index頁面
            else:
                return redirect('/index/')
    return render(request, 'login.html')

　　

login.html頁面代碼：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登錄頁面</title>
</head>
<body>
    <form action="{% url 'login' %}" method="post">
        {% csrf_token %}
        <p>
            <label for="user">用戶名：</label>
            <input type="text" name="user" id="user">
        </p>
        <p>
            <label for="pwd">密碼：</label>
            <input type="text" name="pwd" id="pwd">
        </p>
        <input type="submit" value="登錄">
    </form>
</body>
</html>

　　

mymiddlewares.py 的代碼：

# 自定義中間件
from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import redirect, HttpResponse

class AuthMD(MiddlewareMixin):
    white_list = ['/login/', ]  # 白名單
    black_list = ['/black/', ]  # 黑名單

    def process_request(self, request):
        next_url = request.path_info
        print(request.path_info, request.get_full_path())
        # 黑名單的網址限制訪問
        if next_url in self.black_list:
            return HttpResponse("This is an illegal URL")
        # 白名單的網址或者登錄用戶不做限制
        elif next_url in self.white_list or request.session.get("user"):
            return 
        else:
            return redirect('/login/?next={}'.format(next_url))

　　

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',
    # 注意這個中間件是自己加的
    'app01.mymiddleware.AuthMD',
]

　　AuthMD 中間件注冊后，所有的請求都要走AuthMD的process_request方法。如果URL在黑名單中，則返回This is an illegal  URL的字符串；訪問的URL在白名單或者session中有user用戶名，則不作阻攔走正常流程；正常的URL但是需要登錄后訪問，讓瀏覽器跳轉到登錄頁面。

　　注意：AuthMD中間件中需要session，所以AuthMD注冊的位置要在session中間的下方。

　　如果黑名單的多，我們使用中間件簡單，如果少，我們直接使用裝飾器簡單，就省去了寫代碼的麻煩，所以應用場景還是要看情況。

 

6，跨站請求偽造

1，簡介

　　django為用戶實現防止跨站請求偽造的功能，通過中間件

django.middleware.csrf.CsrfViewMiddleware 來完成。而對於django中設置防跨站請求偽造功能有分為全局和局部。

全局：

　　中間件 django.middleware.csrf.CsrfViewMiddleware

局部：

• @csrf_protect，為當前函數強制設置防跨站請求偽造功能，即便settings中沒有設置全局中間件。
• @csrf_exempt，取消當前函數防跨站請求偽造功能，即便settings中設置了全局中間件。

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

 

2，方式

　　方式1：

$.ajaxSetup({
    data: {csrfmiddlewaretoken: '{{ csrf_token }}' },
});

　　方式2：

<form>
{% csrf_token %}
</form>

$.ajax({
    data:{
    "csrfmiddlewaretoken":$("[name='csrfmiddlewaretoken']").val();
}})

　　方法3：

<script src="{% static 'js/jquery.cookie.js' %}"></script>

$.ajax({
 
    headers:{"X-CSRFToken":$.cookie('csrftoken')},
 
})

　　

3，應用

普通表單

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的話，使用如下方式：

views.py

from django.template.context import RequestContext
# 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>

　　

更多：https://docs.djangoproject.com/en/dev/ref/csrf/#ajax

 https://www.cnblogs.com/huchong/p/7819296.html

https://www.cnblogs.com/yuanchenqi/articles/9036479.html

（自己的學習筆記，不喜勿噴，謝謝）