按照settings.MIDDLEWARE的顺序，先由上至下执行所有的process_request，然后由上至下执行所有的process_view，最后由下至上执行所有的process_response。如：

  1. MIDDLEWARE = [
  2.     "django.middleware.security.SecurityMiddleware",
  3.     "django.middleware.common.CommonMiddleware",
  4.     "django.middleware.clickjacking.XFrameOptionsMiddleware",
  5.     "apps.api.middleware_mgr.Middleware",
  6. ]

settings.MIDDLEWARE存在的情况下，Django加载中间件的源码：

  1. # django/core/handlers/base.py
  3. class BaseHandler(object):
  4.     def __init__(self):
  5.         self._request_middleware = None
  6.         self._view_middleware = None
  7.         self._template_response_middleware = None
  8.         self._response_middleware = None
  9.         self._exception_middleware = None
  10.         self._middleware_chain = None
  11.         
  12.     def load_middleware(self):
  13.         # _get_response是一个方法，它的功能是按顺序调用中间件的process_view方法。并且在最核心执行被层层包裹的实际视图
  14.         # This method is everything that happens inside the request/response middleware.
  15.         # convert_exception_to_response是一个装饰器，相当于是为_get_response加了一个在出错后仍然可以返回HttpResponse的功能
  16.         handler = convert_exception_to_response(self._get_response)
  17.         # 逆序访问 settings.MIDDLEWARE 中定义的中间件路径
  18.         for middleware_path in reversed(settings.MIDDLEWARE):
  19.             # 这个middleware是settings.MIDDLEWARE中定义的中间件类，如 <class \'apps.auth2.middleware_mgr.AdMiddleware\'>
  20.             middleware = import_string(middleware_path)
  21. 	    # mw_instance是中间件类的实例。
  22.             # 由于大多数中间件都继承自MiddlewareMixin，因此初始化中间件实例的时候需要提供一个get_response方法
  23.             # 而handler刚好就是我们需要的这个方法
  24.             # （见下文MiddlewareMixin的__init__方法）
  25.             mw_instance = middleware(handler)
  26.             if hasattr(mw_instance, \'process_view\'):
  27.                 # self._view_middleware 是按照settings.MIDDLEWARE的顺序，由上至下生成的
  28.                 self._view_middleware.insert(0, mw_instance.process_view)
  29.             if hasattr(mw_instance, \'process_template_response\'):
  30.                 # self._template_response_middleware 是按照settings.MIDDLEWARE的顺序，由下至上生成的
  31.                 self._template_response_middleware.append(mw_instance.process_template_response)
  32.             if hasattr(mw_instance, \'process_exception\'):
  33.                 # self._exception_middleware 是按照settings.MIDDLEWARE的顺序，由下至上生成的                
  34.                 self._exception_middleware.append(mw_instance.process_exception)
  35. 	    # 思考：为什么不加载process_request和process_response？
  37.             # 一定要理解这个地方，其实middleware就像套娃的一层一样
  38.             # 它的实例初始化需要接受一个get_response方法，这个方法就相当于这层套娃的内部
  39.             # 然后，中间件的实例可以被当做函数调用，即执行中间件实例的__call__方法
  40.             # 那么这个中间件实例可以被视为另一个get_response方法，被外层的中间件使用
  41.             # 这个handler，就是将当前层中间件实例套上之后的套娃
  42.             handler = convert_exception_to_response(mw_instance)
  43.         # 只有当所有中间件加载完毕后，才会将_middleware_chain赋值为最终的handler(最外层中间件的实例)
  44.         # 这个变量被赋值就是初始化完成的标志
  45.         self._middleware_chain = handler

整个中间件套娃被执行的入口是BaseHandler的get_response方法

  1. # django/core/handlers/base.py
  3. class BaseHandler(object):
  4.         def get_response(self, request):
  5.         """Return an HttpResponse object for the given HttpRequest."""
  6.         # 根据上文，self._middleware_chain就是最外层中间件的实例，这里调用了最外层中间件的__call__方法
  7.         # 然后经过层层中间件抵达核心执行view，再层层递出response，这个response就是最终的结果
  8.         response = self._middleware_chain(request)
  10.         # This block is only needed for legacy MIDDLEWARE_CLASSES
  11.         # if MIDDLEWARE is used, self._response_middleware will be empty.
  12.         # 这里回答了load_middleware为什么不加载process_response的问题，self._response_middleware只会在这里用到
  13.         # 如果定义了MIDDLEWARE，self._response_middleware将会为空
  14.         try:
  15.             # Apply response middleware, regardless of the response
  16.             for middleware_method in self._response_middleware:
  17.                 ...
  19.         return response

看看最外层中间件的__call__方法，中间件如果继承自MiddlewareMixin，则会执行父类的__call__方法

  1. class MiddlewareMixin(object):
  2.     def __init__(self, get_response=None):
  3.         self.get_response = get_response
  4.         super(MiddlewareMixin, self).__init__()
  6.     def __call__(self, request):
  7.         response = None
  8.         if hasattr(self, \'process_request\'):
  9.             # 这里执行的是子类（最外层中间件）的process_request方法，即settings.MIDDLEWARE的第一个列出的中间件
  10.             # 因此process_request是按由上到下的顺序执行的，并且在load_middleware不需要被加载
  11.             # 它的执行顺序由套娃的结构维护
  12.             response = self.process_request(request)
  13.         # process_request发生错误后将返回一个HttpResponse对象，下层中间件将不会被执行
  14.         if not response:
  15.             # 没有发生错误，继续执行下层中间件。这个get_response方法实际上是下层中间件实例的__call__方法
  16.             response = self.get_response(request)
  17.         # response经过下层的一系列中间件返回，执行当前层的process_response，并返回响应
  18.         # 最外层的process_response会最后执行
  19.         # 因此process_response是按settings.MIDDLEWARE的顺序由下至上执行的，并且在load_middleware不需要被加载
  20.         # 它的执行顺序由套娃的结构维护
  21.         if hasattr(self, \'process_response\'):
  22.             response = self.process_response(request, response)
  23.         return response

中间件的最核心是_get_response方法

  1.     def _get_response(self, request):
  2.         """
  3.         Resolve and call the view, then apply view, exception, and
  4.         template_response middleware. This method is everything that happens
  5.         inside the request/response middleware.
  6.         """
  8.         # 在这里按照settings.MIDDLEWARE的顺序依次执行中间件的process_view
  9.         for middleware_method in self._view_middleware:
  10.             # process_view处理失败或者出于一些其他的原因需要中止请求，就返回一个HttpResponse
  11.             # 正常情况下，应返回None
  12.             response = middleware_method(request, callback, callback_args, callback_kwargs)
  13.             if response:
  14.                 break
  16.         if response is None:
  17.             # 执行实际的视图
  18.             wrapped_callback = self.make_view_atomic(callback)
  19.             response = wrapped_callback(request, *callback_args, **callback_kwargs)
  21.         # If the response supports deferred rendering, apply template
  22.         # response middleware and then render the response
  23.         # 如果有渲染的需求才会使用process_template_response方法
  24.         elif hasattr(response, \'render\') and callable(response.render):
  25.             for middleware_method in self._template_response_middleware:
  26.                 response = middleware_method(request, response)
  27.                 ...
  29.         return response
表头 表头 表头 表头
process_request 请求刚到来，执行视图之前 配置列表的正序 None或者HttpResponse对象
process_response 视图执行完毕，返回响应时 逆序 HttpResponse对象
process_view process_request之后，路由转发到视图，执行视图之前 正序 None或者HttpResponse对象
process_exception 视图执行中发生异常时 逆序 None或者HttpResponse对象
process_template_response 视图刚执行完毕，process_response之前 逆序 实现了render方法的响应对象

注意middleware方法的输入参数都是固定的

  1. # utils/my_middleware.py
  2. from django.utils.deprecation import MiddlewareMixin
  5. class MyMiddleware1(MiddlewareMixin):
  6.     def __str__(self):
  7.         return "MyMiddleware1"
  9.     def process_request(self, request):
  10.         print(self, " processing request...")
  12.     def process_view(self, request, view_func, view_args, view_kwargs):
  13.         print(self, " processing view...")
  15.     def process_response(self, request, response):
  16.         print(self, " processing response...")
  17.         return response
  19.     def process_exception(self, request, exception):
  20.         print(self, " processing exception...")
  23. class MyMiddleware2(MiddlewareMixin):
  24.     def __str__(self):
  25.         return "MyMiddleware2"
  27.     def process_request(self, request):
  28.         print(self, " processing request...")
  30.     def process_view(self, request, view_func, view_args, view_kwargs):
  31.         print(self, " processing view...")
  33.     def process_response(self, request, response):
  34.         print(self, " processing response...")
  35.         return response
  37.     def process_exception(self, request, exception):
  38.         print(self, " processing exception...")
  1. # settings.py
  2. MIDDLEWARE = [
  3.     \'django.middleware.security.SecurityMiddleware\',
  4.     \'django.contrib.sessions.middleware.SessionMiddleware\',
  5.     \'django.middleware.common.CommonMiddleware\',
  6.     \'django.middleware.csrf.CsrfViewMiddleware\',
  7.     \'django.contrib.auth.middleware.AuthenticationMiddleware\',
  8.     \'django.contrib.messages.middleware.MessageMiddleware\',
  9.     \'django.middleware.clickjacking.XFrameOptionsMiddleware\',
  10.     \'utils.my_middleware.MyMiddleware1\',
  11.     \'utils.my_middleware.MyMiddleware2\'
  12. ]
  1. # urls.py
  2. from django.conf.urls import url
  4. from demo.views import mid_test
  6. urlpatterns = [
  7.     url(r"^midtest/", mid_test),
  8. ]
  1. # views.py
  2. from django.http import HttpResponse
  4. def mid_test(request):
  5.     print(\'in mid_test view\')
  6.     return HttpResponse(\'ok\')

访问 http://127.0.0.1:8000/midtest/ ，可在控制台得到这样的输出，验证了之前关于中间件执行顺序的理论

  1. MyMiddleware1  processing request...
  2. MyMiddleware2  processing request...
  3. MyMiddleware1  processing view...
  4. MyMiddleware2  processing view...
  5. in mid_test view
  6. MyMiddleware2  processing response...
  7. MyMiddleware1  processing response...
  8. [08/Jun/2020 17:32:54] "GET /midtest/ HTTP/1.1" 200 2

如果process_request返回了一个HttpResponse对象

  1. class MyMiddleware1(MiddlewareMixin):
  2.     def __str__(self):
  3.         return "MyMiddleware1"
  5.     def process_request(self, request):
  6.         print(self, " processing request...")
  7.         return HttpResponse("break")

下层中间件将不会被执行，response会按原路返回

  1. MyMiddleware1  processing request...
  2. MyMiddleware1  processing response...
  3. [08/Jun/2020 18:08:21] "GET /midtest/ HTTP/1.1" 200 5

如果process_view返回了一个HttpResponse对象，同样

  1. class MyMiddleware1(MiddlewareMixin):
  2.     def __str__(self):
  3.         return "MyMiddleware1"
  5.     def process_request(self, request):
  6.         print(self, " processing request...")
  7.         return HttpResponse("break")
  1. MyMiddleware1  processing request...
  2. MyMiddleware2  processing request...
  3. MyMiddleware1  processing view...
  4. MyMiddleware2  processing response...
  5. MyMiddleware1  processing response...
  6. [08/Jun/2020 18:11:00] "GET /midtest/ HTTP/1.1" 200 5

如果视图引发了异常，如

  1. from django.http import HttpResponse
  3. def mid_test(request):
  4.     print(\'in mid_test view\')
  5.     1/0
  6.     return HttpResponse(\'ok\')

则Django会逆序调用中间件的process_exception方法，紧接着逆序调用process_response方法

  1. MyMiddleware1  processing request...
  2. MyMiddleware2  processing request...
  3. MyMiddleware1  processing view...
  4. MyMiddleware2  processing view...
  5. in mid_test view
  6. MyMiddleware2  processing exception...
  7. MyMiddleware1  processing exception...
  8. Internal Server Error: /midtest/
  9. Traceback (most recent call last):
  10.   File "/home/youmi/code/V36DemoForPython/venv/lib/python3.6/site-packages/django/core/handlers/exception.py", line 41, in inner
  11.     response = get_response(request)
  12.   File "/home/youmi/code/V36DemoForPython/venv/lib/python3.6/site-packages/django/core/handlers/base.py", line 187, in _get_response
  13.     response = self.process_exception_by_middleware(e, request)
  14.   File "/home/youmi/code/V36DemoForPython/venv/lib/python3.6/site-packages/django/core/handlers/base.py", line 185, in _get_response
  15.     response = wrapped_callback(request, *callback_args, **callback_kwargs)
  16.   File "/home/youmi/code/V36DemoForPython/demo/views.py", line 6, in mid_test
  17.     1/0
  18. ZeroDivisionError: division by zero
  19. MyMiddleware2  processing response...
  20. MyMiddleware1  processing response...

如果process_exception返回了一个HttpResponse对象

  1. class MyMiddleware2(MiddlewareMixin):
  2.     def process_exception(self, request, exception):
  3.         print(self, " processing exception...")
  4.         return HttpResponse(\'not ok\')

页面会显示process_exception返回的内容，而不再使用默认异常处理。并且，此中间件之上的中间件类的process_exception方法不会被调用。但是process_response方法仍然会被逆序调用

  1. MyMiddleware1  processing request...
  2. MyMiddleware2  processing request...
  3. MyMiddleware1  processing view...
  4. MyMiddleware2  processing view...
  5. in mid_test view
  6. MyMiddleware2  processing exception...
  7. MyMiddleware2  processing response...
  8. MyMiddleware1  processing response...

Django中间件 –刘江

Middleware¶

版权声明：本文为luozx207原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/luozx207/p/13141845.html