Django之中间件

中间件介绍

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

如果你想修改请求，例如被传送到view中的HttpRequest对象。 或者你想修改view返回的HttpResponse对象，这些都可以通过中间件来实现。

可能你还想在view执行之前做一些操作，这种情况就可以用 middleware来实现。

说的直白一点中间件是帮助我们在视图函数执行之前和执行之后都可以做一些额外的操作，它本质上就是一个自定义类，类中定义了几个方法，Django框架会在请求的特定的时间去执行这些方法。

我们一直都在使用中间件，只是没有注意到而已，打开Django项目的Settings.py文件，看到下面的MIDDLEWARE配置项，django默认自带的一些中间件：

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配置项是一个列表，列表中是一个个字符串，这些字符串其实是一个个类，也就是一个个中间件。

自定义中间件

 想多了解中间，在开源中国中有很多关于中间件的详细解释

中间件可以定义五个方法，分别是：（主要的是process_request和process_response）

• process_request(self,request)
• process_view(self, request, view_func, view_args, view_kwargs)
• process_template_response(self,request,response)
• process_exception(self, request, exception)
• process_response(self, request, response)

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

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

上述截图中的中间件都是django中的，我们也可以自己定义一个中间件，我们可以自己写一个类，但是必须继承MiddlewareMixin

自定义一个中间件示例

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

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

class MD1(MiddlewareMixin):
    def process_request(self, request):
        print('in MD1')
        # return None
    
    def process_response(self, request, response):
        print('MD1 的响应') 

process_request

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

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

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

class MD1(MiddlewareMixin):
    def process_request(self, request):
        print('in MD1')

class MD2(MiddlewareMixin):
    def process_request(self, request):
        print('in MD2')

# in MD1
# in MD2

在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',
    'app01.middleware.MD1',
    'app01.middleware.MD2',
]

总结

中间件的process_request方法是在执行视图函数之前执行的。

当配置多个中间件时，会按照MIDDLEWARE中的注册顺序，也就是列表的索引值，从前到后依次执行的。

不同中间件之间传递的request都是同一个对象

process_response

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

给上述的M1和M2加上process_response方法：

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


class MD1(MiddlewareMixin):
    def process_request(self, request):
        print('in MD1')
        # return HttpResponse("你的请求有异常")
        return None

    def process_response(self, request, response):
        print('MD1 的响应')
        return response
        # return HttpResponse("你的响应有异常")

class MD2(MiddlewareMixin):
    def process_request(self, request):
        print('in MD2')

    def process_response(self, request, response):
        print('MD2 的响应')
        return response
        # return HttpResponse("你的响应有异常")

运行结果：
# in MD1
# in MD2
# 111
# MD2 的响应
# MD1 的响应

看运行结果可知：

process_response方法是在视图函数之后执行的，并且顺序是MD2比MD1先执行。

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

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

in MD1
in MD2
111
MD2 的响应
MD1 的响应

如果在MD1请求位置返回一个return HttpResponse("你的请求有异常")，运行结果如下：

in MD1
MD1 的响应

流程图如下：

应用（使用中间件做session认证）

需要注意你的中间件的摆放顺序。

 由于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'^index/', views.index, name='index'),
    url(r'^home/', views.home, name='home'),
    url(r'^login/', views.login, name='login'),
]

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.middleware.MD1',
    'app01.middleware.MD2',
    'app01.middleware.SessionAuth',
]

from django.shortcuts import render, HttpResponse, redirect


# Create your views here.

def index(request):
    print(111)
    return render(request, 'index.html')


def home(request):
    return render(request, 'home.html')


def login(request):
    if request.method == "GET":
        return render(request, "login.html")
    else:
        username = request.POST.get('username')
        password = request.POST.get('password')

        if username == "123" and password == "123":
            request.session['is_login'] = True
            request.session['user'] = username
            return redirect('home')
        else:
            return render(request, 'login.html')

from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import HttpResponse, redirect
from django.urls import reverse


class MD1(MiddlewareMixin):
    def process_request(self, request):
        print('in MD1')
        # return HttpResponse("你的请求有异常")
        return None

    def process_response(self, request, response):
        print('MD1 的响应')
        return response
        # return HttpResponse("你的响应有异常")


class MD2(MiddlewareMixin):
    def process_request(self, request):
        print('in MD2')

    def process_response(self, request, response):
        print('MD2 的响应')
        return response
        # return HttpResponse("你的响应有异常")


