序列化组件介绍
1. 序列化,序列化器会把模型对象转换成字典,经过response以后变成json字符串
2. 反序列化,把客户端发送过来的数据,经过request以后变成字典,序列化器可以把字典转成模型
3. 反序列化,完成数据校验功能
序列化组件的使用
1、写一个序列化的类，继承Serializer
2、在类中写要序列化的字段，想序列化哪个字段，就在类中写哪个字段
3、在视图类中使用，导入--->实例化得到序列化类的对象，把要序列化的对象传入
4、序列化类的对象.data 是一个字典
5、把字典返回，如果不使用rest_framework提供的Response，就得使用JsonResponse
1 写一个序列化的类，继承Serializer
class BookSerializer(serializers.Serializer):
# 在这里写要序列化的字段
# 序列化字段类(有很多，常用的就几个，等同于models中的字段类)
# 字段类，有很多字段参数（）
name = serializers.CharField()
price = serializers.IntegerField()
# publish = serializers.CharField()
2 在类中写要序列化的字段
name = serializers.CharField()
price = serializers.IntegerField()
3 在视图类中使用（实例化）
book_list = models.Book.objects.all() book_ser=BookSerializer(instance=book_list,many=True)
4 得到序列化后的数据,返回
book_ser.data
5 字段参数，source,指定要序列化表中的哪个字段
source
1 指定要序列化的字段（数据表中字段）
publish = serializers.CharField(source='publish.city')
2 用的最多：只有一个字段（也可以跨表）
SerializerMethodField
1 用的最多，跨表查（要么是列表，要么是字典）
publish=serializers.SerializerMethodField()
def get_publish(self,obj):
print(obj)
# return {'name':'sss','city':'sss'}
return {'name':obj.publish.name,'city':obj.publish.city}
在模型表中写方法
# 表模型中写的
def publish_name(self):
return {'name':self.publish.name,'city':self.publish.city}
@property
def author_list(self):
return [{'name':author.name,'age':author.age,'id':author.nid} for author in self.authors.all()]
#序列化类中
# publish = serializers.CharField(source='publish_name')
publish_name = serializers.DictField()
author_list=serializers.ListField()
序列化类的字段类型
有很多 不需要都记住
只需要记住：
CharField IntegerField DateField...
序列化字段选项
max_length 最大长度
min_lenght 最小长度
allow_blank 是否允许为空
trim_whitespace 是否截断空白字符
max_value 最小值
min_value 最大值
序列化组件修改数据
1、写一个序列化的类，继承Serializer
2、在类中写要反序列化的字段，想反序列化哪个字段，就在类中写哪个字段，字段的属性(max_length...)
3、在视图类中使用，导入--->实例化得到序列化类的对象，把要修改的对象传入，要修改的数据传入
book_ser = BookSerializer(book, request.data)
book_ser = BookSerializer(instance=book, data=request.data) # 推荐
4、数据校验
if book_ser.is_valid(): # 返回True,表示验证通过
5、如果校验通过，就保存
book_ser.save() # 注意不是book.save() 而是序列化器提供的
6、如果不通过，逻辑自己写
7、如果字段的校验规则不够，可以写钩子函数(局部和全局)
# 局部钩子
def validate_price(self, data): # validated_字段名 接收一个参数
# 如果价格小于10，就校验不通过
# print(type(data)) # <class 'str'>
# print(data) # 33.66
if float(data)>10:
return data
else:
# 校验失败，抛异常
raise ValidationError('价格太低')
# 全局钩子
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
8、可以使用字段的author = serializers.CharField(validators=[check_author]) # validators=[] 列表中写函数内存地址
写一个自定义函数：
def check_author(data):
if data.startswith('sb'):
raise ValidationError('作者名字不能以sb开头')
else:
return data
配置：
validators=[check_author]
read_only和write_only
read_only 表明该字段仅用于序列化输出，默认False，如果设置成True，postman中可以看到该字段，修改时，不需要传该字段
write_only 表明该字段仅用于反序列化输入，默认False，如果设置成True，postman中看不到该字段，修改时需要传
以下的了解：
required 表明该字段在反序列化时必须输入，默认True
default 反序列化时使用的默认值
allow_null 表明该字段是否允许传入None，默认False
validators 该字段使用的验证器
error_messages 包含错误编号与错误信息的字典
label 用于HTML展示API页面时，显示的字段名称
help_text 用于HTML展示API页面时，显示的字段帮助提示信息
查询所有
# views.py
# 查询所有
def get(self, request):
response_msg = {'status': 100, 'msg': '成功'}
books = Book.objects.all()
book_ser = BookSerializer(books, many=True) # 序列化多条,序列化一条不需要写many=True
response_msg['data'] = book_ser.data
return Response(response_msg)
# urls.py
path('books/', views.BooksView.as_view()),
新增数据
# views.py
class BooksView(APIView):
# 新增
def post(self,request):
response_msg = {'status': 100, 'msg': '成功'}
# 修改的时候才有instance,新增没有instance,只有data
book_ser = BookSerializer(data=request.data)
# book_ser = BookSerializer(request.data) # 这个按位置传request.data会给instance，就报错了
# 校验字段
if book_ser.is_valid():
book_ser.save()
response_msg['data'] = book_ser.data
else:
response_msg['status'] = 102
response_msg['msg'] = '数据校验失败'
response_msg['data'] = book_ser.errors
return Response(response_msg)
# ser.py 序列化类重写create方法
# 新增需要重写create()
def create(self, validated_data):
instance = Book.objects.create(**validated_data)
# Book.objects.create(name=validated_data.get('name'))
return instance
# urls.py
path('books/', views.BooksView.as_view()),
删除一个数据
# views.py:
class BookView(APIView):
# 删除
def delete(self, request, pk):
ret = Book.objects.filter(pk=pk).delete()
return Response({'status': 100, 'msg': '删除成功'})
# urls.py:
re_path('books/(?P<pk>d+)', views.BookView.as_view()),
模型类序列化器
# ser.py
class BookModelSerializer(serializers.ModelSerializer):
class Meta:
model = Book # 对应上models.py中的模型
fields = '__all__'
# fields = ('name','price') # 只序列化指定的字段
# exclude = ('name',) # 跟fields不能都写，写谁，就表示排除谁
# read_only_fields = ('price',)
# write_only_fields = ('author',) # 弃用了，使用extra_kwargs
extra_kwargs = { # 类似于这种形式name = serializers.CharField(max_length=16, min_length=3)
'price': {'write_only': True},
}
# 其他使用一模一样
# 不需要重写create和update方法了
源码分析
many=True实际用途
# 序列化多条，需要传many=True
#
books = Book.objects.all()
book = Book.objects.all().first()
book_ser = BookModelSerializer(books, many=True) # 序列化多条,序列化一条不需要写many=True
book_one_ser = BookModelSerializer(book)
print(type(book_ser))
# <class 'rest_framework.serializers.ListSerializer'>
print(type(book_one_ser))
# <class 'app01.ser.BookModelSerializer'>
# 对象的生成 ---> 先调用类的__new__方法，生成空对象
# 对象=类名(name=lqz),触发类的__init__()
# 类的__new__方法控制对象的生成
def __new__(cls, *args, **kwargs):
if kwargs.pop('many', False):
return cls.many_init(*args, **kwargs)
# 没有传many=True,走下面，正常的对象实例化
return super().__new__(cls, *args, **kwargs)
serializer高级用法
# source的使用
1、可以改字段名字
xxx = serializers.CharField(source='title')
2、可以.跨表
publish = serializers.CharField(source='publish.email') # book.publish.email
3、可以执行方法
pub_date = serializers.CharField(source='test') # test是Book表模型中的方法
# SerializerMethodField()的使用
1、配套一个方法，方法名叫get_字段名，返回值就是要显示的东西
authors = serializers.SerializerMethodField()
def get_authors(self, instance):
# book对象
authors = instance.authors.all() # 去除所有作者
temp = []
for author in authors:
temp.append(author.name)
return temp # return什么就是什么
补充
1 如果有这个错(把rest_framework在app中注册)
2 补充自己封装Response对象
# app01.utils.py:
class MyResponse():
def __init__(self):
self.status = 100
self.msg = '成功'
@property
def get_dict(self):
return self.__dict__
if __name__ == '__main__':
res = MyResponse()
res.data = {'name':'lqz'}
print(res.msg)
print(res.get_dict)
# views.py:
# 导入自己写的response类
from app01.utils import MyResponse
class BooksView(APIView):
# 查询所有
def get(self, request):
response = MyResponse()
books = Book.objects.all()
book_ser = BookSerializer(books, many=True) # 序列化多条,序列化一条不需要写many=True
response.data = book_ser.data
return Response(response.get_dict)
3 你在实际开发中碰到的问题及如何解决的
write_only_fields 不能使用了，使用extra_kwargs
class BookInfoSerializer(serializers.ModelSerializer):
"""图书数据序列化器"""
class Meta:
model = BookInfo
fields = ('id', 'btitle', 'bpub_date', 'bread', 'bcomment')
extra_kwargs = {
'price': {'write_only': True}, # 传id报错
}