Django之中间件介绍、自定义中间件、csrf跨站请求伪造


一、 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.

官方的说法:中间件是一个用来处理Django的请求和响应的框架级别的钩子。它是一个轻量、低级别的插件系统,用于在全局范围内改变Django的输入和输出。每个中间件组件都负责做一些特定的功能。

但是由于其影响的是全局,所以需要谨慎使用,使用不当会影响性能。

说的直白一点中间件是帮助我们在视图函数执行之前和执行之后都可以做一些额外的操作,它本质上就是一个自定义类,类中定义了几个方法,Django框架会在请求的特定的时间去执行这些方法。

我们一直都在使用中间件,只是没有注意到而已,打开Django项目的Settings.py文件,看到下图的MIDDLEWARE配置项。

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中间件:点击劫持保护
]

# SessionMiddleware源码
django.contrib.sessions.middleware.SessionMiddleware
process_request(self, request) # 请求来了会触发
process_response(self, request, response) # 请求走了会触发

MIDDLEWARE配置项是一个列表(列表是有序的,记住这一点,后面你就知道为什么要强调有序二字),列表中是一个个字符串,这些字符串其实是一个个类,也就是一个个中间件。

我们之前已经接触过一个csrf相关的中间件了?我们一开始让大家把他注释掉,再提交post请求的时候,就不会被forbidden了,后来学会使用csrf_token之后就不再注释这个中间件了。

二、 自定义中间件

Django默认有七个中间件,但是django暴露给用户可以自定义中间件并且里面可以写五种方法

中间件可以定义五个方法,分别是:(主要的是process_request和process_response)
1.必须掌握
    process_request(self,request)
    process_response(self, request, response)

2.了解即可
    process_view(self, request, view_func, view_args, view_kwargs)
    process_template_response(self,request,response)
    process_exception(self, request, exception)

以上方法的返回值可以是None或一个HttpResponse对象,如果是None,则继续按照django定义的规则向后继续执行,如果是HttpResponse对象,则直接将该对象返回给用户。

自定义中间件需要在Django配置文件中告诉Django去哪找这个自定义的中间件,默认可以放在项目的对应app中,新建一个任意名称的文件夹eg:middleware,在此文件夹中新建任意名称的文件eg:my_middleware.py,然后在此文件中根据需求自定义五个方法中的任意一个或多个

ps:中间件的本质就是含有五个可以修改的内置方法的类,所以自定义的时候需要做的就是先继承一个Django提供的中间件混合的父类(MiddlewareMixin)。

在settings.py的MIDDLEWARE配置项中注册两个自定义中间件:

在这里插入图片描述
在这里插入图片描述

process_request(重点)

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

# 此时,我们访问一个视图,会发现终端中打印如下内容:
MD1里面的 process_request
MD2里面的 process_request
app01 中的 index视图
'''
1. process_request有一个参数,就是request
2. 请求来的时候会依次(从上往下)执行配置文件中注册了的中间件里面的process_request方法 如果没有直接跳过
3. 不同中间件之间传递的request都是同一个对象
4. 该方法如果直接返回了HttpResponse对象那么请求不再继续往下而是直接原路返回
'''

process_response方法(重点)

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


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

# 访问一个视图,看一下终端的输出:
MD1里面的 process_request
MD2里面的 process_request
app01 中的 index视图
MD2里面的 process_response
MD1里面的 process_response

'''
1. 响应走的时候需要经过每一个中间件里面的 process_response方法,该方法有两个额外的参数 request, response
2. 响应走的时候从下往上依次执行注册了的中间件里面的process_response方法如果没有则直接跳过
3. 该方法需要将形参response返回 该response其实就是视图函数返回给浏览器的数据
4. 该方法还可以拦截返回给浏览器的数据 并且还支持自定义返回内容

'''

在这里插入图片描述

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方法。

它应该返回None或一个HttpResponse对象。 
如果返回None,Django将继续处理这个请求,执行任何其他中间件的process_view方法,然后在执行相应的视图。 
如果它返回一个HttpResponse对象,那么将不会执行Django的视图函数,而是直接在中间件中掉头,倒叙执行一个个process_response方法,最后返回给浏览器
'''
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__)


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

# 访问index视图函数,看一下输出结果
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


'''
process_view方法是在Django路由系统之后,视图系统之前执行的,执行顺序按照配置文件MIDDLEWARE中的注册顺序从前到后顺序执行的
'''

process_exception方法(了解)

'''
process_exception(self, request, exception)

