您的位置：首页 > 编程语言 > Go语言

Django学习笔记（15）——中间件

2019-06-05 09:20 1671 查看

　　当Django处理一个Request的过程是首先通过中间件，然后再通过默认的URL方式进行的。我们可以在Middleware这个地方把所有Request拦截住，用我们自己的方式完成处理以后直接返回Response，因此了解中间件的构成是非常有必要的。

1，中间件的概念

Django默认的Middleware如下：

　　在Django项目中的settings模块中，有一个MIDDLEWARE_CLASSES变量，其中每一个元素就是一个中间件，如下：

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',
]

　　每一个中间件都有具体的功能。中间件可以定义五个方法。

分析源码

　　我们可以查看上面middleware 的源码，我们首先导入security：

from django.middleware.security import SecurityMiddleware

　　我们查看源码，会发现：

　　同样，我们再查看一个：

from django.middleware.common import CommonMiddleware

　　我们查看源码，会发现：

再来继续：

from django.middleware.csrf import CsrfViewMiddleware

　　我们查看源码，发现：

　　我们是不是发现了一个共同的特点。也就是都有process_request和process_response。但是并不是所有的中间件都有process_request，但是所有中间件都有process_response。而且我们在写中间件的时候，在process_response一定要注意有返回值！！，process_request没有！！，如果process_request有return值的时候，就不会执行后面的程序了（所以这里可以拦截）

from django.middleware.clickjacking import XFrameOptionsMiddleware

　　查看源码：

　　我们从浏览器发出一个请求Request，得到一个响应后的内容HttpResponse，也就是说，每一个请求都是先通过中间件中的process_request函数，这个函数返回None 或者HttpResponse 对象，如果返回前者，继续处理其他中间件，如果返回前者，继续处理其他中间件，如果返回一个HttpResponse，就处理终止，返回到网页上。

　　中间件不用集成任何类（可以继承object），下面一个中间件大概的样子：

class CommonMiddleware(object):
def process_request(self, request):
return None

def process_response(self, request, response):
return response

　　还有process_view，process_exception和process_template_response函数。

　　中间件顾名思义，是介于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来实现。

2，自定义中间件的方法

　　中间件一共有五个方法：

process_request（self, request）

process_view（self, request, callback, callback_args, callback_kwargs）

process_template_response()

process_exception(self, request, exception)

process_response(self, request, response)

2.1 Request 预处理函数：process_request(self, request)

　　这个方法的调用时机在Django接收到request之后，但仍未解析URL以确定应当运行的视图函数。Django向它传入相应的Request对象，以便在方法中修改。

　　如果返回None，Django将继续处理这个request，执行后续的中间件，然后调用相应的view。

　　如果返回HttpResponse对象，Django将不再执行任何除了process_response以外的其他的中间件以及相应的view，Django将立即返回该HttpResponse。

2.2 View预处理函数：process_view(self, request, callback, callback_args, callback_kwargs)

　　这个方法的调用时机在Django执行完request预处理函数并确定待执行的view（即callback参数）之后，但在view函数实际执行之前。

request：HttpRequest 对象。

callback：Django将调用的处理request的python函数. 这是实际的函数对象本身,
而不是字符串表述的函数名。

args：将传入view的位置参数列表，但不包括request参数(它通常是传入view的第一个参数)。

kwargs：将传入view的关键字参数字典。

　　process_view() 应当返回None或 HttpResponse 对象。如果返回 None， Django将继续处理这个request ，执行后续的中间件，然后调用相应的view。

如果返回 HttpResponse 对象，Django 将不再执行任何其它的中间件(不论种类)以及相应的view，Django将立即返回。

2.3 Template模板渲染函数：process_template_response()

　　默认不执行，只有在视图函数的返回结果对象中有render方法才会执行，并把对象的render方法的返回值返回给用户（注意不返回视图函数的return的结果了，而是返回视图函数return值（对象）中render方法的结果）

2.4 Exception后处理函数：process_exception(self, request, exception)

　　这个方法只有在request处理过程中出了问题并且view函数抛出了一个未捕获的异常才会被调用。这个钩子可以用来发送错误通知，将现场相关信息输出到日志文件，或者甚至尝试从错误中自动恢复。

　这个函数的参数除了一贯的request对象之外，还包括view函数抛出的实际的异常对象exception 。

　　process_exception() 应当返回None或HttpResponse对象。如果返回None，Django将用框架内置的异常处理机制继续处理相应request。如果返回HttpResponse对象，Django将使用该response对象，而短路框架内置的异常处理机制。

2.5 Response 后处理函数：process_response(self, request, response)

　　这个方法的调用时机在 Django 执行 view 函数并生成 response 之后。

　　该处理器能修改response 的内容；一个常见的用途是内容压缩，如gzip所请求的HTML页面。

