参考：django中间件
官方文档：https://docs.djangoproject.com/en/dev/topics/http/middleware/
中文版：https://yiyibooks.cn/xx/Django_1.11.6/index.html

什么是中间件？

官方文档这么说：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.
关键字：请求响应钩子、全局修改Django的输入输出

官方文档中中间件的写法：

A middleware can be written as a function that looks like this::

    def simple_middleware(get_response):
        # One-time configuration and initialization.

        def middleware(request):
            # Code to be executed for each request before
            # the view (and later middleware) are called.

            response = get_response(request)

            # Code to be executed for each request/response after
            # the view is called.

            return response

        return middleware

Or it can be written as a class whose instances are callable, like this::

    class SimpleMiddleware(object):
        def __init__(self, get_response):
            self.get_response = get_response
            # One-time configuration and initialization.

        def __call__(self, request):
            # Code to be executed for each request before
            # the view (and later middleware) are called.

            response = self.get_response(request)

            # Code to be executed for each request/response after
            # the view is called.

            return response

Django提供的get_response可调用实际的视图（如果这是最后列出的中间件），或者调用链中的下一个中间件。 当前的中间件不需要知道或者关心下一个究竟是什么，它只是代表了接下来的任何事情。
上述讲了中间件书写的简单结构，那么：

如何写自己的中间件？

django 1.10之后可以通过继承MiddlewareMixin来写中间件。

class MiddlewareMixin(object):
    def __init__(self, get_response=None):
        self.get_response = get_response
        super(MiddlewareMixin, self).__init__()

    def __call__(self, request):
        response = None
        if hasattr(self, 'process_request'):
            response = self.process_request(request)
        if not response:
            response = self.get_response(request)
        if hasattr(self, 'process_response'):
            response = self.process_response(request, response)
        return response

中间件示例如下：

from django.utils.deprecation import MiddlewareMixin

class MM1(MiddlewareMixin):
    def process_request(self, request):
        print('MM1里面的 process_request')

    def process_response(self, request, response):
        print('MM1里面的 process_response')
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print("MM1中的process_view")

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

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

class MM2(MiddlewareMixin):
    def process_request(self, request):
        print('MM2里面的 process_request')

    def process_response(self, request, response):
        print('MM2里面的 process_response')
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print("MM2中的process_view")

    def process_exception(self, request, exception):
        print(exception)
        print("MM2中的process_exception")
        # return HttpResponse(str(exception))  # 返回一个响应对象

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

在settings中注册中间件：

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',
    'infomanage.middleware.MM1',
    'infomanage.middleware.MM2',
]

其中视图函数如下：

def hello(request):
    print "我是视图函数！"
    # print 10/0
    def render():
        print("render函数")
        return HttpResponse("O98K")
    rep = HttpResponse("OK")
    rep.render = render
    return rep

中间件中需要实现的函数包括：process_request(self, request)，process_response(self, request, response)，process_view(self, request, view_func, view_args, view_kwargs)，process_exception(self, request, exception)，process_template_response(self, request, response)。

• process_request(self, request)
  有一个参数，就是request，这个request和视图函数中的request是一样的。它的返回值可以是None也可以是HttpResponse对象。返回值是None的话，按正常流程继续走，交给下一个中间件处理，如果是HttpResponse对象，Django将不执行视图函数，而将相应对象返回给浏览器。
  测试，并总结：
  （1）中间件的process_request方法是在执行视图函数之前执行的。
  （2）当配置多个中间件时，会按照MIDDLEWARE中的注册顺序，也就是列表的索引值，从前到后依次执行的。
• process_response(self, request, response)
  它有两个参数，一个是request，一个是response，request就是上述例子中一样的对象，response是视图函数返回的HttpResponse对象。该方法的返回值也必须是HttpResponse对象。
  process_response方法是在视图函数之后执行的，多个中间件中的process_response方法是按照MIDDLEWARE中的注册顺序倒序执行的。
• process_view(self, request, view_func, view_args, view_kwargs)
  该方法有4个参数：

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并返回结果。
process_view方法是在process_request之后，视图函数之前执行的，执行顺序按照MIDDLEWARE中的注册顺序从前到后顺序执行的。