class SessionAuth(MiddlewareMixin):
    def process_request(self, request):
        url = [reverse('login')]  # /login/
        if request.path in url:
            # print(request.path)  # /login/
            return None  # 这里写return None或者pass都可以
        else:
            is_login = request.session.get('is_login')
            if is_login != True:
                return redirect('login')

    def process_response(self, request, response):
        print('SessionAuth的响应')
        return response

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>


<form action="" method="post">
    {% csrf_token %}
    用户名：<input type="text" name="username">
    密码：<input type="password" name="password">
    <input type="submit">
</form>




</body>
</html>

运行效果：

另外的三个（了解）

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并返回结果。

from django.utils.deprecation import MiddlewareMixin

class MD1(MiddlewareMixin):
    def process_request(self, request):
        print('in MD1')
        return None

    def process_view(self, request, view_func, view_args, view_kwargs):
        print('MD1的process_view')

    def process_response(self, request, response):
        print('MD1 的响应')
        return response


class MD2(MiddlewareMixin):
    def process_request(self, request):
        print('in MD2')

    def process_response(self, request, response):
        print('MD2 的响应')
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print('MD2的process_view')

运行结果：

in MD1
in MD2
MD1的process_view
MD2的process_view
MD2 的响应
MD1 的响应

process_view方法是在process_request之后，reprocess_response之前，视图函数之前执行的，执行顺序按照MIDDLEWARE中的注册顺序从前到后顺序执行的

如果在MD1的process_view中return HttpResponse("md1的process_view")

def process_view(self, request, view_func, view_args, view_kwargs):
    print('MD1的process_view')
    return HttpResponse("md1的process_view")

运行结果：

in MD1
in MD2
MD1的process_view
MD2 的响应
MD1 的响应

分析图解：

process_exception

 process_exception(self, request, exception)

 该方法两个参数:

一个HttpRequest对象

一个exception是视图函数异常产生的Exception对象。

这个方法只有在视图函数中出现异常了才执行，它返回的值可以是一个None也可以是一个HttpResponse对象。如果是HttpResponse对象，Django将调用模板和中间件中的process_response方法，并返回给浏览器，否则将默认处理异常。如果返回一个None，则交给下一个中间件的process_exception方法来处理异常。它的执行顺序也是按照中间件注册顺序的倒序执行。

from django.utils.deprecation import MiddlewareMixin

class MD1(MiddlewareMixin):
    def process_request(self, request):
        print('in MD1')
        # return HttpResponse("你的请求有异常")
        return None

    def process_view(self, request, view_func, view_args, view_kwargs):
        print('MD1的process_view')
        # return HttpResponse("md1的process_view")

    def process_response(self, request, response):
        print('MD1 的响应')
        return response

    def process_exception(self, request, exception):
        print(exception)
        print("MD1 中的process_exception")

class MD2(MiddlewareMixin):
    def process_request(self, request):
        print('in MD2')

    def process_response(self, request, response):
        print('MD2 的响应')
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print('MD2的process_view')

    def process_exception(self, request, exception):
        print(exception)
        print("MD2 中的process_exception")

如果视图函数中无异常，process_exception方法不执行。

想办法，在视图函数中抛出一个异常：

def index(request):
    print("index函数")
    raise ValueError('这是个异常')
    return render(request, 'index.html')

执行结果：（倒序）

in MD1
in MD2
MD1的process_view
MD2的process_view
index函数
这是个异常
MD2 中的process_exception
这是个异常
MD1 中的process_exception
MD2 的响应
MD1 的响应

# 出错了，显示的页面也是不好看的，在这个函数中提示下，体验好点
def process_exception(self, request, exception):
    print(exception)
    print("MD2 中的process_exception")
    return HttpResponse("出错啦！")

process_template_response（用的比较少）

 process_template_response(self, request, response)

它的参数，一个HttpRequest对象，response是TemplateResponse对象（由视图函数或者中间件产生）。

process_template_response是在视图函数执行完成后立即执行，但是它有一个前提条件，那就是视图函数返回的对象有一个render()方法（或者表明该对象是一个TemplateResponse对象或等价方法）。

from django.utils.deprecation import MiddlewareMixin

class MD1(MiddlewareMixin):
    def process_request(self, request):
        print('in MD1')
        return None

    def process_view(self, request, view_func, view_args, view_kwargs):
        print('MD1的process_view')

    def process_response(self, request, response):
        print('MD1 的响应')
        return response

    def process_exception(self, request, exception):
        print("MD1 中的process_exception")

    def process_template_response(self, request, response):
        print("MD1 中的process_template_response")
        return response


