今日内容 序列化类的高级用法
-
序列化类常用字段类和字段参数
常用字段类型：
| 字段 | 字段构造方式 |
|---|---|
| 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中看不到该字段，修改时，该字段需要传
-
序列化类高级用法之source，修改序列化字段名字
# source的使用
不使用source参数时，会默认 序列化表名.字段名
使用source参数时，序列化表名.source的参数 下方以Book表为例
class BookSerializer(serializers.Serializer):
name_detail = serializers.CharField(max_length=8, min_length=3,source='name') # 可以改字段名字
# 或
publish_name = serializers.CharField(max_length=8, min_length=3,source='publish.name') # 可以.跨表查
# 或
xx = serializers.CharField(max_length=8, min_length=3,source='xx') # 可以执行方法
-
序列化类高级用法之定制序列化字段的两种方式
# 前端显示形式
{
"name": "西游记",
"price": 33,
"publish": {name:xx,city:xxx,email:sss}
}
# 第一种：在【序列化类】中写SerializerMethodField
publish = serializers.SerializerMethodField()
def get_publish(self, obj):
# obj 是当前序列化的对象
return {'name': obj.publish.name, 'city': obj.publish.city, 'email': obj.publish.email}
# 第二种：在【表模型】中写方法（又多一些）
def publish_detail(self):
return {'name': self.publish.name, 'city': self.publish.city, 'email': self.publish.email}
在序列化中取
publish_detail=serializers.DictField()
方式一：使用SerializerMethodField
class BookSerializer(serializers.Serializer):
name = serializers.CharField(max_length=8, min_length=3)
price = serializers.IntegerField(min_value=10, max_value=99)
publish_date = serializers.DateField()
# publish要序列化成 {name:北京出版社，city：北京，email:2@qq.com}
# 方式一：SerializerMethodField必须配合一个方法(get_字段名,需要接受一个参数)，方法返回什么，这个字段就是什么
publish = serializers.SerializerMethodField()
def get_publish(self, obj):
# obj 是当前序列化的对象
return {'name': obj.publish.name, 'city': obj.publish.city, 'email': obj.publish.email}
# 练习，用方式一，显示所有作者对象 []
authors = serializers.SerializerMethodField()
def get_authors(self, obj):
res_list = []
for author in obj.authors.all():
res_list.append({'id': author.id, 'name': author.name, 'age': author.age})
return res_list
方式二：在表模型中写
# 表模型中
class Book(models.Model):
name = models.CharField(max_length=32)
price = models.DecimalField(max_digits=5, decimal_places=2)
publish_date = models.DateField(null=True)
publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
authors = models.ManyToManyField(to='Author')
# 写了个方法，可以包装成数据属性，也可以不包
def publish_detail(self):
return {'name': self.publish.name, 'city': self.publish.city, 'email': self.publish.email}
def author_list(self):
res_list = []
for author in self.authors.all():
res_list.append({'id': author.id, 'name': author.name, 'age': author.age})
return res_list
有关联关系表的反序列化的保存
# 1 序列化字段和反序列化字段不一样 【序列化类中】
# 反序列化用的
publish = serializers.CharField(write_only=True)
authors = serializers.ListField(write_only=True)
#序列化用的
publish_detail = serializers.DictField(read_only=True)
author_list = serializers.ListField(read_only=True)
# 2 一定要重写create 【序列化类中】
def create(self, validated_data):
# validated_data 校验过后的数据
{"name":"三国1演义",
"price":19,
"publish_date": "2022-09-27",
"publish":1,
"authors":[1,2]
}
book = Book.objects.create(name=validated_data.get('name'),
price=validated_data.get('price'),
publish_date=validated_data.get('publish_date'),
publish_id=validated_data.get('publish'),
)
authors = validated_data.get('authors')
book.authors.add(*authors)
return book
-
反序列化之数据校验
# 跟forms很像
-字段自己的校验规则
-局部钩子
-全局钩子
# 字段自己的校验规则
-如果继承的是Serializer，写法如下
name=serializers.CharField(max_length=8,min_length=3,error_messages={'min_length': "太短了"})
-如果继承的是ModelSerializer，写法如下
extra_kwargs = {
'name': {'max_length': 8, 'min_length': 3, 'error_messages': {'min_length': "太短了"}},
}
# 局部钩子
-如果继承的是Serializer，写法一样
-如果继承的是ModelSerializer，写法一样
def validate_name(self, name):
if name.startswith('sb'):
# 校验不通过，抛异常
raise ValidationError('不能以sb卡头')
else:
return name
# 全局钩子
-如果继承的是Serializer，写法一样
-如果继承的是ModelSerializer，写法一样
def validate(self, attrs):
if attrs.get('name') == attrs.get('publish_date'):
raise ValidationError('名字不能等于日期')
else:
return attrs
-
模型类序列化器(ModelSerializer)的使用
class BookModelSerializer(serializers.ModelSerializer): #ModelSerializer继承Serializer
# 不需要写字段了，字段从表模型映射过来
class Meta:
model = Book # 要序列化的表模型
# fields='__all__' # 所有字段都序列化
fields = ['name', 'price', 'publish_date', 'publish', 'authors', 'publish_detail',
'author_list'] # 列表中有什么，就是序列化哪个字段
# 给authors和publish加write_only属性
# name加max_len属性
extra_kwargs = {
'name': {'max_length': 8},
'publish': {'write_only': True},
'authors': {'write_only': True},
}
总结
# 如何使用
1 定义一个类继承ModelSerializer
2 类内部写内部内 class Meta:
3 在内部类中指定model(要序列化的表)
4 在内部类中指定fields(要序列化的字段，写__all__表示所有，不包含方法，写[一个个字段])
5 在内部类中指定extra_kwargs，给字段添加字段参数的
6 在序列化类中，可以重写某个字段，优先使用你重写的
name = serializers.SerializerMethodField()
def get_name(self, obj):
return 'sb---' + obj.name
7 以后不需要重写create和update了
-ModelSerializer写好了，兼容性更好，任意表都可以直接存
-
反序列化数据校验源码分析(了解)
点击查看
# 先校验字段自己的规则(最大，最小)，走局部钩子校验，走全局钩子
# 局部：validate_name，全局叫：validate 为什么？
# 入口：从哪开始看，哪个操作，执行了字段校验ser.is_valid()
-BaseSerializer内的is_valid()方法
def is_valid(self, *, raise_exception=False):
if not hasattr(self, '_validated_data'):
try:
# 真正的走校验，如果成功，返回校验过后的数据
self._validated_data = self.run_validation(self.initial_data)
except ValidationError as exc:
return not bool(self._errors)
"""内部执行了：self.run_validation(self.initial_data)---》本质执行的Serializer的
如果你按住ctrl键，鼠标点击，会从当前类中找run_validation，找不到会去父类找
这不是代码的执行，代码执行要从头开始找，从自己身上再往上找 """
def run_validation(self, data=empty):
#局部钩子的执行
value = self.to_internal_value(data)
try:
# 全局钩子的执行，从根上开始找着执行，优先执行自己定义的序列化类中得全局钩子
value = self.validate(value)
except (ValidationError, DjangoValidationError) as exc:
raise ValidationError(detail=as_serializer_error(exc))
return value
# 全局钩子看完了，局部钩子---》 self.to_internal_value---》从根上找----》本质执行的Serializer的
def to_internal_value(self, data):
for field in fields: # fields：序列化类中所有的字段，for循环每次取一个字段对象
# 反射：去self：序列化类的对象中，反射 validate_字段名 的方法
validate_method = getattr(self, 'validate_' + field.field_name, None)
try:
# 这句话是字段自己的校验规则（最大最小长度）
validated_value = field.run_validation(primitive_value)
# 局部钩子
if validate_method is not None:
validated_value = validate_method(validated_value)
except ValidationError as exc:
errors[field.field_name] = exc.detail
return ret
# 你自己写的序列化类---》继承了ModelSerializer---》继承了Serializer---》BaseSerializer---》Field
图书的5个接口(增删改查)
models.py
from django.db import models
class Book(models.Model):
name = models.CharField(max_length=32)
price = models.DecimalField(max_digits=5, decimal_places=2)
publish_date = models.DateField(null=True)
publish = models.ForeignKey(to='Publish',on_delete=models.CASCADE)
authors = models.ManyToManyField(to='Author')
def __str__(self):
return self.name
def publish_detail(self):
return {'name': self.publish.name, 'city': self.publish.city, 'emial': self.publish.email}
def author_list(self):
res_list = []
for author in self.authors.all():
res_list.append({'id': author.id, 'name': author.name,'age': author.age})
return res_list
class Author(models.Model):
name = models.CharField(max_length=32)
age = models.IntegerField()
author_detail = models.OneToOneField(to='AuthorDetail', on_delete=models.CASCADE)
def __str__(self):
return self.name
class AuthorDetail(models.Model):
telephone = models.BigIntegerField()
birthday = models.DateField()
address = models.CharField(max_length=64)
class Publish(models.Model):
name = models.CharField(max_length=32)
city = models.CharField(max_length=32)
email = models.EmailField()
ser.py
class BookModelSerializer(serializers.ModelSerializer):
class Meta:
model = Book
fields = ['name','price','publish', 'author', 'publish_date', 'publish_detail',
'author_list']
extra_kwargs = {
'name': {'max_length': 8, 'min_length': 3},
'price': {'max_value': 199, 'min_value': 9},
'publish': {'write_only': True},
'authors': {'write_only': True}
}
def validate_name(self,name):
if 'sb' in name:
raise ValidationError('名字不能有sb')
else:
return name
def validate_price(self,price):
if price == 66:
raise ValidationError('价格不能是66')
else:
return price
views.py
class BookView(APIView):
# 获取所有
def get(self, request):
book_list = models.Book.objects.all()
res = BookModelSerializer(instance=book_list, many=True)
return Response(res.data)
# 新增
def post(self, request):
res = BookModelSerializer(data=request.data)
if res.is_valid():
res.save()
return Response({'code': 100, 'msg': '新增成功'})
else:
return Response({'code': 1000, 'msg': res.errors})
class BookDetailView(APIView):
# 获取单个
def get(self, request,pk):
book = models.Book.objects.filter(pk=pk).first()
res = BookModelSerializer(instance=book)
return Response(res.data)
# 删除
def delete(self,request,pk):
models.Book.objects.filter(pk=pk).delete()
return Response()
# 修改
def put(self,request,pk):
book = models.Book.objects.filter(pk=pk).first()
res = BookModelSerializer(instance=book, data=request.data)
if res.is_valid():
res.save()
return Response({'code': 100, 'msg':'修改成功'})
else:
return Response({'code': 1000, 'msg': res.errors})
浙公网安备 33010602011771号