• process_exception(self, request, exception)
  该方法两个参数：一个HttpRequest对象，一个exception是视图函数异常产生的Exception对象。
  这个方法只有在视图函数中出现异常了才执行，它返回的值可以是一个None也可以是一个HttpResponse对象。如果是HttpResponse对象，Django将调用模板和中间件中的process_response方法，并返回给浏览器，否则将默认处理异常。如果返回一个None，则交给下一个中间件的process_exception方法来处理异常。它的执行顺序也是按照中间件注册顺序的倒序执行。
• process_template_response(self, request, response)（用的比较少）
  它的参数，一个HttpRequest对象，response是TemplateResponse对象（由视图函数或者中间件产生）。
  process_template_response是在视图函数执行完成后立即执行，但是它有一个前提条件，那就是视图函数返回的对象有一个render()方法（或者表明该对象是一个TemplateResponse对象或等价方法）。
  视图函数执行完之后，立即执行了中间件的process_template_response方法，顺序是倒序，先执行MM2的，再执行MM1的，接着执行了视图函数返回的HttpResponse对象的render方法，返回了一个新的HttpResponse对象，接着执行中间件的process_response方法。

中间件的执行顺序

通过上衣部分的介绍，我们了解了中间件的执行顺序，具体如下所示：
请求到达中间件之后，先按照正序执行每个注册中间件的process_request方法，process_request方法返回的值是None，就依次执行，如果返回的值是HttpResponse对象，不再执行后面的process_request方法，而是执行当前对应中间件的process_response方法，将HttpResponse对象返回给浏览器。也就是说：如果MIDDLEWARE中注册了6个中间件，执行过程中，第3个中间件返回了一个HttpResponse对象，那么第4,5,6中间件的process_request和process_response方法都不执行，顺序执行3,2,1中间件的process_response方法。
process_request方法都执行完后，匹配路由，找到要执行的视图函数，先不执行视图函数，先执行中间件中的process_view方法，process_view方法返回None，继续按顺序执行，所有process_view方法执行完后执行视图函数。加入中间件3 的process_view方法返回了HttpResponse对象，则4,5,6的process_view以及视图函数都不执行，直接从最后一个中间件，也就是中间件6的process_response方法开始倒序执行。
process_template_response和process_exception两个方法的触发是有条件的，执行顺序也是倒序。总结所有的执行流程如下：

image.png
image.png
image.png

源码分析

• 从WSGI看起
  从头开始梳理django处理request的流程，找寻中间件的执行规律。

class WSGIHandler(base.BaseHandler):
    request_class = WSGIRequest

    def __init__(self, *args, **kwargs):
        super(WSGIHandler, self).__init__(*args, **kwargs)
        self.load_middleware()

    def __call__(self, environ, start_response):
        set_script_prefix(get_script_name(environ))
        signals.request_started.send(sender=self.__class__, environ=environ)
        request = self.request_class(environ)
        response = self.get_response(request)

        response._handler_class = self.__class__

        status = '%d %s' % (response.status_code, response.reason_phrase)
        response_headers = [(str(k), str(v)) for k, v in response.items()]
        for c in response.cookies.values():
            response_headers.append((str('Set-Cookie'), str(c.output(header=''))))
        start_response(force_str(status), response_headers)
        if getattr(response, 'file_to_stream', None) is not None and environ.get('wsgi.file_wrapper'):
            response = environ['wsgi.file_wrapper'](response.file_to_stream)
        return response

WSGI初始化时会load中间件，通过看源码，得知该函数作用：从settings配置文件读取设置的middleware，然后初始化WSGIHandler类中的各个middleware的相关变量，这些变量主要包括self._request_middleware，self._view_middleware，self._template_response_middleware，self._response_middleware，self._exception_middleware，均为存放中间件方法的列表。

• load_middleware