该方法两个参数:
一个HttpRequest对象
一个exception是视图函数异常产生的Exception对象。

这个方法只有在视图函数中出现异常了才执行,它返回的值可以是一个None也可以是一个HttpResponse对象。
如果是HttpResponse对象,Django将调用模板和中间件中的process_response方法,并返回给浏览器,否则将默认处理异常。
如果返回一个None,则交给下一个中间件的process_exception方法来处理异常。它的执行顺序也是按照中间件注册顺序的倒序执行。
'''
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")

process_template_response方法(了解)

'''
process_template_response(self, request, response)

它的参数,一个HttpRequest对象,response是TemplateResponse对象(由视图函数或者中间件产生)。

process_template_response是在视图函数执行完成后立即执行,但是它有一个前提条件,那就是视图函数返回的对象有一个render()方法(或者表明该对象是一个TemplateResponse对象或等价方法)。
'''

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")
        return HttpResponse(str(exception))

    def process_template_response(self, request, response):
        print("MD1 中的process_template_response")
        return 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__)

    def process_exception(self, request, exception):
        print(exception)
        print("MD2 中的process_exception")

    def process_template_response(self, request, response):
        print("MD2 中的process_template_response")
        return response

# views.py
def index(request):
    print("app01 中的 index视图")

    def render():
        print("in index/render")
        return HttpResponse("O98K")
    rep = HttpResponse("OK")
    rep.render = render
    return rep

'''
视图函数执行完之后,立即执行了中间件的process_template_response方法,顺序是倒序,先执行MD1的,在执行MD2的,接着执行了视图函数返回的HttpResponse对象的render方法,返回了一个新的HttpResponse对象,接着执行中间件的process_response方法
'''

三、 中间件的执行流程

上一部分,我们了解了中间件中的5个方法,它们的参数、返回值以及什么时候执行,现在总结一下中间件的执行流程。

请求到达中间件之后,先按照正序执行每个注册中间件的process_request方法,process_request方法返回的值是None,就依次执行,如果返回的值是HttpResponse对象,不再执行后面的process_request方法,而是执行当前对应中间件的process_response方法(注意不是掉头执行所有的process_response方法),将HttpResponse对象返回给浏览器。也就是说:如果MIDDLEWARE中注册了6个中间件,执行过程中,第3个中间件返回了一个HttpResponse对象,那么第4,5,6中间件的process_request和process_response方法都不执行,顺序执行3,2,1中间件的process_response方法。

在这里插入图片描述
process_request方法都执行完后,匹配路由,找到要执行的视图函数,先不执行视图函数,先执行中间件中的process_view方法,process_view方法返回None,继续按顺序执行,所有process_view方法执行完后执行视图函数。假如中间件3 的process_view方法返回了HttpResponse对象,则4,5,6的process_view以及视图函数都不执行,直接从最后一个中间件,也就是中间件6的process_response方法开始倒序执行。
在这里插入图片描述
process_template_response和process_exception两个方法的触发是有条件的,执行顺序也是倒序。总结所有的执行流程如下:

在这里插入图片描述
在这里插入图片描述

四、 中间件版登录验证

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

urls.py

from app02 import views as v2
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^login/',v2.login),
    url(r'^home/',v2.home),
    url(r'^index/',v2.index)
]

views.py

from django.shortcuts import render,redirect,HttpResponse
from app02 import models
# Create your views here.
def login(request):
    error_msg=''
    if request.method=='POST':
        username=request.POST.get('username')
        password=request.POST.get('password')
        user_obj=models.User.objects.filter(username=username,password=password)
        if  user_obj:
            #设置session
            request.session['login']='ok'
            #获取用户想直接访问的URL
            url=request.GET.get('next')
            #如果有,就跳转到客户初始想访问的URL
            if not url:
                #没有则默认跳转到home页面
                url='/home/'
            return redirect(url)
        else:
            error_msg='username or password error!'
    return render(request,'login.html',{'error_msg':error_msg})

def home(request):
    return HttpResponse('<h1>这是home页面 只有登录了才能看到</h1>')

def index(request):
    return HttpResponse('<h1>这是index页面 也只有登录了才能看到<h1>')

login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登陆页面</title>
    <meta name="viewport" content="width=device-width, initial-scale=1">
</head>
<body>
<form action="" method="post">
    {% csrf_token %}
    <label for="">username:<input type="text" name="username"></label>
    <label for="">password:<input type="password" name="password"></label>
    <input type="submit" value="submit">
</form>
<h1 style="color: red">{{ error_msg }}</h1>

</body>
</html>

middlewares.py

from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import redirect

class Check_Login(MiddlewareMixin):
    def process_request(self,request):
        next_url=request.path_info
        if not next_url.startswith('/login/'):
            is_login=request.session.get('login','')
            if not is_login:
                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',
    'middleware.my_middleware.Check_Login',

]

五、 CSRF_TOKEN跨站请求伪造

csrf使用

1.form表单
	表单中直接书写下列的语句即可
<form action="" method="post">
    {% csrf_token %}
    <p>给谁转:<input type="text" name="to_user" id="id_name"></p>
    <p>转多少:<input type="text" name="money" id="id_money"></p>
    <input type="submit" value="转账">

</form>

 
2.ajax
	$.ajax({
            url: '/transfer/',
            method: 'post',
            //data: {to_user: $('#id_name').val(), money: $('#id_money').val(),csrfmiddlewaretoken:$('[name="csrfmiddlewaretoken"]').val()},
            data: {to_user: $('#id_name').val(), money: $('#id_money').val(),csrfmiddlewaretoken:'{{csrf_token}}'},
            success: function (data) {
                console.log(data)

            }
        })
方式1:借助于{% csrf_token %}生成的标签(不推荐)
$("[name = 'csrfmiddlewaretoken']").val()

方式2:借助于模板语法直接获取
'{{ csrf_token }}'

方式3:借助于官方提供的js文件自动获取
下方js文件导入即可

导入该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');

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);
    }
  }
});

更多细节详见:Djagno官方文档中关于CSRF的内容

csrf相关装饰器

from django.views.decorators.csrf import csrf_exempt, csrf_protect
'''
csrf_protect  局部校验csrf
	针对csrf_exempt 符合我们正确所学的装饰器的三种玩法  
