08.django之中间件

一、中间件介绍

# 中间件简单来说,就是给所有的请求都加上了相同的操作或功能

# 如果想修改传到视图的HTTPRequest对象,或修改view返回的HttpResponse对象,都可以通过中间件实现

"""
说白了,就是帮助我们在视图函数执行之前和之后做一些额外操作.
本质就是一个类,类中有几个方法,django会自动执行相应的方法
"""

二、django请求生命周期

当用户在浏览器中输入url时,浏览器会生成请求头和请求体发给服务端，请求头和请求体中会包含浏览器的动作(action),这个动作通常为get或者post
url经过Django中的wsgi，wsgi中封装了socket，然后按照http协议解包
接着会经过中间件，按顺序执行每个中间件的request方法
最后经过url路由映射表，在路由系统中一条一条进行匹配，一旦其中一条匹配成功就执行对应的视图函数,后面的路由就不再继续匹配了.
视图函数根据客户端的请求查询相应的数据，经过中间件按倒序执行每个中间件的response方法
接着通过wsgi按http协议封装相应数据
最后Django把客户端想要的数据做为一个字符串返回给客户端，客户端浏览器接收到返回的数据,经过渲染后显示给用户.

三、中间件方法及自定义中间件

1、中间件方法

中间件五种方法，分别为：
process_request(self,request)
process_response(self, request, response)
process_exception(self, request, exception)
process_view(self, request, view_func, view_args, view_kwargs)
process_template_response(self,request,response)

　　以上方法的返回值可以是None或一个HttpResponse对象，如果是None，则继续按照django定义的规则向后继续执行，如果是HttpResponse对象，则直接将该对象返回给用户。

　　当用户发起请求的时候会依次经过所有的的中间件，这个时候的请求时process_request,最后到达views的函数中，views函数处理后，在依次穿过中间件，这个时候是process_response,最后返回给请求者。

2、自定义中间件

# 在项目中创建一个包，随便起名字，一般都放在一个叫做utils的包里面，表示一个公用的组件，
# 创建一个py文件，随便起名字，例如叫做：middlewares.py，内容如下

from django.utils.deprecation import MiddlewareMixin

class MD1(MiddlewareMixin):
    #自定义中间件，不是必须要有下面这两个方法，有request方法说明请求来了要处理，有response方法说明响应出去时需要处理，
    #不是非要写这两个方法，如果你没写process_response方法，那么会一层一层的往上找，哪个中间件有process_response方法就将返回对象给哪个中间件
    def process_request(self, request):
        print("MD1里面的 process_request")

    def process_response(self, request, response):
        print("MD1里面的 process_response")
        return response

3、关于中间件方法详细

3.1、process_request

process_request有一个参数，就是request，这个request和视图函数中的request是一样的

它的返回值可以是None也可以是HttpResponse对象。返回值是None的话，按正常流程继续走，交给下一个中间件处理，如果是HttpResponse对象，Django将不执行视图函数，而将相应对象返回给浏览器。

多个中间件都有process_request怎么执行的

from django.utils.deprecation import MiddlewareMixin


class MD1(MiddlewareMixin):

    def process_request(self, request):
        print("MD1里面的 process_request")


class MD2(MiddlewareMixin):
    def process_request(self, request):
        print("MD2里面的 process_request")
        pass

在settings.py的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',
    'middlewares.MD1',  
    # 自定义中间件MD1，这个写的是你项目路径下的一个路径，
    # 例如，如果你放在项目下，文件夹名成为utils，那么这里应该写utils.middlewares.MD1
    'middlewares.MD2'  # 自定义中间件MD2
]

此时,访问一个视图,会自动在MIDDLEWARE列表从上到下执行,发现终端打印如下内容:

MD1里面的 process_request
MD2里面的 process_request
app01 中的 index视图

把settings里MIDDLEWARE中MD1和MD2调换一下:

MD2里面的 process_request
MD1里面的 process_request
app01 中的 index视图

哪个中间件在前先执行哪个,视图函数是最后执行的,MD2比MD1先执行自己的process_request方法。

总结:

"""
中间件的process_request方法是在执行视图函数之前执行的。
当配置多个中间件时，会按照MIDDLEWARE中的注册顺序，也就是列表的索引值，从前到后依次执行的。
不同中间件之间传递的request都是同一个对象
"""

3.2、process_response

多个中间件中的process_response方法是按照MIDDLEWARE中的注册顺序倒序执行的，也就是说第一个中间件的process_request方法首先执行，而它的process_response方法最后执行，最后一个中间件的process_request方法最后一个执行，它的process_response方法是最先执行。

"""
它有两个参数，一个是request，一个是response，request就是上述例子中一样的对象，
response是视图函数返回的HttpResponse对象。该方法的返回值也必须是HttpResponse对象。
"""

给上面M1和M2加上process_response方法

from django.utils.deprecation import MiddlewareMixin


class MD1(MiddlewareMixin):

    def process_request(self, request):
        print("MD1里面的 process_request")
        #不必须写return值
    def process_response(self, request, response):#request和response两个参数必须有，名字随便取
        print("MD1里面的 process_response")
        #print(response.__dict__['_container'][0].decode('utf-8')) #查看响应体里面的内容的方法，或者直接使用response.content也可以看到响应体里面的内容，