　　这个方法的参数相当直观：request是request对象，而response则是从view中返回的response对象。

　　process_response() 必须返回 HttpResponse 对象. 这个 response 对象可以是传入函数的那一个原始对象（通常已被修改），也可以是全新生成的。

3，自定义中间件方法练习

3.1 自定义中间件方法应用1（关于process_request 和 process_response方法）

　　　　当用户发起请求的时候会依次经过所有的中间件，这个时候的请求是process_request，最后到达views的函数中，views函数处理后，在依次穿过中间件，这个时候是process_response，最后返回给请求者。

　　上述截图中的中间件都是django中的，我们也可以自己定义一个中间件，我们可以自己写一个类，但是必须继承MiddlewareMixin。

（为什么必须继承MiddlewareMinxin？当时是因为我们之前查看settings里面的中间件的情形，他们也是这样定义的。既然都是中间件，我们就需要按照人家的语法来写）

需要导入：

from django.utils.deprecation import MiddlewareMixin

在 views 中：

def index(request):

print("view函数...")
return HttpResponse("OK")

在Mymiddlewares.py 中：

from django.utils.deprecation import MiddlewareMixinfrom django.shortcuts import HttpResponse

class Md1(MiddlewareMixin):

def process_request(self,request):
print("Md1请求")

def process_response(self,request,response):
print("Md1返回")
return response

class Md2(MiddlewareMixin):

def process_request(self,request):
print("Md2请求")
#return HttpResponse("Md2中断")
def process_response(self,request,response):
print("Md2返回")
return response

结果：

Md1请求
Md2请求
view函数...
Md2返回
Md1返回

　　注意：如果当请求到达请求2的时候直接不符合条件返回，即return HTTPResponse（“Md2中断”），程序将请求直接发给中间件2 返回，然后依次返回到请求者，结果如下：

　　返回Md2 中断的页面，后台打印如下：

Md1请求
Md2请求
Md2返回
Md1返回

　　流程图如下：

3.2 自定义中间件方法应用2（关于process_view 方法）

　　Mymiddlewares.py 修改如下：

from django.utils.deprecation import MiddlewareMixinfrom 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")

　　细心的话，会发现我们增加了 process_view 函数。

　　views.py 视图函数不用改，还是这样：

def index(request):

print("view函数...")
return HttpResponse("OK")

　　我们运行程式，结果如下：

Md1请求
Md2请求
Md1view
Md2view
view函数...
Md2返回
Md1返回

　　下面继续使用流程图分析上面过程：

　　当最后一个中间的 process_request 到达路由关系映射之后，返回到中间件1的 process_view ，然后依次往下，到达 views 函数，最后通过 process_response 依次返回到达用户。

　　那么这样做有什么意义？

　　我们可以发现，process_view() 里面有很多的参数。

我们捋一遍过程。

　　首先，执行中间件1的process_request，然后执行中间件2的 process_request：

from django.utils.deprecation import MiddlewareMixinfrom django.shortcuts import HttpResponse

class Md1(MiddlewareMixin):

def process_request(self,request):
print("Md1请求")

class Md2(MiddlewareMixin):

def process_request(self,request):
print("Md2请求")

　　然后去urls.py 去找到 index() 函数：

urlpatterns = [
path('index/', views.index),
]

　　然后返回中间件1的process_view 和中间件2的 process_view，将拿到的 views.index 传到 callback，去执行process_view()。

from django.utils.deprecation import MiddlewareMixinfrom django.shortcuts import HttpResponse

class Md1(MiddlewareMixin):

def process_view(self, request, callback, callback_args, callback_kwargs):
print("Md1view")

class Md2(MiddlewareMixin):

def process_view(self, request, callback, callback_args, callback_kwargs):
print("Md2view")

　　我们也可以尝试打印 callback这个视图函数，可以看到其结果如下：

callback =============>

<function  index at 0x103338bf8>

　　而process_view中 callback_args 和 claaback_kwargs 是视图函数的参数。

　　当执行完process_view的时候，就去视图函数执行其函数，然后执行 process_response。

　　注意：process_view函数可以用来调用视图函数，我们调用如下：

from django.utils.deprecation import MiddlewareMixinfrom django.shortcuts import HttpResponse

class Md1(MiddlewareMixin):

def process_request(self,request):
print("Md1请求")

def process_response(self,request,response):
print("Md1返回")
return response

def process_view(self, request, callback, callback_args, callback_kwargs):
print("Md1 view")

class Md2(MiddlewareMixin):

def process_request(self,request):
print("Md2请求")

def process_response(self,request,response):
print("Md2返回")
return response

def process_view(self, request, callback, callback_args, callback_kwargs):
print("Md2 view")
return  HttpResponse("123")

　　结果如下：

Md1请求
Md2请求
Md1 views
Md2 views
Md2返回
Md1返回

