Serializer序列化与ModelSerializer序列化
序列化类高级用法之cource，修改序列化字段名字
- 用法一
使用cource的时候，字段参数可以指定序列化哪个参数，如果指定别人的字段那么就会渲染自己的不渲染别人的
1.class BookSerializer(serializers.Serializer):
name = serializers.CharField(max_length=8, min_length=3)
name_detail = serializers.CharField(max_length=8, min_length=3, source='name')
- 用法二
使用cource的时候，我们也可以重命名前方的用字，最后渲染的时候就会变成后方的名字
name = serializers.CharField(max_length=8, min_length=3, source='name_detail')
- 用法三
使用cource的时候，我们也进行连表查询指定另外一个表的字段
publish_name = serializers.CharField(max_length=15, min_length=8, source='author.name')
序列化类高级用法之定制序列化字典的两种方式
- 序列化对象
1.postman中显示:
{
"name": "日不落",
"price": "151",
"publish": "{'name':'东方出版社', 'city':'北京','email':'[email protected]'}"
}
2.在序列化类中写SerializerMethodField
publish = serializers.SerializerMethodField()
def get_publish(self, obj):
# obj 是当前序列化的对象
return {'name': obj.publish.name, 'city': obj.publish.city, 'email': obj.publish.email}
3.在表模型中显示
def publish_detail(self):
return {'name': self.publish.name, 'city': self.publish.city, 'email': self.publish.email}
在序列化中取
publish_detail=serializers.DictField()
4.领域驱动模型(DDD)
领域驱动模型一种设计思想，我们又称为DDD设计思想。是一种为了解决传统设计思想带来的维护困难，沟通困难和交互困难而产生的一种新的思想。也解决了在部分公司中，一个项目组就是一套服务，不同项目组中又相互通过RPC访问，相互之间交互的安全保障。
5.领域驱动模型作用
在传统微服务的单服务设计上，我们通常只顾自己开发，只顾自己业务，只管理自己数据库，一旦其他服务需要使用另一个服务上的某些功能时，我们通常需要使用HTTP来内网访问达到目的，或是使用RPC来访问业务。首先假设我们需要用HTTP来访问其他服务接口，首先，我们需要知道对应服务的URL，其次需要开发方提供对应的参数VO，一旦VO变化，开发方忘记通知下游业务方，下游业务方是无法感知的。接下来会讲解模型中每一层概念，会一步步证明领域驱动模型的出现，降低了微服务下，服务之间的耦合程度，提高了内聚力。
- 类方法中序列化，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:[email protected]}
# 方式一：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
- 缺点：使用继承Serializer的序列化类保存需要重写create方法
1.在序列化中的没一个字段都需要写入，无论是序列化还是反序列化
2.如果是新增或者修改都需要重写create或update方法才可以保存数据，非常不方便，所以我们有了ModelSerializer来解决重写方法，这个里面就带有了兼容性很强的create和update方法。
反序列化之数据校验
1.与forms相似经过三层校验
1.1字段自己的校验规则
1.2局部钩子校验
1.3全局钩子校验
2.字段校验规则
extra_kwargs = { # 渲染错误信息和条件
'name': {
'max_length': 8,
'min_length': 3,
'error_messages': {
'max_length': '书名最多不超过八个字符',
'min_length': '书名最小不少于三个字符'
}
},
'price': {
'max_value': 199,
'min_value': 9,
'error_message': {
'max_value': '价格最高不得超过199元',
'min_value': '价格最低不得超过9元',
}
}
}
3.局部钩子
如果我么继承的是Serializer或ModelSerializer方法一致
def validate_name(self, name):
if 'sb' in name:
raise ValidationError('书名内不不能有sb字样')
else:
return name
4.全局钩子
如果我么继承的是Serializer或ModelSerializer方法一致
def validate(self, attrs):
if attrs.get('name') == attrs.get('publish'):
raise ValidationError('名字不能等于出版社')
else:
return attrs
模型类序列化器(ModelSerializer)的使用
class BookModelSerializer(serializers.ModelSerializer):
#ModelSerializer也是继承了serializer
# 我们不需要重复写字段直接在meta这个类中用model直接映射过来就可以直接使用该模型
class Meta:
model = Book # 直接印涉即可
fields = ['name', 'price', 'publish', 'publish_date', 'authors', 'publish_detail', 'author_list'] # 不需要直接全部导入，只需要将列表中有什么就导入什么即可
fields = '__all__' # 直接将所有的字段都序列化导入
extra_kwargs = { # 渲染错误信息和条件
'name': {
'max_length': 8,
'min_length': 3,
'error_messages': {
'max_length': '书名最多不超过八个字符',
'min_length': '书名最小不少于三个字符'
}
},
'price': {
'max_value': 199,
'min_value': 9,
'error_message': {
'max_value': '价格最高不得超过199元',
'min_value': '价格最低不得超过9元',
}
}
}
# 局部钩子
def validate_name(self, name):
if 'sb' in name:
raise ValidationError('书名内不不能有sb字样')
else:
return name
# 给author_list和publish_detail增加write_only只写属性，只有在写入的时候才会被显示
publish_detail = serializers.SerializerMethodField(read_only=True)
...
author_list = serializers.SerializerMethodField(read_only=True)
...
反序列化数据校验源码分析
# 我们在校验的时候经常会有一个误区就是ctrl+右键直接颠倒父类去寻找方法，这种方法经常会误导我们，我们应该谨记先寻找自己的，如果找不到就在局部寻找，局部没有再去父类中寻找
# 先校验字段自己的规则(最大，最小)，走局部钩子校验，走全局钩子
# 局部：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
断言assert
1.断言的应用:断言在源码中经常使用，直接断定你这个是否属于这个类型或者符合某些条件，如果不符合那么直接抛异常
2.关键字:assert
3.我们现阶段的书写
name = 'joseph'
if not name == 'joseph':
raise Exception('name不等于joseph')
else:
print('校验完成')
4.assert大佬写法
name = 'joseph'
assert name == 'jason', 'name不等于jason'
return HttpResponse('校验完成')
练习
ModelSerializer(接口)
class BookModelSerializer(serializers.ModelSerializer):
class Meta:
model = Book
fields = ['name', 'price', 'publish']
extra_kwargs = {
'name': {
'max_length': 8,
'min_length': 3,
'error_messages': {
'max_length': '书名最多不超过八个字符',
'min_length': '书名最小不少于三个字符'
}
},
'price': {
'max_value': 199,
'min_value': 9,
'error_message': {
'max_value': '价格最高不得超过199元',
'min_value': '价格最低不得超过9元',
}
}
}
def validate_name(self, name):
if 'sb' in name:
raise ValidationError('书名内不不能有sb字样')
else:
return name
class BookView(APIView):
def get(self, request):
book_list = Book.objects.all()
ser = BookModelSerializer(instance=book_list, many=True)
return Response(ser.data)
def post(self, request):
name = request.POST.get('name')
price = request.POST.get('price')
publish = request.POST.get('publish')
res = Book.objects.create(name=name, price=price, publish=publish)
return JsonResponse({'name': res.name, 'price':res.price, 'publish':res.publish})
class BookDetailView(APIView):
def get(self, request, pk):
book = Book.objects.filter(pk=pk).first()
ser = BookModelSerializer(instance=book)
return Response(ser.data)
def post(self, request, pk):
book = Book.objects.filter(pk=pk).first()
ser = BookModelSerializer(instance=book)
if ser.is_valid():
ser.save()
return Response(ser.data)
else:
Response(ser.errors)
def put(self, request, pk):
name = request.POST.get('name')
price = request.POST.get('price')
publish = request.POST.get('publish')
book = Book.objects.filter(pk=pk).first()
book.name = name
book.price = price
book.publish = publish
book.save()
return JsonResponse({'name': book.name, 'price': book.price, 'publish': book.publish})
def delete(self, request, pk):
Book.objects.filter(pk=pk).delete()
return redirect('/books/')