# 由于response是个变量，直接点击看源码是看不到的，你打印type(response)发现是HttpResponse对象，
# 查看这个对象的源码就知道有什么方法可以用了。
　　　　 return response  #必须有返回值，写return response  ，这个response就像一个接力棒一样
        #return HttpResponse('瞎搞') ,如果你写了这个，那么你视图返回过来的内容就被它给替代了

class MD2(MiddlewareMixin):
    def process_request(self, request):
        print("MD2里面的 process_request")
        pass

    def process_response(self, request, response): #request和response两个参数必须要有，名字随便取
        print("MD2里面的 process_response") 
        return response  #必须返回response，不然你上层的中间件就没有拿到httpresponse对象，就会报错

访问视图,查看结果:

MD2里面的 process_request
MD1里面的 process_request
app01 中的 index视图
MD1里面的 process_response
MD2里面的 process_response

settings.py中MD2比MD1先注册,process_response方法是在视图函数之后执行的，并且顺序是MD1比MD2先执行

如果当请求到达请求2的时候直接不符合条件返回，即return HttpResponse("Md2中断")，程序将把请求直接发给中间件2返回，然后依次返回到请求者，结果如下：

MD2里面的 process_request
MD1里面的 process_request
MD1里面的 process_response
MD2里面的 process_response

流程如下:

例:

基于session的登录验证:

# 基于session的登录认证中间件
class LoginAuth(MiddlewareMixin):
    
    white_list = ['/login/', ]  # 白名单
    def process_request(self,request):
        path = request.path
        #设置路径白名单，只要访问的是login登陆路径，就不做这个cookie认证
        if path not in self.white_list:
            is_login = request.session.get('is_login')
            print(is_login, type(is_login)) #True <class 'bool'>

            # request.session['is_login']
            # 1 取出请求中cookie键为sessionid的值
            # 2 通过这个值到django-session表中获取数据
            # 3 将数据解密并且反序列化得到原来的数据

            # is_login = request.COOKIES.get('is_login')
            if is_login != True:
                return redirect('/login/')

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),
    url(r'^home/', views.home)
]

urls.py

def login(request):
    if request.method == 'GET':
        return render(request, 'login.html')
    else:
        uname = request.POST.get('username')
        if uname == 'root' or uname=='abc':
            request.session['is_login'] = True
            request.session['username'] = uname

            # request.session
            #1 生成一个随机字符串
            #2 将随机字符串放到cookie中,名称为sessionid
            #3 将设置的session数据,序列化+加密,保存到了django-session表中

            return redirect('/home/')
        else:
            return redirect('/login/')

views.py

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<form action="" method="post">
    用户名: <input type="text" name="username">
    密码: <input type="password" name="password">
    <input type="submit">
</form>


</body>
</html>

3.3、process_view

process_view(self, request, view_func, view_args, view_kwargs)

　　　　　　该方法有四个参数

　　　　　　request是HttpRequest对象。

　　　　　　view_func是Django即将使用的视图函数。（它是实际的函数对象，而不是函数的名称作为字符串。）

　　　　　　view_args是将传递给视图的位置参数的列表.

　　　　　　view_kwargs是将传递给视图的关键字参数的字典。 view_args和view_kwargs都不包含第一个视图参数（request）。

　　　　　　Django会在调用视图函数之前调用process_view方法。

　　　　　　它应该返回None或一个HttpResponse对象。如果返回None，Django将继续处理这个请求，执行任何其他中间件的process_view方法，然后在执行相应的视图。如果它返回一个HttpResponse对象，Django不会调用对应的视图函数。它将执行中间件的process_response方法并将应用到该HttpResponse并返回结果。

给MD1和MD2添加process_view方法:

from django.utils.deprecation import MiddlewareMixin


class MD1(MiddlewareMixin):

    def process_request(self, request):
        print("MD1里面的 process_request")

    def process_response(self, request, response):
        print("MD1里面的 process_response")
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print("-" * 80)
        print("MD1 中的process_view")
        print(view_func, view_func.__name__) #就是url映射到的那个视图函数，也就是说每个中间件的这个process_view已经提前拿到了要执行的那个视图函数
        #ret = view_func(request) #提前执行视图函数，不用到了上图的试图函数的位置再执行，如果你视图函数有参数的话，可以这么写 view_func(request,view_args,view_kwargs) 
        #return ret  #直接就在MD1中间件这里这个类的process_response给返回了，就不会去找到视图函数里面的这个函数去执行了。

class MD2(MiddlewareMixin):
    def process_request(self, request):
        print("MD2里面的 process_request")
        pass

    def process_response(self, request, response):
        print("MD2里面的 process_response")
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print("-" * 80)
        print("MD2 中的process_view")
        print(view_func, view_func.__name__)

访问视图,得到结果:

MD2里面的 process_request
MD1里面的 process_request
--------------------------------------------------------------------------------
MD2 中的process_view
<function index at 0x000001DE68317488> index
--------------------------------------------------------------------------------
MD1 中的process_view
<function index at 0x000001DE68317488> index
app01 中的 index视图
MD1里面的 process_response
MD2里面的 process_response