Django基础之中间件
一 什么是中间件
中间件顾名思义，是介于request与response处理之间的一道处理过程，相对比较轻量级，并且在全局上改变django的输入与输出。因为改变的是全局，所以需要谨慎实用，用不好会影响到性能
Django中间件的定义：
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.
请求来了要先经过中间件，响应走了最后也要经过中间件。
二 中间件有什么用
如果你想修改请求，例如被传送到view中的HttpRequest对象。 或者你想修改view返回的HttpResponse对象，这些都可以通过中间件来实现。
可能你还想在view执行之前做一些操作，这种情况就可以用 middleware来实现。
七个中间件
Django默认的有七个中间件：（在django项目的settings模块中，有一个 MIDDLEWARE_CLASSES 变量，其中每一个元素就是一个中间件，如下图）
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware', # 安全中间件
'django.contrib.sessions.middleware.SessionMiddleware', # 会话中间件，处理session
'django.middleware.common.CommonMiddleware', # 站点中间件，处理是否带斜杠的
'django.middleware.csrf.CsrfViewMiddleware', # CSRF保护中间件，跨站请求伪造的处理
'django.contrib.auth.middleware.AuthenticationMiddleware', # 认证中间件，提供用户认证服务
'django.contrib.messages.middleware.MessageMiddleware', # 消息中间件，基于cookie或者会话的消息功能
'django.middleware.clickjacking.XFrameOptionsMiddleware', # X-Frame-Options中间件，点击劫持保护
]
每一个中间件都有具体的功能。以上这些都是一些路径，底层就是定义的类。想要查看中间件的类，变形成导入文件的类，然后点击类名。
from django.middleware.security import SecurityMiddleware
from django.contrib.sessions.middleware import SessionMiddleware
# 然后点击最后的类名，查看源码即可
django的中间件给我们暴露了一些方法
class SessionMiddleware(MiddlewareMixin):
def process_request(self, request):
session_key = request.COOKIES.get(settings.SESSION_COOKIE_NAME)
request.session = self.SessionStore(session_key)
def process_response(self, request, response):
return response
中间件中的方法
中间件中主要有几个方法：
1. 需要我们掌握的有：
process_request：请i去进来时，权限认证
process_response：请求有响应时，执行
2. 了解的方法：
process_view :路由匹配之后，能够得到视图函数
process_exception ：出现异常时执行
process_template_response ：模板渲染时执行
这些方法中的具体形参有：
process_request(self,request)
process_view(self, request, callback, callback_args, callback_kwargs)
process_template_response(self,request,response)
process_exception(self, request, exception)
process_response(self, request, response)
在一个中间件中，暴露的这几个方法不是每个类都必须有的，而是需要什么就写什么。
三 自定义中间件
上述截图中的中间件都是django中的，我们也可以自己定义一个中间件，我们可以自己写一个类，但是必须继承MiddlewareMixin。
自定义中间件的步骤：
- 在项目名下或者应用名下新建一个任意名称的文件夹
- 在这个文件夹下面新建一个py文件
- 在这个py文件中，新建一个类，必须继承MiddlewareMixin
- 在你新建的这个类下面写那几个方法：
process_reqeust
process_response - 一定要在配置文件的中间件里面注册你的中间件路径
process_request和process_response
当用户发起请求的时候会依次经过所有的的中间件，这个时候的请求时process_request，最后到达views的函数中，views函数处理后，在依次穿过中间件，这个时候是process_response，最后返回给请求者。
# process_request方法
1.请求来的时候需要经过每一个中间件里面的 process_request方法，经过的顺序是按照配置文件中注册的中间件从上
往下的顺序依次执行
2.如果中间件里面没有定义该方法，那么直接跳过执行下一个中间件
3.它的返回值可以是None，按正常流程继续走，交给下一个中间件处理，如果该方法返回了Httpresponse对象，那么请
求将不再继续往后执行，而是直接原路返回（校验失败不允许访问.）
'process_request方法就是用来做全局相关的所有限制功能'
# process_response方法
1.响应走的时候需要经过每一个中间件里面的 process_response方法，该方法有两个额外的参数 request, response
2,该方法必须返回一个 HttpResponse对象: 默认返回的就是形参 response,你也可以自己返回自己的
3.顺序是按照配置文件中注册了的中间件从下往上依次经过，如果你没有定义的话直接跳过执行下一个
总结：当前端发来请求，Django会执行每个中间件中的process_request，执行顺序按照配置文件由上至下执行。响应走
的时候，Django会执行每个中间件中的 process_response方法，process_response方法是在视图函数之后执行的，执
行顺序是按照配置文件中注册了的中间件从下往上依次执行
自定义中间件：
from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import render, HttpResponse
class MyMiddleware1(MiddlewareMixin):
def process_request(self, request):
print('我是第一个中间件的process_request')
def process_response(self, request, response):
print('我是第一个中间件process_response')
return response
class MyMiddleware2(MiddlewareMixin):
def process_request(self, request):
print('我是第二个中间件的process_request')
def process_response(self, request, response):
print('我是第二个中间件的process_response')
return response
view.py中定义一个视图函数:
def index(request):
print('index函数')
return HttpResponse('index')
在settings.py的MIDDLEWARE里注册自己定义的中间件
结果：
我是第一个中间件的process_request
我是第二个中间件的process_request
index函数
我是第二个中间件的process_response
我是第一个中间件process_response
总结
# 针对process_reqeust
1. 执行顺序是按照配置文件中注册的顺序，从上往下依次执行
2. 视图函数在中间件的process_reqeust函数之后执行
3. 如果在process_reqeust里面直接返回HttpResponse，之后的中间件一律不在走了，包括视图函数
# 针对process_response
1. 必须要返回一个HttpResponse(response的底层严格还是HttpResponse)
2. 执行顺序：是按照配置文件的注册顺序，从下往上依次执行
注意：研究我在第一个中间件的process_reqeust方法中，直接返回HttpResponse，然后，观察所有中间件的process_response的执行顺序?代码如下：
from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import render, HttpResponse
class MyMiddleware1(MiddlewareMixin):
def process_request(self, request):
print('我是第一个中间件的process_request')
return HttpResponse('我是第一个中间件的process_request')
def process_response(self, request, response):
print('我是第一个中间件process_response')
return response
class MyMiddleware2(MiddlewareMixin):
def process_request(self, request):
print('我是第二个中间件的process_request')
def process_response(self, request, response):
print('我是第二个中间件的process_response')
return response
拦截之后的结果如下：
我是第一个中间件的process_request
我是第一个中间件process_response
结论：如果在第一个中间件中得process_reqeust中直接拦截，只走第一个中间件的process_reqeust和第一个中间件的process_response，直接原路返回。
流程图如下：
# 补充：
但是，在flask框架中，如果你在第一个拦截了，后面的类似于是process_response都会走一遍。
'''flask框架中实际上没有真正的中间件，它是需要你看源码自己做成类似于django的这种中间件'''
process_view
process_view(self, request, callback, callback_args, callback_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
from django.shortcuts import HttpResponse
class Md1(MiddlewareMixin):
def process_request(self,request):
print("Md1请求")
#return HttpResponse("Md1中断")
def process_response(self,request,response):
print("Md1返回")
return response
def process_view(self, request, callback, callback_args, callback_kwargs):
print("Md1view")
class Md2(MiddlewareMixin):
def process_request(self,request):
print("Md2请求")
return HttpResponse("Md2中断")
def process_response(self,request,response):
print("Md2返回")
return response
def process_view(self, request, callback, callback_args, callback_kwargs):
print("Md2view")
结果如下：
Md1请求
Md2请求
Md1view
Md2view
view函数...
Md2返回
Md1返回
下图进行分析上面的过程：
当最后一个中间的process_request到达路由关系映射之后，返回到中间件1的process_view，然后依次往下，到达views函数，最后通过process_response依次返回到达用户。
process_view可以用来调用视图函数：
class Md1(MiddlewareMixin):
def process_request(self,request):
print("Md1请求")
#return HttpResponse("Md1中断")
def process_response(self,request,response):
print("Md1返回")
return response
def process_view(self, request, callback, callback_args, callback_kwargs):
# return HttpResponse("hello")
response=callback(request,*callback_args,**callback_kwargs)
return response
结果如下：
Md1请求
Md2请求
view函数...
Md2返回
Md1返回
注意：process_view如果有返回值，会越过其他的process_view以及视图函数，但是所有的process_response都还会执行。
process_exception
process_exception(self, request, exception)
该方法两个参数:
-
request，一个HttpRequest对象
-
exception，一个exception是视图函数异常产生的Exception对象。
这个方法只有在视图函数中出现异常了才执行，它返回的值可以是一个None也可以是一个HttpResponse对象。如果是HttpResponse对象，Django将调用模板和中间件中的process_response方法，并返回给浏览器，否则将默认处理异常。如果返回一个None，则交给下一个中间件的process_exception方法来处理异常。它的执行顺序也是按照中间件注册顺序的倒序执行。
示例修改如下：
class Md1(MiddlewareMixin):
def process_request(self,request):
print("Md1请求")
#return HttpResponse("Md1中断")
def process_response(self,request,response):
print("Md1返回")
return response
def process_view(self, request, callback, callback_args, callback_kwargs):
# return HttpResponse("hello")
# response=callback(request,*callback_args,**callback_kwargs)
# return response
print("md1 process_view...")
def process_exception(self,request,exception):
print("md1 process_exception...")
class Md2(MiddlewareMixin):
def process_request(self,request):
print("Md2请求")
# return HttpResponse("Md2中断")
def process_response(self,request,response):
print("Md2返回")
return response
def process_view(self, request, callback, callback_args, callback_kwargs):
print("md2 process_view...")
def process_exception(self,request,exception):
print("md1 process_exception...")
结果如下：
Md1请求
Md2请求
md1 process_view...
md2 process_view...
view函数...
Md2返回
Md1返回
流程图如下：
当views出现错误时：
将md2的process_exception修改如下：
def process_exception(self,request,exception):
print("md2 process_exception...")
return HttpResponse("error")
结果如下：
Md1请求
Md2请求
md1 process_view...
md2 process_view...
view函数...
md2 process_exception...
Md2返回
Md1返回
process_template_response
process_template_response(self,request,response)
该方法对视图函数返回值有要求，必须是一个含有render方法类的对象，才会执行此方法
class Test:
def __init__(self,status,msg):
self.status=status
self.msg=msg
def render(self):
import json
dic={'status':self.status,'msg':self.msg}
return HttpResponse(json.dumps(dic))
def index(response):
return Test(True,'测试')
四 中间件应用场景
1、做IP访问频率限制
某些IP访问服务器的频率过高，进行拦截，比如限制每分钟不能超过20次。
2、URL访问过滤
可以直接在中间件中做一个验证登录的process_request，如果没有登录，就直接拦截。
如果用户访问的是login视图（放过）
如果访问其他视图，需要检测是不是有session认证，已经有了放行，没有返回login，这样就省得在多个视图函数上写装饰器了！
五 CSRF_TOKEN跨站请求伪造
介绍：浅谈CSRF（Cross-site request forgery）跨站请求伪造
背景信息
钓鱼网站
“钓鱼网站”的页面与真实网站界面基本一致，欺骗消费者或者窃取访问者提交的账号和密码信息
eg：
现在有一个正规的中国银行的网站，我自己也写一个页面根中国银行的页面完全一模一样。
有个客户去中国银行转行，不小心来到了我的这个钓鱼网站，开始在这个钓鱼网站转账，转账完毕之后，钱也少了，这个也达到了中国银行，但是，它想转账的这个对方账户不是它自己想要的哪个账户.
针对上述情况，钓鱼网站是如何做的呢？
在钓鱼网站上的form表单中，它是写一个没有name属性的input框，它在这个input框下面，在隐藏一个input框，这个隐藏的input框，我给他提前写好name属性和value值，但是用户不知道
target_user: <input type="text">
target_user: <input type="text" name="target_username" value='jack' style="display:none">
{# display:"none" HTML文档中元素存在，但是在浏览器中不显示。 #}
如何规避上述问题？
在正规网站中给form表单一个唯一标识，然后，表单每次提交的时候，后端都做一个验证。如果正确就可以提交，如果不正确，就直接403(forbidden)
form表单中如何规避csrf的验证
<form action="" method="post">
{% csrf_token %}
username: <input type="text" name="username">
target_user: <input type="text" name="target_username">
money: <input type="text" name="money">
<input type="submit">
</form>
ajax如何规避csrf的验证
放在data里：
<button class="btn">点击</button>
<script>
$('.btn').click(function () {
$.ajax({
url: '',
type: 'post',
// 方式1：获取表单中的属性值
// 属性选择器：$([attribute])
{#data: {'username': 'kevin', 'csrfmiddlewaretoken': $("[name='csrfmiddlewaretoken']").val()},#}
// 方式2:模板变量{{ csrf_token }}
data: {'username': 'kevin', 'csrfmiddlewaretoken': '{{ csrf_token }}'},
success: function (res) {
}
})
})
上述两种方式都需要使用模板来渲染，前后端分离项目中不能使用。
方式3：使用官方的js文件
django官方提供的js文件
function getCookie(name) {
var cookieValue = null;
if (document.cookie && document.cookie !== '') {
var cookies = document.cookie.split(';');
for (var i = 0; i < cookies.length; i++) {
var cookie = jQuery.trim(cookies[i]);
// Does this cookie string begin with the name we want?
if (cookie.substring(0, name.length + 1) === (name + '=')) {
cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
break;
}
}
}
return cookieValue;
}
var csrftoken = getCookie('csrftoken');
// 每一次都这么写太麻烦了，可以使用$.ajaxSetup()方法为ajax请求统一设置。
function csrfSafeMethod(method) {
// these HTTP methods do not require CSRF protection
return (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method));
}
$.ajaxSetup({
beforeSend: function (xhr, settings) {
if (!csrfSafeMethod(settings.type) && !this.crossDomain) {
xhr.setRequestHeader("X-CSRFToken", csrftoken);
}
}
});
将上面的文件配置到你的Django项目的静态文件中，在html页面上通过导入该文件即可自动帮我们解决ajax提交post数据时校验csrf_token的问题，(导入该配置文件之前，需要先导入jQuery，因为这个配置文件内的内容是基于jQuery来实现的)。也要记得在配置文件中配置static的路径。
更多细节详见：Djagno官方文档中关于CSRF的内容
具体应用：
<button class="btn">点击</button>
<!--引入官方的js文件-->
<script src="/static/js/myjs.js"></script>
<script>
$('.btn').click(function () {
$.ajax({
url: '',
type: 'post',
// 方式3，使用js后，数据正常写
data: {'username': 'kevin'},
success: function (res) {
}
})
})
</script>
放在cookie里：
获取cookie：document.cookie
是一个字符串，可以自己用js切割，也可以用jquery的插件
获取cookie：$.cookie(‘csrftoken’)
设置cookie：$.cookie(‘key’,’value’)
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<script src="/static/jquery-3.3.1.js"></script>
<script src="/static/jquery.cookie.js"></script>
<title>Title</title>
</head>
<body>
<form action="" method="post">
{% csrf_token %}
<p>用户名：<input type="text" name="name"></p>
<p>密码：<input type="text" name="password" id="pwd"></p>
<p><input type="submit"></p>
</form>
<button class="btn">点我</button>
</body>
<script>
$(".btn").click(function () {
var token=$.cookie('csrftoken')
//var token='{{ csrf_token }}'
$.ajax({
url: '',
headers:{'X-CSRFToken':token},
type: 'post',
data: {
'name': $('[name="name"]').val(),
'password': $("#pwd").val(),
},
success: function (data) {
console.log(data)
}
})
})
</script>
</html>
csrf的相关装饰器
全站禁用：注释掉中间件
'django.middleware.csrf.CsrfViewMiddleware',
局部禁用：用装饰器
@csrf_exempt，不验证csrf
@csrf_protect，验证csrf
FBV使用
from django.views.decorators.csrf import csrf_exempt, csrf_protect
# 不再检测，局部禁用（前提是全站使用）
# @csrf_exempt
# 检测，局部使用（前提是全站禁用）
# @csrf_protect
def func(request):
if request.method=='POST':
print(request.POST)
return HttpResponse('ok')
return render(request,'func.html')
CBV使用
1.禁用 csrf_exempt
"""
针对CBV
csrf_exempt第一种方式(加在方法上)不可行
csrf_exempt第二种方式(加在类上)不可行
只有csrf_exempt第三种方式(加在dispatch方法上)可行
"""
from django.views import View
from django.utils.decorators import method_decorator
from django.views.decorators.csrf import csrf_exempt, csrf_protect
class Login(View):
@method_decorator(csrf_exempt)
def dispatch(self, request, *args, **kwargs):
return super(Login, self).dispatch(request, *args, **kwargs)
def post(self, request):
print('post')
return HttpResponse('POST')
2.使用csrf_protect
"""
针对CBV
csrf_protect第一种方式(加在方法上)，可行
csrf_protect第二种方式(加在类上)，可行
csrf_protect第三种方式(加在dispatch方法上)，可行
三种方法都可以用
"""
from django.views import View
from django.utils.decorators import method_decorator
from django.views.decorators.csrf import csrf_exempt, csrf_protect
# 方式2：
# @method_decorator(csrf_protect,name='dispatch')
class Login(View):
# 方式3：
@method_decorator(csrf_protect)
def dispatch(self, request, *args, **kwargs):
return super(Login, self).dispatch(request, *args, **kwargs)
# 方式1：
# @method_decorator(csrf_protect)
def post(self, request):
print('post')
return HttpResponse('POST')