def load_middleware(self):
    """
    Populate middleware lists from settings.MIDDLEWARE (or the deprecated
    MIDDLEWARE_CLASSES).
    
    Must be called after the environment is fixed (see __call__ in subclasses).
    """
    self._request_middleware = []
    self._view_middleware = []
    self._template_response_middleware = []
    self._response_middleware = []
    self._exception_middleware = []
    
    if settings.MIDDLEWARE is None:
        warnings.warn(
            "Old-style middleware using settings.MIDDLEWARE_CLASSES is "
            "deprecated. Update your middleware and use settings.MIDDLEWARE "
            "instead.", RemovedInDjango20Warning
        )
        handler = convert_exception_to_response(self._legacy_get_response)
        for middleware_path in settings.MIDDLEWARE_CLASSES:
            mw_class = import_string(middleware_path)
            try:
                mw_instance = mw_class()
            except MiddlewareNotUsed as exc:
                if settings.DEBUG:
                    if six.text_type(exc):
                        logger.debug('MiddlewareNotUsed(%r): %s', middleware_path, exc)
                    else:
                        logger.debug('MiddlewareNotUsed: %r', middleware_path)
                continue
    
            if hasattr(mw_instance, 'process_request'):
                self._request_middleware.append(mw_instance.process_request)
            if hasattr(mw_instance, 'process_view'):
                self._view_middleware.append(mw_instance.process_view)
            if hasattr(mw_instance, 'process_template_response'):
                self._template_response_middleware.insert(0, mw_instance.process_template_response)
            if hasattr(mw_instance, 'process_response'):
                self._response_middleware.insert(0, mw_instance.process_response)
            if hasattr(mw_instance, 'process_exception'):
                self._exception_middleware.insert(0, mw_instance.process_exception)
    else:
        handler = convert_exception_to_response(self._get_response)
        for middleware_path in reversed(settings.MIDDLEWARE):
            middleware = import_string(middleware_path)
            try:
                mw_instance = middleware(handler)
            except MiddlewareNotUsed as exc:
                if settings.DEBUG:
                    if six.text_type(exc):
                        logger.debug('MiddlewareNotUsed(%r): %s', middleware_path, exc)
                    else:
                        logger.debug('MiddlewareNotUsed: %r', middleware_path)
                continue
    
            if mw_instance is None:
                raise ImproperlyConfigured(
                    'Middleware factory %s returned None.' % middleware_path
                )
    
            if hasattr(mw_instance, 'process_view'):
                self._view_middleware.insert(0, mw_instance.process_view)
            if hasattr(mw_instance, 'process_template_response'):
                self._template_response_middleware.append(mw_instance.process_template_response)
            if hasattr(mw_instance, 'process_exception'):
                self._exception_middleware.append(mw_instance.process_exception)
    
            handler = convert_exception_to_response(mw_instance)
    
    # We only assign to this when initialization is complete as it is used
    # as a flag for initialization being complete.
    self._middleware_chain = handler

开始遍历所有中间件之前，handler(即handler[0])赋值给调用实体的_get_response成员函数。 (即handler[0] = WSGIHandler._get_response = BaseHandler._get_response())。遍历所有中间件过程中，加载并进行初始化(middleware()调用对应着init成员函数)中间件，因此中间件的get_response赋值为handler[i]，注意middleware()返回一个中间件类实体，接着调用调用handler = convert_exception_to_response (mw_instance)，convert_exception_to_response只是对输入函数进行了容错封装，在分析逻辑时，可以简单看成输入函数本身，因此，可以看成handler = mw_instance(request)，对于一个类实体调用即调用call成员函数，从目前来看，大部分的中间件并没有重载该成员函数，因此是直接调用基类的成员函数，即: MiddlewareMixin. __call__(self)。因此handler[i] = MiddlewareMixin. __call__(self)。注意该函数有一个self输入参数，各个中间件在调用时，传入该中间件对应的self实体，这样self.process_request, self.process_response的调用就分别对应着不同中间件的处理函数。load_middleware()调用之后，各个中间件通过get_response链接起来，这样一个request请求到来时，可以顺序通过各个中间件依次进行处理：

image.png

• get_response——django处理request的入口

