中间件

<li>中间件是一个钩子框架，它们可以介入Django 的请求和响应处理过程。它是一个轻量级、底层的“插件”系统，用于在全局修改Django 的输入或输出。
<li>每个中间件组件负责完成某个特定的功能。例如，Django 包含的一个中间件组件AuthenticationMiddleware，它使用会话将用户和请求关联起来。
<li>这篇文档讲解中间件如何工作、如何激活中间件以及如何编写你自己的中间件。Django集成了一些内置的中间件可以直接开箱即用。

在1.10中的变化
jango 1.10 版本 更名为 MIDDLEWARE（单复同形）。

激活中间件

要激活一个中间件组件，需要把它添加到Django 配置文件中MIDDLEWARE_CLASSES(新版是MIDDLEWARE中)

<pre>
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.middleware.locale.LocaleMiddleware',
'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',
]
</pre>
Django的程序中，中间件不是必需的 —— 只要你喜欢,MIDDLEWARE可以为空 —— 但是强烈推荐你至少使用CommonMiddleware 元组中.
MIDDLEWARE中的顺序非常重要，因为一个中间件可能依赖于另外一个。例如，AuthenticationMiddleware在会话中储存已认证的用户。所以它必须在SessionMiddleware之后运行。

image.png

老版本中在请求阶段中，调用视图之前，Django会按照MIDDLEWARE_CLASSES中定义的顺序自顶向下应用中间件。
会用到两个钩子：
process_request()
process_view()
在响应阶段中，调用视图之后，中间件会按照相反的顺序应用，自底向上。会用到三个钩子：
process_exception()（仅当视图抛出异常的时候）
process_template_response()（仅用于模板响应）
process_response()。

编写自己的中间件

老版本

编写自己的中间件很容易的。每个中间件组件是一个独立的Python 类，你可以定义上面这些方法中的一个或多个。
<li>process_request
process_request(request)
request是一个HttpRequest对象。在Django决定执行哪个视图之前，process_request()会在每个请求上调用。它应该返回一个None或一个HttpResponse对象。如果返回None，Django会继续处理这个请求，执行其它process_request()中间件，然后process_view()中间件，最后是对应的视图。如果它返回一个HttpResponse对象，Django 就不用再去调用其它的request、view 或exception 中间件，或对应的视图；它将对HttpResponse 运用响应阶段的中间件，并返回结果。
<li>process_view
process_view(request, view_func, view_args, view_kwargs)

request
是一个HttpRequest对象。view_func是 Django会调用的一个Python的函数。（它是一个真实的函数对象，不是函数的字符名称。) view_args是一个会被传递到视图的位置参数列表，而view_kwargs是一个会被传递到视图的关键字参数字典。view_args和 view_kwargs都不包括第一个视图参数(request)。
process_view()会在Django 调用视图之前被调用。
它将返回None或一[HttpResponse对象。如果返回None，Django 将会继续处理这个请求，执行其它的process_view()中间件，然后调用对应的视图。如果返回一个HttpResponse对象，Django 就不用再去调用其它的view 或exception 中间件，或对应的视图；它将对HttpResponse 运用响应阶段的中间件，并返回结果。

Accessing request.POST inside middleware before the view runs or in process_view() will prevent any view running after the middleware from being able to modify the upload handlers for the request, and should normally be avoided.

<li>process_exception
process_exception(request, exception)
request是一个HttpRequest对象。exception是一个被视图中的方法抛出来的 Exception对象。
当一个视图抛出异常时，Django会调用process_exception()来处理。process_exception()应该返回一个None 或者一HttpResponse
对象。如果它返回一个HttpResponse对象，模型响应和响应中间件会被应用，响应结果会返回给浏览器。否则， 默认的异常处理机制将会被触发。再次提醒，在处理响应期间，中间件的执行顺序是倒序执行的，这包括process_exception。如果一个异常处理的中间件返回了一个响应，那这个中间件上面的中间件都将不会被调用。

<li>process_template_response
process_template_response(request, response)
request是一个HttpRequest对象。response是一TemplateResponse对象（或等价的对象），由Django视图或者中间件返回。
如果响应的实例有render()方法，process_template_response()在视图刚好执行完毕之后被调用，这表明了它是一个TemplateResponse对象（或等价的对象）。这个方法必须返回一个实现了render方法的响应对象。它可以修改给定的response对象，通过改 response.template_name和response.context_data或者它可以创建一个全新的 TemplateResponse或等价的对象。你不需要显式渲染响应 —— 一旦所有的模板响应中间件被调用，响应会自动被渲染。在一个响应的处理期间，中间件以相反的顺序运行，这包括process_template_response()

<li>process_response
process_response(request, response)
request是一个HttpRequest对象。
response是Django视图或者中间件返回的HttpResponse或者StreamingHttpResponse对象。
process_response()在所有响应返回浏览器之前被调用。
这个方法必须返回HttpResponse或者StreamingHttpResponse对象。它可以改变已有的response，或者创建并返回新的HttpResponse或StreamingHttpResponse)对象。不像 process_request()和process_view()方法，即使同一个中间件类中的process_request()和process_view()方法会因为前面的一个中间件返回HttpResponse而被跳过，process_response()方法总是会被调用。特别是，这意味着你的process_response()方法不能依赖于process_request()方法中的设置。
最后，记住在响应阶段中，中间件以相反的顺序被应用，自底向上。意思是定义在MIDDLEWARE_CLASSES最底下的类会最先被运行。

例如
<pre>
class BookMiddleware(object):
def process_request(self, request):
print ("Middleware executed")
return None

把这个加到MIDDLEWARE_CLASSES里面，则相应每一个请求时都会输出Middleware executed
</pre>

<pre>
class AnotherMiddleware(object):
def process_request(self, request):
print "Another middleware executed"

在把BookMiddleware和AnotherMiddleware先后加入MIDDLEWARE_CLASSES中时，输出：
Middleware executed
Another middleware executed
</pre>

process_response
<pre>
class AnotherMiddleware(object):
def process_request(self, request):
print "Another middleware executed"

def process_response(self, request, response):
    print "AnotherMiddleware process_response executed"
    return response

class BookMiddleware(object):
def process_request(self, request):
print "Middleware executed"
print request.user
#return HttpResponse("some response")
#self._start = time.time()

def process_response(self, request, response):
    print "BookMiddleware process_response executed"
    return response

在把BookMiddleware和AnotherMiddleware先后加入MIDDLEWARE_CLASSES中时，输出
Middleware executed
Another middleware executed
AnotherMiddleware process_response executed
BookMiddleware process_response executed
requset和response的相反的顺序
</pre>

新版中
内置的中间件都继承自
<pre>
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

__call__ 方法会先调用 self.process_request(request)，接着执行 self.get_response(request) 然后调用 self.process_response(request, response) （如果子类中定义的话）
</pre>

自定义一个新版的中间件(不继承MiddlewareMixin)
<pre>
class SimpleMiddleware(object):
def __init__(self, get_response):
self.get_response = get_response
# One-time configuration and initialization.
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
def process_request(self,request):
pass
def process_response(self,request,response):
#code
</pre>

或者直接继承MiddlewareMixin实现相应的方法