一. 中间件的介绍
中间件顾名思义, 是介于 request 与 response 处理之间的一道处理过程, 相对比较轻量级,
并且在全局上改变 django 的输入与输出. 因为改变的是全局, 所以需要谨慎实用,
用不好会影响到性能
1.Django 的请求生命周期
2.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',
- ]
3. 执行中间件的过程
二. 自定义中间件
1. 在项目中创建一个包
在项目中创建一个包, 随便起名字, 一般都放在一个叫做 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
2. 在 settings.py 文件中进行注册
- 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',
- 'utils.middlewares.MD1', # 自定义中间件 MD1, 这个写的是你项目路径下的一个路径,
例如, 如果你放在项目下, 文件夹名成为 utils,
那么这里应该写 utils.middlewares.MD1
- 'utils.middlewares.MD2' # 自定义中间件 MD2
- ]
三. 常用方法
1. process_request
process_request 有一个参数, 就是 request, 这个 request 和
视图函数中的 request 是一样的.
它的返回值可以是 None 也可以是 HttpResponse 对象. 返回值是 None 的话,
按正常流程继续走, 交给下一个中间件处理, 如果是 HttpResponse 对象,
Django 将不执行视图函数, 而将相应对象返回给浏览器.
- 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
1在注册时 先注册 MD1 再注册 MD2, 打印结果为:
MD1 里面的 process_request
MD2 里面的 process_request
app01 中的 index 视图
2在注册时 先注册 MD2 再注册 MD1, 打印结果为:
MD2 里面的 process_request
MD1 里面的 process_request
app01 中的 index 视图
注:
多个中间件中的 process_response 方法是按照 MIDDLEWARE 中的注册顺序倒序执行的,
也就是说第一个中间件的 process_request 方法首先执行, 而它的 process_response
方法最后执行, 最后一个中间件的 process_request 方法最后一个执行,
它的 process_response 方法是最先执行.
2. process_response
它有两个参数, 一个是 request, 一个是 response,request 就是上述例子中一样的对象,
response 是视图函数返回的 HttpResponse 对象. 该方法的返回值也必须是 HttpResponse 对象.
1示例 1:
- 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')) #查看响应体里面的内容的方法
- 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
看结果可知:
process_response 方法是在视图函数之后执行的, 并且顺序是 MD1 比 MD2 先执行.
(此时 settings.py 中 MD2 比 MD1 先注册)
多个中间件中的 process_response 方法是按照 MIDDLEWARE 中的注册顺序倒序执行的,
也就是说第一个中间件的 process_request 方法首先执行, 而它的 process_response 方法最后执行,
最后一个中间件的 process_request 方法最后一个执行, 它的 process_response 方法是最先执行.
2示例 2:
- from django.utils.deprecation import MiddlewareMixin
- from django.shortcuts import HttpResponse
- class Md1(MiddlewareMixin):
- def process_request(self,request):
- print("Md1 请求")
- return HttpResponse("Md2 中断")
- #process_request 方法里面不写返回值, 默认也是返回 None, 如果你自己写了 return None,
也是一样的效果, 不会中断你的请求, 但是如果你 return 的一个 httpresponse 对象,
那么就会在这个方法中断你的请求, 直接返回给用户, 这就成了非正常的流程了
#并且, 如果你在这里 return 了 httpresponse 对象, 那么会从你这个中间件类中的
process_response 方法开始执行返回操作, 所以这个类里面只要有 process_response 方法,
肯定会执行
- def process_response(self,request,response):
- print("Md1 返回")
- return response
- class Md2(MiddlewareMixin):
- def process_request(self,request):
- print("Md2 请求")
- def process_response(self,request,response):
- print("Md2 返回")
- return response
结果为:
Md1 请求 Md1 返回
流程图如下:
实例: 访问白名单设置
- class M1(MiddlewareMixin):
- def process_request(self,request):
- #设置路径白名单, 只要访问的是 login 登陆路径, 就不做这个 cookie 认证
- if request.path not in [reverse('login'),]:
- print('我是 M1 中间件') #客户端 IP 地址
- # return HttpResponse('sorry, 没有通过我的 M1 中间件')
- is_login = request.COOKIES.get('is_login', False)
- if is_login:
- pass
- else:
- # return render(request,'login.html')
- return redirect(reverse('login'))
- else:
- return None #别忘了 return None
- def process_response(self,request,response):
- print('M1 响应部分')
- # print(response.__dict__['_container'][0].decode('utf-8'))
- return response
- # return HttpResponse('瞎搞')
- 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 方法.
1 流程图
2 示例:(访问 index 视图函数)
- 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__)
结果:
MD1 里面的 process_request
MD2 里面的 process_request
--------------------------------------------------------------------------------
MD1 中的 process_view
- <function index at 0x000001DE68317488>
- index --------------------------------------------------------------------------------
MD2 中的 process_view
<function index at 0x000001DE68317488> index
app01 中的 index 视图
MD2 里面的 process_response
MD1 里面的 process_response
3写了返回对象的情况
- 4.process_exception
- process_exception(self, request, exception)
该方法两个参数:
一个 HttpRequest 对象
一个 exception 是视图函数异常产生的 Exception 对象.
这个方法只有在视图函数中出现异常了才执行,
它返回的值可以是一个 None 也可以是一个 HttpResponse 对象. 如果是 HttpResponse 对象,
Django 将调用模板和中间件中的 process_response 方法, 并返回给浏览器, 否则将默认处理异常.
如果返回一个 None, 则交给下一个中间件的 process_exception 方法来处理异常.
它的执行顺序也是按照中间件注册顺序的倒序执行.
1示例 1:
- 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__)
- def process_exception(self, request, exception):
- print(exception)
- print("MD1 中的 process_exception")
- 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__)
- def process_exception(self, request, exception):
- print(exception)
- print("MD2 中的 process_exception")
在视图函数中抛出一个异常
- def index(request):
- print("app01 中的 index 视图")
- raise ValueError("呵呵")
- return HttpResponse("O98K")
流程图:
2示例 2: 在 process_exception 中返回一个响应对象
- class MD2(MiddlewareMixin):
- def process_request(self, request):
- print("MD2 里面的 process_request")
- 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__)
- def process_exception(self, request, exception):
- print(exception)
- print("MD2 中的 process_exception")
- return HttpResponse(str(exception)) # 返回一个响应对象
结果:
MD1 里面的 process_request
MD2 里面的 process_request
--------------------------------------------------------------------------------
MD1 中的 process_view
- <function index at 0x0000022C09727488>
- index --------------------------------------------------------------------------------
MD2 中的 process_view
<function index at 0x0000022C09727488> index
app01 中的 index 视图
呵呵
MD2 中的 process_exception
MD2 里面的 process_response
MD1 里面的 process_response
流程图:
补充: 登录时浏览器自动加 "/"
1在输入时
2浏览器自动加 '/'
3在一些情况下不需要加时,
在 settings.py 文件中进行设置
来源: http://www.bubuko.com/infodetail-2980538.html