def get_response(self, request):
    """Return an HttpResponse object for the given HttpRequest."""
    # Setup default url resolver for this thread
    set_urlconf(settings.ROOT_URLCONF)
    
    response = self._middleware_chain(request)
    
    # This block is only needed for legacy MIDDLEWARE_CLASSES; if
    # MIDDLEWARE is used, self._response_middleware will be empty.
    try:
        # Apply response middleware, regardless of the response
        for middleware_method in self._response_middleware:
            response = middleware_method(request, response)
            # Complain if the response middleware returned None (a common error).
            if response is None:
                raise ValueError(
                    "%s.process_response didn't return an "
                    "HttpResponse object. It returned None instead."
                    % (middleware_method.__self__.__class__.__name__))
    except Exception:  # Any exception should be gathered and handled
        signals.got_request_exception.send(sender=self.__class__, request=request)
        response = self.handle_uncaught_exception(request, get_resolver(get_urlconf()), sys.exc_info())
    
    response._closable_objects.append(request)
    
    # If the exception handler returns a TemplateResponse that has not
    # been rendered, force it to be rendered.
    if not getattr(response, 'is_rendered', True) and callable(getattr(response, 'render', None)):
        response = response.render()
    
    if response.status_code == 404:
        logger.warning(
            'Not Found: %s', request.path,
            extra={'status_code': 404, 'request': request},
        )
    
    return response

重点关注response = self._middleware_chain(request)这句,_middleware_chain相当于一个middleware对象，其可以溯源到_get_response方法。

• _get_response

def _get_response(self, request):
    """
    Resolve and call the view, then apply view, exception, and
    template_response middleware. This method is everything that happens
    inside the request/response middleware.
    """
    response = None

    if hasattr(request, 'urlconf'):
        urlconf = request.urlconf
        set_urlconf(urlconf)
        resolver = get_resolver(urlconf)
    else:
        resolver = get_resolver()

    resolver_match = resolver.resolve(request.path_info)
    callback, callback_args, callback_kwargs = resolver_match
    request.resolver_match = resolver_match

    # Apply view middleware
    for middleware_method in self._view_middleware:
        response = middleware_method(request, callback, callback_args, callback_kwargs)
        if response:
            break

    if response is None:
        wrapped_callback = self.make_view_atomic(callback)
        try:
            response = wrapped_callback(request, *callback_args, **callback_kwargs)
        except Exception as e:
            response = self.process_exception_by_middleware(e, request)

    # Complain if the view returned None (a common error).
    if response is None:
        if isinstance(callback, types.FunctionType):  # FBV
            view_name = callback.__name__
        else:  # CBV
            view_name = callback.__class__.__name__ + '.__call__'

        raise ValueError(
            "The view %s.%s didn't return an HttpResponse object. It "
            "returned None instead." % (callback.__module__, view_name)
        )

    # If the response supports deferred rendering, apply template
    # response middleware and then render the response
    elif hasattr(response, 'render') and callable(response.render):
        for middleware_method in self._template_response_middleware:
            response = middleware_method(request, response)
            # Complain if the template response middleware returned None (a common error).
            if response is None:
                raise ValueError(
                    "%s.process_template_response didn't return an "
                    "HttpResponse object. It returned None instead."
                    % (middleware_method.__self__.__class__.__name__)
                )

        try:
            response = response.render()
        except Exception as e:
            response = self.process_exception_by_middleware(e, request)

    return response

该段代码发生在请求响应中间，包括了view、exception、template_response三个部分。先执行_view_middleware，如有response则直接返回response，再执行view，然后执行_template_response_middleware，再执行render()。

中间件的应用

由于中间件工作在视图函数执行前、执行后（像不像所有视图函数的装饰器！）适合所有的请求/一部分请求做批量处理

• 做IP限制
  放在 中间件类的列表中，阻止某些IP访问；
• URL访问过滤
  如果用户访问的是login视图（放过）
  如果访问其他视图（需要检测是不是有session已经有了放行，没有返回login），这样就省得在多个视图函数上写装饰器了！
• 缓存
  客户端请求来了，中间件去缓存看看有没有数据，有直接返回给用户，没有再去逻辑层执行视图函数