[Django REST framework – 序列化组件、source、钩子函数]
[Django REST framework – 序列化组件、source、钩子函数]
序列化器-Serializer
什么是rest_framework序列化？
在写前后端不分离的项目时：
我们有form组件帮我们去做数据校验
我们有模板语法，从数据库取出的queryset对象不需要人为去转格式
当我们写前后端分离项目的时：
我们需要自己去做数据校验
我们需要手动去转数据格式，因为跨平台数据传输都用json字符串，不能直接jsonqueryset对象
序列化器的作用
1 序列化：把python中的对象转成json格式字符串
序列化器会把模型对象转换成字典,经过response以后变成json字符串
2 反序列化：把json格式字符串转成python中的对象
把客户端发送过来的数据,经过request以后变成字典,序列化器可以把字典转成模型
3 注意：drf的序列化组件（序列化器）
把对象（Book，queryset对象）转成字典
因为有字典，直接丢到Response中就可以了
序列化，反序列化
-对象----》json
-json---》对象
序列化器
-定义一个类，继承Serializer
-在类内些字段（常用字段，和非常用字段）（字段参数）
-在视图类中，实例化得到一个序列化类的对象，传入要序列化的数据
-对象.data---》就是字典
-source
序列化器的基本使用
from rest_framework.serializers import Serializer,ModelSerializer
from rest_framework import serializers
Serializer是rest_framework原生的序列化组件
ModelSerializer是rest_framework在原生的序列化组件的基础上封装了一层的序列化组件
用法：1、在用我们的rest_framework序列化组件的时候，我们的视图层都必须写视图类，不能再写视图函数
2、我们需要针对每一张模型表写一个类来继承Serailizer或者ModelSerailizer类，
注：当我们在视图类里需要对数据进行序列化或者反序列化的时候，在自己定义的类传入需要序列化的数据实例化，
调用.data即可拿到序列化或者校验后的数据了
Django REST framework中的Serializer使用类来定义，须继承自rest_framework.serializers.Serializer
1 写一个序列化的类，继承Serializer
class BookSerializer(serializers.Serializer):
# 在这里写要序列化的字段
# 序列化字段类(有很多，常用的就几个，等同于models中的字段类)
# 字段类，有很多字段参数（）
name = serializers.CharField()
price = serializers.IntegerField()
# publish = serializers.CharField()
2 在类中写要序列化的字段（常用字段，和非常用字段）（字段参数）
name = serializers.CharField()
price = serializers.IntegerField()
3 在视图类中使用（实例化得到一个序列化类的对象，传入要序列化的数据）
class BookView(APIView):
def get(self, request):
book_list = models.Book.objects.all()
# instance=None, 要序列化的数据
# data=empty ,要反序列化的数据（目前data先不用）
# many=True 如果序列化多条，一定要写many=True
book_ser = BookSerializer(instance=book_list, many=True)
# book_ser.data就是序列化后的数据
return Response(book_ser.data)
4 得到序列化后的数据,返回（对象.data---》就是字典）
book_ser.data
5 字段参数，source,指定要序列化表中的哪个字段
##########具体操作步骤见下方详细操作#########
路由层 urls.py
from django.urls import path
from app import views
urlpatterns = [
path('admin/', admin.site.urls),
# 获取所有的书籍信息
path('books_new/', views.BookView.as_view()),
# 对某本书进行操作
path('books_new/<int:id>/', views.BookViewId.as_view()),
]
模型层 models.py
from django.db import models
class Book(models.Model):
name = models.CharField(max_length=32, verbose_name='书名')
publish = models.CharField(max_length=32, verbose_name='出版社')
price = models.IntegerField(verbose_name='价格')
序列化器层 serializer.py
from rest_framework import serializers
from app import models
# 新建序列化类，继承Serializer
class BookSerializer(serializers.Serializer):
# 类中定义和模型表一一对应的字段，在这里写要序列化的字段
# 序列化字段类(有很多，常用的就几个，等同于models中的字段类)
# 字段类，有很多字段参数（）
name = serializers.CharField()
price = serializers.IntegerField()
publish = serializers.CharField()
视图层 views.py
# 获取所有书籍信息
class BookView(APIView):
def get(self, request):
book_list = models.Book.objects.all()
book_ser = BookSerializer(instance=book_list, many=True)
# book_ser.data就是序列化后的数据
return Response(book_ser.data)
"""
instance=None, 要序列化的数据
data=empty ,要反序列化的数据（目前data先不用）
many=True 如果序列化多条，一定要写many=True
"""
# 对某一本书进行操作
class BookViewId(APIView):
# 对某一个进行操作需要带上id
def get(self, request, id):
book = models.Book.objects.all().filter(pk=id).first()
book_ser = BookSerializer(instance=book)
return Response(book_ser.data)
source
1 指定要序列化的字段（数据表中字段）
publish = serializers.CharField(source='publish.city') # 拿到出版社所在的城市
2 用的最多：只有一个字段（也可以跨表）
SerializerMethodField
用的最多：跨表查（(来定制返回的字段)要么是列表，要么是字典）
publish=serializers.SerializerMethodField()
def get_publish(self,obj):
print(obj)
# return {'name':'sss','city':'sss'}
return {'name':obj.publish.name,'city':obj.publish.city,'email': obj.publish.email}
在模型表中写方法
# models.py 表模型中写的
class Book(models.Model):
nid = models.AutoField(primary_key=True)
name = models.CharField(max_length=32)
price = models.DecimalField(max_digits=5, decimal_places=2)
publish_date = models.DateField()
publish = models.ForeignKey(to='Publish',to_field='nid',on_delete=models.CASCADE)
authors=models.ManyToManyField(to='Author')
def __str__(self):
return self.name
# def publish_name(self):
# return self.publish.name
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()]
# serializers.py 序列化类中
class BookSerializer(serializers.Serializer):
name = serializers.CharField()
price = serializers.IntegerField()
publish_name = serializers.DictField()
author_list = serializers.ListField()
注意：serializer不是只能为数据库模型类定义，也可以为非数据库模型类的数据定义。serializer是独立于数据库之外的存在。
序列化类常用字段类型及属性
字段参数针对性分类
# 针对charfield
max_length 最大长度
min_lenght 最小长度
allow_blank 是否允许为空
# 针对interfield
max_value 最小值
min_value 最大值
# 通用的，大家都有
# 这两个最重要
read_only 表明该字段仅用于序列化输出，默认False（序列化）
write_only 表明该字段仅用于反序列化输入，默认False（反序列化）
required 表明该字段在反序列化时必须输入，默认True
default 反序列化时使用的默认值
allow_null 表明该字段是否允许传入None，默认False
error_messages 包含错误编号与错误信息的字典
validators 该字段使用的验证器（了解）
反序列化，局部钩子，全局钩子
使用序列化器进行反序列化时，需要对数据进行验证后，才能获取验证成功的数据或保存成模型类对象。
在获取反序列化的数据前，必须调用is_valid()方法进行验证，验证成功返回True，否则返回False。
验证失败，可以通过序列化器对象的errors属性获取错误信息，返回字典，包含了字段和字段的错误。如果是非字段错误，可以通过修改REST framework配置中的NON_FIELD_ERRORS_KEY来控制错误字典中的键名。
验证成功，可以通过序列化器对象的validated_data属性获取数据。
在定义序列化器时，指明每个字段的序列化类型和选项参数，本身就是一种验证行为。
1 如果要反序列化，继承了Serializer，必须重写create方法
2 使用
# 视图类
def post(self, request):
publish_ser = serializer.PublishSerializer(data=request.data)
if publish_ser.is_valid(): # 校验数据
# 直接保存，保存到哪个表里？需要重写save
publish_ser.save()
return Response(publish_ser.data)
else:
print(publish_ser.errors)
return Response('数据有问题啊')
# 序列化类
def create(self, validated_data):
# 校验过后的数据
res = models.Publish.objects.create(**validated_data)
return res
"""
父类的save内部调用了create，所以我们重写create
return res 给了self.instance以后，instance就有值了
publish_ser.data，instance就有值调用data就能拿到序列化后的数据
is_valid()方法还可以在验证失败时抛出异常serializers.ValidationError，可以通过传递raise_exception=True参数开启，
REST framework接收到此异常，会向前端返回HTTP 400 Bad Request响应。
"""
局部和全局钩子
# validate_字段名
def validate_name(self, data):
# data就是当前字段的值
if data.startswith('sb'):
raise ValidationError('不能以sb开头')
else:
return data
# 在序列化器中需要同时对多个字段进行比较验证时，可以定义validate方法来验证
def validate(self, attrs):
if attrs.get('name') == attrs.get('city'):
raise ValidationError('city和名字不能一样')
else:
return attrs
模型类序列化器
如果我们想要使用序列化器对应的是Django的模型类，DRF为我们提供了ModelSerializer模型类序列化器来帮助我们快速创建一个Serializer类
ModelSerializer与常规的Serializer相同，但提供了：
- 基于模型类自动生成一系列字段
- 基于模型类自动为Serializer生成validators，比如unique_together
- 包含默认的create()和update()的实现
视图类 views.py
class BookView(APIView):
def get(self,request):
qs=models.Book.objects.all()
ser=serializer.BookModelSerializer(instance=qs,many=True)
return Response(ser.data)
def post(self,request):
ser = serializer.BookModelSerializer(data=request.data)
if ser.is_valid():
ser.save()
return Response(ser.data)
else:
return Response(ser.errors)
class BookDetailView(APIView):
def get(self,request,id):
book = models.Book.objects.filter(pk=id).first()
ser = serializer.BookModelSerializer(instance=book)
return Response(ser.data)
def put(self,request,id):
book = models.Book.objects.filter(pk=id).first()
ser = serializer.BookModelSerializer(instance=book,data=request.data)
if ser.is_valid():
ser.save()
return Response(ser.data)
else:
return Response(ser.errors)
def delete(self,request,id):
res = models.Book.objects.filter(pk=id).delete()
if res[0] > 0:
return Response('')
else:
return Response('要删的不存在')
序列化类 serializers.py
"""
ModelSerializer
使用步骤：
1、新建序列化类，继承ModelSerializer
2、类中定义和模型表一一对应的字段，这里可以定义class Meta() 然后指定模型表model和 映射字段fields，比Serializer更简洁
-其中类中的名字可以改变，需要在serializers.CharField()的括号中指定source=某个字段，建议映射关系
-外键关系的字段可以用serializers.SerializerMethodField()，需要在下方固定写 get_字段名 的方法，
这里可以写具体逻辑，最终返回结果就是该字段的结果
3、当新增数据的时候不需要重写父类的create方法，这里ModelSerializer做了封装
4、当修改数据的时候不需要重写父类的update方法，这里ModelSerializer做了封装
5、当完成这些配置后就可以在视图类中实例化调用了，序列化的时候序列化，反序列化的时候校验
"""
from rest_framework import serializers
from app import models
class BookModelSerializer(serializers.ModelSerializer):
class Meta:
model = models.Book # model 指明参照哪个模型类
fields = '__all__' # fields 指明为模型类的哪些字段生成，__all__表名包含所有字段
# 给字段类加属性
extra_kwargs = {
'publish': {'required': True, 'write_only': True},
'authors': {'required': True, 'write_only': True},
}
publish_detail = PublishSerializer(source='publish',read_only=True)
author_list=serializers.ListField(read_only=True)
# 字段自己的校验，全局钩子，局部钩子
"""
使用fields来明确字段，__all__表名包含所有字段，也可以写明具体哪些字段，如
使用exclude可以明确排除掉哪些字段
使用extra_kwargs参数为ModelSerializer添加或修改原有的选项参数
"""
表模型 models.py
这是完整的模型表，上面的视图和序列化类只展示了部分表的增删改查演示
from django.db import models
class Book(models.Model):
nid = models.AutoField(primary_key=True)
name = models.CharField(max_length=32, verbose_name='书名')
price = models.DecimalField(max_digits=5, decimal_places=2, verbose_name='价格')
publish_date = models.DateField(verbose_name='出版时间')
publish = models.ForeignKey(to='Publish',to_field='nid',on_delete=models.CASCADE)
authors=models.ManyToManyField(to='Author')
class Meta:
verbose_name_plural = '书籍表'
def __str__(self):
return self.name
# 表模型写方法，展示更多字段
# def publish_name(self):
# return self.publish.name
# 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()]
class Author(models.Model):
nid = models.AutoField(primary_key=True)
name = models.CharField(max_length=32, verbose_name='名字')
age = models.IntegerField(verbose_name='年龄')
author_detail = models.OneToOneField(to='AuthorDetail',to_field='nid',unique=True,on_delete=models.CASCADE)class Meta:
verbose_name_plural = '作者表'
def __str__(self):
return self.name
class AuthorDetail(models.Model):
nid = models.AutoField(primary_key=True)
telephone = models.BigIntegerField(verbose_name='电话')
birthday = models.DateField(verbose_name='生日')
addr = models.CharField(max_length=64, verbose_name='地址')
class Meta:
verbose_name_plural = '作者详情表'
class Publish(models.Model):
nid = models.AutoField(primary_key=True)
name = models.CharField(max_length=32, verbose_name='社名')
city = models.CharField(max_length=32, verbose_name='地址')
email = models.EmailField(verbose_name='邮箱')
class Meta:
verbose_name_plural = '出版社表'
def __str__(self):
return self.name
路由urls.py
urlpatterns = [
path('books/',views.BookView.as_view()),
path('books/<int:id>/',views.BookDetailView.as_view()),
]
序列化高级用法
ModelSerializer用的基本就是下面这个方法
class BookModelSerializer(serializers.ModelSerializer):
class Meta:
model = models.Book
fields = "__all__"
"""
如果想让字段更丰富些,可以采用任意一种方法实现（方法有很多种）
第一种方法：source
publish = serializers.CharField(source='publish.city')
第二种方法：SerializerMethodField
publish=serializers.SerializerMethodField()
def get_publish(self,obj):
return {'name':obj.publish.name,'city':obj.publish.city,'email': obj.publish.email}
第三种方法：在表模型写方法
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 = Publishserializer()
"""