csrf_exempt   局部不校验csrf
	针对csrf_exempt 只能给dispatch方法加才有效
'''

# @csrf_protect
# @csrf_exempt
def index(request):
    if request.method == 'POST':
        username = request.POST.get('username')
        money = request.POST.get('money')
        target_user = request.POST.get('target_user')
        print('%s 给 %s 转了 %s 元钱'%(username,target_user,money))
    return render(request,'index.html')

from django.utils.decorators import method_decorator

from django import views
# @method_decorator(csrf_protect,name='post')  # 第二种  行
# @method_decorator(csrf_exempt,name='post')  # 第二种  不行
@method_decorator(csrf_exempt,name='dispatch') # 行
class MyLogin(views.View):
    # @method_decorator(csrf_protect)  # 第三种 行 所有的方法都会加上该功能
    @method_decorator(csrf_exempt)  # 第三种 行 所有的方法都会加上该功能
    def dispatch(self, request, *args, **kwargs):
        return super().dispatch(request,*args,**kwargs)

    def get(self,request):
        return HttpResponse('from get')

    # @method_decorator(csrf_protect)  # 第一种  行
    # @method_decorator(csrf_exempt)  # 第一种  不行
    def post(self,request):
        return HttpResponse('from post')
 
"""
csrf_exempt该装饰器在CBV中只能给dispatch装才能生效
"""

总结

1 中间件:request对象,response
    -process_request
        -返回None,继续往下走
        -返回response对象,直接返回
    -process_response
        -处理response
    -定义一个类,继承MiddlewareMixin
    -配置文件配置(执行顺序)
2 中间件能干什么
    -全局的登陆认证
    -记录日志(访问日志,登录日志,客户端类型。。。)
    -对ip地址进行限制(一分钟访问十次)
    
3 csrf,xsrf:跨站请求伪造
    
4 django中处理csrf攻击
    1 form表单形式  {% csrf_token %}
    2 ajax提交:手动传,2种方式
    3 ajax提交:放到请求头中
       $.ajax({
            url: '/transfer/',
            headers:{'X-CSRFToken':'sssssss','name':'lqz'},
            method: 'post',
            data: {to_user: $('#id_name').val(), money: $('#id_money').val(),csrfmiddlewaretoken:'{{csrf_token}}'},
            success: function (data) {
                console.log(data)

            }
        })
        
        
4 请求头中的数据,django如何获取
    request.META.get('HTTP_字段名大写')

5 django的csrf中间件
 -全局使用csrf,中间件解开
    -局部禁用:在视图函数上加一个装饰器csrf_exempt
    -全局禁用,中间件加注释
    -局部使用:在视图函数上加一个装饰器csrf_protect

版权声明:本文为LHQ626原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。