drf(序列化器）
一 序列化器组件介绍(Serializer)
1 序列化器组件介绍
序列化组件，又称序列化器，是处理对象和字典的数据格式转换，json的序列化和反序列化，在Request和Response处理了。
''' 1 序列化，序列化器会把模型对象转换成字典，经过response以后变成json字符串 2 反系列化，把客户端发送过来的数据，经过request以后变成字典，序列化器可以把字典转成模型 3 反序列化，完成数据校验功能 '''
# 在应用下新建一个ser.py文件 1 写一个序列化的类，继承Serializer 2 在类中写序列化的字段，需要序列化哪些字段，就写哪些字段 3 在视图函数中使用，从ser.py中导入类，在把序列化的对象传入 4 序列化的对象.data，是一个字典 5 把字典返回，如果不使用rest_framework提供的Response,就得使用JsongRsponse
记得在settings.py中的应用注册下，注册'rest_framework'
3 序列化的字段类型
注意：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 |
| 作用 | |
|---|---|
| max_length | 最大长度 |
| min_length | 最小长度 |
| allow_blank | 是否允许为空 |
| trim_whitespace | 是否截断空白字符 |
| max_value | 最小值 |
| min_value |
如果字段的校验规则不够，可以写钩子函数（局部和全局），原理和forms组件一样。
除了局部钩子和全局钩子校验数据，还可以用validators=[check_author]，author = serializers.CharField(validators=[check_author]) # validators=[]写的函数内存地址
| 说明 | |
|---|---|
| read_only | 表明该字段仅用于序列化输出，默认False |
| write_only | 表明该字段仅用于反序列化输入，默认False |
| required | 表明该字段在反序列化时必须输入，默认True |
| default | 反序列化时使用的默认值 |
| allow_null | 表明该字段是否允许传入None，默认False |
| validators | 该字段使用的验证器 |
| error_messages | 包含错误编号与错误信息的字典 |
| label | 用于HTML展示API页面时，显示的字段名称 |
| help_text |
read_only 表明该字段仅用于序列化输出，默认False,如果设置成True,postman中可以看到该字段，修改时，不需要传该字段
write_only 表明该字段仅用于反序列化输入，默认False，如果设置成True,postman看不到该字段，修改时，该字段需要传该字段
6 获取单条数据（get)和修改数据（put）
7 获取多条数据（get)和新增数据(put)
8 删除一条数据（delete)
9 自己封装的Response对象
总结
1 get单条数据和多条数据的区别(序列化），如果序列化一条，不需要写many=True，序列化多条，需要加many=True
在序列化类中，对应模型表，写对应的序列化字段，序列化对象book_ser,book_ser.data是字典，最后通过Response返回序列后的字典
2 修改数据put（反序列化），需要序列化传入BookSerializer(instance=book_obj, data=request.data)，instance是要被修改的对象，data是前端发送过来的修改数据。
序列化对象book_ser要先经过book_ser.is_valid()校验，校验通过字段校验、钩子函数校验以及自定义函数校验validators=[check_author]，校验通过后，
在.save()前 ，面向对象接口思想，要求重写update方法，传入instance和校验通过的数据validated_data
先instance.save(),再返回instance,再book_ser.save(),通过Response返回修改数据情况。
3 新增数据put（反序列化），新增数据传入books_ser = BookSerializer(data=request.data)，反序列化，一样要经过校验，
同上，重写ceatef方法，返回新增对象instance,返回，同上
4 删除delete（），直接操作模型表。
models.py
class Book(models.Model): name = models.CharField(max_length=32) price = models.DecimalField(max_digits=6, decimal_places=2) author = models.CharField(max_length=32) publish = models.CharField(max_length=32)
urls.py
from django.contrib import admin from django.urls import path, re_path, include from app01 import views urlpatterns = [ path('admin/', admin.site.urls), # 查询单个 path('book/<int:pk>/', views.BookView.as_view()), # 查询多个 path('books/', views.BooksViews.as_view()), # 模型类序列化器 path('book1/', views.Books1Views.as_view()), # 路由分发 path('app02/', include('app02.urls')) ]
views.py
from django.shortcuts import render from rest_framework.views import APIView from rest_framework.views import Response from app01 import models from app01.ser import BookSerializer from app01.ser import BookModelSerializer # 自定义返回字段的类 from app01.utils import BackMsg class BookView(APIView): # 通过序列化器获得数据 def get(self, request, pk): # 自定义的封装返回字典类 back_obj = BackMsg() book_obj = models.Book.objects.filter(pk=pk).first() # 要序列化谁，就把随传过去 book_ser = BookSerializer(book_obj) # book_ser.data 序列化对象.data就是序列化后的字典 back_obj.data = book_ser.data print(book_ser.data) return Response(back_obj.get_msg) # 通过序列化器修改数据 def put(self, request, pk): response_dic = {'status': 1000, 'msg': '成功'} # 找到需要修改的对象 book_obj = models.Book.objects.filter(pk=pk).first() # 得到一个序列化对象，request.data是前端发过的要修改的数据 # book_ser = BookSerializer(book_obj, request.data) # 标准写法 print(request.data) import json print(json.dumps(request.data)) # request.data已是普通字典格式，已经被新的封装处理后的request反序列化 book_ser = BookSerializer(instance=book_obj, data=request.data) # 进行数据验证（类似于form组件的验证） if book_ser.is_valid(): # book_ser.save()只写会报错，用面向对象的继承里的接口，要求子类必须有父类的方法（ABC模块） # 所有需要在要在BookSerializer写update()方法，才能写book_ser.save() book_ser.save() response_dic['data'] = book_ser.data else: response_dic['status'] = 2000 response_dic['msg'] = '数据校验失败' response_dic['data'] = book_ser.errors return Response(response_dic) # 删除数据 def delete(self, request, pk): response_dic = {'status': 100, 'msg': '删除成功'} models.Book.objects.filter(pk=pk).delete() return Response(response_dic) # 查多条，也可以用第一个视图，但要做判断，简单点，就用低下这个 class BooksViews(APIView): # 获取多条 def get(self, request): response_dic = {'status': 100, 'msg': '成功'} books_obj = models.Book.objects.all() # 序列化 books_ser = BookSerializer(books_obj, many=True) # 序列化多条，如果序列化一条，不需要写many=True response_dic['data'] = books_ser.data return Response(response_dic) # 新增 def put(self, request): response_dic = {'status': 100, 'msg': '成功'} books_ser = BookSerializer(data=request.data) # 用关键字参数形式，如果用位置参数，就给instance传参 # 校验数据 if books_ser.is_valid(): # 新增，需要Book序列化器中写create()方法，才能save books_ser.save() response_dic['data'] = books_ser.data else: response_dic['status'] = 200 response_dic['msg'] = '校验有误' response_dic['data'] = books_ser.errors return Response(response_dic)
ser.py
from rest_framework import serializers
from rest_framework.exceptions import ValidationError
from app01 import models
def check_author(data):
if data.startswith('sb'):
raise ValidationError('作者姓名不能以sb开头')
else:
return data
# 需要继承,序列化器组件
class BookSerializer(serializers.Serializer):
id = serializers.CharField(read_only=True) # postman可以看到该字段，修改不用传给字段
name = serializers.CharField()
price = serializers.CharField()
author = serializers.CharField(validators=[check_author]) # validators=[]写的函数内存地址
publish = serializers.CharField()
# 局部钩子，对序列化器字段进行校验,钩子函数要记得返回数据(类似于form组件中，clean_字段名，局部钩子函数）
def validate_price(self, data): # validate_字段名，接受一个参数
# 假设价格小于10，校验不通过
print(type(data), data) # 字符串
if float(data) > 10:
return data
else:
# forms组件是self.add_error()
raise ValidationError('价格太低')
# 全局钩子，对序列化器字段进行校验,钩子函数，记得要返回数据（类似于form组件中，clean全局钩子函数）
def validate(self, validate_data):
print(validate_data)
author = validate_data.get('author')
publish = validate_data.get('publish')
if author == publish:
raise ValidationError('作者名和出版社名不能一样')
else:
return validate_data
# 修改数据
def update(self, instance, validated_data):
# instance是book对象
# validated_data是校验后的数据，是字典，类似于forms组件中的cleaned_data
instance.name = validated_data.get('name')
instance.price = validated_data.get('price')
instance.author = validated_data.get('author')
instance.publish = validated_data.get('publish')
instance.save() # 就是book_obj保存，ORM提供的
return instance
# 第二种修改数据方法
def update(self, instance, validate_data):
for key, value in validate_data.items():
if hasattr(instance, key):
setattr(instance, key, value)
instance.save()
return instance
# 新增数据
def create(self, validated_data):
# **validated_data，把字典打散成关键字参数的形式
# book_obj = models.Book(**validated_data)
# book_obj.save()
# return book_obj
# 第二种创建方式
instance = models.Book.objects.create(**validated_data)
return instance
utils.py 自定义封装返回字典对象
class BackMsg(object): def __init__(self): self.status = 100 self.msg = '成功' @property def get_msg(self): return self.__dict__
10 源码分析
序列化多条，为什么需要many=True
''' 元类的思想 对象的生成--->先调用类的__new__方法，生成空对象 类的实例化，触发类的__init__方法 类的__new__方法控制对象的生成 ''' book_ser = BookSerializer(book_obj) books_ser = BookSerializer(books_obj, many=True) book_ser是<class 'rest-framework.serializors.ListSerializor'> books_ser是<class 'app01.ser.BookModelSerializor'> # 同一个类，为什么生成了两个不同的对象 def __new__(cls, *args, **kwargs): if kwargs.pop('many', False): return cls.many_init(*args, **kwargs) # 没有写many=True，就下面，正常的对象实例化 return super().__new__(cls, *args, **kwargs) @classmethod def many_init(cls, *args, **kwargs): meta = getattr(cls, 'Meta', None) list_serializer_class = getattr(meta, 'list_serializer_class', ListSerializer) # list_serializer_class多个序列化对象的一个列表 return list_serializer_class(*args, **list_kwargs)
接口：统一子类的行为，怎么统一，要么用ABC模块，要么就抛出异常
（save()方法，重写update和create方法，是用的抛出异常的方法）
鸭子类型，是反过来的，子类的行为一样，就叫鸭子类型
二 模型类序列化器(ModelSerializer)
如果我们想要使用序列化器对应的是Django的模型类，DRF为我们提供了ModelSerializer模型类序列化器来帮助我们快速创建一个Serializer类。
ModelSerializer与常规的Serializer相同，但提供了：
-
基于模型类自动生成一系列字段
-
基于模型类自动为
Serializer生成validators，比如unique_together -
包含默认的create()和update()的实现
# 其他使用一模一样 # 不需要重写create和update方法了
views.py
# 模型类序列化器 class Books1Views(APIView): def get(self, request): back_dic = BackMsg() books_obj = models.Book.objects.all() books_ser = BookModelSerializer(books_obj, many=True) back_dic.data = books_ser.data return Response(back_dic.get_msg)
ser.py
# 模型类序列化器 # 要用局部钩子和全局钩子校验，validate_字段名和validate和class Meta同级，不要写到内部了 class BookModelSerializer(serializers.ModelSerializer): class Meta: model = models.Book # 对应上models.py中的模型 fields = '__all__' # 对所有的字段进行序列化 # fields = ('name', 'price') # 序列化指定的字段 # exclude = ('name',) # 排除谁 read_only_fields = ('id',) # 不能单独使用，要和上面的结合用 # write_only_fields = ('author', 'id') # 不能单独使用，要和上面的结合用 # 添加额外参数 extra_kwargs = { 'price': {'write_only': True} }
三 Serializer高级用法
多表的序列化和反序列化
复习了一下路由分发
# source的用法 1 可以该字段名字 price = serializers.CharField(write_only=True, required=True, source='price11') 2 可以跨表查询（一对多） publish = serializers.CharField(source='publish.address') 3 可以执行模型表中的方法 title = serializers.CharField(max_length=16, min_length=4, source='test') # test是模型表Book的方法 # SerializerMethodField()的使用（多对多关系） # 需要有个配套方法，方法名叫get_字段名，返回一个列表
from django.db import models class Book(models.Model): title = models.CharField(max_length=64) price = models.DecimalField(max_digits=5, decimal_places=2) # pub_date = models.DateField(auto_now_add=True) publish = models.ForeignKey(to='Publish', null=True, on_delete=models.CASCADE ) authors = models.ManyToManyField(to='Author') def __str__(self): return self.title def test(self): return '今天好开心' class Publish(models.Model): name = models.CharField(max_length=64) address = models.CharField(max_length=64) email = models.EmailField() class Meta: verbose_name = '出版社' def __str__(self): return self.name class Author(models.Model): name = models.CharField(max_length=64) age = models.IntegerField() author_detail = models.OneToOneField(to='AuthorDetail', null=True, on_delete=models.CASCADE ) def __str__(self): return self.name class AuthorDetail(models.Model): mobile = models.CharField(max_length=11) class Meta: verbose_name = '作者详情' def __str__(self): return '%s的详情' % self.author.name
from django.shortcuts import render from rest_framework.views import APIView from rest_framework.response import Response from app02 import models from app02.ser import BookSerializer from app02.utils import BackMsg # Create your views here. class App02BookView(APIView): # 通过序列化器获得数据 def get(self, request, pk): # 自定义的返回字典类 back_obj = BackMsg() book_obj = models.Book.objects.filter(pk=pk).first() print(book_obj) # 要序列化谁，就把随传过去 book_ser = BookSerializer(book_obj) # book_ser.data 序列化对象.data就是序列化后的字典 back_obj.data = book_ser.data print(book_ser.data) return Response(back_obj.get_msg)
''' @作者：xiaobao @联系方式：lqiao88@163.com ''' from rest_framework import serializers # 需要继承,序列化器组件 class BookSerializer(serializers.Serializer): id = serializers.CharField(read_only=True) # postman可以看到该字段，修改不用传给字段 title = serializers.CharField(max_length=16, min_length=4, source='test') # source='test'，"title": "今天好开心", test是book模型表的函数，可以固定返回数据 price = serializers.CharField(write_only=True, required=True, source='price11') # authors = serializers.CharField() # validators=[]写的函数内存地址 # "authors": "app02.Author.None"，多对多，跨表查询，需要用其他方法 authors = serializers.SerializerMethodField() # 需要有个配套方法，方法名叫get_字段名，返回一个列表 publish = serializers.CharField(source='publish.address') # "publish": "渝中区",和orm的子查询一样，一对多的关系 def get_authors(self, instance): # 这里的instance，就是视图类中的book_obj query_authors = instance.authors.all() # 基于子对象查询，正向按字段名，多个加.all() l = [] for author_obj in query_authors: l.append({'name': author_obj.name, 'age': author_obj.age, 'addr': author_obj.author_detail.mobile}) # 用的方法和orm一样 return l
