drf快速上手之序列化器
4. 序列化
api接口开发，最核心最常见的一个代码编写过程就是序列化，所谓序列化就是把**数据转换格式**。常见的序列化方式：
json，pickle，base64，struct，….
序列化可以分两个阶段：
**序列化**： 把我们识别的数据转换成指定的格式提供给别人。 例如：我们在django中获取到的数据默认是模型对象，但是模型对象数据无法直接提供给前端或别的平台使用，所以我们需要把数据进行序列化，变成字符串或者json数据，提供给别人。 **反序列化**：把别人提供的数据转换/还原成我们需要的格式。 例如：前端js提供过来的json数据，对于python而言json就是字符串，我们需要进行反序列化换成字典，然后接着字典再进行转换成模型对象，这样我们才能把数据保存到数据库中。
5. Django Rest_Framework
核心思想: 大量缩减编写api接口的代码 Django REST framework是一个建立在Django基础之上的Web 应用开发框架，可以快速的开发REST API接口应用。在REST framework中，提供了序列化器Serialzier的定义，可以帮助我们简化序列化与反序列化的过程，
不仅如此，还提供丰富的类视图、扩展类、视图集来简化视图的编写工作。REST framework还提供了认证、权限、限流、过滤、分页、接口文档等功能支持。REST framework还提供了一个调试API接口 的Web可视化界面来方便查看测试接口。  中文文档：https://q1mi.github.io/Django-REST-framework-documentation/#django-rest-framework github: https://github.com/encode/django-rest-framework/tree/master
### 特点
- 提供了定义序列化器Serializer的方法，可以快速根据 Django ORM 或者其它库自动序列化/反序列化； - 提供了丰富的类视图、Mixin扩展类，简化视图的编写； - 丰富的定制层级：函数视图、类视图、视图集合到自动生成 API，满足各种需要； - 多种身份认证和权限认证方式的支持；[jwt] - 内置了限流系统； - 直观的 API web 界面；【方便我们调试开发api接口】 - 可扩展性，插件丰富
6. 环境安装与配置
DRF需要以下依赖： - Python (3.5 以上) - Django (2.2 以上) **DRF是以Django子应用的方式提供的，所以我们可以直接利用已有的Django环境而无需从新创建。（若没有Django环境，需要先创建环境安装Django）**
## 6.1 安装DRF
anaconda (内置180多个python模块，)/ miniconda（内置仅仅是30多个常用模块） 前提是已经安装了django，建议安装在虚拟环境 ```python # conda create -n drfdemo python=3.8 # pip install django==3.2.4 -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 ```
### 6.1.1 创建django项目
cd ~/Desktop
django-admin startproject drfdemo
使用pycharm打开项目，设置虚拟环境的解析器，并修改manage.py中的后缀参数。
## 6.2 添加rest_framework应用
在**settings.py**的**INSTALLED_APPS**中添加'rest_framework'。
```python INSTALLED_APPS = [ ... 'rest_framework', ] ```
接下来就可以使用DRF提供的功能进行api接口开发了。在项目中如果使用rest_framework框架实现API接口，主要有以下三个步骤：
- 将请求的数据（如JSON格式）转换为模型类对象
- 操作数据库
- 将模型类对象转换为响应的数据（如JSON格式）
## 6.3 体验drf完全简写代码的过程
5个接口:
添加1条数据
获取所有数据
获取1条数据
更新1条数据
删除1条数据
# 终端下执行：
django-admin startapp stuapi # 提供原生的django代码实现的API接口
django-admin startapp students # 提供drf代码实现的API接口
## 6.3.1. 创建模型操作类
from django.db import models # Create your models here. class Student(models.Model): """学生信息""" name = models.CharField(max_length=255, verbose_name="姓名") sex = models.BooleanField(default=1, verbose_name="性别") age = models.IntegerField(verbose_name="年龄") classmate = 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
为了方便测试，所以我们可以先创建一个数据库。
mysql -uroot -p123
create database students charset=utf8mb4;
## 6.3.1.1 执行数据迁移
把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
我们先使用原生的Django代码提供基本API接口
views.py
import json from django.views import View from django.http.response import JsonResponse from .models import Student # Create your views here. """ POST /students/ 添加一个学生信息 GET /students/ 获取所有学生信息 GET /students/<pk>/ 获取一个学生信息 PUT /students/<pk>/ 更新一个学生信息 DELETE /students/<pk>/ 删除一个学生信息 一个路由对应一个视图类，所以我们可以把5个API分成2个类来完成 """ class StudentView(View): """学生视图""" def post(self, request): """添加一个学生信息""" # 1. 接收客户单提交的数据，验证客户端的数据 data = json.loads(request.body) name = data.get("name") sex = data.get("sex") age = data.get("age") classmate = data.get("classmate") description = data.get("description") # 2. 操作数据库，保存数据 instance = Student.objects.create( name=name, sex=sex, age=age, classmate=classmate, description=description, ) # 3. 返回结果 return JsonResponse(data={ "id": instance.pk, "name": instance.name, "sex": instance.sex, "age": instance.age, "classmate": instance.classmate, "description": instance.description, }, status=201) def get(self, request): """获取多个学生信息""" # 1. 读取数据库 students_list = list(Student.objects.values()) # 2. 返回数据 return JsonResponse(data=students_list, status=200, safe=False) class StudentInfoView(View): def get(self, request, pk): """获取一条数据""" try: instance = Student.objects.get(pk=pk) return JsonResponse(data={ "id": instance.pk, "name": instance.name, "sex": instance.sex, "age": instance.age, "classmate": instance.classmate, "description": instance.description, }, status=200) except Student.DoesNotExist: return JsonResponse(data=None, status=404) # 没有内容 def put(self, request, pk): """更新一个学生信息""" # 1. 接收客户单提交的数据，验证客户端的数据 data = json.loads(request.body) name = data.get("name") # alt+j 选中多个一样的 sex = data.get("sex") age = data.get("age") classmate = data.get("classmate") description = data.get("description") # 2. 操作数据库，保存数据 try: instance = Student.objects.get(pk=pk) instance.name = name instance.sex = sex instance.age = age instance.classmate = classmate instance.description = description instance.save() except Student.DoesNotExist: return JsonResponse(data={}, status=404) # 没有内容 # 3. 返回结果 return JsonResponse(data={ "id": instance.pk, "name": instance.name, "sex": instance.sex, "age": instance.age, "classmate": instance.classmate, "description": instance.description, }, status=201) def delete(self, request, pk): """删除一个学生信息""" try: Student.objects.filter(pk=pk).delete() except: pass return JsonResponse(data={}, status=204)
子应用下创建urls.py，代码：
from django.urls import path,re_path from . import views urlpatterns = [ path("students/", views.StudentView.as_view()), re_path("^students/(?P<pk>\d+)/$", views.StudentInfoView.as_view()), ]
在settings.py，配置子应用
INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'rest_framework', 'stuapi', 'students', ] #暂时关闭csrf 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', ]
总路由，urls.py，代码：
from django.contrib import admin from django.urls import path, include urlpatterns = [ path('admin/', admin.site.urls), path('api/', include("stuapi.urls")), ]
### 6.3.2. 创建序列化器 - 最终版
例如，在django项目中创建学生子应用。
python manage.py startapp students
在students应用目录中新建serializers.py用于保存该应用的序列化器。
创建一个StudentModelSerializer用于序列化与反序列化。
from rest_framework import serializers
from stu.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("stu/",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按钮，可以访问**删除学生的接口**： 返回，如下页面：
# 7. 序列化器-Serializer
作用： 1. 序列化,序列化器会把模型对象转换成字典,经过response以后变成json字符串 2. 反序列化,把客户端发送过来的数据,经过request以后变成字典,序列化器可以把字典转成模型 3. 反序列化,完成数据校验功能
## 7.1 定义序列化器
Django REST framework中的Serializer使用类来定义，须继承自rest_framework.serializers.Serializer。
接下来，为了方便演示序列化器的使用，我们先创建一个新的子应用sers
python manage.py startapp sers
我们已有了一个数据库模型类students/Student
models.py
from django.db import models # Create your models here. class Student(models.Model): # 模型字段 name = models.CharField(max_length=100,verbose_name="姓名",help_text="提示文本:账号不能为空！") sex = models.BooleanField(default=True,verbose_name="性别") age = models.IntegerField(verbose_name="年龄") class_null = models.CharField(max_length=5,verbose_name="班级编号") description = models.TextField(verbose_name="个性签名") class Meta: db_table="tb_student" verbose_name = "学生" verbose_name_plural = verbose_name
我们想为这个模型类提供一个序列化器，可以定义如下：
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(max*length=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 = AccountSerializer(account, context={'request': request}) **通过context参数附加的数据，可以通过Serializer对象的context属性获取。**
1. 使用序列化器的时候一定要注意，序列化器声明了以后，不会自动执行，需要我们在视图中进行调用才可以。
2. 序列化器无法直接接收数据，需要我们在视图中创建序列化器对象时把使用的数据传递过来。
3. 序列化器的字段声明类似于我们前面使用过的表单系统。
4. 开发restful api时，序列化器会帮我们把模型数据转换成字典.
5. drf提供的视图会帮我们把字典转换成json,或者把客户端发送过来的数据转换字典.
## 7.3 序列化器的使用
序列化器的使用分两个阶段： 1. 在客户端请求时，使用序列化器可以完成对数据的反序列化。 2. 在服务器响应时，使用序列化器可以完成对数据的序列化。
### 7.3.1 序列化
#### 7.3.1.1 基本使用
1） 先查询出一个学生对象
from students.models import Student student = Student.objects.get(id=3)
2） 构造序列化器对象
from .serializers import StudentSerializer serializer = StudentSerializer(instance=student)
3）获取序列化数据
通过data属性可以获取序列化后的数据
serializer.data # {'id': 4, 'name': '小张', 'age': 18, 'sex': True, 'description': '猴赛雷'}
完整视图代码：
from django.views import View from students.models import Student from .serializers import StudentSerializer from django.http.response import JsonResponse class StudentView(View): """使用序列化器序列化转换单个模型数据""" def get(self,request,pk): # 获取数据 student = Student.objects.get(pk=pk) # 数据转换[序列化过程] serializer = StudentSerializer(instance=student) print(serializer.data) # 响应数据 return JsonResponse(serializer.data)
4）如果要被序列化的是包含多条数据的查询集QuerySet，可以通过添加**many=True**参数补充说明
"""使用序列化器序列化转换多个模型数据""" def get(self,request): # 获取数据 student_list = Student.objects.all() # 转换数据[序列化过程] # 如果转换多个模型对象数据，则需要加上many=True serializer = StudentSerializer(instance=student_list,many=True) print( serializer.data ) # 序列化器转换后的数据 # 响应数据给客户端 # 返回的json数据，如果是列表，则需要声明safe=False return JsonResponse(serializer.data,safe=False) # 访问结果： # [OrderedDict([('id', 1), ('name', 'xiaoming'), ('age', 20), ('sex', True), ('description', '测试')]), OrderedDict([('id', 2), ('name', 'xiaohui'), ('age', 22), ('sex', True), ('description', '后面来的测试')]), OrderedDict([('id', 4), ('name', '小张'), ('age', 18), ('sex', True), ('description', '猴赛雷')])]
示例
from django.views import View
from django.http.response import JsonResponse
from .serializers import Student1Serializer
from stuapi.models import Student
class StudentView(View): """序列化器""" def get1(self,request): """序列化一个模型对象""" # 1. 获取数据集 student = Student.objects.first() # 2. 实例化序列化器，获取序列化对象 serializer = Student1Serializer(student) # 3. 调用序列化对象的data属性方法获取转换后的数据 data = serializer.data # 4. 响应数据 return JsonResponse(data=data, status=200, safe=False, json_dumps_params={"ensure_ascii": False}) def get(self,request): """序列化多个模型对象""" # 1. 获取数据集 student_list = Student.objects.all() # 2. 实例化序列化器，得到序列化对象[传递到序列化器的模型对象如果是多个，务必使用many=True] serializer = Student1Serializer(student_list, many=True) # 3. 调用序列化对象的data属性方法获取转换后的数据 data = serializer.data # 4. 响应数据 return JsonResponse(data=data, status=200, safe=False, json_dumps_params={"ensure_ascii": False})
绑定路由，urls.py，代码：
from django.urls import path from . import views urlpatterns = [ path("students/", views.StudentView.as_view()), ]
### 7.3.2 反序列化
#### 7.3.2.1 数据验证
使用序列化器进行反序列化时，需要对数据进行验证后，才能获取验证成功的数据或保存成模型类对象。
在获取反序列化的数据前，必须调用**is_valid()**方法进行验证，验证成功返回True，否则返回False。
验证失败，可以通过序列化器对象的**errors**属性获取错误信息，返回字典，包含了字段和字段的错误。如果是非字段错误，可以通过修改REST framework配置中的**NON_FIELD_ERRORS_KEY**来控制错误字典中的键名。
验证成功，可以通过序列化器对象的**validated_data**属性获取数据。
在定义序列化器时，指明每个字段的序列化类型和选项参数，本身就是一种验证行为。
serialziers.py，代码
from rest_framework import serializers class Student2Serializer(serializers.Serializer): """学生信息序列化器""" # 1. 转换的字段声明 # 字段 = serializers.字段类型(选项=选项值,) id = serializers.IntegerField(read_only=True) # read_only=True, 在客户端提交数据[反序列化阶段不会要求id字段] name = serializers.CharField(required=True) # required=True , 反序列化阶段必填 sex = serializers.BooleanField(default=True) # default=True， 反序列化阶段，客户端没有提交，则默认为True age = serializers.IntegerField(max_value=100, min_value=0, error_messages={ "min_value": "The Age Filed Must Be 0 <= age", # age在反序列化必须是 0 <= age <= 100 "max_value": "The Age Filed Must Be age <= 100", }) description = serializers.CharField(allow_null=True, allow_blank=True) # 允许客户端不填写内容(None)，或者值为 "" # 2. 如果当前序列化器继承的是ModelSerializer，则需要声明调用的模型信息 # class Meta: # model = 模型 # fields = ["字段1","字段2",....] # 3. 验证代码的对象方法 # def validate(self, attrs): # validate是固定的 # pass # return attrs # def validate_<字段名>(self, data): # 方法名的格式必须以 validate_<字段名> 为名称，否则序列化器不识别！ # pass # return data_ # 4. 模型操作的方法， # def create(self, validated_data): # 添加数据操作，添加数据以后，就自动实现了从字典变成模型对象的过程 # pass # # def update(self, instance, validated_data): # 更新数据操作，更新数据以后，就自动实现了从字典变成模型对象的过程 # pass
通过构造序列化器对象，并将要反序列化的数据传递给data构造参数，进而进行验证
views.py，代码：
import json from django.views import View from django.http.response import JsonResponse from .serializers import Student1Serializer, Student2Serializer from stuapi.models import Student # Create your views here. class StudentView(View): def get(self,request): """反序列化-采用字段选项来验证数据[验证失败不抛出异常]""" # 1. 接收客户端提交的数据 # data = json.dumps(request.body) # 模拟来自客户端的数据 data = { "name": "xiaohong", "age": 117, "sex": True, "classmate": "301", "description": "这家伙很懒，什么都没有留下~" } # 1.1 实例化序列化器，获取序列化对象 serializer = Student2Serializer(data=data) # 1.2 调用序列化器进行数据验证 ret = serializer.is_valid() # 不抛出异常 print(f"ret={ret}") # 1.3 获取验证以后的结果 if ret: return JsonResponse(dict(serializer.validated_data)) else: return JsonResponse(dict(serializer.errors)) # 2. 操作数据库 # 3. 返回结果
is_valid()方法还可以在验证失败时抛出异常serializers.ValidationError，可以通过传递**raise_exception=True**参数开启，REST framework接收到此异常，会向前端返回HTTP 400 Bad Request响应。
views.py，代码：
import json from django.views import View from django.http.response import JsonResponse from .serializers import Student1Serializer, Student2Serializer from stuapi.models import Student # Create your views here. class StudentView(View): def get(self,request): """反序列化-采用字段选项来验证数据[验证失败抛出异常，工作中最常用]""" # 1. 接收客户端提交的数据 # 模拟来自客户端的数据 data = { "name": "xiaohong", "age": 11, "sex": True, "classmate": "301", "description": "这家伙很懒，什么都没有留下~" } # 1.1 实例化序列化器，获取序列化对象 serializer = Student2Serializer(data=data) # 1.2 调用序列化器进行数据验证 serializer.is_valid(raise_exception=True) # 抛出异常，代码不会往下执行 # 1.3 获取验证以后的结果 print(serializer.validated_data) # 2. 操作数据库 # 3. 返回结果 return JsonResponse({})
如果觉得这些还不够，需要再补充定义验证行为，可以使用以下三种方法：
##### 1) validate_字段名
对`<field_name>`字段进行验证，如
class Student2Serializer(serializers.Serializer): """学生信息序列化器""" # 1. 转换的字段声明 # 字段 = serializers.字段类型(选项=选项值,) id = serializers.IntegerField(read_only=True) # read_only=True, 在客户端提交数据[反序列化阶段不会要求id字段] name = serializers.CharField(required=True) # required=True , 反序列化阶段必填 sex = serializers.BooleanField(default=True) # default=True， 反序列化阶段，客户端没有提交，则默认为True age = serializers.IntegerField(max_value=100, min_value=0, error_messages={ "min_value": "The Age Filed Must Be 0 <= age", # age在反序列化必须是 0 <= age <= 100 "max_value": "The Age Filed Must Be age <= 100", }) description = serializers.CharField(allow_null=True, allow_blank=True) # 允许客户端不填写内容(None)，或者值为 "" # 2. 如果当前序列化器继承的是ModelSerializer，则需要声明调用的模型信息 # class Meta: # model = 模型 # fields = ["字段1","字段2",....] # 3. 验证代码的对象方法 # def validate(self, attrs): # validate是固定的 # pass # return attrs def validate_name(self, data): """验证单个字段 方法名的格式必须以 validate_<字段名> 为名称，否则序列化器不识别！ validate开头的方法，会自动被is_valid调用的 """ if data in ["python", "django"]: # 在序列化器中，验证失败可以通过抛出异常的方式来告知 is_valid raise serializers.ValidationError(detail="学生姓名不能是python或django", code="validate_name") # 验证成功以后，必须返回数据，否则最终的验证结果中，就不会出现这个数据了。 return data # 4. 模型操作的方法， # def create(self, validated_data): # 添加数据操作，添加数据以后，就自动实现了从字典变成模型对象的过程 # pass # # def update(self, instance, validated_data): # 更新数据操作，更新数据以后，就自动实现了从字典变成模型对象的过程 # pass
视图代码，测试
import json from django.views import View from django.http.response import JsonResponse from .serializers import Student1Serializer, Student2Serializer from stuapi.models import Student # Create your views here. class StudentView(View): def get(self,request): """反序列化-采用字段选项来验证数据[验证失败抛出异常，工作中最常用]""" # 1. 接收客户端提交的数据 # 模拟来自客户端的数据 data = { "name": "xiaohong", "age": 11, "sex": True, "classmate": "301", "description": "这家伙很懒，什么都没有留下~" } # 1.1 实例化序列化器，获取序列化对象 serializer = Student2Serializer(data=data) # 1.2 调用序列化器进行数据验证 serializer.is_valid(raise_exception=True) # 抛出异常，代码不会往下执行 # 1.3 获取验证以后的结果 print(serializer.validated_data) # 2. 操作数据库 # 3. 返回结果 return JsonResponse({})
##### 2) validate
在序列化器中需要同时对多个字段进行比较验证时，可以定义validate方法来验证，如
class Student2Serializer(serializers.Serializer): """学生信息序列化器""" # 1. 转换的字段声明 # 字段 = serializers.字段类型(选项=选项值,) id = serializers.IntegerField(read_only=True) # read_only=True, 在客户端提交数据[反序列化阶段不会要求id字段] name = serializers.CharField(required=True) # required=True , 反序列化阶段必填 sex = serializers.BooleanField(default=True) # default=True， 反序列化阶段，客户端没有提交，则默认为True age = serializers.IntegerField(max_value=100, min_value=0, error_messages={ "min_value": "The Age Filed Must Be 0 <= age", # age在反序列化必须是 0 <= age <= 100 "max_value": "The Age Filed Must Be age <= 100", }) classmate = serializers.CharField() description = serializers.CharField(allow_null=True, allow_blank=True) # 允许客户端不填写内容(None)，或者值为 "" # 2. 如果当前序列化器继承的是ModelSerializer，则需要声明调用的模型信息 # class Meta: # model = 模型 # fields = ["字段1","字段2",....] # 3. 验证代码的对象方法 def validate(self, attrs): """ 验证来自客户端的所有数据 类似会员注册的密码和确认密码，就只能在validate方法中校验 validate是固定方法名， 参数：attrs，是在序列化器实例化时的data选项数据 """ # 307班只能有女生，不能加入其他男生 if attrs["classmate"] == "307" and attrs["sex"]: raise serializers.ValidationError(detail="307班只能进去小姐姐~", code="validate") return attrs def validate_name(self, data): """验证单个字段 方法名的格式必须以 validate_<字段名> 为名称，否则序列化器不识别！ validate开头的方法，会自动被is_valid调用的 """ if data in ["python", "django"]: # 在序列化器中，验证失败可以通过抛出异常的方式来告知 is_valid raise serializers.ValidationError(detail="学生姓名不能是python或django", code="validate_name") # 验证成功以后，必须返回数据，否则最终的验证结果中，就不会出现这个数据了。 return data # 4. 模型操作的方法， # def create(self, validated_data): # 添加数据操作，添加数据以后，就自动实现了从字典变成模型对象的过程 # pass # # def update(self, instance, validated_data): # 更新数据操作，更新数据以后，就自动实现了从字典变成模型对象的过程 # pass
视图代码，测试
import json from django.views import View from django.http.response import JsonResponse from .serializers import Student1Serializer, Student2Serializer from stuapi.models import Student # Create your views here. class StudentView(View): def get(self,request): """反序列化-采用字段选项来验证数据[验证失败抛出异常，工作中最常用]""" # 1. 接收客户端提交的数据 # 模拟来自客户端的数据 data = { "name": "xiaoming", "age": 11, "sex": True, "classmate": "307", "description": "这家伙很懒，什么都没有留下~" } # 1.1 实例化序列化器，获取序列化对象 serializer = Student2Serializer(data=data) # 1.2 调用序列化器进行数据验证 serializer.is_valid(raise_exception=True) # 抛出异常，代码不会往下执行 # 1.3 获取验证以后的结果 print(serializer.validated_data) # 2. 操作数据库 # 3. 返回结果 return JsonResponse({})
##### 3) validators
def check_classmate(data): """外部验证函数""" if len(data) != 3: raise serializers.ValidationError(detail="班级编号格式不正确！必须是3个字符", code="check_classmate") # 验证完成以后，务必返回结果，否则最终的验证结果没有该数据 return data class Student2Serializer(serializers.Serializer): """学生信息序列化器""" # 1. 转换的字段声明 # 字段 = serializers.字段类型(选项=选项值,) id = serializers.IntegerField(read_only=True) # read_only=True, 在客户端提交数据[反序列化阶段不会要求id字段] name = serializers.CharField(required=True) # required=True , 反序列化阶段必填 sex = serializers.BooleanField(default=True) # default=True， 反序列化阶段，客户端没有提交，则默认为True age = serializers.IntegerField(max_value=100, min_value=0, error_messages={ "min_value": "The Age Filed Must Be 0 <= age", # age在反序列化必须是 0 <= age <= 100 "max_value": "The Age Filed Must Be age <= 100", }) # validators 外部验证函数选项，值是一个列表，列表得到成员是函数名，不能是字符串！！！ classmate = serializers.CharField(validators=[check_classmate]) description = serializers.CharField(allow_null=True, allow_blank=True) # 允许客户端不填写内容(None)，或者值为 "" # 2. 如果当前序列化器继承的是ModelSerializer，则需要声明调用的模型信息 # class Meta: # model = 模型 # fields = ["字段1","字段2",....] # 3. 验证代码的对象方法 def validate(self, attrs): """ 验证来自客户端的所有数据 类似会员注册的密码和确认密码，就只能在validate方法中校验 validate是固定方法名， 参数：attrs，是在序列化器实例化时的data选项数据 """ # 307班只能有女生，不能加入其他男生 if attrs["classmate"] == "307" and attrs["sex"]: raise serializers.ValidationError(detail="307班只能进去小姐姐~", code="validate") return attrs def validate_name(self, data): """验证单个字段 方法名的格式必须以 validate_<字段名> 为名称，否则序列化器不识别！ validate开头的方法，会自动被is_valid调用的 """ if data in ["python", "django"]: # 在序列化器中，验证失败可以通过抛出异常的方式来告知 is_valid raise serializers.ValidationError(detail="学生姓名不能是python或django", code="validate_name") # 验证成功以后，必须返回数据，否则最终的验证结果中，就不会出现这个数据了。 return data # 4. 模型操作的方法， # def create(self, validated_data): # 添加数据操作，添加数据以后，就自动实现了从字典变成模型对象的过程 # pass # # def update(self, instance, validated_data): # 更新数据操作，更新数据以后，就自动实现了从字典变成模型对象的过程 # pass
视图代码，测试：
import json from django.views import View from django.http.response import JsonResponse from .serializers import Student1Serializer, Student2Serializer from stuapi.models import Student # Create your views here. class StudentView(View): def get(self,request): """反序列化-采用字段选项来验证数据[验证失败抛出异常，工作中最常用]""" # 1. 接收客户端提交的数据 # 模拟来自客户端的数据 data = { "name": "xiaoming", "age": 11, "sex": True, "classmate": "301", "description": "这家伙很懒，什么都没有留下~" } # 1.1 实例化序列化器，获取序列化对象 serializer = Student2Serializer(data=data) # 1.2 调用序列化器进行数据验证 serializer.is_valid(raise_exception=True) # 抛出异常，代码不会往下执行 # 1.3 获取验证以后的结果 print(serializer.validated_data) # 2. 操作数据库 # 3. 返回结果 return JsonResponse({})
#### 7.3.2.2 保存数据
前面的验证数据成功后,我们可以使用序列化器来完成数据反序列化的过程.这个过程可以把数据转成模型类对象.
可以通过实现create()和update()两个方法来实现。
class Student2Serializer(serializers.Serializer): """学生信息序列化器""" # 1. 转换的字段声明 # 字段 = serializers.字段类型(选项=选项值,) id = serializers.IntegerField(read_only=True) # read_only=True, 在客户端提交数据[反序列化阶段不会要求id字段] name = serializers.CharField(required=True) # required=True , 反序列化阶段必填 sex = serializers.BooleanField(default=True) # default=True， 反序列化阶段，客户端没有提交，则默认为True age = serializers.IntegerField(max_value=100, min_value=0, error_messages={ "min_value": "The Age Filed Must Be 0 <= age", # age在反序列化必须是 0 <= age <= 100 "max_value": "The Age Filed Must Be age <= 100", }) # validators 外部验证函数选项，值是一个列表，列表得到成员是函数名，不能是字符串！！！ classmate = serializers.CharField(validators=[check_classmate]) description = serializers.CharField(allow_null=True, allow_blank=True) # 允许客户端不填写内容(None)，或者值为 "" # 2. 如果当前序列化器继承的是ModelSerializer，则需要声明调用的模型信息 # class Meta: # model = 模型 # fields = ["字段1","字段2",....] # 3. 验证代码的对象方法 def validate(self, attrs): """ 验证来自客户端的所有数据 类似会员注册的密码和确认密码，就只能在validate方法中校验 validate是固定方法名， 参数：attrs，是在序列化器实例化时的data选项数据 """ # 307班只能有女生，不能加入其他男生 if attrs["classmate"] == "307" and attrs["sex"]: raise serializers.ValidationError(detail="307班只能进去小姐姐~", code="validate") return attrs def validate_name(self, data): """验证单个字段 方法名的格式必须以 validate_<字段名> 为名称，否则序列化器不识别！ validate开头的方法，会自动被is_valid调用的 """ if data in ["python", "django"]: # 在序列化器中，验证失败可以通过抛出异常的方式来告知 is_valid raise serializers.ValidationError(detail="学生姓名不能是python或django", code="validate_name") # 验证成功以后，必须返回数据，否则最终的验证结果中，就不会出现这个数据了。 return data # 4. 模型操作的方法， def create(self, validated_data): """ 添加数据 方法名固定为create，固定参数validated_data就是验证成功以后的结果 """ student = Student.objects.create(**validated_data) return student def update(self, instance, validated_data): """ 更新数据操作， 方法名固定为update， 固定参数instance，实例化序列化器对象时，必须传入的模型对象 固定参数validated_data就是验证成功以后的结果 更新数据以后，就自动实现了从字典变成模型对象的过程 """ instance.name = validated_data["name"] instance.age = validated_data["age"] instance.sex = validated_data["sex"] instance.classmate = validated_data["classmate"] instance.description = validated_data["description"] instance.save() # 调用模型对象的save方法，和视图中的serialzier.save()不是同一个类的方法 return instance
实现了上述两个方法后，在反序列化数据的时候，就可以通过save()方法返回一个数据对象实例了
book = serializer.save()
如果创建序列化器对象的时候，没有传递instance实例，则调用save()方法的时候，create()被调用，相反，如果传递了instance实例，则调用save()方法的时候，update()被调用。
视图代码
import json from django.views import View from django.http.response import JsonResponse from .serializers import Student1Serializer, Student2Serializer from stuapi.models import Student # Create your views here. class StudentView(View): def get5(self,request): """反序列化-验证完成以后，添加数据入库""" # 1. 接收客户端提交的数据 # 模拟来自客户端的数据 data = { "name": "xiaoming", "age": 11, "sex": True, "classmate": "301", "description": "这家伙很懒，什么都没有留下~" } # 1.1 实例化序列化器，获取序列化对象 serializer = Student2Serializer(data=data) # 1.2 调用序列化器进行数据验证 serializer.is_valid(raise_exception=True) # 抛出异常，代码不会往下执行 # 2. 获取验证以后的结果。操作数据库 serializer.save() # 会根据实例化序列化器的时候，是否传入instance属性来自动调用create或者update方法。传入instance属性，自动调用update方法;没有传入instance属性，则自动调用create # 3. 返回结果 return JsonResponse(serializer.data, status=201) def get(self,request): """反序列化-验证完成以后，更新数据入库""" #1. 根据客户端访问的url地址中，获取pk值 # sers/students/2/ path("/students/(?P<pk>)\d+/", views.StudentView.as_view()), pk = 5 try: student = Student.objects.get(pk=pk) except Student.DoesNotExist: return JsonResponse({"errors": "当前学生不存在！"}, status=400) # 2. 接收客户端提交的修改数据 # 模拟来自客户端的数据 data = { "name": "xiaohong", "age": 18, "sex": False, "classmate": "303", "description": "这家伙很懒，什么都没有留下~" } # 3. 修改操作中的实例化序列化器对象 serializer = Student2Serializer(instance=student, data=data) # 4. 验证数据 serializer.is_valid(raise_exception=True) # 5. 入库 serializer.save() # 6. 返回结果 return JsonResponse(serializer.data, status=201)
#### 7.3.2.3 附加说明
1） 在对序列化器进行save()保存时，可以额外传递数据，这些数据可以在create()和update()中的validated_data参数获取到
# request.user 是django中记录当前登录用户的模型对象
serializer.save(owner=request.user) # 可以在save中，传递一些不需要验证的数据到模型里面
2）默认序列化器必须传递所有required的字段，否则会抛出验证异常。但是我们可以使用partial参数来允许部分字段更新
# 更新 `name` ，不需要验证其他的字段，可以设置partial=True serializer = StudentSerializer(student, data={'name': 'xiaohui'}, partial=True)
幻想毫无价值，计划渺如尘埃，目标不可能达到。这一切的一切毫无意义——除非我们付诸行动。
