标签：process 中间件 self request 高级 Django csrf 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来实现。

七个中间件

Django默认的有七个中间件：（在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',
]

每一个中间件都有具体的功能。以上这些都是一些路径，底层就是定义的类。想要查看中间件的类，变形成导入文件的类，然后点击类名。

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
    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,最后返回给请求者。

自定义中间件：

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')

标签：process,中间件,self,request,高级,Django,csrf,response
From： https://www.cnblogs.com/zjyao/p/17383351.html

Django高级之-中间件

一什么是中间件

二中间件有什么用

七个中间件

中间件中的方法

三自定义中间件

process_request和process_response

process_view

process_exception

process_template_response

四中间件应用场景

1、做IP访问频率限制

2、URL访问过滤

五 CSRF_TOKEN跨站请求伪造

背景信息

form表单中如何规避csrf的验证

ajax如何规避csrf的验证

放在data里：

django官方提供的js文件

放在cookie里：

csrf的相关装饰器

FBV使用

CBV使用

相关文章

赞助商

阅读排行

Django高级之-中间件

一 什么是中间件

二 中间件有什么用

七个中间件

中间件中的方法

三 自定义中间件

process_request和process_response

process_view

process_exception

process_template_response

四 中间件应用场景

1、做IP访问频率限制

2、URL访问过滤

五 CSRF_TOKEN跨站请求伪造

背景信息

form表单中如何规避csrf的验证

ajax如何规避csrf的验证

放在data里：

django官方提供的js文件

放在cookie里：

csrf的相关装饰器

FBV使用

CBV使用

相关文章

赞助商

阅读排行

一什么是中间件

二中间件有什么用

三自定义中间件

四中间件应用场景