目录
- drf
- 1. Web应用模式
- 2. api接口
- 3. RESTful API规范
- 4. 序列化
- 5. Django Rest_Framework
- 6. 环境安装与配置
- 7. 序列化器-Serializer
- 8. drf中的请求与响应
- 9. 视图
- 10. 路由Routers
- 11 认证、权限、频率
- 12 分页器
- 13 使用coreapi自动生成接口文档
- 14 使用第三方模块实现jwt
- 15 基于角色的权限控制RBAC
- 16 django缓存
drf
Django Rest Framework
程序的客户端有很多，例如硬件设备，游戏，APP，软件，其他的外部服务端，都可以充当客户端
1. Web应用模式
在开发Web应用中，有两种应用模式：
1.1 前后端不分离
[客户端看到的内容和所有界面效果都是由服务端提供的]
这种情况下，前端页面中会出现很多涉及到服务端的模板语法。
1.2 前后端分离
把前端的界面效果(html，css，js分离到另一个项目中，python服务端只需要返回数据即可)
前端形成一个独立的网站，服务端构成一个独立的网站
django，一般都用于web网站项目，
而如果可以利用django实现前后端分离，则django就可以作为一个完整的后台服务端，
完成地铁站的运营调度系统，路由的终端系统，pos机的服务端系统，游戏的服务端后台，软件的服务端后台等等。
2. api接口
api接口是前后台信息交互的媒介，前端可以通过访问api接口获取后端返回的json或xml格式的数据
·
为了在团队内部形成共识、防止个人习惯差异引起的混乱，我们需要找到一种大家接受的接口实现规范，
这种规范能够让后端写的接口，及用途一目了然，减少双方之间的合作成本。
目前市面上大部分公司开发人员使用的接口服务架构主要有：restful、rpc，soap。
2.1 rpc架构
rpc: 远程过程调用/远程服务调用.（Remote Procedure Call）
服务端提供统一的一个请求数据的api地址：http://api.renran.cn/
前端的所有请求都往该地址发送，所有请求都为post请求
发送数据的形式为：action=get_all_student&class=301&sex=1
（get_all_student函数，传入参数class和sex）
通过指定FBV名，找到视图并传入参数，得到对应的返回数据
优势：
不需要考虑当前的操作是什么http请求方式，也不需要操作url地址的编写，对接简单
缺点：
接口多了,对应函数名和参数就多了,前端在请求api接口时,就会比较难找.容易出现重复的接口
2.2 restful架构
restful:资源状态转换.
restful把后端所有的数据/文件都看成资源.
那么接口请求数据,本质上就是对资源的操作了.
web项目中操作资源,无非就是增删查改.所以要求在地址栏中声明要操作的资源是什么,然后通过http请求作为动词来说明对资源进行的操作.
POST http://www.renran.cn/api/students/ 添加学生数据
GET http://www.renran.cn/api/students/ 获取所有学生
DELETE http://www.renran.cn/api/students/
PUT http://www.renran.cn/api/students/
PATCH http://www.renran.cn/api/students/
优点：
1. 维护开发简单，可以保证后期的开发不会出现太多重复接口
缺点：
- 有部分接口不会有明确的增删查改这种区分的，所以会出现一些不伦不类的接口。会因为这些语义不明，不伦不类的接口导致后期的维护成本上升。
- 因为restful把对于资源的操作都理解成了增删查改，建议使用http请求，所以restful接口天生局限于web开发。
3. RESTful API规范
REST全称是Representational State Transfer，中文意思是表述（编者注：通常译为表征）性状态转移。 它首次出现在2000年Roy Fielding的博士论文中。
RESTful是一种定义Web API接口的设计风格，尤其适用于前后端分离的应用模式中。
这种风格的理念认为后端开发任务就是提供数据的，对外提供的是数据资源的访问接口，所以在定义接口时，客户端访问的URL路径就表示这种要操作的数据资源。
而对于数据资源分别使用POST、DELETE、GET、UPDATE等请求动作来表达对数据的增删查改。
| 请求方法 | 请求地址 | 后端操作 |
|---|---|---|
| GET | /students | 获取所有学生 |
| POST | /students | 增加学生 |
| GET | /students/ |
获取主键为pk的学生 |
| PUT | /students/ |
修改主键为pk的学生 |
| DELETE | /students/ |
删除主键为pk的学生 |
事实上，我们可以使用任何一个框架都可以实现符合restful规范的API接口。
参考文档：http://www.runoob.com/w3cnote/restful-architecture.html
接口实施过程中，会存在幂等性。所谓幂等性是指代客户端发起多次请求是否对于服务端里面的资源产生不同结果。如果多次请求，服务端结果还是一样，则属于幂等接口，如果多次请求，服务端产生结果是不一样的，则属于非幂等接口。在http请求，get/put/patch/delete都属于幂等性接口，post属于非幂等接口。
为什么要考虑幂等性？主要就是接口操作的安全性问题。
delete /api/students/1
get /api/students/
post /api/students/
4. 序列化
api接口开发，最核心最常见的一个过程就是序列化，所谓序列化就是把数据转换格式，序列化可以分两个阶段：
序列化： 把我们识别的数据转换成指定的格式提供给别人。
例如：我们在django中获取到的数据默认是模型对象，但是模型对象数据无法直接提供给前端或别的平台使用，所以我们需要把数据进行序列化，变成字符串或者json数据，提供给前端或者其他平台。
反序列化：把别人提供的数据转换/还原成我们需要的格式。
例如：前端js提供过来的json数据，对于python而言就是字符串，我们需要进行反序列化换成模型类对象，这样我们才能把数据保存到数据库中。
5. Django Rest_Framework
核心思想: 缩减编写api接口的代码
Django REST framework是一个建立在Django基础之上的Web 应用开发框架,本质上就是一个内置在django里面的子应用，可以快速的开发REST API接口应用。
在REST framework中，提供了序列化器对象Serialzier的定义，可以帮助我们简化序列化与反序列化的过程，不仅如此，还提供丰富的类视图、扩展类、视图集来简化视图的编写工作。REST framework还提供了认证、权限、限流、过滤、分页、接口文档等功能支持。REST framework提供了一个用于测试API接口 的可视化Web界面【可以浏览器直接访问接口，drf的api接口测试页面非常美观】。
中文文档：https://q1mi.github.io/Django-REST-framework-documentation/#django-rest-framework
github: https://github.com/encode/django-rest-framework/tree/master
5.1 drf的特点
- 提供了定义序列化器Serializer的方法，可以快速根据 Django ORM 或者其它库自动序列化/反序列化；
- 提供了丰富的类视图、Mixin扩展类，简化视图的编写；
- 丰富的定制层级：函数视图、类视图、视图集合到自动生成 API，满足各种需要；
- 多种身份认证和权限认证方式的支持；[jwt Json web token]
- 内置了限流系统；
- 直观的 API web 界面；【方便我们调试开发api接口】
- 可扩展性，插件丰富
6. 环境安装与配置
DRF需要以下依赖：
- Python (2.7, 3.2以上)
- Django (1.10, 1.11, 2.0以上)
DRF是以Django扩展应用的方式提供的，所以我们可以直接利用已有的Django环境而无需从新创建。
（若没有Django环境，需要先创建环境安装Django）
6.1 安装DRF
前提是已经安装了django，建议安装在虚拟环境
windows的复制粘贴在linux终端是无效的，在ubuntu终端下粘贴的快捷键是 shift+insert
# mkvirtualenv drfdemo -p python3
# pip install django==2.2.0 -i https://pypi.douban.com/simple
pip install djangorestframework -i https://pypi.douban.com/simple
# 因为我们需要接下来，需要开发api接口肯定要操作数据，所以安装pymysql
pip install pymysql -i https://pypi.douban.com/simple
linux的终端下 粘贴内容 快捷键： shift+insert
这里使用django 2.2.0
6.1.1 创建django项目
cd ~/Desktop
django-admin startproject drfdemo
使用pycharm打开项目，设置虚拟环境的解析器，并修改manage.py中的后缀参数。
6.2 添加rest_framework应用
在settings.py的INSTALLED_APPS中添加'rest_framework'。
INSTALLED_APPS = [
...
'rest_framework',
]
接下来就可以使用DRF提供的功能进行api接口开发了。在项目中如果使用rest_framework框架实现API接口，主要有以下三个步骤：
- 将请求的数据（如JSON格式）转换为模型类对象
- 通过模型类对象进行数据库操作，完成客户端请求的增删查改
- 将模型类对象转换为响应的数据（如JSON格式）
接下来，我们快速体验下四天后我们学习完成drf以后的开发代码。接下来代码不需要理解，看步骤。
6.3 体验drf简写代码的过程
6.3.0 创建子应用
# 项目根目录下创建子应用，用于展示当前例子。
python manage.py startapp students
6.3.1. 创建模型操作类
子应用的models.py文件中创建模型对象。
from django.db import models
# Create your models here.
class Student(models.Model):
# 表字段声明
# 字段名=models.数据类型(字段约束)
name = models.CharField(null=False, max_length=32, verbose_name="姓名")
sex = models.BooleanField(default=True, verbose_name="性别")
age = models.IntegerField(verbose_name="年龄")
class_num = models.CharField(max_length=5, verbose_name="班级编号")
description = models.TextField(max_length=1000, verbose_name="个性签名")
# 表信息
class Meta:
# 设置表名
db_table="tb_students"
verbose_name="学生"
verbose_name_plural=verbose_name
# 模型的操作方法
def __str__(self):
return self.name
为了方便测试，所以我们可以先创建一个数据库。
create database students charset=utf8;
执行数据迁移
把students子应用添加到INSTALL_APPS中
初始化数据库连接
安装pymysql
pip install pymysql
主引用中__init__.py设置使用pymysql作为数据库驱动
import pymysql
pymysql.install_as_MySQLdb()
settings.py配置文件中设置mysql的账号密码
DATABASES = {
# 'default': {
# 'ENGINE': 'django.db.backends.sqlite3',
# 'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
# },
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': "students",
"HOST": "127.0.0.1",
"PORT": 3306,
"USER": "root",
"PASSWORD":"123",
},
}
终端下，执行数据迁移。
python manage.py makemigrations
python manage.py migrate
错误列表
# 执行数据迁移 python manage.py makemigrations 报错如下：
解决方案：
注释掉 backends/mysql/base.py中的35和36行代码。
# 执行数据迁移发生以下错误：
解决方法：
backends/mysql/operations.py146行里面把decode换成encode：
6.3.2. 创建序列化器
在students应用目录中新建serializers.py用于保存该应用的序列化器。
创建一个StudentModelSerializer用于序列化与反序列化。
# 创建序列化器类，回头会在试图中被调用
from rest_framework import serializers
from .models import Student
class StudentModelSerializer(serializers.ModelSerializer):
class Meta:
model = Student
fields = "__all__"
- model 指明该序列化器处理的数据字段从模型类BookInfo参考生成
- fields 指明该序列化器包含模型类中的哪些字段，'all'指明包含所有字段
6.3.3. 编写视图
在students应用的views.py中创建视图StudentViewSet，这是一个视图集合。
from rest_framework.viewsets import ModelViewSet
from .models import Student
from .serializers import StudentModelSerializer
# Create your views here.
class StudentViewSet(ModelViewSet):
queryset = Student.objects.all()
serializer_class = StudentModelSerializer
- queryset 指明该视图集在查询数据时使用的查询集
- serializer_class 指明该视图在进行序列化或反序列化时使用的序列化器
6.3.4. 定义路由
在students应用的urls.py中定义路由信息。
from . import views
from rest_framework.routers import DefaultRouter
# 路由列表
urlpatterns = []
router = DefaultRouter() # 可以处理视图的路由器
router.register('students', views.StudentViewSet) # 向路由器中注册视图集
urlpatterns += router.urls # 将路由器中的所以路由信息追到到django的路由列表中
最后把students子应用中的路由文件加载到总路由文件中.
from django.contrib import admin
from django.urls import path,include
urlpatterns = [
path('admin/', admin.site.urls),
path("student/",include("students.urls")),
]
6.3.5. 运行测试
运行当前程序（与运行Django一样）
python manage.py runserver
在浏览器中输入网址127.0.0.1:8000，可以看到DRF提供的API Web浏览页面：
1）点击链接127.0.0.1:8000/stu/students 可以访问获取所有数据的接口，呈现如下页面：
2）在页面底下表单部分填写学生信息，可以访问添加新学生的接口，保存学生信息：
点击POST后，返回如下页面信息：
3）在浏览器中输入网址127.0.0.1:8000/stu/students/5/，可以访问获取单一学生信息的接口（id为5的学生），呈现如下页面：
4）在页面底部表单中填写学生信息，可以访问修改学生的接口：
点击PUT，返回如下页面信息：
5）点击DELETE按钮，可以访问删除学生的接口：
返回，如下页面：
作业：
1. 在自己电脑上安装搭建项目，并完成上面的快速体验开发接口的代码测试。
2. 使用django提供5个接口给用户使用postman访问操作。
分别是：
添加一个学生信息，
修改一个学生信息，
删除一个学生信息，
查询一个学生信息，
查询所有学生信息。
restful是一种接口开发的规范。
不局限于django或者drf，即便我们不使用drf，django，也能实现符合restful规范的api接口。
同时，drf框架不是restful作者开发的！！！
7. 序列化器-Serializer
作用：
- 序列化,序列化器会把模型对象转换成字典,将来提供给视图经过response以后变成json字符串
- 反序列化,把客户端发送过来的数据,经过视图调用request以后变成python字典,序列化器可以把字典转成模型
- 反序列化,完成数据校验功能和操作数据库
序列化与反序列化
序列化和反序列化就是一个概念，表示转换数据的2个不同的场景。
序列化主要表示我们把当前数据转换成别人需要的数据，如 字典--->json格式数据反序列化表示把别人提供的数据转换成我们需要的，如 json格式数字--->字典
而drf框架中提供的序列化器只是为了让我们把这两部分代码分离出来，减少程序员的代码量。
即便没有drf框架，我们也可以使用python的json模块进行序列化和反序列化，只是较为麻烦。
drf中的data变量是用于保存 提供给客户端的数据，
而validated_data是用于保存 提供给数据库的数据。
data和validated_data的值都是字典（或有序字典）。
7.1 定义序列化器
Django REST framework中的Serializer使用类来定义，须继承自rest_framework.serializers.Serializer。
接下来，为了方便演示序列化器的使用，我们另外创建一个新的子应用sers
python manage.py startapp sers
先注册子应用到项目中，settings.py，代码：
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'rest_framework', # 把drf框架注册到django项目中
'students', # 注册子应用
'sers',
]
因为我们已有了一个数据库模型类students/Student，我们直接在接下来的演示中使用这个模型。
class Student(models.Model):
# 模型字段
name = models.CharField(max_length=100,verbose_name="姓名")
sex = models.BooleanField(default=1,verbose_name="性别")
age = models.IntegerField(verbose_name="年龄")
class_number = models.CharField(max_length=5,verbose_name="班级编号")
description = models.TextField(max_length=1000,verbose_name="个性签名")
class Meta:
db_table="tb_student"
verbose_name = "学生"
verbose_name_plural = verbose_name
我们想为这个模型类提供一个序列化器，可以命名为StudentSerializer，
我们都会把序列化器代码保存到当前子应用下的serializers.py模块中，
可以定义如下：
from rest_framework import serializers
# 声明序列化器，所有的序列化器都要直接或者间接继承于 Serializer
# 其中，ModelSerializer是Serializer的子类，ModelSerializer在Serializer的基础上进行了代码简化
class StudentSerializer(serializers.Serializer):
"""学生信息序列化器"""
# 1. 需要进行数据转换的字段
id = serializers.IntegerField()
name = serializers.CharField()
age = serializers.IntegerField()
sex = serializers.BooleanField()
description = serializers.CharField()
# 2. 如果序列化器集成的是ModelSerializer，则需要声明调用的模型信息
# 3. 验证代码
# 4. 编写添加和更新模型的代码
注意：serializer不是只能为数据库模型类定义，也可以为非数据库模型类的数据定义。serializer是独立于数据库之外的存在。
常用字段类型：
| 字段 | 字段构造方式 |
|---|---|
| BooleanField | BooleanField() |
| NullBooleanField | NullBooleanField() |
| CharField | CharField(max_length=None, min_length=None, allow_blank=False, trim_whitespace=True) |
| EmailField | EmailField(max_length=None, min_length=None, allow_blank=False) |
| RegexField | RegexField(regex, max_length=None, min_length=None, allow_blank=False) |
| SlugField | SlugField(maxlength=50, min_length=None, allow_blank=False) 正则字段，验证的正则表达式固定为 [a-zA-Z0-9-]+ |
| URLField | URLField(max_length=200, min_length=None, allow_blank=False) |
| UUIDField | UUIDField(format='hex_verbose') format: 1) 'hex_verbose' 如"5ce0e9a5-5ffa-654b-cee0-1238041fb31a" 2） 'hex' 如 "5ce0e9a55ffa654bcee01238041fb31a" 3） 'int' - 如: "123456789012312313134124512351145145114" 4） 'urn' 如: "urn:uuid:5ce0e9a5-5ffa-654b-cee0-1238041fb31a" |
| IPAddressField | IPAddressField(protocol='both', unpack_ipv4=False, **options) |
| IntegerField | IntegerField(max_value=None, min_value=None) |
| FloatField | FloatField(max_value=None, min_value=None) |
| DecimalField | DecimalField(max_digits, decimal_places, coerce_to_string=None, max_value=None, min_value=None) max_digits: 数字总位数 decimal_palces: 小数点位数 |
| DateTimeField | DateTimeField(format=api_settings.DATETIME_FORMAT, input_formats=None) |
| DateField | DateField(format=api_settings.DATE_FORMAT, input_formats=None) |
| TimeField | TimeField(format=api_settings.TIME_FORMAT, input_formats=None) |
| DurationField | DurationField() |
| ChoiceField | ChoiceField(choices) choices与Django的用法相同 |
| MultipleChoiceField | MultipleChoiceField(choices) |
| FileField | FileField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL) |
| ImageField | ImageField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL) |
| ListField | ListField(child=, min_length=None, max_length=None) |
| DictField | DictField(child=) |
选项参数：
| 参数名称 | 作用 |
|---|---|
| max_length | 最大长度[适用于字符串，列表，文件] |
| min_lenght | 最小长度[适用于字符串，列表，文件] |
| allow_blank | 是否允许数据的值为空，如果使用这个选项，则前端传递过来的数据必须有这个属性。 |
| trim_whitespace | 是否截断空白字符 |
| max_value | 【数值】最小值 |
| min_value | 【数值】最大值 |
通用参数：
| 参数名称 | 说明 |
|---|---|
| read_only | 表明该字段仅用于序列化输出，默认False |
| write_only | 表明该字段仅用于反序列化输入，默认False |
| required | 表明该字段在反序列化时必须输入，默认True |
| default | 反序列化时使用的默认值 |
| allow_null | 表明该字段是否允许传入None，默认False |
| validators | 该字段使用的验证器 |
| error_messages | 包含错误编号与错误信息的字典 |
| label | 用于HTML展示API页面时，显示的字段名称 |
| help_text | 用于HTML展示API页面时，显示的字段帮助提示信息 |
7.2 创建Serializer对象
定义好Serializer类后，就可以创建Serializer对象了。
Serializer的构造方法为：
Serializer(instance=None, data=empty, **kwarg)
说明：
1）用于序列化时，将模型类对象传入instance参数
2）用于反序列化时，将要被反序列化的数据传入data参数
3）除了instance和data参数外，在构造Serializer对象时，还可通过context参数额外添加数据，如
serializer = StudentSerializer(student, context={'request': request},many=False)
通过context参数附加的数据，可以通过Serializer对象的self.context属性获取。
- 使用序列化器的时候一定要注意，序列化器声明了以后，不会自动执行，需要我们在视图中进行调用才可以。
- 序列化器无法直接接收客户端的请求数据，需要我们在视图中创建序列化器对象时把使用的数据传递过来。
- 序列化器的字段声明类似于我们前面使用过的表单系统（forms组件）。
- 开发restful api时，序列化器会帮我们把模型数据转换成字典（serializer.data）.
- drf提供的视图会帮我们把字典转换成json(Response),或者把客户端发送过来的数据转换字典(Request)
7.3 序列化器的使用
序列化器的使用分两个阶段：
- 在客户端请求时，使用序列化器可以完成对数据的反序列化(可以附带校验功能)。
- 在服务器响应时，使用序列化器可以完成对数据的序列化(可以通过write_only指定不返回的字段)。
7.3.1 序列化功能
7.3.1.1 基本使用
1） 先查询出一个学生对象
视图中获取模型对象，代码：
from students.models import Student
student = Student.objects.get(pk=3)
2） 构造序列化器对象
from .serializers import StudentSerializer
serializer = StudentSerializer(instance=student)
3）获取序列化数据
通过data属性可以获取序列化后的数据
serializer.data
# {'id': 4, 'name': '小张', 'age': 18, 'sex': True, 'description': '猴赛雷'}
完整视图代码：
class Student2APIView(View):
def get(self,request):
"""返回一个学生信息"""
# 读取模型对象
student = Student.objects.get(pk=1)
# 实例化序列化器
serializer = StudentSerializer(instance=student)
print( serializer.data )
"""打印效果：
{'id': 1, 'name': '张三', 'sex': True, 'age': 18}
"""
return JsonResponse(serializer.data)
4）如果要被序列化的是包含多条数据的查询集QuerySet，可以通过添加many=True参数补充说明
`
`
"""
目前我们先学习序列化器，所以我们还是使用原来django内置的视图类和路由。
使用序列化器对数据进行序列化器，一般用于返回数据给客户端。
"""
from django.views import View
from .serializers import StudentSerializer
from students.models import Student
from django.http.response import JsonResponse
class Student1APIView(View):
def get(self,request):
"""返回所有学生给客户端"""
"""
序列化器对象初始化有３个参数:
1. instance，模型对象或者模型对象组成的列表，用于对数据进行序列化，把模型转换成字典
2. data，字典，用于对数据进行反序列化，把数据进行验证和保存到数据库
3. context，字典，用于把路由或者视图的自定义参数传递到序列化器里面使用
context将来作为序列化器对象的子属性
4. many，当序列化器进行序列化时，如果模型有多个，则many必须为True
"""
student_list = Student.objects.all()
serializer = StudentSerializer(instance=student_list, many=True)
print('student_list===>',student_list)
print('serializer===>', serializer)
print('转换的结果===>', serializer.data)
"""打印效果：
[
OrderedDict([('name', '张三'), ('sex', True), ('age', 18), ('class_null', '3011')]),
OrderedDict([('name', '张三'), ('sex', True), ('age', 18), ('class_null', '309')]),
OrderedDict([('name', '张三'), ('sex', True), ('age', 18), ('class_null', '309')]),
....
]
说明：
OrderedDict是python内置的高级数据类型，表示有序字典，因为普通数据类型中的字典是无序的.
有序字典的成员读取方式，和无序字典一样
导入路径：
from collections import OrderedDict
"""
# jsonResponse的第一个参数如果是列表则必须声明safe=False，否则报错如下：
# In order to allow non-dict objects to be serialized set the safe parameter to False.
return JsonResponse(serializer.data, safe=False)
many=True实际上是控制了StudentSerializer实例化时产生的对象的类(在自定义元类中进行了判断)
当many=False时StudentSerializer正常实例化，生成的是StudentSerializer对象
当many=True时StudentSerializer生成的是ListSerializer对象
books_serializer = BookModelSerializer(instance=books,many=True)
book_serializer = BookModelSerializer(instance=book)
print(type(book_ser))
#<class 'rest_framework.serializers.ListSerializer'>
print(type(book_one_ser))
#<class 'app01.ser.BookModelSerializer'>
7.3.2 反序列化功能
7.3.2.1 数据验证
开发中，用户的数据都是不可信任的。
使用序列化器进行反序列化时，需要对数据进行验证后，才能获取验证成功的数据或保存成模型类对象。
在获取反序列化的客户端数据前，必须在视图中调用序列化对象的is_valid()方法，序列化器内部是在is_valid方法内部调用验证选项和验证方法进行验证，验证成功返回True，否则返回False。
验证失败，可以通过序列化器对象的errors属性获取错误信息，返回字典，包含了字段和字段的错误提示。如果是非字段错误，可以通过修改REST framework配置中的NON_FIELD_ERRORS_KEY来控制错误字典中的键名。
验证成功，可以通过序列化器对象的validated_data属性获取数据。
在定义序列化器时，指明每个字段的序列化类型和选项参数，本身就是一种验证行为。
为了方便演示，我们这里采用另一个图书模型来完成反序列化的学习。当然也创建一个新的子应用unsers。
python manage.py startapp unsers
注册子应用，setting.py注册子应用，代码：
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'rest_framework', # 把drf框架注册到django项目中
'students', # 注册子应用
'sers', # 演示序列化
'unsers', # 演示反序列化
]
模型代码：
from django.db import models
# Create your models here.
class BookInfo(models.Model):
"""图书信息"""
title = models.CharField(max_length=20, verbose_name='标题')
pub_date = models.DateField(verbose_name='发布日期')
image = models.ImageField(verbose_name='图书封面')
price = models.DecimalField(max_digits=8, decimal_places=2, verbose_name="价格")
read = models.IntegerField(verbose_name='阅读量')
comment = models.IntegerField(verbose_name='评论量')
class Meta:
# db_table = "表名"
db_table = "tb_book_info"
verbose_name = "图书"
verbose_name_plural = verbose_name
注意：因为当前模型中， 设置到图片上传处理，所以我们需要安装PIL库
pip install Pillow
数据迁移
python manage.py makemigrations
python manage.py migrate
经过上面的准备工作，我们接下来就可以给图书信息增加图书的功能，那么我们需要对来自客户端的数据进行处理，例如，验证和保存到数据库中，此时，我们就可以使用序列化器的反序列化器，接下来，我们就可以参考之前定义学生信息的序列化器那样，定义一个图书的序列化器，当然，不同的是，接下来的序列化器主要用于反序列化器阶段，在unsers子应用，创建serializers.py，代码如下：
from rest_framework import serializers
class BookInfoSerializer(serializers.Serializer):
# 这里声明的字段用于进行反序列化器
# 字段名 = serializers.字段类型(验证选项)
title = serializers.CharField(max_length=20, label="标题", help_text="标题")
# required=True 当前字段必填
pub_date = serializers.DateField(required=True,label="发布日期", help_text="发布日期")
image = serializers.ImageField(max_length=3*1024*1024, label="图书封面", help_text="图书封面")
price = serializers.DecimalField(max_digits=8, decimal_places=2, required=True, label="价格", help_text="价格")
read = serializers.IntegerField(min_value=0, default=0, label="阅读量", help_text="阅读量")
comment = serializers.IntegerField(min_value=0, default=0, label="评论量", help_text="评论量")
# 关于继承数据库选项
# 验证部分的代码
# 数据库
通过构造序列化器对象，并将要反序列化的数据传递给data构造参数，进而进行验证
# Create your views here.
from django.views import View
from django.http.response import HttpResponse
from .serializers import BookInfoSerializer
class BookInfoView(View):
def get(self,request):
"""模拟客户端发送过来的数据"""
data = {
"title":"西厢记",
"pub_date":"1980-10-10",
"price": 19.80,
"read": 100,
"comment": -1,
}
# 对上面的数据进行反序列化器处理
# 1. 初始化，填写data属性
serializer = BookInfoSerializer(data=data)
# 2. 调用序列化器提供的is_valid方法进行验证
# raise_exception=True 表示终断程序，直接抛出错误
ret = serializer.is_valid(raise_exception=True)
print(ret) # is_valid的方法值就是验证结果，只会是True/False
if ret:
# 3.1 验证通过后，可以通过validated_data得到数据
print("验证成功，ret=%s" % ret)
print(serializer.validated_data) # 验证处理后的数据
"""打印结果：
OrderedDict([('title', '西厢记'), ('pub_date', datetime.date(1980, 10, 10)), ('price', Decimal('19.80')), ('read', 100), ('comment', 15)])
"""
else:
print("验证失败，ret=%s" % ret)
# 3.1 验证没通过，可以通过
print( serializer.errors )
"""打印结果：
{'comment': [ErrorDetail(string='Ensure this value is greater than or equal to 0.', code='min_value')]}
"""
return HttpResponse("ok")
is_valid()方法还可以在验证失败时抛出异常serializers.ValidationError，可以通过传递raise_exception=True参数开启，REST framework接收到此异常，会向前端返回HTTP 400 Bad Request响应。
# Return a 400 response if the data was invalid.
serializer.is_valid(raise_exception=True)
如果觉得这些还不够，需要再补充定义验证行为，可以使用以下三种方法：
1) validate_字段名
对<field_name>字段进行验证，如
class BookInfoSerializer(serializers.Serializer):
"""图书数据序列化器"""
...
# 单个字段的验证，方法名必须： validate_<字段名>(self,data) # data 就是当前字段中客户端提交的数据
# validate_price 会被is_valid调用
def validate_price(self, data):
""""""
if data < 0:
raise serializers.ValidationError("对不起，价格不能低于0元")
# 验证通过以后，必须要返回验证的结果数据，否则序列化器的validated_data无法得到当前字段的结果
return data
把前面的例子的price改为-19.80，运行就可以测试了。
2) validate
在序列化器中需要同时对多个字段进行比较验证时，可以定义validate方法来验证，如
class BookInfoSerializer(serializers.Serializer):
"""图书数据序列化器"""
...
# 多个字段的验证，必须方法名叫 "validate"
# data 表示客户端发送过来的所有数据，字典格式
def validate(self, data):
# 判断图书的阅读量不能低于评论量
read = data.get("read")
comment = data.get("comment")
if read < comment:
raise serializers.ValidationError("对不起，阅读量不能低于评论量")
return data
运行之前的例子，把read改为1，comment改为100，访问测试。
3) validators验证器
验证器类似于验证方法，但是验证方法只属于当前序列化器，如果有多个序列化器共用同样的验证功能，则可以把验证代码分离到序列化器外部，作为一个普通函数，由validators加载到序列化器中使用。
在字段中添加validators选项参数，也可以补充验证行为，如
from rest_framework import serializers
# 可以把验证函数进行多次使用，提供不用的字段或者不同的序列化器里面使用
def about_django(data):
if "django" in data:
raise serializers.ValidationError("对不起，图书标题不能出现关键字django")
# 返回验证以后的数据
return data
class BookInfoSerializer(serializers.Serializer):
# 这里声明的字段用于进行反序列化器
# 字段名 = serializers.字段类型(验证选项)
title = serializers.CharField(max_length=20,validators=[about_django], label="标题", help_text="标题")
# required=True 当前字段必填
pub_date = serializers.DateField(required=True, label="发布日期", help_text="发布日期")
# max_length 文件的大小
# allow_null=True 允许传递的image数据为None
image = serializers.ImageField(required=False, allow_null=True, max_length=3*1024*1024, label="图书封面", help_text="图书封面")
price = serializers.DecimalField(max_digits=8, decimal_places=2, required=True, label="价格", help_text="价格")
# min_value 数值大小
# default 设置默认值
read = serializers.IntegerField(min_value=0, default=0, label="阅读量", help_text="阅读量")
comment = serializers.IntegerField(min_value=0, default=0, label="评论量", help_text="评论量")
把前面的例子修改成title=“西厢记django版本”，然后运行测试
视图代码：
# Create your views here.
from django.views import View
from django.http.response import HttpResponse
from .serializers import BookInfoSerializer
class BookInfoView(View):
def get(self,request):
"""模拟客户端发送过来的数据"""
data = {
"title":"西厢记django版本",
"pub_date":"1980-10-10",
"price": 19.80,
"read": 10000,
"comment": 100,
}
# 对上面的数据进行反序列化器处理
# 1. 初始化，填写data属性
serializer = BookInfoSerializer(data=data)
# 2. 调用序列化器提供的is_valid方法进行验证
# raise_exception=True 表示终断程序，直接抛出错误
ret = serializer.is_valid(raise_exception=True)
print(ret) # is_valid的方法值就是验证结果，只会是True/False
if ret:
# 3.1 验证通过后，可以通过validated_data得到数据
print("验证成功，ret=%s" % ret)
print(serializer.validated_data) # 验证处理后的数据
"""打印结果：
OrderedDict([('title', '西厢记'), ('pub_date', datetime.date(1980, 10, 10)), ('price', Decimal('19.80')), ('read', 100), ('comment', 15)])
"""
else:
print("验证失败，ret=%s" % ret)
# 3.1 验证没通过，可以通过
print( serializer.errors )
"""打印结果：
{'comment': [ErrorDetail(string='Ensure this value is greater than or equal to 0.', code='min_value')]}
"""
return HttpResponse("ok")
is_valid实际上内部执行了三种不同的验证方式：
1. 字段内置的验证选项，如max_length=20
2. validators自定义选项，如validators=[about_django]
3. validate自定义验证方法[包含了validate_<字段>, validate]
如：validate_username(),validate()
执行的顺序：
1. 内部选项
2. 局部钩子
3. validators
4. 全局钩子
7.3.2.2 数据保存
通过序列化器来完成数据的更新或者添加，把视图中对于模型中的操作代码移出视图中，放入到序列化器。
前面的验证数据成功后,我们可以使用序列化器来完成数据反序列化的过程.这个过程可以把数据转成模型类对象.
可以通过实现create()和update()两个方法来实现。
·
create和update方法都是对于数据库的操作，不能保证百分百的操作成功，
我们应该在数据库操作中进行容错处理，try...except....，同时返回对应的错误信息等
from rest_framework import serializers
# 可以把验证函数进行多次使用，提供不用的字段或者不同的序列化器里面使用
def about_django(data):
if "django" in data:
raise serializers.ValidationError("对不起，图书标题不能出现关键字django")
# 返回验证以后的数据
return data
class BookInfoSerializer(serializers.Serializer):
# 这里声明的字段用于进行反序列化器
# 字段名 = serializers.字段类型(验证选项)
title = serializers.CharField(max_length=20,validators=[about_django], label="标题", help_text="标题")
# required=True 当前字段必填
pub_date = serializers.DateField(required=True, label="发布日期", help_text="发布日期")
# max_length 文件的大小
# allow_null=True 允许传递的image数据为None
image = serializers.ImageField(required=False, allow_null=True, max_length=3*1024*1024, label="图书封面", help_text="图书封面")
price = serializers.DecimalField(max_digits=8, decimal_places=2, required=True, label="价格", help_text="价格")
# min_value 数值大小
# default 设置默认值
read = serializers.IntegerField(min_value=0, default=0, label="阅读量", help_text="阅读量")
comment = serializers.IntegerField(min_value=0, default=0, label="评论量", help_text="评论量")
# 关于继承数据库选项
# 自定义验证的代码
# 单个字段的验证，方法名必须： validate_<字段名>(self,data) # data 就是当前字段中客户端提交的数据
# validate_price 会被is_valid调用
def validate_price(self, data):
""""""
if data < 0:
raise serializers.ValidationError("对不起，价格不能低于0元")
# 验证通过以后，必须要返回验证的结果数据，否则序列化器的validated_data无法得到当前字段的结果
return data
# 多个字段的验证，必须方法名叫 "validate"
# data 表示客户端发送过来的所有数据，字典格式
def validate(self, data):
# 判断图书的阅读量不能低于评论量
read = data.get("read")
comment = data.get("comment")
if read < comment:
raise serializers.ValidationError("对不起，阅读量不能低于评论量")
return data
# 数据库操作
def create(self, validated_data): # 这里会在调用时，由序列化器补充验证成功以后的数据进来
"""完成添加操作"""
print(validated_data) # 字典
# 导入模型
from .models import BookInfo
# 添加数据
book = BookInfo.objects.create(
title=validated_data.get("title"),
price=validated_data.get("price"),
pub_date=validated_data.get("pub_date"),
read=validated_data.get("read"),
comment=validated_data.get("comment"),
)
return book
# instance就是要修改的模型，系统会自动从对象初始化时的instance提取过来
# validated_data 就是经过验证以后的客户端提交的数据
def update(self, instance, validated_data):
"""更新操作"""
instance.title = validated_data.get('title')
instance.pub_date = validated_data.get('pub_date')
instance.comment = validated_data.get('comment')
instance.price = validated_data.get('price')
instance.read = validated_data.get('read')
instance.save()
return instance
# 编写的create和update方法都是对于数据库的操作，所以不能保证百分百的操作成功，那么此时我们应该在数据库操作中进行容错处理，try...except....，当然自然也需要抛出异常提供给视图，由视图转发给客户端，抛出异常则使用 raise serializers.ValidationError。
视图代码：
# Create your views here.
from django.views import View
from django.http.response import HttpResponse
from .serializers import BookInfoSerializer
class BookInfoView(View):
# ...
def get(self,request):
"""保存数据[更新]"""
# 客户端提交数据过来
id = 2
data = { # 模拟客户端发送过来的数据
"title": "东游记",
"pub_date": "1998-10-01",
"price": 19.98,
"read": 330,
"comment": 100,
}
from .models import BookInfo
book = BookInfo.objects.get(pk=id)
# 使用序列化器验证数据[如果是更新操作，需要传入2个参数，分别是instance和data]
serializer = BookInfoSerializer(instance=book,data=data)
serializer.is_valid()
book = serializer.save() # 此时，我们必须在序列化器中预先声明update方法
"""
serailzier对象调用的save方法是什么？怎么做到自动调用update和create?
1. 这里的save不是数据库ORM模型对象的save，是BaseSerializer定义的。
2. save方法中根据实例化serializer时是否传入instance参数来判断执行update还是create的
当传入instance时，则instance.save调用的就是update方法
没有传入instance，则instance.save调用的就是create方法
3. serializer.save使用前提是必须在序列化器中声明create或者update方法，否则报错！！！
"""
print(book)
"""打印结果：
BookInfo object (2)
"""
return HttpResponse("ok")
在序列化器实现了create和update两个方法后，在反序列化数据的时候，就可以通过save()方法返回一个数据对象实例了
save()会自动执行create或update，通过serializer实例化时是否传入instance参数来分辨执行哪个方法
book = serializer.save()
如果创建序列化器对象的时候，没有传递instance实例，则调用save()方法的时候，create()被调用，相反的，
如果传递了instance实例，则调用save()方法的时候，update()被调用。
serailzier对象调用的save方法是什么？怎么做到自动调用update和create?
1. 这里的save不是数据库ORM模型对象的save，是BaseSerializer定义的。
2. save方法中根据实例化serializer时是否传入instance参数来判断执行update还是create的
当传入instance时，则instance.save调用的就是update方法
没有传入instance，则instance.save调用的就是create方法
3. serializer.save使用前提是必须在序列化器中声明create或者update方法，否则报错！！！
BaseSerializer中定义的save方法源码：
7.3.2.3 附加参数说明
1） 在对序列化器进行save()保存时，可以额外传递数据，这些数据可以在create()和update()中的validated_data参数获取到
# 可以传递任意参数到数据保存方法中
# 例如：request.user 是django中记录当前登录用户的模型对象
serializer.save(owner=request.user)
2）默认序列化器必须传递所有必填字段[required=True]，否则会抛出验证异常。但是我们可以使用partial参数来允许部分字段更新
# Update `BookInfo` with partial data
# partial=True 设置序列化器只是针对客户端提交的字段进行验证，没有提交的字段，即便有验证选项或方法也不进行验证。
serializer = BookInfoSerializer(book, data=data, partial=True)
7.3.3 模型类序列化器
如果我们想要使用序列化器对应的是Django的模型类，DRF为我们提供了ModelSerializer模型类序列化器来帮助我们快速创建一个Serializer类。
ModelSerializer与常规的Serializer相同，但提供了：
- 基于模型类自动生成一系列的序列化器中的字段
- 基于模型类自动为Serializer生成validators，比如unique_together
- 默认的create()和update()的实现
7.3.3.1 定义序列化器
比如我们创建一个BookInfoSerializer
class BookInfoSerializer(serializers.ModelSerializer):
"""图书数据序列化器"""
class Meta:
model = BookInfo
fields = '__all__'
- model 用于指明该序列化器参照的模型类（数据表）
- fields 用于指明该序列化器影响的所有字段
我们可以在python manage.py shell中查看自动生成的BookInfoSerializer的具体实现
>>> from booktest.serializers import BookInfoSerializer
>>> serializer = BookInfoSerializer()
>>> serializer
BookInfoSerializer():
id = IntegerField(label='ID', read_only=True)
btitle = CharField(label='名称', max_length=20)
bpub_date = DateField(allow_null=True, label='发布日期', required=False)
bread = IntegerField(label='阅读量', max_value=2147483647, min_value=-2147483648, required=False)
bcomment = IntegerField(label='评论量', max_value=2147483647, min_value=-2147483648, required=False)
image = ImageField(allow_null=True, label='图片', max_length=100, required=False)
7.3.3.2 指定影响字段
- 使用fields来明确字段，
__all__表示包含所有字段，也可以写明具体哪些字段，如
class BookInfoSerializer(serializers.ModelSerializer):
"""图书数据序列化器"""
class Meta:
model = BookInfo
# fields = ('id', 'btitle', 'bpub_date')
fields = '__all__'
- 使用exclude可以明确排除掉哪些字段
class BookInfoSerializer(serializers.ModelSerializer):
"""图书数据序列化器"""
class Meta:
model = BookInfo
exclude = ('image',)
- 显示指明字段，如：
class HeroInfoSerializer(serializers.ModelSerializer):
hbook = BookInfoSerializer()
class Meta:
model = HeroInfo
fields = ('id', 'hname', 'hgender', 'hcomment', 'hbook')
- 指明只读字段
可以通过read_only_fields指明只读字段，即仅用于序列化输出的字段
class BookInfoSerializer(serializers.ModelSerializer):
"""图书数据序列化器"""
class Meta:
model = BookInfo
fields = ('id', 'title', 'pub_date'， 'read', 'comment')
read_only_fields = ('id', 'read', 'comment')
write_only_fields属性在新版本的drf中已经弃用，但是可以使用添加额外参数的方式（extra_kwargs）给字段添加write_only=True的选项参数实现相同的效果
7.3.3.3 添加额外参数
我们可以使用extra_kwargs参数为ModelSerializer添加或修改原有的选项参数
（原本实例化字段括号内的参数都用该方法添加，如label,error_messages,max_length等）
class BookInfoSerializer(serializers.ModelSerializer):
"""图书数据序列化器"""
class Meta:
model = BookInfo
fields = ('id', 'btitle', 'bpub_date', 'bread', 'bcomment')
extra_kwargs = {
'bread': {'min_value': 0, 'required': True},
'bcomment': {'min_value': 0, 'required': True},
}
# BookInfoSerializer():
# id = IntegerField(label='ID', read_only=True)
# btitle = CharField(label='名称', max_length=20)
# bpub_date = DateField(allow_null=True, label='发布日期', required=False)
# bread = IntegerField(label='阅读量', max_value=2147483647, min_value=0, required=True)
# bcomment = IntegerField(label='评论量', max_value=2147483647, min_value=0, required=True)
7.3.3.4 高阶用法
# models.py
from django.db import models
class Book(models.Model):
title=models.CharField(max_length=32)
price=models.IntegerField()
pub_date=models.DateField()
publish=models.ForeignKey("Publish",on_delete=models.CASCADE,null=True)
authors=models.ManyToManyField("Author")
def __str__(self):
return self.title
class Publish(models.Model):
name=models.CharField(max_length=32)
email=models.EmailField()
def __str__(self):
return self.name
class Author(models.Model):
name=models.CharField(max_length=32)
age=models.IntegerField()
def __str__(self):
return self.name
# ser.py
from rest_framework import serializers
from app01.models import Book
class BookSerializers(serializers.Serializer):
id=serializers.CharField(read_only=True)
title=serializers.CharField(max_length=32)
price=serializers.IntegerField()
pub_date=serializers.DateField()
# publish=serializers.CharField(source="publish.name",read_only=True)
publish=serializers.CharField(source="publish.name",default='xxx')
#authors=serializers.CharField(source="authors.all")
authors=serializers.SerializerMethodField(read_only=True)
def get_authors(self,obj):
temp=[]
for author in obj.authors.all():
temp.append(author.name)
return temp
def create(self, validated_data):
print(validated_data)
publish_id=validated_data.get('publish').get('name')
print(publish_id)
del validated_data['publish']
return Book.objects.create(publish_id=publish_id,**validated_data)
def update(self, instance, validated_data):
print(validated_data.get('aa'))
instance.title = validated_data.get('title', instance.title)
instance.price = validated_data.get('price', instance.price)
instance.pub_date = validated_data.get('pub_date', instance.pub_date)
print(validated_data.get('publish', instance.publish))
instance.publish_id = validated_data.get('publish', instance.publish).get('name')
instance.save()
return instance
# views.py
from django.shortcuts import render,HttpResponse
from app01 import models
from django.http import HttpRequest
from rest_framework.views import APIView
from app01.models import Book
from rest_framework.response import Response
from app01.ser import BookSerializers
class BookViewSet(APIView):
def get(self,request,*args,**kwargs):
book_list=Book.objects.all()
# 序列化方式3:
bs=BookSerializers(book_list,many=True)
#many=True代表有多条数据，如果只有一条数据，many=False
return Response(bs.data)
def post(self,request,*args,**kwargs):
bs=BookSerializers(data=request.data)
bs.is_valid(raise_exception=True)
# print(bs.validated_data)
bs.save()
return Response(bs.data)
class BookDetailView(APIView):
def get(self,request,pk):
book_obj=models.Book.objects.filter(pk=pk).first()
bs=BookSerializers(book_obj,many=False)
return Response(bs.data)
def put(self,request,pk):
book_obj = models.Book.objects.filter(pk=pk).first()
bs=BookSerializers(instance=book_obj,data=request.data,partial=True)
if bs.is_valid():
bs.save(aa="lqz") # update
return Response(bs.data)
else:
return Response(bs.errors)
def delete(self,request,pk):
models.Book.objects.filter(pk=pk).delete()
return Response("")
# urls.py
from django.contrib import admin
from django.urls import path,re_path
from app01 import views
urlpatterns = [
path('admin/', admin.site.urls),
path('books/', views.BookViewSet.as_view()),
re_path('books/(?P<pk>\d+)/', views.BookDetailView.as_view()),
]
7.3.3.4.1 source
在序列化器的XField()中可以使用source参数
source参数可以有三种功能：
①指定数据来源
xxxx=serializers.CharField(source="publish",default='xxx')
xxxx可以自由指定，作为序列化后的字典的key，字典的值可以通过source指定的字段获取
相当于将原本的publish改名为xxxx
②可以跨表
publish=serializers.CharField(source='publish.email')
原本publish为publish对象，而使用source后该字段值变为了publish表中的email字段值
从原本的book表跨到了publish表
③可以执行函数
在Book表模型中创建test方法
pub_date=serializers.CharField(source='test')
使用source后可以得到该方法的返回值，作为数据来源
此处有点类似于DTL模版语法中的{{ test }}
class BookSerializers(serializers.Serializer):
id=serializers.CharField(read_only=True)
title=serializers.CharField(max_length=32)
price=serializers.IntegerField()
pub_date=serializers.DateField()
# publish=serializers.CharField(source="publish.name",read_only=True)
publish=serializers.CharField(source="publish.name",default='xxx')
#authors=serializers.CharField(source="authors.all")
authors=serializers.SerializerMethodField(read_only=True)
7.3.3.4.2 serializers.SerializerMethodField()
可以在序列化器中写SerializerMethodField字段
authors=serializers.SerializerMethodField()
要使用必须在序列化器中写一个配套方法，方法名为 get_字段名 ，返回值就是展示的数据
def get_authors(self,instance):
# book对象
authors=instance.authors.all() # 取出所有作者
l=[]
for author in authors:
l.append({'name':author.name,'age':author.age})
return l
7.3.4 两种序列化器类的选择
什么时候声明的序列化器应该继承序列化器基类Serializer？
什么时候继承模型序列化器类ModelSerializer？
继承序列化器类Serializer
字段声明
验证
添加/保存数据功能
继承模型序列化器类ModelSerializer
字段声明[可选,看需要]
Meta声明
验证
添加/保存数据功能[可选]
看表字段多少，
看使用哪个更方便，代码更少。
8. drf中的请求与响应
REST framework 提供了Parser解析器，在接收到请求后会自动根据Content-Type指明的请求数据类型（如JSON、表单等）将请求数据进行parse解析，解析为类字典[QueryDict]对象保存到Request对象中。
Request对象的数据是自动根据前端发送数据的格式进行解析之后的结果。
无论前端发送的哪种格式的数据，我们都可以以统一的方式读取数据。
·
在继承drf的视图类后视图中的request就不再是原本django的request，
而是drf定义的Request类实例化得到的request
8.1 请求Request
REST framework 传入视图的request对象不再是Django默认的HttpRequest对象，而是REST framework提供的扩展了HttpRequest类的Request类的对象。
REST framework 提供了Parser解析器，在接收到请求后会自动根据Content-Type指明的请求数据类型（如JSON、表单等）将请求数据进行parse解析，解析为类字典[QueryDict]对象/字典对象，保存到Request对象中。
Request对象的数据是自动根据前端发送数据的格式进行解析之后的结果。
无论前端发送的哪种格式的数据，我们都可以以统一的方式读取数据。
8.1.1 Request常用属性
8.1.1.1 request.data
在drf继承了APIView的视图函数的request中可以统一通过request.data获取原本request.POST，request.FILES和request.body里的所有数据（文件，form表单，json格式数据）
request.data 直接返回解析之后的请求体数据（QueryDict或Dict格式）。
- 包含了解析之后的文件和非文件数据
- 包含了对POST、PUT、PATCH请求方式解析后的数据
- 利用了REST framework的parsers解析器，不仅支持表单类型数据，也支持JSON数据
8.1.1.2 request.query_params
request.query_params返回解析之后的查询字符串数据（如url中的?id=1&name=wu）
request.query_params与Django标准的request.GET相同，只是更换了更准确的名称而已。
8.1.2 注意点
Request并不是继承的Django中的HttpRequest类，而是重新定义的新类
他们的关联在于Request实例化时是需要传入HttpRequest对象的，保存到Request对象的_request属性中。
当然，在继承了APIView的视图中，可以直接通过request._request获取到django原生的request对象
如果客户端发送的数据不是rest_framework默认配置中的三种可解析类型（json，form，MultiPart）则request.data无法接收到数据
可从rest-framework的settings文件中查看配置
DEFAULT_PARSER_CLASSES = [
'rest_framework.parsers.JSONParser',
'rest_framework.parsers.FormParser',
'rest_framework.parsers.MultiPartParser'
]
8.2 响应Response
rest_framework.response.Response
8.2.1 Response简介
REST framework提供了一个响应类Response，使用该类构造响应对象时，响应的具体数据内容会被转换（render渲染器）成符合前端需求的类型。
8.2.2 renderer渲染器
REST framework提供了Renderer 渲染器，用来根据请求头中的Accept（接收数据类型声明）来自动转换响应数据到对应格式。如果前端请求中未进行Accept声明，则会采用默认方式处理响应数据，我们可以通过配置来修改默认响应格式。
【简而言之，就是Renderer能通过请求中的Accept参数，查询出客户端想要接收的数据类型，
然后将视图的结果以该格式（客户端能识别的格式）返回】
可以在rest_framework.settings.py查找所有的drf默认配置项
REST_FRAMEWORK = {
'DEFAULT_RENDERER_CLASSES': ( # 默认响应渲染类
'rest_framework.renderers.JSONRenderer', # json渲染器
'rest_framework.renderers.BrowsableAPIRenderer', # 浏览器API渲染器
)
}
8.2.3 构造方式
Response(data, status=None, template_name=None, headers=None, content_type=None)
data数据不要是render处理之后的数据，只需传递python的内建类型数据即可，REST framework会使用renderer渲染器处理data。
data不能是复杂结构的数据，如Django的模型类对象，对于这样的数据我们可以使用Serializer序列化器序列化处理后（转为了Python字典类型）再传递给data参数。
参数说明：
data: 为响应准备的序列化处理后的数据；status: 状态码，默认200；template_name: 模板名称，如果使用HTMLRenderer时需指明；headers: 用于存放响应头信息的字典；content_type: 响应数据的Content-Type，通常此参数无需传递，REST framework会根据前端所需类型数据来设置该参数。
8.2.4 常用属性
8.2.4.1 .data
传给response对象的序列化后，但尚未render处理的数据
8.2.4.2 .status_code
状态码的数字
8.2.4.3 .content
经过render处理后的响应数据
8.2.5 状态码
为了方便设置状态码，REST framewrok在rest_framework.status模块中提供了常用状态码常量。
8.2.5.1 信息告知 - 1xx
HTTP_100_CONTINUE
HTTP_101_SWITCHING_PROTOCOLS
8.2.5.2 成功 - 2xx
HTTP_200_OK
HTTP_201_CREATED
HTTP_202_ACCEPTED
HTTP_203_NON_AUTHORITATIVE_INFORMATION
HTTP_204_NO_CONTENT
HTTP_205_RESET_CONTENT
HTTP_206_PARTIAL_CONTENT
HTTP_207_MULTI_STATUS
8.2.5.3 重定向 - 3xx
HTTP_300_MULTIPLE_CHOICES
HTTP_301_MOVED_PERMANENTLY
HTTP_302_FOUND
HTTP_303_SEE_OTHER
HTTP_304_NOT_MODIFIED
HTTP_305_USE_PROXY
HTTP_306_RESERVED
HTTP_307_TEMPORARY_REDIRECT
8.2.5.4 客户端错误 - 4xx
HTTP_400_BAD_REQUEST
HTTP_401_UNAUTHORIZED
HTTP_402_PAYMENT_REQUIRED
HTTP_403_FORBIDDEN
HTTP_404_NOT_FOUND
HTTP_405_METHOD_NOT_ALLOWED
HTTP_406_NOT_ACCEPTABLE
HTTP_407_PROXY_AUTHENTICATION_REQUIRED
HTTP_408_REQUEST_TIMEOUT
HTTP_409_CONFLICT
HTTP_410_GONE
HTTP_411_LENGTH_REQUIRED
HTTP_412_PRECONDITION_FAILED
HTTP_413_REQUEST_ENTITY_TOO_LARGE
HTTP_414_REQUEST_URI_TOO_LONG
HTTP_415_UNSUPPORTED_MEDIA_TYPE
HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE
HTTP_417_EXPECTATION_FAILED
HTTP_422_UNPROCESSABLE_ENTITY
HTTP_423_LOCKED
HTTP_424_FAILED_DEPENDENCY
HTTP_428_PRECONDITION_REQUIRED
HTTP_429_TOO_MANY_REQUESTS
HTTP_431_REQUEST_HEADER_FIELDS_TOO_LARGE
HTTP_451_UNAVAILABLE_FOR_LEGAL_REASONS
8.2.5.5 服务器错误 - 5xx
HTTP_500_INTERNAL_SERVER_ERROR
HTTP_501_NOT_IMPLEMENTED
HTTP_502_BAD_GATEWAY
HTTP_503_SERVICE_UNAVAILABLE
HTTP_504_GATEWAY_TIMEOUT
HTTP_505_HTTP_VERSION_NOT_SUPPORTED
HTTP_507_INSUFFICIENT_STORAGE
HTTP_511_NETWORK_AUTHENTICATION_REQUIRED
8.2.6 注意点
Response的data可以传入Json格式数据，且不需要添加safe=False参数
响应状态码不推荐只写数字，推荐写HTTP_201_CREATED
from rest_framework import status
return Response(data="ok",status=status.HTTP_201_CREATED,headers={"company":"laonanhai"})
9. 视图
REST framework 除了在数据序列化部分简写代码以外，还在视图层提供了众多的通用视图基类与扩展类，以简化视图的编写。
drf是在django原有的django.views.View类的基础上，封装了多个视图子类提供给我们使用，如APIView，GenericAPIView，CreateAPIView，UpdateAPIView，RetrieveAPIView，ListAPIView，DestroyAPIView等。
·
Django REST framwork 提供的视图的主要作用：
- 控制序列化器的执行（检验、保存、转换数据）
- 控制数据库查询的执行
- 调用drf定义的请求类和响应类[这两个类由drf扩展了一些额外功能]
9.1 两个视图基类
9.1.1 APIView
rest_framework.views.APIView
APIView是REST framework提供的所有视图的基类，继承自Django的View父类。
9.1.1.1 APIView与View的不同点
drf的APIView与djangoView的不同之处在于：
- 传入到视图方法中的是REST framework的
Request对象，而不是Django的HttpRequeset对象； - 视图方法可以返回REST framework的
Response对象，视图会为响应数据设置（render）符合前端要求的格式（accept）； - 任何
APIException异常都会被捕获到，并且处理成合适的响应信息； - 重写了as_view()，在进行dispatch()路由分发前，会对http请求进行身份认证、权限检查、访问频率控制。
支持定义的类属性
- authentication_classes 列表或元组，身份认证类
- permissoin_classes 列表或元组，权限检查类
- throttle_classes 列表或元祖，流量控制类
在APIView中仍然以常规的类视图定义方法来实现get() 、post() 或者其他请求方式的方法。
9.1.1.2 APIView实例
"""
APIView是drf里面提供的所有视图类的父类
APIView提供的功能/属性/方法是最少的,所以使用APIView基本类似我们使用django的View
按照url的不同，分为两类
GET /students/ 获取多个学生信息
POST /students/ 添加一个学生信息
GET /students/<pk>/ 获取一个学生信息
PUT /students/<pk>/ 修改一个学生信息
DELETE /students/<pk>/ 删除一个学生信息
"""
from rest_framework.views import APIView
from students.models import Student
from .serializers import StudentModelSerializer
from rest_framework.response import Response
from rest_framework import status
class StudentAPIView(APIView):
def get(self,request):
# 1. 获取学生信息的数据模型
student_list = Student.objects.all()
# 2. 调用序列化器
serializer = StudentModelSerializer(instance=student_list, many=True)
# 3. 返回数据
return Response(serializer.data)
def post(self,request):
# 1. 调用序列化器对用户提交的数据进行验证
serializer = StudentModelSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
# 2. 调用序列化器进行数据库操作
instance = serializer.save() # save()方法返回的是添加成功以后的模型对象
serializer = StudentModelSerializer(instance=instance)
# 3. 返回新增数据
return Response(serializer.data, status=status.HTTP_201_CREATED)
class Student2APIView(APIView):
def get(self,request,pk):
# 1. 根据pk获取模型对象
student = Student.objects.get(pk=pk)
# 2. 序列化器转换数据
serializer = StudentModelSerializer(instance=student)
# 3. 响应数据
return Response(serializer.data)
def put(self,request,pk):
# 1. 通过pk查询学生信息
student = Student.objects.get(pk=pk)
# 3. 调用序列化器对客户端发送过来的数据进行验证
serializer = StudentModelSerializer(instance=student, data=request.data)
serializer.is_valid(raise_exception=True)
# 4. 保存数据
instance = serializer.save()
# 5. 返回结果
serializer = StudentModelSerializer(instance=instance)
return Response(serializer.data, status=status.HTTP_201_CREATED)
def delete(self, request, pk):
# 1. 通过pk查询学生信息
Student.objects.get(pk=pk).delete()
return Response({"message":"ok"}, status=status.HTTP_204_NO_CONTENT)
9.1.2 GenericAPIView
GenericAPIView通用视图类的主要作用是把视图中的独特的代码抽取出来，让视图方法中的代码更加通用，方便把通用代码进行简写。
rest_framework.generics.GenericAPIView
继承自APIVIew，主要增加了操作序列化器和数据库查询的方法，作用是为下面Mixin扩展类的执行提供方法支持。通常在使用时，可搭配一个或多个Mixin扩展类。
提供的关于序列化器使用的属性与方法
-
属性：
- serializer_class 指明视图使用的序列化器
- queryset 指明使用的数据查询集
-
序列化器相关方法：
-
get_serializer_class(self)
当出现一个视图类中调用多个序列化器时,那么可以通过条件判断在get_serializer_class方法中通过返回不同的序列化器类名就可以让视图方法执行不同的序列化器对象了。
返回序列化器类，默认返回
serializer_class，可以重写，例如：def get_serializer_class(self): if self.request.user.is_staff: return FullAccountSerializer return BasicAccountSerializer -
get_serializer(self, args, *kwargs)
返回序列化器对象，主要用来提供给Mixin扩展类使用，如果我们在视图中想要获取序列化器对象，也可以直接调用此方法。
注意，该方法在提供序列化器对象的时候，会向序列化器对象的context属性补充三个数据：request、format、view，这三个数据对象可以在定义序列化器时使用。
- request 当前视图的请求对象
- view 当前请求的类视图对象
- format 当前请求期望返回的数据格式
-
-
数据库操作相关方法
-
get_queryset(self)
返回视图使用的查询集，主要用来提供给Mixin扩展类使用，是列表视图与详情视图获取数据的基础，默认返回
queryset属性，可以重写，例如：def get_queryset(self): user = self.request.user return user.accounts.all() -
get_object(self)
返回详情视图所需的模型类数据对象，主要用来提供给Mixin扩展类使用。
在试图中可以调用该方法获取详情信息的模型类对象。
若详情访问的模型类对象不存在，会返回404。
该方法会默认使用APIView提供的check_object_permissions方法检查当前对象是否有权限被访问。
举例：
# url(r'^books/(?P<pk>\d+)/$', views.BookDetailView.as_view()), class BookDetailView(GenericAPIView): queryset = BookInfo.objects.all() serializer_class = BookInfoSerializer def get(self, request, pk): book = self.get_object() # get_object()方法根据pk参数查找queryset中的数据对象 serializer = self.get_serializer(book) return Response(serializer.data)
-
其他可以设置的属性
- pagination_class 指明分页控制类
- filter_backends 指明过滤控制后端
为了方便学习上面的GenericAPIView通用视图类，我们新建一个子应用。
python manage.py startapp gen
实例：
views.py
from rest_framework.generics import GenericAPIView
from students.models import Student
from .serializers import StudentModelSerializer, StudentModel2Serializer
from rest_framework.response import Response
class StudentsGenericAPIView(GenericAPIView):
queryset = Student.objects.all() # 本次视图类中要操作的数据[必填]
serializer_class = StudentModelSerializer # 本次视图类中要调用的默认序列化器[选填]
def get(self, request):
"""获取所有学生信息"""
serializer = self.get_serializer(instance=self.get_queryset(), many=True)
return Response(serializer.data)
def post(self,request):
data = request.data
serializer = self.get_serializer(data=data)
serializer.is_valid(raise_exception=True)
instance = serializer.save()
serializer = self.get_serializer(instance=instance)
return Response(serializer.data)
class StudentGenericAPIView(GenericAPIView):
queryset = Student.objects.all()
serializer_class = StudentModelSerializer
def get_serializer_class(self):
"""重写获取序列化器类的方法"""
if self.request.method == "GET":
return StudentModel2Serializer
else:
return StudentModelSerializer
# 在使用GenericAPIView视图获取或操作单个数据时,视图方法中的代表主键的参数最好是pk
def get(self,request,pk):
"""获取一条数据"""
serializer = self.get_serializer(instance=self.get_object())
return Response(serializer.data)
def put(self,request,pk):
data = request.data
serializer = self.get_serializer(instance=self.get_object(),data=data)
serializer.is_valid(raise_exception=True)
serializer.save()
serializer = self.get_serializer(instance=self.get_object())
return Response(serializer.data)
student_serializers.py
from rest_framework import serializers
from students.models import Student
class StudentModelSerializer(serializers.ModelSerializer):
class Meta:
model= Student
fields = "__all__"
class StudentModel2Serializer(serializers.ModelSerializer):
class Meta:
model= Student
fields = ("name","class_null")
9.2 5个视图扩展类
作用：
提供了几种后端视图（对数据资源进行增删改查）处理流程的实现，如果需要编写的视图属于这五种，则视图可以通过继承相应的扩展类来复用代码，减少代码量。
这五个扩展类需要搭配GenericAPIView父类，因为五个扩展类的实现需要调用GenericAPIView提供的序列化器与数据库查询的方法。
1）ListModelMixin
列表视图扩展类，提供list(request, *args, **kwargs)方法快速实现列表视图，返回200状态码。
该Mixin的list方法会对数据进行过滤和分页。
源代码：
class ListModelMixin(object):
"""
List a queryset.
"""
def list(self, request, *args, **kwargs):
# 过滤
queryset = self.filter_queryset(self.get_queryset())
# 分页
page = self.paginate_queryset(queryset)
if page is not None:
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
# 序列化
serializer = self.get_serializer(queryset, many=True)
return Response(serializer.data)
举例：
from rest_framework.mixins import ListModelMixin
class BookListView(ListModelMixin, GenericAPIView):
queryset = BookInfo.objects.all()
serializer_class = BookInfoSerializer
def get(self, request):
return self.list(request)
2）CreateModelMixin
创建视图扩展类，提供create(request, *args, **kwargs)方法快速实现创建资源的视图，成功返回201状态码。
如果序列化器对前端发送的数据验证失败，返回400错误。
源代码：
class CreateModelMixin(object):
"""
Create a model instance.
"""
def create(self, request, *args, **kwargs):
# 获取序列化器
serializer = self.get_serializer(data=request.data)
# 验证
serializer.is_valid(raise_exception=True)
# 保存
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
def perform_create(self, serializer):
serializer.save()
def get_success_headers(self, data):
try:
return {'Location': str(data[api_settings.URL_FIELD_NAME])}
except (TypeError, KeyError):
return {}
3）RetrieveModelMixin
详情视图扩展类，提供retrieve(request, *args, **kwargs)方法，可以快速实现返回一个存在的数据对象。
如果存在，返回200， 否则返回404。
源代码：
class RetrieveModelMixin(object):
"""
Retrieve a model instance.
"""
def retrieve(self, request, *args, **kwargs):
# 获取对象，会检查对象的权限
instance = self.get_object()
# 序列化
serializer = self.get_serializer(instance)
return Response(serializer.data)
举例：
class BookDetailView(RetrieveModelMixin, GenericAPIView):
queryset = BookInfo.objects.all()
serializer_class = BookInfoSerializer
def get(self, request, pk):
return self.retrieve(request)
4）UpdateModelMixin
更新视图扩展类，提供update(request, *args, **kwargs)方法，可以快速实现更新一个存在的数据对象。
同时也提供partial_update(request, *args, **kwargs)方法，可以实现局部更新。
成功返回200，序列化器校验数据失败时，返回400错误。
源代码：
class UpdateModelMixin(object):
"""
Update a model instance.
"""
def update(self, request, *args, **kwargs):
partial = kwargs.pop('partial', False)
instance = self.get_object()
serializer = self.get_serializer(instance, data=request.data, partial=partial)
serializer.is_valid(raise_exception=True)
self.perform_update(serializer)
if getattr(instance, '_prefetched_objects_cache', None):
# If 'prefetch_related' has been applied to a queryset, we need to
# forcibly invalidate the prefetch cache on the instance.
instance._prefetched_objects_cache = {}
return Response(serializer.data)
def perform_update(self, serializer):
serializer.save()
def partial_update(self, request, *args, **kwargs):
kwargs['partial'] = True
return self.update(request, *args, **kwargs)
5）DestroyModelMixin
删除视图扩展类，提供destroy(request, *args, **kwargs)方法，可以快速实现删除一个存在的数据对象。
成功返回204，不存在返回404。
源代码：
class DestroyModelMixin(object):
"""
Destroy a model instance.
"""
def destroy(self, request, *args, **kwargs):
instance = self.get_object()
self.perform_destroy(instance)
return Response(status=status.HTTP_204_NO_CONTENT)
def perform_destroy(self, instance):
instance.delete()
使用GenericAPIView和视图扩展类，实现api接口，代码：
"""GenericAPIView结合视图扩展类实现api接口"""
from rest_framework.mixins import ListModelMixin,CreateModelMixin
class Students2GenericAPIView(GenericAPIView,ListModelMixin,CreateModelMixin):
# 本次视图类中要操作的数据[必填]
queryset = Student.objects.all()
# 本次视图类中要调用的默认序列化器[玄天]
serializer_class = StudentModelSerializer
def get(self, request):
"""获取多个学生信息"""
return self.list(request)
def post(self,request):
"""添加学生信息"""
return self.create(request)
from rest_framework.mixins import RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin
class Student2GenericAPIView(GenericAPIView,RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin):
queryset = Student.objects.all()
serializer_class = StudentModelSerializer
# 在使用GenericAPIView视图获取或操作单个数据时,视图方法中的代表主键的参数最好是pk
def get(self,request,pk):
"""获取一条数据"""
return self.retrieve(request,pk)
def put(self,request,pk):
"""更新一条数据"""
return self.update(request,pk)
def delete(self,request,pk):
"""删除一条数据"""
return self.destroy(request,pk)
9.3 GenericAPIView的视图子类
1）CreateAPIView
提供 post 方法
继承自： GenericAPIView、CreateModelMixin
2）ListAPIView
提供 get 方法
继承自：GenericAPIView、ListModelMixin
3）RetrieveAPIView
提供 get 方法
继承自: GenericAPIView、RetrieveModelMixin
4）DestroyAPIView
提供 delete 方法
继承自：GenericAPIView、DestroyModelMixin
5）UpdateAPIView
提供 put 和 patch 方法
继承自：GenericAPIView、UpdateModelMixin
6）ListCreateAPIView
提供 get、post方法
继承自： GenericAPIView、ListModelMixin、CreateModelMixin
7）RetrieveUpdateAPIView
提供 get、put、patch方法
继承自： GenericAPIView、RetrieveModelMixin、UpdateModelMixin
8）RetrieveDestroyAPIView
提供 get、delete方法
继承自： GenericAPIView、RetrieveModelMixin、DestroyModelMixin
9）RetrieveUpdateDestroyAPIView
提供 get、put、patch、delete方法
继承自：GenericAPIView、RetrieveModelMixin、UpdateModelMixin、DestroyModelMixin
9.4 视图集ViewSet
使用视图集ViewSet，可以将一系列逻辑相关的动作放到一个类中：
- list() 提供一组数据
- retrieve() 提供单个数据
- create() 创建数据
- update() 保存数据
- destroy() 删除数据
ViewSet视图集类不再实现get()、post()等方法，而是实现动作 action 如 list() 、create() 等。
视图集只在使用as_view()方法的时候，才会将action动作与具体请求方式对应上。如：
class BookInfoViewSet(viewsets.ViewSet):
def list(self, request):
books = BookInfo.objects.all()
serializer = BookInfoSerializer(books, many=True)
return Response(serializer.data)
def retrieve(self, request, pk=None):
try:
books = BookInfo.objects.get(id=pk)
except BookInfo.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
serializer = BookInfoSerializer(books)
return Response(serializer.data)
在设置路由时，我们可以如下操作
urlpatterns = [
url(r'^books/$', BookInfoViewSet.as_view({'get':'list'}),
url(r'^books/(?P<pk>\d+)/$', BookInfoViewSet.as_view({'get': 'retrieve'})
]
9.4.1 常用视图集父类
1） ViewSet
继承自APIView与ViewSetMixin，作用也与APIView基本类似，提供了身份认证、权限校验、流量管理等。
ViewSet主要通过继承ViewSetMixin来实现在调用as_view()时传入字典（如{'get':'list'}）的映射处理工作。
在ViewSet中，没有提供任何动作action方法，需要我们自己实现action方法。
2）GenericViewSet
使用ViewSet通常并不方便，因为list、retrieve、create、update、destroy等方法都需要自己编写，而这些方法与前面讲过的Mixin扩展类提供的方法同名，所以我们可以通过继承Mixin扩展类来复用这些方法而无需自己编写。但是Mixin扩展类依赖与GenericAPIView，所以还需要继承GenericAPIView。
GenericViewSet就帮助我们完成了这样的继承工作，继承自GenericAPIView与ViewSetMixin，在实现了调用as_view()时传入字典（如{'get':'list'}）的映射处理工作的同时，还提供了GenericAPIView提供的基础方法，可以直接搭配Mixin扩展类使用。
举例：
from rest_framework.viewsets import GenericViewSet
from rest_framework.mixins import ListModelMixin,CreateModelMixin,RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin
class Student4ViewSet(GenericViewSet,ListModelMixin,CreateModelMixin,RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin):
queryset = Student.objects.all()
serializer_class = StudentModelSerializer
url的定义
urlpatterns = [
path("students7/", views.Student4ViewSet.as_view({"get": "list", "post": "create"})),
re_path("students7/(?P<pk>\d+)/", views.Student4ViewSet.as_view({"get": "retrieve","put":"update","delete":"destroy"})),
]
3）ModelViewSet
继承自GenericViewSet，同时包括了ListModelMixin、RetrieveModelMixin、CreateModelMixin、UpdateModelMixin、DestroyModelMixin。
4）ReadOnlyModelViewSet
继承自GenericViewSet，同时包括了ListModelMixin、RetrieveModelMixin。
9.4.2 视图集中定义附加action动作
在视图集中，除了上述默认的方法动作外，还可以添加自定义动作。
举例：
from rest_framework.viewsets import ModelViewSet,ReadOnlyModelViewSet
class StudentModelViewSet(ModelViewSet):
queryset = Student.objects.all()
serializer_class = StudentModelSerializer
def login(self,request):
"""学生登录功能"""
return Response({"message":"登录成功"})
url的定义
urlpatterns = [
path("students8/", views.StudentModelViewSet.as_view({"get": "list", "post": "create"})),
re_path("students8/(?P<pk>\d+)/",
views.StudentModelViewSet.as_view({"get": "retrieve", "put": "update", "delete": "destroy"})),
path("stu/login/",views.StudentModelViewSet.as_view({"get":"login"}))
]
9.4.3 action属性
在视图集中，我们可以通过action对象属性来获取当前请求视图集时的action动作是哪个。
例如：
from rest_framework.viewsets import ModelViewSet
from students.models import Student
from .serializers import StudentModelSerializer
from rest_framework.response import Response
class StudentModelViewSet(ModelViewSet):
queryset = Student.objects.all()
serializer_class = StudentModelSerializer
def get_new_5(self,request):
"""获取最近添加的5个学生信息"""
# 操作数据库
print(self.action) # 获取本次请求的视图方法名
通过路由访问到当前方法中.可以看到本次的action就是请求的方法名
9.5 总结
#两个基类
APIView
GenericAPIView：有关数据库操作，queryset 和serializer_class
#5个视图扩展类(rest_framework.mixins)
CreateModelMixin：create方法创建一条
DestroyModelMixin：destory方法删除一条
ListModelMixin：list方法获取所有
RetrieveModelMixin：retrieve获取一条
UpdateModelMixin：update修改一条
#9个子类视图(rest_framework.generics)
CreateAPIView:继承CreateModelMixin,GenericAPIView，有post方法，新增数据
DestroyAPIView：继承DestroyModelMixin,GenericAPIView，有delete方法，删除数据
ListAPIView：继承ListModelMixin,GenericAPIView,有get方法获取所有
UpdateAPIView：继承UpdateModelMixin,GenericAPIView，有put和patch方法，修改数据
RetrieveAPIView：继承RetrieveModelMixin,GenericAPIView，有get方法，获取一条
ListCreateAPIView：继承ListModelMixin,CreateModelMixin,GenericAPIView，有get获取所有，post方法新增
RetrieveDestroyAPIView：继承RetrieveModelMixin,DestroyModelMixin,GenericAPIView，有get方法获取一条，delete方法删除
RetrieveUpdateAPIView：继承RetrieveModelMixin,UpdateModelMixin,GenericAPIView，有get获取一条，put，patch修改
RetrieveUpdateDestroyAPIView：继承RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin,GenericAPIView，有get获取一条，put，patch修改，delete删除
#视图集
ViewSetMixin：重写了as_view
ViewSet： 继承ViewSetMixin和APIView
GenericViewSet：继承ViewSetMixin, generics.GenericAPIView
ModelViewSet：继承mixins.CreateModelMixin,mixins.RetrieveModelMixin,mixins.UpdateModelMixin,mixins.DestroyModelMixin,mixins.ListModelMixin,GenericViewSet
ReadOnlyModelViewSet：继承mixins.RetrieveModelMixin,mixins.ListModelMixin,GenericViewSet
10. 路由Routers
对于视图集ViewSet，我们除了可以自己手动指明请求方式与动作action之间的对应关系外，还可以使用Routers来帮助我们快速实现路由信息。
REST framework提供了两个router
- SimpleRouter
- DefaultRouter
10.1 使用方法
1） 创建router对象，并注册视图集，例如
from rest_framework import routers
router = routers.DefaultRouter()
router.register(r'router_stu', StudentModelViewSet, base_name='student')
register(prefix, viewset, base_name)
- prefix 该视图集的路由前缀(不用加斜杠/)
- viewset 视图集
- base_name 路由别名的前缀（用于反向解析）
如上述代码会形成的路由如下：
^books/$ name: book-list
^books/{pk}/$ name: book-detail
2）添加路由数据
可以有两种方式：
urlpatterns = [
...
]
urlpatterns += router.urls
或
urlpatterns = [
...
url(r'^', include(router.urls))
]
使用路由类自动给视图集生成路由地址
from rest_framework.viewsets import ModelViewSet,ReadOnlyModelViewSet
class StudentModelViewSet(ModelViewSet):
queryset = Student.objects.all()
serializer_class = StudentModelSerializer
def login(self,request):
"""学生登录功能"""
print(self.action)
return Response({"message":"登录成功"})
路由代码：
from django.urls import path, re_path
from . import views
urlpatterns = [
...
]
"""使用drf提供路由类router给视图集生成路由列表"""
# 实例化路由类
# drf提供一共提供了两个路由类给我们使用,他们用法一致,功能几乎一样
from rest_framework.routers import DefaultRouter
router = DefaultRouter()
# 注册视图集
# router.register("路由前缀",视图集类)
router.register("router_stu",views.StudentModelViewSet)
# 把生成的路由列表追加到urlpatterns
print( router.urls )
urlpatterns += router.urls
上面的代码就成功地自动生成了路由地址[增/删/改/查一条/查多条的功能]，
但是不会自动生成在视图集中自定义的方法的路由。
所以我们如果也要给自定义方法生成路由，则需要进行action动作的声明。
10.2 视图集中附加action的声明
在视图集中，如果想要让Router自动帮助我们为自定义的动作生成路由信息，需要使用rest_framework.decorators.action装饰器。
以action装饰器装饰的方法名会作为action动作名，与list、retrieve等同。
action装饰器可以接收两个参数：
-
methods: 声明触发该action的请求方式，该参数需传入列表
-
detail: 声明该action的路径是否与单一资源对应，该参数传入布尔值
xxx/<pk>/action方法名/- True 表示路径格式是
xxx/<pk>/action方法名/ - False 表示路径格式是
xxx/action方法名/
- True 表示路径格式是
举例：
from rest_framework.viewsets import ModelViewSet
from rest_framework.decorators import action
class StudentModelViewSet(ModelViewSet):
queryset = Student.objects.all()
serializer_class = StudentModelSerializer
# methods 设置当前方法允许哪些http请求访问当前视图方法
# detail 设置当前视图方法是否是操作一个数据
# detail为True，表示路径名格式应该为 router_stu/{pk}/login/
@action(methods=['get'], detail=True)
def login(self, request,pk):
"""登录"""
...
# detail为False 表示路径名格式应该为 router_stu/get_new_5/
@action(methods=['put'], detail=False)
def get_new_5(self, request):
"""获取最新添加的5个学生信息"""
...
由路由器自动为此视图集自定义action方法形成的路由会是如下内容：
^router_stu/get_new_5/$ name: router_stu-get_new_5
^router_stu/{pk}/login/$ name: router_stu-login
10.3 路由router形成URL的方式
1） SimpleRouter
2）DefaultRouter
DefaultRouter与SimpleRouter的区别是，DefaultRouter会多附带一个默认的API根视图，返回一个包含所有列表视图的超链接响应数据。
11 认证、权限、频率
11.1 认证Authentication
11.1.1 认证器类的创建
drf中的认证需要创建一个认证器类，继承BaseAuthentication，并在类内写一个名为authenticate的对象方法，传入参数request，内部写认证逻辑，通过认证则返回元组（用户，校验信息），不通过认证则抛出异常：AuthenticationFailed
from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed
from app01 import models
class App01Authentication(BaseAuthentication):
def authenticate(self, request):
token = request.META.get('HTTP_TOKEN')
if token:
user_token = models.UserToken.objects.filter(token=token)
if user_token:
return user_token.first().user, token
else:
back_dic = {'msg': '请重新登录', 'url': '127.0.0.1:8080/login/', 'status': 450}
raise AuthenticationFailed(back_dic)
else:
back_dic = {'msg': '请先登录', 'url': '127.0.0.1:8080/login/', 'status': 440}
raise AuthenticationFailed(back_dic)
11.1.2 认证器的使用
认证器可以在全局使用，或局部使用，或局部禁用
全局使用是在django项目的settings.py文件中配置
REST_FRAMEWORK = {'DEFAULT_AUTHENTICATION_CLASSES': [
'app01.app01authentications.App01Authentication'
]}
局部使用是在app的views.py的视图类中配置
class BookViewSet(ModelViewSet):
queryset = models.Book.objects.all()
serializer_class = ser.BookSerializer
authentication_classes = [app01authentications.App01Authentication]
def list(self, request, *args, **kwargs):
serializer = self.serializer_class(instance=self.queryset, many=True)
return Response(serializer.data[:3])
@action(['GET','POST'],detail=False)
def lalala(self,request):
serializer = self.serializer_class(instance=self.queryset, many=True)
return Response(serializer.data[:5])
局部禁用是在app的views.py的视图类中配置
class Login(APIView):
authentication_classes = []
def post(self, request):
username = request.data.get('username')
password = request.data.get('password')
user = models.User.objects.filter(username=username, password=password)
if user:
user = user.first()
token = uuid.uuid4()
models.UserToken.objects.update_or_create(defaults={'token': token}, user=user)
return Response({'token': token, 'status': '200', 'msg': '登陆成功'})
else:
return Response({'status': '400', 'msg': '用户名或密码错误'})
11.2 权限permission
11.2.1 权限源码分析
APIView中的as_view方法--->
View的as_view方法--->
APIView的dispatch方法--->
dispatch中的initial方法--->
self.perform_authentication(request)
self.check_permissions(request)
self.check_throttles(request)
def check_permissions(self, request):
# for i in [权限类1，权限类2....]
for permission in self.get_permissions():
# 注意：这里的has_permission本质上是有三个实参，因为对象使用对象方法会自动将自己传入
if not permission.has_permission(request, self):
self.permission_denied(
request, message=getattr(permission, 'message', None)
)
通过源码可以看出，每个权限类都要有has_permission方法，需要传入的参数为权限对象self，request，视图类对象，返回值为True或者False，True为通过，False为未通过
11.2.2 权限的使用
11.2.2.1 定义权限类
# 定义一个权限类，继承BasePermission，重写has_permission方法，如果权限通过则返回True，不通过返回False
from rest_framework.permissions import BasePermission
class UserPermission(BasePermission):
def has_permission(self, request, view):
# 不是超级用户，不能访问
# 由于权限校验在认证校验之后，request内有user对象了，即当前登录用户
user=request.user
# user_type=models.IntegerField(choices=((1,'超级用户'),(2,'普通用户'),(3,'游客')))
# 如果字段用了choice，通过get_字段名_display()就能取出choice后面的中文
print(user.get_user_type_display())
if user.user_type==1:
return True
else:
return False
11.2.2.2 配置
# 全局使用：在项目的settings.py文件中配置
REST_FRAMEWORK={
"DEFAULT_AUTHENTICATION_CLASSES":["app01.app_auth.MyAuthentication",],
'DEFAULT_PERMISSION_CLASSES': [
'app01.app_auth.UserPermission',
],
}
# 局部使用：在视图类中配置permission_classes
class TestView(APIView):
permission_classes = [app_auth.UserPermission]
# 局部禁用：在视图类中配置permission_classes，覆盖全局的权限类
class TestView(APIView):
permission_classes = []
11.2.3 内置权限（了解）
# 演示一下django内置的权限的使用：
# IsAdminUser，校验当前用户是否是对网站后台有权限的人
# 1 创建超级管理员
# python3 manage.py createsuperuser
# 2 写一个视图类用于测试
from rest_framework.permissions import IsAdminUser
from rest_framework.authentication import SessionAuthentication
class TestView3(APIView):
authentication_classes=[SessionAuthentication,]
permission_classes = [IsAdminUser]
def get(self,request,*args,**kwargs):
return Response('这是22222222测试数据，管理员可以看')
# 3 超级用户登录到admin后台，再访问test3，能获取到数据，通过了权限校验
# 4 登录普通用户则没有权限查看test3接口（该权限类判断的是is_staff字段，不是superuser字段）
11.3 频率Throttle
11.3.1 频率源码分析
APIView中的as_view方法--->
View的as_view方法--->
APIView的dispatch方法--->
dispatch中的initial方法--->
self.perform_authentication(request)
self.check_permissions(request)
self.check_throttles(request)
def check_throttles(self, request):
throttle_durations = []
# for i in [频率类1，频率类2....]
for throttle in self.get_throttles():
# 注意：这里的allow_request本质上是有三个实参，因为对象使用对象方法会自动将自己传入
if not throttle.allow_request(request, self):
throttle_durations.append(throttle.wait())
if throttle_durations:
durations = [
duration for duration in throttle_durations
if duration is not None
]
duration = max(durations, default=None)
self.throttled(request, duration)
通过源码可以看出，每个频率类都要有allow_request方法，需要传入的参数为频率对象self，request，视图类对象，返回值为True或者False，True为通过，False为未通过
11.3.2 内置的频率限制(限制未登录用户)
# 限制未登录用户1分钟访问5次
# 全局使用：在项目的settings.py中配置
REST_FRAMEWORK = {
'DEFAULT_THROTTLE_CLASSES': (
'rest_framework.throttling.AnonRateThrottle',
),
'DEFAULT_THROTTLE_RATES': {
'anon': '3/m',
}
}
# views.py
from rest_framework.permissions import IsAdminUser
from rest_framework.authentication import SessionAuthentication,BasicAuthentication
class TestView4(APIView):
authentication_classes=[]
permission_classes = []
def get(self,request,*args,**kwargs):
return Response('我是未登录用户')
# 局部使用：在视图类中配置throttle_classes，并在全局配置DEFAULT_THROTTLE_RATES（设置限制的频率）
REST_FRAMEWORK = {
'DEFAULT_THROTTLE_RATES': {
'anon': '3/m',
}
}
from rest_framework.permissions import IsAdminUser
from rest_framework.authentication import SessionAuthentication,BasicAuthentication
from rest_framework.throttling import AnonRateThrottle
class TestView5(APIView):
authentication_classes=[]
permission_classes = []
throttle_classes = [AnonRateThrottle]
def get(self,request,*args,**kwargs):
return Response('我是未登录用户，TestView5')
11.3.3 内置的频率限制(限制登录用户)
该方法只能用于基于auth模块user表的登录！！！！
# 需求：未登录用户1分钟访问5次，登录用户一分钟访问10次
# 全局使用：在项目下的settings.py中配置
REST_FRAMEWORK = {
'DEFAULT_THROTTLE_CLASSES': (
'rest_framework.throttling.AnonRateThrottle',
'rest_framework.throttling.UserRateThrottle'
),
'DEFAULT_THROTTLE_RATES': {
'user': '10/m',
'anon': '5/m',
}}
# 局部使用：在视图类中配置throttle_classes，并在全局配置DEFAULT_THROTTLE_RATES（设置限制的频率）
REST_FRAMEWORK = {
'DEFAULT_THROTTLE_RATES': {
'user': '10/m',
'anon': '5/m',
}
}
from rest_framework.permissions import IsAdminUser
from rest_framework.authentication import SessionAuthentication,BasicAuthentication
from rest_framework.throttling import AnonRateThrottle,UserRateThrottle
class TestView5(APIView):
authentication_classes=[]
permission_classes = []
throttle_classes = [AnonRateThrottle,UserRateThrottle]
def get(self,request,*args,**kwargs):
return Response('hello，TestView5')
11.3.4 基于SimpleRateThrottle的ip的频率限制
# 写一个类，继承SimpleRateThrottle，只需要重写get_cache_key
# get_cache_key的返回值即为频率校验的依据
# 例如返回固定值，内部得到一个字典{'xxx':1},所有请求都会导致这个数字的增加
# 例如返回请求的ip，内部得到的字典为{'127.0.0.1':1,'192.168.1.1':2},各个ip的频率限制互相独立
from rest_framework.throttling import ScopedRateThrottle,SimpleRateThrottle
class MyThrottle(SimpleRateThrottle):
scope='ipthrottle'
def get_cache_key(self, request, view):
print(request.META.get('REMOTE_ADDR'))
return request.META.get('REMOTE_ADDR') # 返回发送请求的ip
# 同样可以局部使用/全局使用
REST_FRAMEWORK={
'DEFAULT_THROTTLE_CLASSES': (
'utils.throttling.MyThrottle',
),
'DEFAULT_THROTTLE_RATES': {
'ipthrottle': '3/m' # key要跟类中的scop对应
},
}
# python3 manage.py runserver 0.0.0.0:8000
11.3.5 自定制频率类
# 自定制的频率类，需要继承BaseThrottle并重写两个方法：
1.allow_request
用于写频率的判断逻辑，允许则返回True，不允许则返回False
def allow_request(self, request, view):
2.wait
限次后调用该函数，用于显示还需等待的时间，返回等待的时间int（秒）
def wait(self):
# 实例
from rest_framework.throttling import BaseThrottle
import time
class IPThrottle(BaseThrottle):
#定义成类属性,所有对象用的都是这个
VISIT_DIC = {}
def __init__(self):
self.history_list=[]
def allow_request(self, request, view):
'''
#（1）取出访问者ip
#（2）判断当前ip是否在访问字典里，如果不在就添加进去，并且返回True,表示第一次访问，如果在字典中，就继续执行
#（3）循环判断当前ip的列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间，
#（4）判断，当列表小于3，说明一分钟以内访问不足三次，把当前时间插入到列表第一个位置，返回True，顺利通过
#（5）当大于等于3，说明一分钟内访问超过三次，返回False验证失败
'''
ip=request.META.get('REMOTE_ADDR')
ctime=time.time()
if ip not in self.VISIT_DIC:
self.VISIT_DIC[ip]=[ctime,]
return True
self.history_list=self.VISIT_DIC[ip] # 将当前访问者对应的列表取出
# list:[500,400,300] ctime:555
# list:[554,553,552] ctime:555
while True:
if ctime-self.history_list[-1]>60:
self.history_list.pop() # 把最后一个移除
else:
break
# list:[500] ctime:555
# list:[554,553,552] ctime:555
if len(self.history_list)<3:
self.history_list.insert(0,ctime)
# # list:[555,500]
return True
else:
# list:[554,553,552] ctime:555
return False
def wait(self):
# 当前时间减去列表中最后一个时间
ctime=time.time()
return 60-(ctime-self.history_list[-1])
#全局使用，局部使用
11.3.6 SimpleRateThrottle源码分析
class SimpleRateThrottle(BaseThrottle):
def __init__(self):
if not getattr(self, 'rate', None):
self.rate = self.get_rate()
self.num_requests, self.duration = self.parse_rate(self.rate)
def get_rate(self):
"""
'DEFAULT_THROTTLE_RATES': {
'ipthrottle': '3/m' # 类中的scope与这里的key对应
},
该方法用于获取配置中的频率（str格式），这里是3/m
"""
if not getattr(self, 'scope', None):
msg = ("You must set either `.scope` or `.rate` for '%s' throttle" %
self.__class__.__name__)
raise ImproperlyConfigured(msg)
try:
return self.THROTTLE_RATES[self.scope] # scope：'user' => '3/min'
except KeyError:
msg = "No default throttle rate set for '%s' scope" % self.scope
raise ImproperlyConfigured(msg)
def parse_rate(self, rate):
"""
该方法返回 频率限制的次数 和 频率限制的时间
"""
if rate is None:
return (None, None)
#3 mmmmm
num, period = rate.split('/') # rate：'3/min'
num_requests = int(num)
duration = {'s': 1, 'm': 60, 'h': 3600, 'd': 86400}[period[0]]
return (num_requests, duration)
def allow_request(self, request, view):
if self.rate is None:
return True
# key就是频率的依据，可以是ip，user_id等
self.key = self.get_cache_key(request, view)
if self.key is None:
return True
# 初次访问时缓存为空，self.history为[]，这个变量是用于存放时间的列表
self.history = self.cache.get(self.key, [])
# 获取一下当前时间，存放到 self.now
self.now = self.timer()
# 当前访问与第一次访问时间间隔如果大于60s，第一次记录清除，不再算作一次计数
while self.history and self.now - self.history[-1] >= self.duration:
self.history.pop()
# history的长度与限制次数进行比较
# history的长度第一次访问为0，第二次访问为1，第三次访问为2，第四次访问为3失败
if len(self.history) >= self.num_requests:
# 直接返回False，代表频率超过限制了
return self.throttle_failure()
# history的长度未达到限制次数3，代表可以访问
return self.throttle_success()
# 将当前时间插入到history列表的开头，并将history列表作为数据存到缓存中，key是频率依据，过期时间60s
11.4 过滤
自带的过滤类使用不方便，使用第三方模块进行过滤
# 1 安装：pip3 install django-filter
# 2 注册，在项目settings.py的INSTALLED_APPS中注册'django_filters'
# 3 全局配置，或者局部配置
全局：
REST_FRAMEWORK = {
'DEFAULT_FILTER_BACKENDS': ('django_filters.rest_framework.DjangoFilterBackend',)
}
-------------------------------------------------------------------------------
局部：
class TestView5(APIView):
filter_backends=[DjangoFilterBackend]
def get(self,request,*args,**kwargs):
return Response('hello，TestView5')
# 4 视图类中设置可过滤的字段
class BookView(ListAPIView):
queryset = Book.objects.all()
serializer_class = BookSerializer
filter_fields = ('name',) # 配置可以按照什么字段过滤数据
# 5 进阶用法
# 自定义过滤类，继承FilterSet
from django_filters.filterset import FilterSet
from django_filters import filters
class CourseFilter(FilterSet):
max_price = filters.NumberFilter(field_name='price', lookup_expr='lt')
min_price = filters.NumberFilter(field_name='price', lookup_expr='gt')
# 可以直接新增查询参数max_price，在url中即可使用
class Meta:
model = models.Course
fields = {'id': ['gt', 'lt'], 'name': ['icontains'], 'price': ['gt', 'lt'],'course_category':[]}
# fields可以写列表或字典
# 列表为['id','name','price'],不支持扩展功能
# 字典的value内可以增加扩展功能，如gt,icontains等
11.5 排序
一般直接使用rest_framework自带的排序类
# 全局使用：在项目下的settings.py中配置并在视图类中配置ordering_fields（设置可排序的字段）
REST_FRAMEWORK = {
'DEFAULT_FILTER_BACKENDS': ['rest_framework.filters.OrderingFilter',],
}
class Book2View(ListAPIView):
queryset = Book.objects.all()
serializer_class = BookSerializer
ordering_fields = ('id', 'price')
# 局部使用：在视图类中配置filter_backends和ordering_fields（设置可排序的字段）
from rest_framework.generics import ListAPIView
from rest_framework.filters import OrderingFilter
from app01.models import Book
from app01.ser import BookSerializer
class Book2View(ListAPIView):
queryset = Book.objects.all()
serializer_class = BookSerializer
filter_backends = [OrderingFilter]
ordering_fields = ('id', 'price')
# 使用：
http://127.0.0.1:8000/books2/?ordering=-price
http://127.0.0.1:8000/books2/?ordering=price
http://127.0.0.1:8000/books2/?ordering=-id
# 负号代表降序，无负号代表升序
# 如果与过滤一起使用，需要都写入filter_backends，不能只写OrderingFilter
from rest_framework.filters import OrderingFilter
from django_filters.rest_framework import DjangoFilterBackend
class BookView(ModelViewSet):
queryset = models.Book.objects.all()
serializer_class = ser.BookSerializer
filter_backends = [DjangoFilterBackend, OrderingFilter]
filter_fields = ['id', 'name', 'price']
ordering_fields = ['id', 'price']
11.6 过滤排序总结
排序：
按id正序倒叙排序，按price正序倒叙排列
使用：
http://127.0.0.1:8000/course/free/?ordering=-id
配置类：
filter_backends=[OrderingFilter]
配置字段：
ordering_fields=['id','price']
内置过滤：
使用：
http://127.0.0.1:8000/course/free/?search=39
按照price过滤（表自有的字段直接过滤）
配置类：
filter_backends=[SearchFilter]
配置字段：
search_fields=['price']
扩展：django-filter
支持自由字段的过滤还支持外键字段的过滤
安装：
pip3 install django-filter
使用：
注册，在项目settings.py的INSTALLED_APPS中注册'django_filters'
http://127.0.0.1:8000/course/free/?course_category=1
# 过滤分类为1 （python的所有课程）
配置类:
filter_backends=[DjangoFilterBackend]
配置字段：
filter_fields=['course_category']
11.7 异常处理
# DRF中有自带的异常处理'EXCEPTION_HANDLER': 'rest_framework.views.exception_handler',
# 但是在开发中，需要统一接口返回数据的格式，因此需要自定义异常方法，替换掉自带的全局异常处理
# 自定义异常处理的方法：写一个方法，执行自带的异常处理：exception_handler
from rest_framework.views import exception_handler
from rest_framework.response import Response
from rest_framework import status
def my_exception_handler(exc, context):
response=exception_handler(exc, context)
# response有两种结果
# 第一种结果：None：drf没有处理异常
# 第二种结果：response对象，django处理了，但是处理结果不符合格式的要求
print(type(exc))
if not response:
# 根据实际情况可以进行更细化的处理
if isinstance(exc, ZeroDivisionError):
return Response(data={'status': 777, 'msg': "除以0的错误" + str(exc)}, status=status.HTTP_400_BAD_REQUEST)
return Response(data={'status':999,'msg':str(exc)},status=status.HTTP_400_BAD_REQUEST)
else:
return Response(data={'status':888,'msg':response.data.get('detail')},status=status.HTTP_400_BAD_REQUEST)
# 全局配置：在项目的settings.py中配置
REST_FRAMEWORK = {
'EXCEPTION_HANDLER': 'app01.app_auth.my_exception_handler',
}
11.8 封装Response对象
# 可以自己封装Response对象，更方便地返回规范的数据格式
# 封装
class APIResponse(Response):
def __init__(self,code=100,msg='成功',data=None,status=None,headers=None,**kwargs):
if data:
dic = {'code': code, 'msg': msg,'data':data}
else:
dic = {'code': code, 'msg': msg}
dic.update(kwargs)
super().__init__(data=dic, status=status,headers=headers)
# 使用
return APIResponse(data={"name":'wu'},token='dsafsdfa',aa='dsafdsafasfdee')
return APIResponse(data={"name":'wu'})
return APIResponse(code='101',msg='错误',data={"name":'wu'},token='dsafsdfa',aa='dsafdsafasfdee',header={})
12 分页器
# drf内置了三种分页器类
# 1. PageNumberPagination -----普通分页器
# 特点：普通
# 2. LimitOffsetPagination -----偏移分页器
# 特点：可以设置偏移量（起始位置）
# 3. CursorPagination -----游标分页器
# 特点：只有上一页、下一页，效率最高
#views.py
from rest_framework.pagination import PageNumberPagination,LimitOffsetPagination,CursorPagination
from rest_framework.generics import ListAPIView
class MyPageNumberPagination(PageNumberPagination):
#http://127.0.0.1:8000/api/books2/?aaa=1&size=6
page_size=3 #每页条数
page_query_param='aaa' #查询第几页的key
page_size_query_param='size' # 每一页显示的条数
max_page_size=5 # 每页最大显示条数
class MyLimitOffsetPagination(LimitOffsetPagination):
default_limit = 3 # 每页条数
limit_query_param = 'limit' # 往后拿几条
offset_query_param = 'offset' # 标杆
max_limit = 5 # 每页最大几条
class MyCursorPagination(CursorPagination):
cursor_query_param = 'cursor' # 每一页查询的key
page_size = 2 #每页显示的条数
ordering = '-id' #排序字段
# ListAPIView等视图类的使用分页器的方法
class BookView(ListAPIView):
# queryset = models.Book.objects.all().filter(is_delete=False)
queryset = models.Book.objects.all()
serializer_class = BookModelSerializer
#配置分页器类型
pagination_class = MyCursorPagination
# APIView/GenericAPIView使用分页器的方法
from utils.throttling import MyThrottle
class BookView(APIView):
def get(self,request,*args,**kwargs):
book_list=models.Book.objects.all()
# 实例化得到一个分页器对象
page_cursor=MyPageNumberPagination()
book_list=page_cursor.paginate_queryset(book_list,request,view=self)
next_url =page_cursor.get_next_link()
pr_url=page_cursor.get_previous_link()
# print(next_url)
# print(pr_url)
book_ser=BookModelSerializer(book_list,many=True)
return Response(data=book_ser.data)
#settings.py
REST_FRAMEWORK={
'PAGE_SIZE': 2,
}
13 使用coreapi自动生成接口文档
# 1 安装：pip3 install coreapi
# 2 在路由中配置
from rest_framework.documentation import include_docs_urls
urlpatterns = [
...
path('docs/', include_docs_urls(title='站点页面标题'))
]
#3 视图类：自动接口文档能生成的是继承自APIView及其子类的视图。
-1) 单一方法的视图，可直接使用类视图的文档字符串，如
class BookListView(generics.ListAPIView):
"""
返回所有图书信息.
"""
-2) 包含多个方法的视图，在类视图的文档字符串中，按方法分开定义，如
class BookListCreateView(generics.ListCreateAPIView):
"""
get:
返回所有图书信息.
post:
新建图书.
"""
-3) 对于视图集ViewSet，仍在类视图的文档字符串中按方法分开定义，注意要使用action名称区分，
而不是请求方式名，如
class BookInfoViewSet(mixins.ListModelMixin, mixins.RetrieveModelMixin, GenericViewSet):
"""
list:
返回图书列表数据
retrieve:
返回图书详情数据
latest:
返回最新的图书数据
read:
修改图书的阅读量
"""
14 使用第三方模块实现jwt
pip install djangorestframework-jwt
安装
14.1 jwt简介
jwt=Json Web token
# JWT原理
1）jwt分三段式：头.体.签名 （head.payload.sgin）
2）头和体是可逆加密，让服务器可以反解出user对象；签名是不可逆加密，保证整个token的安全性的
3）头体签名三部分，都是采用json格式的字符串，进行加密，可逆加密一般采用base64算法，不可逆加密一般采用hash(md5)算法
4）头中的内容是基本信息：公司信息、项目组信息、token采用的加密方式信息
{"company": "公司信息",...}
5）体中的内容是关键信息：用户主键、用户名、签发时客户端信息(设备号、地址)、过期时间
{"user_id": 1,...}
6）签名中的内容时安全信息：头的加密结果 + 体的加密结果 + 服务器不对外公开的安全码 进行md5加密
{"head": "头的加密字符串","payload": "体的加密字符串","secret_key": "安全码"}
14.2 jwt的校验流程
1）将token按 . 拆分为三段字符串，第一段是 头进行BASE64加密的字符串 一般不需要做任何处理
2）第二段 体是执行了BASE64加密的字符串，要反解该字符串，得到用户主键，通过主键就可以从User表中查到登录的用户对象，过期时间和设备信息都是安全信息，确保token没过期，且时同一设备来的
3）再用 第一段 + 第二段 + 服务器安全码 不可逆md5加密，与第三段 签名字符串 进行碰撞校验，通过后才能代表第二段校验得到的user对象就是合法的登录用户
14.3 jwt认证开发思路
drf项目的jwt认证开发流程（重点）
1）用账号密码访问登录接口，登录接口逻辑中调用 签发token 算法，得到token，返回给客户端，客户端自己存到cookies中
2）校验token的算法应该写在认证类中(在认证类中调用)，全局配置给认证组件，所有视图类请求，都会进行认证校验，所以请求带了token，就会反解出user对象，在视图类中用request.user就能访问登录的用户
注：登录接口需要做 认证+权限 两个局部禁用
14.4 jwt应用实例
14.4.1 token的获取
14.4.1.1 通过jwt模块签发token
# urls.py
from rest_framework_jwt.views import ObtainJSONWebToken,VerifyJSONWebToken,RefreshJSONWebToken,obtain_jwt_token
urlpatterns = [path('login/', obtain_jwt_token),]
向login地址发送username和password即可获得一个只含有token串的响应
{
"token":"eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VyX2lkIjoxLCJ1c2VybmFtZSI6Ind1IiwiZXhwIjoxNTk0Nzk2NDQ2LCJlbWFpbCI6IiJ9.VraoRouDkX2jdwWOoa_VmIEhyibbnKooEBAxNdEeiAA"
}
# 如果想定制rest_framework_jwt的视图返回的响应需要重写jwt_response_payload_handler方法，并修改配置
def my_jwt_response_payload_handler(token, user=None, request=None):
# 返回值即为Response.data
return {
'token': token,
'msg':'登录成功',
'status':100,
'username':user.username
}
# 在settings.py中配置
JWT_AUTH={
'JWT_RESPONSE_PAYLOAD_HANDLER':'rest_framework_jwt.utils.jwt_response_payload_handler',
}
tips:
obtain_jwt_token = ObtainJSONWebToken.as_view()
refresh会在每次登录后返回一个新的token
14.4.1.2 手动签发token（多方式登录）
# 需求：使用用户名，手机号，邮箱，都可以登录
# 前端需要传的数据格式
{
"username":"lqz/1332323223/33@qq.com",
"password":"lqz12345"
}
# 序列化类
import re
from rest_framework import serializers
from rest_framework.exceptions import ValidationError
from rest_framework_jwt.utils import jwt_encode_handler,jwt_payload_handler
from api import models
class LoginModelSerializer(serializers.ModelSerializer):
username=serializers.CharField()
# 数据库中该字段是unique,字段自带属性的校验在全局钩子校验之前
# 如果不覆盖就无法进入全局钩子校验，所以需要覆盖username字段，或使用其他名称
class Meta:
model=models.User
fields=['username','password']
def validate(self, attrs):
print(self.context)
username=attrs.get('username') # 用户名有三种可能
password=attrs.get('password')
# 通过正则匹配判断username值的字段类型，查询不同的字段
if re.match('^1[3-9][0-9]{9}$',username): # 手机号
user=models.User.objects.filter(mobile=username).first()
elif re.match('^.+@.+$',username): # 邮箱
user=models.User.objects.filter(email=username).first()
else:
user=models.User.objects.filter(username=username).first()
if user:
# 校验密码,由于是密文，要使用check_password
if user.check_password(password):
# 签发token
payload = jwt_payload_handler(user) # 将user传入，得到payload
token = jwt_encode_handler(payload) # 将payload传入，得到token
self.context['token']=token
# 将数据存入context，后续可从序列化器对象中取出
self.context['username']=user.username
return attrs
else:
raise ValidationError('密码错误')
else:
raise ValidationError('用户不存在')
# 视图
from rest_framework.views import APIView
from rest_framework.viewsets import ViewSetMixin, ViewSet
from app02 import ser
class Login2View(ViewSet):
def login(self, request, *args, **kwargs):
login_ser = ser.LoginModelSerializer(data=request.data,context={})
login_ser.is_valid(raise_exception=True)
token=login_ser.context.get('token') # 取出序列化器中存入的token
return Response({
'status':100,'msg':'登录成功','token':token,
'username':login_ser.context.get('username')
})
14.4.2 jwt模块中的token认证类
控制用户登录后才能访问，和不登录就能访问
# 1 用户登录后才能访问的视图
from rest_framework.permissions import IsAuthenticated
class OrderAPIView(APIView): # 该视图只有登录用户才能查看
authentication_classes = [JSONWebTokenAuthentication,]
# 需要搭配权限控制
permission_classes = [IsAuthenticated,]
def get(self,request,*args,**kwargs):
return Response('这是订单信息')
# 2 不登录就能访问的视图
class UserInfoAPIView(APIView): # 该视图匿名用户和登录用户都可以查看（非法用户不行）
authentication_classes = [JSONWebTokenAuthentication,] # 无权限控制
def get(self,request,*args,**kwargs):
return Response('UserInfoAPIView')
14.4.3 自定义token认证类
14.4.3.1 基于BaseAuthentication的认证类
import jwt
from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed
# from rest_framework_jwt.authentication import jwt_decode_handler
from rest_framework_jwt.utils import jwt_decode_handler # 两种导入相同
from api import models
class MyJwtAuthentication(BaseAuthentication):
def authenticate(self, request):
jwt_value=request.META.get('HTTP_AUTHORIZATION')
if jwt_value:
try:
# jwt提供了通过token，取出payload的方法，并且内置有校验功能
payload=jwt_decode_handler(jwt_value)
except jwt.ExpiredSignature:
raise AuthenticationFailed('签名过期')
except jwt.InvalidTokenError:
raise AuthenticationFailed('用户非法')
except Exception as e:
# 所有其他异常都会被捕获
raise AuthenticationFailed(str(e))
# payload是一个保存了用户信息的字典
print(payload)
# authenticate需要返回两个值：user和auth
# 获取user对象
# 第一种方法，根据payload的信息从数据库查询出user对象
user=models.User.objects.get(pk=payload.get('user_id'))
# 第二种不查库，通过payload的信息实例化，产生一个不完整的user对象
user=models.User(id=payload.get('user_id'),username=payload.get('username'))
return user,jwt_value
# 没有值，直接抛异常
raise AuthenticationFailed('您没有携带认证信息')
14.4.3.2 基于BaseJSONWebTokenAuthentication的token校验类
import jwt
from rest_framework_jwt.authentication import BaseJSONWebTokenAuthentication
from rest_framework.exceptions import AuthenticationFailed
# from rest_framework_jwt.authentication import jwt_decode_handler
from rest_framework_jwt.utils import jwt_decode_handler # 两种导入相同
from api import models
class MyJwtAuthentication(BaseJSONWebTokenAuthentication):
def authenticate(self, request):
jwt_value=request.META.get('HTTP_AUTHORIZATION')
if jwt_value:
try:
#jwt提供了通过三段token，取出payload的方法，并且有校验功能
payload=jwt_decode_handler(jwt_value)
except jwt.ExpiredSignature:
raise AuthenticationFailed('签名过期')
except jwt.InvalidTokenError:
raise AuthenticationFailed('用户非法')
except Exception as e:
# 所有异常都会走到这
raise AuthenticationFailed(str(e))
user=self.authenticate_credentials(payload)
return user,jwt_value
# 没有值，直接抛异常
raise AuthenticationFailed('您没有携带认证信息')
14.5 jwt的配置参数
# jwt的配置
import datetime
JWT_AUTH={
'JWT_RESPONSE_PAYLOAD_HANDLER':'app02.utils.my_jwt_response_payload_handler',
'JWT_EXPIRATION_DELTA': datetime.timedelta(days=7), # 过期时间，手动配置
}
15 基于角色的权限控制RBAC
RBAC :是基于角色的访问控制（Role-Based Access Control ）,一般用于公司内部系统OA等
# django的auth就是内置了一套基于RBAC的权限系统
# django中
# 后台的权限控制（公司内部系统，crm，erp，协同平台）
user表
permssion表
group表
user_groups表是user和group的中间表
group_permissions表是group和permssion中间表
user_user_permissions表是user和permission中间表
# 前台（主站），需要用三大认证
# 演示：
16 django缓存
缓存可以存在文件，内存，数据库等各个位置
16.1 django缓存的配置
16.1.1 开发调试(此模式为开发调试使用,实际上不执行任何操作)
在项目的settings.py中配置
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.dummy.DummyCache', # 缓存后台使用的引擎
'TIMEOUT': 300, # 缓存超时时间（默认300秒，None表示永不过期，0表示立即过期）
'OPTIONS':{
'MAX_ENTRIES': 300, # 最大缓存记录的数量（默认300）
'CULL_FREQUENCY': 3, # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
},
}
}
16.1.2 内存缓存(将缓存内容保存至内存区域中)
在项目的settings.py中配置
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache', # 指定缓存使用的引擎
'LOCATION': 'unique-snowflake', # 写在内存中的变量的唯一值
'TIMEOUT':300, # 缓存超时时间(默认为300秒,None表示永不过期)
'OPTIONS':{
'MAX_ENTRIES': 300, # 最大缓存记录的数量（默认300）
'CULL_FREQUENCY': 3, # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
}
}
}
16.1.3 文件缓存(把缓存数据存储在文件中)
在项目的settings.py中配置
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache', #指定缓存使用的引擎
'LOCATION': '/var/tmp/django_cache', #指定缓存的路径
'TIMEOUT':300, #缓存超时时间(默认为300秒,None表示永不过期)
'OPTIONS':{
'MAX_ENTRIES': 300, # 最大缓存记录的数量（默认300）
'CULL_FREQUENCY': 3, # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
}
}
}
16.1.4 数据库缓存(把缓存数据存储在数据库中)
在项目的settings.py中配置
注意,创建缓存的数据库表使用的语句:
python manage.py createcachetable
16.1.5 Memcache缓存(使用python-memcached模块连接memcache)
Memcached是Django原生支持的缓存系统.要使用Memcached,需要下载Memcached的支持库python-memcached或pylibmc.
在项目的settings.py中配置
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache', # 指定缓存使用的引擎
'LOCATION': '192.168.10.100:11211', # 指定Memcache缓存服务器的IP地址和端口
'OPTIONS':{
'MAX_ENTRIES': 300, # 最大缓存记录的数量（默认300）
'CULL_FREQUENCY': 3, # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
}
}
}
LOCATION也可以配置成如下:
'LOCATION': 'unix:/tmp/memcached.sock', # 指定局域网内的主机名加socket套接字为Memcache缓存服务器
'LOCATION': [ # 指定一台或多台其他主机ip地址加端口为Memcache缓存服务器
'192.168.10.100:11211',
'192.168.10.101:11211',
'192.168.10.102:11211',
]
16.1.6 Memcache缓存(使用pylibmc模块连接memcache)
settings.py文件配置
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache', # 指定缓存使用的引擎
'LOCATION':'192.168.10.100:11211', # 指定本机的11211端口为Memcache缓存服务器
'OPTIONS':{
'MAX_ENTRIES': 300, # 最大缓存记录的数量（默认300）
'CULL_FREQUENCY': 3, # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
},
}
}
LOCATION也可以配置成如下:
'LOCATION': '/tmp/memcached.sock', # 指定某个路径为缓存目录
'LOCATION': [ # 分布式缓存,在多台服务器上运行Memcached进程,程序会把多台服务器当作一个单独的缓存,而不会在每台服务器上复制缓存值
'192.168.10.100:11211',
'192.168.10.101:11211',
'192.168.10.102:11211',
]
Memcached是基于内存的缓存,数据存储在内存中.所以如果服务器死机的话,数据就会丢失,所以Memcached一般与其他缓存配合使用
这里以存在文件为例
16.2 前后端不分离使用缓存
16.2.1 全站缓存
在项目的settings.py中配置
MIDDLEWARE = [
'django.middleware.cache.UpdateCacheMiddleware',
...
...
...
...
'django.middleware.cache.FetchFromCacheMiddleware',
]
CACHE_MIDDLEWARE_SECONDS=10 # 全站缓存时间
注意这两个中间件的顺序。
UpdateCacheMiddleware是更新缓存，必须是最后一个执行process_response的中间件，response是从下往上返回的
FetchFromCacheMiddleware是获取缓存，必须是最后一个执行process_request的中间件，必须通过上面所有校验才能获取缓存数据，request是从上往下传递的
16.2.2 单页面缓存
在视图函数上加装饰器
from django.views.decorators.cache import cache_page
@cache_page(5) # 缓存5秒
def test_cache(request):
import time
ctime=time.time()
return render(request,'index.html',context={'ctime':ctime})
16.2.3 页面局部缓存
{% load cache %}
{% cache 5 'name' %} # 5表示5秒，name是缓存中的唯一key值，从缓存中取出时使用
{{ ctime }}
{% endcache %}
16.3 前后端不分离使用缓存
from django.core.cache import cache
cache.set('key',value可以是任意数据类型)
cache.get('key')
posted on