　　但是请注意，页面返回的是 ‘123’，而不是我们视图函数里面的 “OK”（为了怕大家混淆，我这里将index的视图函数贴上）。

def index(request):

return HttpResponse("OK")

　　如果要返回 OK 的话，怎么做呢？我们修改代码如下：

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都还会执行。

3.3 自定义中间件方法应用3（关于process_exception 方法）

　　Mymiddlewares.py 修改如下：

class Md1(MiddlewareMixin):

def process_request(self,request):
print("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请求")

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("md2 process_exception...")

　　结果如下：

Md1请求
Md2请求
md1 process_view...
md2 process_view...
view函数...
Md2返回
Md1返回

　　当没有问题（异常）的时候，我们发现，和正常的执行没有任何区别。

　　当views出错的时候， process_exception才会执行，我们看报错后的执行流程，如下：

　　下面我们来模拟一个错误，执行看流程：

我们给views.py 里面加一个简单的错误，代码如下：

def index(request):
print("index  doing")
james
return HttpResponse("index  OK")

　　我们执行程式，发现其执行流程如下：

Md1请求
Md2请求
md1 process_view...
md2 process_view...
view函数...
md2 process_exception...
md1 process_exception...

Traceback (most recent call last):
File "C:\Users\Administrator\AppData\Local\Programs\Python\Python37\lib\site-packages\django\core\handlers\exception.py", line 34,
in inner
response = get_response(request)
File "C:\Users\Administrator\AppData\Local\Programs\Python\Python37\lib\site-packages\django\core\handlers\base.py", line 126, in _
get_response
response = self.process_exception_by_middleware(e, request)
File "C:\Users\Administrator\AppData\Local\Programs\Python\Python37\lib\site-packages\django\core\handlers\base.py", line 124, in _
get_response
response = wrapped_callback(request, *callback_args, **callback_kwargs)
File "E:\backup\pycode\web开发\User_model\users\views.py", line 7, in index
james
NameError: name 'james' is not defined

Md2返回
Md1返回

　　并且前端调用如下（当然这是Django自带默认的错误报错程式）：

　　我们也可以自己设定报错，我们将Mymiddlewares.py 修改如下：

class Md1(MiddlewareMixin):

def process_request(self,request):
print("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请求")

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("md2 process_exception...")return HttpResponse(exception)

　　我们再执行程式，会发现前台是这样的：

　　后台是这样的：

Md1请求
Md2请求
md1 process_view...
md2 process_view...
view函数...
md2 process_exception...
Md2返回
Md1返回

　　我们发现在执行中间件2的process_exception后，不会去执行中间件1 了。因为中间件2将错误处理完之后，直接去执行response了。

4，中间件应用场景

　　由于中间件工作在视图函数执行前，执行后。所以适合所有的请求/一部分请求做批量处理

1，做IP访问频率限制

　　放在中间件类的列表中，阻止某些IP访问了。

　　因为某些IP访问服务器的频率过高，所以进行拦截，比如限制每分钟不能超过20次。

2，缓存

　　客户端请求来了，中间件去缓存看看有没有数据，有直接返回给用户，没有再去逻辑层，执行视图函数。

3，URL访问过滤

　　如果用户访问的是login视图

　　如果访问的是其他视图（需要检测是不是由session已经有了放行，没有返回login），这样就省的在多个视图函数上写装饰器了！

　　那么如何写呢？如下：

Django通过中间件实现登录验证DEMO

　　前提：中间件版的登录验证需要依靠session，所以数据库中要有django_session表。

urls.py代码：

from django.conf.urls import url
from django.contrib import admin
from app01 import views

urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^login/$', views.login, name='login'),
url(r'^index/$', views.index, name='index'),
url(r'^home/$', views.home, name='home'),
]

views.py代码：

from django.shortcuts import render, HttpResponse, redirect

def index(request):
return HttpResponse("this is index")

def home(request):
return HttpResponse("this is home")

def login(request):
if request.method == 'POST':
user = request.POST.get("user")
pwd = request.POST.get("pwd")

if user == 'james' and pwd == '123':
# 设置session
request.session['user'] = user
# 获取跳到登录页面之前的URL
next_url = request.GET.get('next')
# 如果有，就跳转到登录之前的URL
if next_url:
return redirect(next_url)
# 否则默认跳转到index页面
else:
return redirect('/index/')
return render(request, 'login.html')

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>登录页面</title>
</head>
<body>
<form action="{% url 'login' %}" method="post">
{% csrf_token %}
<p>
<label for="user">用户名：</label>
<input type="text" name="user" id="user">
</p>
<p>
<label for="pwd">密码：</label>
<input type="text" name="pwd" id="pwd">
</p>
<input type="submit" value="登录">
</form>
</body>
</html>

mymiddlewares.py 的代码：

