序列化组件的使用
序列化器的作用:
序列化:序列化器会将模型对象转换成字典，经过response变成json格式字符串
反序列化：把客户端发来的数据，经由response对象变成字典，序列化器可以将字典转换成模型对象
反序列化，可以完成数据的校验功能
1.1 定义序列化器
Django REST framework 中的序列化器，需要 继承于rest_framework.serializer.Serializer
序列化流程如下：
1写一个继承于Serializer类的序列化类;
2在类中写要序列化的字段，想要序列化的字段，就在类中写哪个字段
3在视图类中使用，导入实例化得到序列化器
4序列化器.data 是一个字典
5把字典返回，使用rest_framework中的Response
serializer.py
class BookSerializer(serializers.Serializer):
id = serializers.CharField(read_only=True)
book_name = serializers.CharField(source='name')
book_price = serializers.DecimalField(max_digits=5, decimal_places=2, source='price')
publish = serializers.CharField()
author = serializers.CharField()
vierws.py
class Book1Detail(APIView):
def get(self,request,pk):
book_obj = BookModel.objects.filter(pk=pk).first()
if book_obj:
book_ser = BookSerializer(book_obj) # 调用类的__init__
# book_ser.data 序列化对象.data就是序列化后的字典
return Response(book_ser.data)
else:
return Response({'status':101,'msg':'无效的pk'})
class Book1View(APIView):
def get(self,request):
book = BookModel.objects.all()
book_ser = BookSerializer(book,many=True)
return Response(book_ser.data)
urls.py
path('books/<int:pk>/', views.Book1View.as_view()), # GET/PUT/DELETE 一条数据
path('books/',views.Book1Detail.as_view()), # GET/POST 或者所有的数据，或者新增加一条数据
反序列化流程如下：
使用序列化器进行反序列化的时，需要对客户端传过来的数据进行校验工作，数据校验通过后，才会操作保存模型对象，其通过book_ser.is_valid()来校验，若成功，返回True,可通过序列化器的validated_data属性来获取验证通过的数据;如果失败，则返回False,可通过序列化器的errors属性来获取错误的字段。
# 关于字段的校验:
(1)每个字段的序列化类型(Charfield)和选项参数(max_length,min_length,max_digits...)是第一道关卡
(2)钩子函数是第二道关卡，主要分为局部钩子函数，和全局钩子函数
def validated_price(self,price):
if float(price)<10:
raise ValidationError('价格不能低于10元')
return price
def validated(self,validated_data):
password = validated_data.get('password')
re_password = validated_data.get('re_password')
if not re_password == password:
raise ValidationError('两次密码输入不一致')
else:
return Validated_data
# 此外，在第一道关卡中，还有validator参数，可以使用外部函数做当前字段的校验方式
def check_author(name):
if name.startswith('sb') or name.endswith('sb'):
raise ValidationError('作者姓名中含有敏感词')
else:
return name
# 配置
author = serializers.CharField(validators=[check_author])
serializer.py
def check_name(name):
if name.startswith('sb') or name.endswith('sb'):
raise ValidationError('书籍名称中含有敏感词')
else:
return name
class BookSerializer(serializers.Serializer):
id = serializer.CharField(read_only=True)
book_name = serializer.CharField(source='name',validators=[check_name,])
book_price = serializers.DecimalField(source='price',max_digits=5,decimal_place=2)
publish = serializers.SerializerMethodField()
author = serializers.CharField(source='author.name')
def get_publish(self, instance):
# instance 就是book对象
publish_dict = {}
attr_list = ['name', 'addr', 'email', 'phone']
publish = instance.publish
for attr in attr_list:
if hasattr(publish, attr):
publish_dict[attr] = getattr(publish, attr)
return publish_dict
def create(self, validated_data): # 增加一条数据
instance = BookModel.objects.create(**validated_data)
return instance
def update(self, instance, validated_data): # 新增一条数据
for attr, value in validated_data.items():
if hasattr(instance, attr):
setattr(instance, attr, value)
instance.save()
return instance
models.py
from django.db import models
# Create your models here.
from django.db.models import CASCADE
GENDER_CHOICE = (
(0, 'male'),
(1, 'female'),
(2, 'secret'),
)
class BookModel(models.Model):
id = 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 = models.ForeignKey(to='Publish', on_delete=CASCADE)
authors = models.ManyToManyField(to='Author')
def __str__(self):
return self.name
class Meta:
verbose_name_plural = '书名表'
views.py
class Book1View(APIView):
def post(self,request):
# 新增没有instance,更新才有instance
book_ser = BookSerializer(data=request.data)
if book_ser.is_valid():
book_ser.save()
return Resposne(book_ser.data)
else:
return Response({'status':101,'msg':'数据检验未通过'})
class Book1Detail(APIView):
def put(self, request, pk):
# 修改需要instance
instance = BookModel.objects.filter(pk=pk).first()
book_ser = BookSerializer(instance=instance, data=request.data)
if book_ser.is_valid():
book_ser.save()
return Response(book_ser.data)
else:
return Response({'status': 101, 'smg': '数据校验未通过'})
def delete(self, request, pk):
book = BookModel.objects.filter(pk=pk)
if book:
book.delete()
return Response({'status': 200, 'msg': '删除成功'})
else:
return Response({'status': 101, 'msg': '无效的pk'})
1.2 序列化的字段类型
| 字段 | 字段构造方式 |
|---|---|
| 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页面时，显示的字段帮助提示信息 |
read_only 表明该字段仅用于序列化输出，默认False,如果设置成True，postman中可以看到该字段，修改时，不需要传该字段
write_only 表明该字段仅用于反序列化输入，默认False，如果设置成True，postman中看不到该字段，修改时，该字段需要传
# 以下的了解
required 表明该字段在反序列化时必须输入，默认True
default 反序列化时使用的默认值
allow_null 表明该字段是否允许传入None，默认False
validators 该字段使用的验证器
error_messages 包含错误编号与错误信息的字典
1.3 模型类序列化器ModelSerializer
class BookModelSerializer(serializers.ModelSerializer):
class Meta:
model=Book # 对应上models.py中的模型
fields='__all__'
# fields=('name','price','id','author') # 只序列化指定的字段
# exclude=('name',) #跟fields不能都写，写谁，就表示排除谁
# read_only_fields=('price',)
# write_only_fields=('id',) # 弃用了，使用extra_kwargs
extra_kwargs = { # 类似于这种形式name=serializers.CharField(max_length=16,min_length=4)
'price': {'write_only': True},
}
# 其他使用和Serializer的使用方法一模一样
# 不需要重写create和updata方法了
# 注意：write_only_fields弃用了，使用extra_kwargs
# id此时默认是read_only的，不能给id使用write_only
1.4 序列化器的高级用法
#1 source的作用及其使用
1 可以改字段名字 book_name=serializers.CharField(source='name')
2 可以.跨表publish=serializers.CharField(source='publish.email')[基于对象的跨表查询，子查询]
3 可以执行方法pub_date=serializers.CharField(source='test') test是在Book表模型中定义的方法
#2 SerializerMethodField(）的使用
1 它需要有个配套方法，方法名叫get_字段名，返回值就是要显示的东西
authors=serializers.SerializerMethodField()
def get_authors(self,instance):
# book对象
authors=instance.authors.all() # 取出所有作者
ll=[]
for author in authors:
ll.append({'name':author.name,'age':author.age})
return ll
# 注意：
- 如果在模型类序列化器中使用source和SerializerMethodField, 需要重写字段，把class Meta中的fields覆盖掉
class BookModelSerializer(ModelSerializer):
class Meta:
model = models.Book
# exclude = ('authors', )
fields = '__all__'
extra_kwargs = {
'pub_date': {'read_only': True},
# 'publish': {'source': 'publish.email'},
}
publish = serializers.CharField(source='publish.name')
authors = serializers.SerializerMethodField()
def get_authors(self, instance):
authors = instance.authors.all() # 取出所有作者
ll = []
for author in authors:
ll.append({'name': author.name, 'age': author.age})
return ll
1.5 源码分析many=True的实际用途
# 序列化多条，需要传many=True
#
book_ser=BookModelSerializer(books,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)