Django框架——中间件、Auth模块、ContentType
文章目录
-
- 一 什么是中间件
- 二 中间件有什么用
- 三 自定义中间件
-
- process_request和process_response
- process_view
- process_exception
- process_template_response(self,request,response)
- 四 中间件应用场景
-
- 1、做IP访问频率限制
- 2、URL访问过滤
- 五 CSRF_TOKEN跨站请求伪造
-
- 在form表单中应用：
- 在Ajax中应用：
-
- 放在data里：
- 放在cookie里：
- 其它操作
- 2 Auth
-
- 1 Auth模块是什么
- 2 auth模块常用方法
-
- authenticate()
- login(HttpRequest, user)
- *logout(request) *
- is_authenticated()
- login_requierd()
- create_user()
- create_superuser()
- check_password(password)
- set_password(password)
- User对象的属性
- 3 扩展默认的auth_user表
- 3 ContentType
-
- 一 项目背景
- 二 版本一
- 三 版本二
- 四 最终版（使用ContentType）
一 什么是中间件
中间件顾名思义，是介于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',
]
每一个中间件都有具体的功能
三 自定义中间件
中间件中主要有几个方法：
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)
process_request和process_response
当用户发起请求的时候会依次经过所有的的中间件，这个时候的请求时process_request,最后到达views的函数中，views函数处理后，在依次穿过中间件，这个时候是process_response,最后返回给请求者。
上述截图中的中间件都是django中的，我们也可以自己定义一个中间件，我们可以自己写一个类，但是必须继承MiddlewareMixin
第一步：导入
from django.utils.deprecation import MiddlewareMixin
第二步：自定义中间件
from django.utils.deprecation import MiddlewareMixin
from 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
第三步：在view中定义一个视图函数（index）
def index(request):
print("view函数...")
return HttpResponse("OK")
第四步：在settings.py的MIDDLEWARE里注册自己定义的中间件
结果：
Md1请求
Md2请求
view函数...
Md2返回
Md1返回
**注意：**如果当请求到达请求2的时候直接不符合条件返回，即return HttpResponse(“Md2中断”)，程序将把请求直接发给中间件2返回，然后依次返回到请求者，结果如下：
返回Md2中断的页面，后台打印如下：
Md1请求
Md2请求
Md2返回
Md1返回
流程图如下：
由此总结一下：
- 中间件的process_request方法是在执行视图函数之前执行的。
- 当配置多个中间件时，会按照MIDDLEWARE中的注册顺序，也就是列表的索引值，从前到后依次执行的。
- 不同中间件之间传递的request都是同一个对象
多个中间件中的process_response方法是按照MIDDLEWARE中的注册顺序倒序执行的，也就是说第一个中间件的process_request方法首先执行，而它的process_response方法最后执行，最后一个中间件的process_request方法最后一个执行，它的process_response方法是最先执行。
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方法并将应用到该HttpResponse并返回结果。
process_view(self, request, callback, callback_args, callback_kwargs)
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)
该方法两个参数:
一个HttpRequest对象
一个exception是视图函数异常产生的Exception对象。
这个方法只有在视图函数中出现异常了才执行，它返回的值可以是一个None也可以是一个HttpResponse对象。如果是HttpResponse对象，Django将调用模板和中间件中的process_response方法，并返回给浏览器，否则将默认处理异常。如果返回一个None，则交给下一个中间件的process_exception方法来处理异常。它的执行顺序也是按照中间件注册顺序的倒序执行。
process_exception(self, request, 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(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访问过滤
如果用户访问的是login视图（放过）
如果访问其他视图，需要检测是不是有session认证，已经有了放行，没有返回login，这样就省得在多个视图函数上写装饰器了！
作为延伸扩展内容，有余力的同学可以尝试着读一下以下两个自带的中间件：
'django.contrib.sessions.middleware.SessionMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
五 CSRF_TOKEN跨站请求伪造
介绍：浅谈CSRF（Cross-site request forgery）跨站请求伪造
在form表单中应用：
<form action="" method="post">
{% csrf_token %}
<p>用户名：<input type="text" name="name"></p>
<p>密码：<input type="text" name="password"></p>
<p><input type="submit"></p>
</form>
在Ajax中应用：
放在data里：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<script src="/static/jquery-3.3.1.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 () {
$.ajax({
url: '',
type: 'post',
data: {
'name': $('[name="name"]').val(),
'password': $("#pwd").val(),
'csrfmiddlewaretoken': $('[name="csrfmiddlewaretoken"]').val()
},
success: function (data) {
console.log(data)
}
})
})
</script>
</html>
放在cookie里：
获取cookie：document.cookie
是一个字符串，可以自己用js切割，也可以用jquery的插件
获取cookie： . c o o k i e ( ‘ c s r f t o k e n ’ ) 设 置 c o o k i e ： .cookie(‘csrftoken’) 设置cookie： .cookie(‘csrftoken’)设置cookie：.cookie(‘key’,’value’)
<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>Titletitle>
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>
其它操作
全站禁用：注释掉中间件 ‘django.middleware.csrf.CsrfViewMiddleware’,
局部禁用：用装饰器（在FBV中使用）
from django.views.decorators.csrf import csrf_exempt,csrf_protect
# 不再检测，局部禁用（前提是全站使用）
# @csrf_exempt
# 检测，局部使用（前提是全站禁用）
# @csrf_protect
def csrf_token(request):
if request.method=='POST':
print(request.POST)
return HttpResponse('ok')
return render(request,'csrf_token.html')
在CBV中使用：
# CBV中使用
from django.views import View
from django.views.decorators.csrf import csrf_exempt,csrf_protect
from django.utils.decorators import method_decorator
# CBV的csrf装饰器，只能加载类上（指定方法为dispatch）和dispatch方法上（django的bug）
# 给get方法使用csrf_token检测
@method_decorator(csrf_exempt,name='dispatch')
class Foo(View):
def get(self,request):
pass
def post(self,request):
pass
在CBV中使用：
```python
# CBV中使用
from django.views import View
from django.views.decorators.csrf import csrf_exempt,csrf_protect
from django.utils.decorators import method_decorator
# CBV的csrf装饰器，只能加载类上（指定方法为dispatch）和dispatch方法上（django的bug）
# 给get方法使用csrf_token检测
@method_decorator(csrf_exempt,name='dispatch')
class Foo(View):
def get(self,request):
pass
def post(self,request):
pass
2 Auth
1 Auth模块是什么
Auth模块是Django自带的用户认证模块：
我们在开发一个网站的时候，无可避免的需要设计实现网站的用户系统。此时我们需要实现包括用户注册、用户登录、用户认证、注销、修改密码等功能，这还真是个麻烦的事情呢。
Django作为一个完美主义者的终极框架，当然也会想到用户的这些痛点。它内置了强大的用户认证系统–auth，它默认使用 auth_user 表来存储用户数据。
2 auth模块常用方法
from django.contrib import auth
authenticate()
提供了用户认证功能，即验证用户名以及密码是否正确，一般需要username 、password两个关键字参数。
如果认证成功（用户名和密码正确有效），便会返回一个 User 对象。
authenticate()会在该 User 对象上设置一个属性来标识后端已经认证了该用户，且该信息在后续的登录过程中是需要的。
用法：
user = authenticate(username='usernamer',password='password')
login(HttpRequest, user)
该函数接受一个HttpRequest对象，以及一个经过认证的User对象。
该函数实现一个用户登录的功能。它本质上会在后端为该用户生成相关session数据。
用法：
from django.contrib.auth import authenticate, login
def my_view(request):
username = request.POST['username']
password = request.POST['password']
user = authenticate(username=username, password=password)
if user is not None:
login(request, user)
# Redirect to a success page.
...
else:
# Return an 'invalid login' error message.
...
*logout(request) *
该函数接受一个HttpRequest对象，无返回值。
当调用该函数时，当前请求的session信息会全部清除。该用户即使没有登录，使用该函数也不会报错。
用法：
from django.contrib.auth import logout
def logout_view(request):
logout(request)
# Redirect to a success page.
is_authenticated()
用来判断当前请求是否通过了认证。
用法：
def my_view(request):
if not request.user.is_authenticated():
return redirect('%s?next=%s' % (settings.LOGIN_URL, request.path))
login_requierd()
auth 给我们提供的一个装饰器工具，用来快捷的给某个视图添加登录校验。
用法：
from django.contrib.auth.decorators import login_required
@login_required
def my_view(request):
...
若用户没有登录，则会跳转到django默认的 登录URL ‘/accounts/login/ ‘ 并传递当前访问url的绝对路径 (登陆成功后，会重定向到该路径)。
如果需要自定义登录的URL，则需要在settings.py文件中通过LOGIN_URL进行修改。
示例：
LOGIN_URL = '/login/' # 这里配置成你项目登录页面的路由
create_user()
auth 提供的一个创建新用户的方法，需要提供必要参数（username、password）等。
用法：
from django.contrib.auth.models import User
user = User.objects.create_user（username='用户名',password='密码',email='邮箱',...）
create_superuser()
auth 提供的一个创建新的超级用户的方法，需要提供必要参数（username、password）等。
用法：
from django.contrib.auth.models import User
user = User.objects.create_superuser（username='用户名',password='密码',email='邮箱',...）
check_password(password)
auth 提供的一个检查密码是否正确的方法，需要提供当前请求用户的密码。
密码正确返回True，否则返回False。
用法：
ok = user.check_password('密码')
set_password(password)
auth 提供的一个修改密码的方法，接收 要设置的新密码 作为参数。
注意：设置完一定要调用用户对象的save方法！！！
用法：
user.set_password(password='')
user.save()
@login_required
def set_password(request):
user = request.user
err_msg = ''
if request.method == 'POST':
old_password = request.POST.get('old_password', '')
new_password = request.POST.get('new_password', '')
repeat_password = request.POST.get('repeat_password', '')
# 检查旧密码是否正确
if user.check_password(old_password):
if not new_password:
err_msg = '新密码不能为空'
elif new_password != repeat_password:
err_msg = '两次密码不一致'
else:
user.set_password(new_password)
user.save()
return redirect("/login/")
else:
err_msg = '原密码输入错误'
content = {
'err_msg': err_msg,
}
return render(request, 'set_password.html', content)
User对象的属性
User对象属性：username， password
is_staff ： 用户是否拥有网站的管理权限.
is_active ： 是否允许用户登录, 设置为 False，可以在不删除用户的前提下禁止用户登录。
3 扩展默认的auth_user表
这内置的认证系统这么好用，但是auth_user表字段都是固定的那几个，我在项目中没法拿来直接使用啊！
比如，我想要加一个存储用户手机号的字段，怎么办？
聪明的你可能会想到新建另外一张表然后通过一对一和内置的auth_user表关联，这样虽然能满足要求但是有没有更好的实现方式呢？
答案是当然有了。
我们可以通过继承内置的 AbstractUser 类，来定义一个自己的Model类。
这样既能根据项目需求灵活的设计用户表，又能使用Django强大的认证系统了。
from django.contrib.auth.models import AbstractUser
class UserInfo(AbstractUser):
"""
用户信息表
"""
nid = models.AutoField(primary_key=True)
phone = models.CharField(max_length=11, null=True, unique=True)
def __str__(self):
return self.username
注意：
按上面的方式扩展了内置的auth_user表之后，一定要在settings.py中告诉Django，我现在使用我新定义的UserInfo表来做用户认证。写法如下：
# 引用Django自带的User表，继承使用时需要设置
AUTH_USER_MODEL = "app名.UserInfo"
再次注意：
一旦我们指定了新的认证系统所使用的表，我们就需要重新在数据库中创建该表，而不能继续使用原来默认的auth_user表了。
3 ContentType
一 项目背景
路飞学成项目，有课程，学位课（不同的课程字段不一样），价格策略
问题，1 如何设计表结构，来表示这种规则 2 为专题课，添加三个价格策略 3 查询所有价格策略，并且显示对应的课程名称 4 通过课程id，获取课程信息和价格策略
二 版本一
一个课程表，包含学位课和专题课，一个价格策略表，一对多关联
三 版本二
学位课表，专题课表，装逼课表，价格策略表（在价格策略课表中加入多个FK跟课程表做关联）：后期再加其它课程，可维护性差
四 最终版（使用ContentType）
通过Django提供的ContentType表，来构建
models层创建：
from django.db import models
from django.contrib.contenttypes.models import ContentType
from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
class Course(models.Model):
title = models.CharField(max_length=32)
# 不会在数据库中生成字段，只用于数据库操作
# policy = GenericRelation('PricePolicy',object_id_field='object_id',content_type_field='contentType')
class DegreeCourse(models.Model):
title = models.CharField(max_length=32)
class PricePolicy(models.Model):
# 跟ContentType表做外键关联
contentType = models.ForeignKey(to=ContentType)
# 正数
object_id = models.PositiveIntegerField()
# 引入一个字段，不会在数据库中创建，只用来做数据库操作
# content_obj = GenericForeignKey('contentType', 'object_id')
period = models.CharField(max_length=32)
price = models.FloatField()
views层：
from app01 import models
def test(request):
import json
# 方式一插入价格规则
# ret=models.ContentType.objects.filter(model='course').first()
# course=models.Course.objects.filter(pk=1).first()
# print(ret.id)
# models.PricePolicy.objects.create(period='30',price=100,object_id=course.id,contentType_id=ret.id)
# 方式二插入价格规则
# course=models.Course.objects.filter(pk=1).first()
# # content_obj=course 会自动的把课程id放到object_id上，并且去ContentType表中查询课程表的id，放到contentType上
# models.PricePolicy.objects.create(period='60',price=800,content_obj=course)
# 增加学位课，价格规则
# degreecourse = models.DegreeCourse.objects.filter(pk=1).first()
# models.PricePolicy.objects.create(period='60', price=800, content_obj=degreecourse)
# 查询所有价格策略，并且显示对应的课程名称
# ret=models.PricePolicy.objects.all()
# for i in ret:
# print(i.price)
# print(i.period)
# # content_obj 就是代指关联的课程，或者学位课程的那个对象
# print(type(i.content_obj))
# print(i.content_obj.title)
# 通过课程id，获取课程信息和价格策略
course=models.Course.objects.filter(pk=1).first()
print(course.policy.all())
return render(request,'test.html')