# 自定义中间件
from django.utils.deprecation import MiddlewareMixinfrom django.shortcuts import redirect, HttpResponse

class AuthMD(MiddlewareMixin):
white_list = ['/login/', ]  # 白名单
black_list = ['/black/', ]  # 黑名单

def process_request(self, request):
next_url = request.path_info
print(request.path_info, request.get_full_path())
# 黑名单的网址限制访问
if next_url in self.black_list:
return HttpResponse("This is an illegal URL")
# 白名单的网址或者登录用户不做限制
elif next_url in self.white_list or request.session.get("user"):
return
else:
return redirect('/login/?next={}'.format(next_url))

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',
# 注意这个中间件是自己加的
'app01.mymiddleware.AuthMD',
]

　　AuthMD 中间件注册后，所有的请求都要走AuthMD的process_request方法。如果URL在黑名单中，则返回This is an illegal URL的字符串；访问的URL在白名单或者session中有user用户名，则不作阻拦走正常流程；正常的URL但是需要登录后访问，让浏览器跳转到登录页面。

　　注意：AuthMD中间件中需要session，所以AuthMD注册的位置要在session中间的下方

6，跨站请求伪造

1，简介

　　django为用户实现防止跨站请求伪造的功能，通过中间件

django.middleware.csrf.CsrfViewMiddleware 来完成。而对于django中设置防跨站请求伪造功能有分为全局和局部。

全局：

　　中间件 django.middleware.csrf.CsrfViewMiddleware

局部：

@csrf_protect，为当前函数强制设置防跨站请求伪造功能，即便settings中没有设置全局中间件。
@csrf_exempt，取消当前函数防跨站请求伪造功能，即便settings中设置了全局中间件。

注：from django.views.decorators.csrf import csrf_exempt,csrf_protect

2，方式

　　方式1：

$.ajaxSetup({
data: {csrfmiddlewaretoken: '{{ csrf_token }}' },
});

　　方式2：

<form>
{% csrf_token %}
</form>

$.ajax({
data:{
"csrfmiddlewaretoken":$("[name='csrfmiddlewaretoken']").val();
}})

　　方法3：

<script src="{% static 'js/jquery.cookie.js' %}"></script>

$.ajax({

headers:{"X-CSRFToken":$.cookie('csrftoken')},

})

3，应用

普通表单

veiw中设置返回值：
　　return render_to_response('Account/Login.html',data,context_instance=RequestContext(request))　　
或者
return render(request, 'xxx.html', data)

html中设置Token:
　　{% csrf_token %}

ajax

　　对于传统的form，可以通过表单的方式将token再次发送到服务端，而对于ajax的话，使用如下方式：

views.py

from django.template.context import RequestContext
# Create your views here.

def test(request):

if request.method == 'POST':
print request.POST
return HttpResponse('ok')
return  render_to_response('app01/test.html',context_instance=RequestContext(request))

text.html

<!DOCTYPE html>
<html>
<head lang="en">
<meta charset="UTF-8">
<title></title>
</head>
<body>
{% csrf_token %}

<input type="button" onclick="Do();"  value="Do it"/>

<script src="/static/plugin/jquery/jquery-1.8.0.js"></script>
<script src="/static/plugin/jquery/jquery.cookie.js"></script>
<script type="text/javascript">
var csrftoken = $.cookie('csrftoken');

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);
}
}
});
function Do(){

$.ajax({
url:"/app01/test/",
data:{id:1},
type:'POST',
success:function(data){
console.log(data);
}
});

}
</script>
</body>
</html>

更多：https://docs.djangoproject.com/en/dev/ref/csrf/#ajax

https://www.cnblogs.com/huchong/p/7819296.html

https://www.cnblogs.com/yuanchenqi/articles/9036479.html

（自己的学习笔记，不喜勿喷，谢谢）

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航

Django学习笔记（15）——中间件

1，中间件的概念

Django默认的Middleware如下：

分析源码

Django中间层的定义

2，自定义中间件的方法

2.1 Request 预处理函数：process_request(self, request)

2.2 View预处理函数：process_view(self, request, callback, callback_args, callback_kwargs)

2.3 Template模板渲染函数：process_template_response()

2.4 Exception后处理函数：process_exception(self, request, exception)

2.5 Response 后处理函数：process_response(self, request, response)

3， 自定义中间件方法练习

3.1 自定义中间件方法应用1（关于process_request 和 process_response方法）

3.2 自定义中间件方法应用2（关于process_view 方法）

3.3 自定义中间件方法应用3（关于process_exception 方法）

4，中间件应用场景

1，做IP访问频率限制

2，缓存

3，URL访问过滤

Django通过中间件实现登录验证DEMO

6，跨站请求伪造

1，简介

2，方式

3，应用

3，自定义中间件方法练习