class MD2(MiddlewareMixin):
    def process_request(self, request):
        print('in MD2')

    def process_response(self, request, response):
        print('MD2 的响应')
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print('MD2的process_view')

    def process_exception(self, request, exception):
        print("MD2 中的process_exception")

    def process_template_response(self, request, response):
        print("MD2 中的process_template_response")
        return response

运行结果:

in MD1
in MD2
MD1的process_view
MD2的process_view
index函数
MD2 的响应
MD1 的响应

很显然没有执行process_template_response，需要视图函数返回对象中有个render()方法。

views.py

def index(request):
    print("index函数")
    # raise ValueError('这是个异常')
    ret = HttpResponse('ok')

    def render():
        print("我是render函数")
        return HttpResponse('render函数的返回数据')

    ret.render = render
    return ret

运行结果如下：（倒序）

in MD1
in MD2
MD1的process_view
MD2的process_view
index函数
MD2 中的process_template_response
MD1 中的process_template_response
我是render函数
MD2 的响应
MD1 的响应

视图函数执行完之后，立即执行了中间件的process_template_response方法，顺序是倒序，先执行MD2的，在执行MD1的，接着执行了视图函数返回的HttpResponse对象的render方法，返回了一个新的HttpResponse对象，接着执行中间件的process_response方法。

总结下五个方法

process_request(self,request)  

#请求来的时候,过中间件会自动执行的方法,正常的话,return None,异常的话直接可以回复HttpResponse对象,顺序从上之下执行。

process_response(self, request, response) 

#响应回去会自动执行的方法,注意,写的话，要return response  顺序从下往上倒序的.其他任意一个中间件的process_request方法里面如果出现了return一个HttpResponse对象,那么就会不继续执行其他内容了,而是直接执行各个中间件的process_response方法,如果自己的中间件里面有process_response这个方法,会先执行它自己的如果自己的中间件里面有process_response这个方法.直接返回.

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

#url分发之后,视图执行之前,执行,从上到下正序的.

process_exception(self, request, exception) 

#视图函数报错了,会执行,顺序倒序的

process_template_response(self,request,response)

#HttpResponse对象里面必须有个render函数,才会执行process_template_response方法,并且顺序是倒序的.并且render函数里面必须return一个HttpResponse对象,会将之前的覆盖掉

 

中间件版登陆认证

中间件版的登录验证需要依靠session，所以数据库中要有django_session表。

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

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

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 == "Q1mi" and pwd == "123456":
            # 设置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")

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>登录页面</title>
</head>
<body>
<form action="{% url 'login' %}">
    <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>

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

    def process_request(self, request):
        from django.shortcuts import redirect, HttpResponse

        next_url = request.path_info
        print(request.path_info, request.get_full_path())

        if next_url in self.white_list or request.session.get("user"):
            return
        elif next_url in self.balck_list:
            return HttpResponse('This is an illegal URL')
        else:
            return redirect("/login/?next={}".format(next_url))

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',
    'middlewares.AuthMD',
]

AuthMD中间件注册后，所有的请求都要走AuthMD的process_request方法。

访问的URL在白名单内或者session中有user用户名，则不做阻拦走正常流程；

如果URL在黑名单中，则返回This is an illegal URL的字符串；

正常的URL但是需要登录后访问，让浏览器跳转到登录页面。

注：AuthMD中间件中需要session，所以AuthMD注册的位置要在session中间的下方。

做IP访问频率限制

from rest_framework.throttling import BaseThrottle,SimpleRateThrottle
import time
from rest_framework import exceptions
visit_record = {}
class VisitThrottle(BaseThrottle):
    # 限制访问时间
    VISIT_TIME = 10
    VISIT_COUNT = 3

    # 定义方法 方法名和参数不能变
    def allow_request(self, request, view):
        # 获取登录主机的id
        id = request.META.get('REMOTE_ADDR')
        self.now = time.time()

        if id not in visit_record:
            visit_record[id] = []

        self.history = visit_record[id]
        # 限制访问时间
        while self.history and self.now - self.history[-1] > self.VISIT_TIME:
            self.history.pop()
        # 此时 history中只保存了最近10秒钟的访问记录
        if len(self.history) >= self.VISIT_COUNT:
            return False
        else:
            self.history.insert(0, self.now)
            return True

    def wait(self):
        return self.history[-1] + self.VISIT_TIME - self.now