drf从入门到精通---day04（序列化类常用字段和字段参数,source用法,定制字段的两种方式,多表关联反序列化保存,反序列化字段的校验规则,ModelSerializer使用,校验展示信息改英文变中文）
昨日回顾
# 1 APIView---->drf 提供的，继承了原来的View，以后如果写视图类，都继承APIView及其子类
# 2 APIView执行流程
-1 去除了csrf认证
-2 包装了新的Request对象---》视图类中使用的request都是drf的Request
-原来的哪？
-用起来跟之前一样---》__getattr__ -----》学过的魔法方法
-request.data ---->put,post..请求体中携带的数据，无论什么编码，都是字典
-request.query_params--->老的request.GET
-request.FILES --->跟之前一样，重写了文件类
-3 执行了三大认证(认证，权限，频率)---》在执行视图类的方法之前执行的
-4 三大认证的代码，视图类方法的代码，如果出了异常，会有异常捕获----》后期会做统一处理
# 3 Request源码分析
-----------------------------------------
# 4 序列化类---》APIView+序列化类+Response----》5个接口
-序列化类的作用：做序列化，反序列化，反序列化校验
-序列化过程：
-写一个序列化类，继承Serializer，写一个个要序列化和反序列化的字段
-视图类中：导入，实例化得到对象，对查出来的queryset或单个对象序列化，
传入instance参数，如果是qs，一定要传many=True
ser = BookSerializer(instance=books_queryset, many=True) 实际上
序列化类序列化对象的时候，如果是单个对象，就是用要序列化的对象去点写在序列化类里面的
字段名，将拿到的结果组织成字典的形式返回出去
同理是queryset对象，将queryset里面的每一个对象去点写在序列化类里面的字段名，
将每一个对象的结果组织成字典，最后用列表将所有字典包起来！！返回出去
简单点说就是，BookSerializer序列化类只是将传给它的对象转成字典或列表，
ser.data干的就是这件事，但还没有结束了，还要将字典或列表给Resonse转json格式字符串，整个序列化才结束！
-序列化类对象的方法 ser.data(将对象模型表对象或queryset对象转字典或列表)------
给Resonse---转json格式字符给前端
-序列化单条和序列化多条，路由不一样，写成了两个视图类，分别用一个get方法
-----------------------------------------------
-反序列化过程：新增，修改
-新增：
-前端传入的无论什么编码格式，都在request.data中，都是字典
-request.data：
但是如果是-urlencoded，form-data编码格式---》QueryDict字典
如果是 json编码格式-----》dict就是普通的字典
两种字典用都是正常用，
-拿到前端传入的数据，进行反序列化---》序列化类的反序列化，完成
-序列化类得到对象，传入参数， data=request.data
-校验数据ser.isvalid
-保存：ser.save() --->序列化类中重写create方法
简单点说ser = BookSerializer(data=request.data)
前端字符串到后端被APIview的处理通过request.data已经拿到了放在请求体里面的字典形式的
数据！ 序列化类将传进来的数据校验后，放到了validated_data字典里面去了，
最后再将该字典打散用ORM语句将数据转成了模型类对象，存到数据库里面去了！！！
------------------------------------------------
-修改：
-查出要修改的对象
-拿到前端传入的数据，与要修改的对象，进行反序列化---》通过序列化类完成反序列化
-序列化类得到对象，传入参数， instance=要修改的对象,data=request.data
-校验数据 ser.isvalid
-保存：ser.save() --->序列化类中重写update方法
-------------------------------------------------
# 4 反序列化的校验
-只要在序列化类中写局部和全局钩子
-局部钩子
def validate_字段名(self,validated_value):
# 这个validated_value行参接收的是前端传进来的数据中,字段名对应的值
# 比如局部钩子函数的函数名validate_name，那么接收的就是name字段对应的值
校验通过，返回validated_value，
如果不通过，抛出异常
-全局钩子
def validate(self,attrs):
# attr是 前端传入的数据，走完局部钩子校验后的数据是个字典！
校验通过，返回attrs
如果不通过，抛出异常
.
.
.
.
作业
# 原生的djagno的request中没有data
import json
# 通过装饰器做,装饰器视图函数的，以后都会有request
def wrapper(func):
def inner(request, *args, **kwargs):
# 造个新的requeset
# 如果是 urlencoded,form-data ----》request.POST 就有值
# 如果request.POST 没有值，就是json格式编码
try:
print(request.body)
request.data = json.loads(request.body) # 表示是json格式编码
except Exception as e:
request.data = request.POST
res = func(request, *args, **kwargs)
return res
return inner
--------------------------------------
@wrapper # test=wrapper(func)------>以后执行test()本质是---》wrapper(func)(request)---》本质是inner(request)
def test(request):
print(request.POST) # urlencoded,form-data----->都转成QueryDict
print(request.data) # 报错了
return HttpResponse('ok')
----------------------------------------
# 总结：前端提交数据的编码格式
-urlencoded： 以name=lqz&age=19&price=999形式 放在了请求体中
-formdata: 分数据部分和文件部分，放在了请求体中
'----------------------------585520151165741599946333\r\n
Content-Disposition: form-data;
name="name"\r\n\r\nlqz\r\n
----------------------------585520151165741599946333--\r\n'
-json格式： 原封不动json格式{"name":"lqz","age":19} 放在了请求体中
.
.
.
.
今日内容
1 序列化类常用字段和字段参数（了解）
# 序列化类---》字段类 CharField，除此之外还有哪些其他的
# 序列化类---的字段类上，是可以传属性的【models.CharField(max_length=32)】
.
1.1 常用字段类
#1 BooleanField BooleanField()
#2 NullBooleanField NullBooleanField()
#3 CharField CharField(max_length=None, min_length=None, allow_blank=False, trim_whitespace=True)
#4 EmailField EmailField(max_length=None, min_length=None, allow_blank=False)
#5 RegexField RegexField(regex, max_length=None, min_length=None, allow_blank=False)
#6 SlugField SlugField(max_length=50, min_length=None, allow_blank=False) 正则字段，验证正则模式 [a-zA-Z0-9-]+
#7 URLField URLField(max_length=200, min_length=None, allow_blank=False)
#8 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"
#9 IPAddressField IPAddressField(protocol=’both’, unpack_ipv4=False, **options)
#10 IntegerField IntegerField(max_value=None, min_value=None)
#11 FloatField FloatField(max_value=None, min_value=None)
#12 DecimalField DecimalField(max_digits, decimal_places, coerce_to_string=None, max_value=None, min_value=None) max_digits: 最多位数 decimal_palces: 小数点位置
#13 DateTimeField DateTimeField(format=api_settings.DATETIME_FORMAT, input_formats=None)
#14 DateField DateField(format=api_settings.DATE_FORMAT, input_formats=None)
#15 TimeField TimeField(format=api_settings.TIME_FORMAT, input_formats=None)
#16 DurationField DurationField()
#17 ChoiceField ChoiceField(choices) choices与Django的用法相同
#18 MultipleChoiceField MultipleChoiceField(choices)
#19 FileField FileField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)
#20 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=)
#记住的：CharField IntegerField DecimalField DateTimeField BooleanField
ListField
DictField
.
.
.
.
1.2 常用字段参数
选项参数：
# 参数的主要作用：主要就是做反序列化校验的,字段自己的规则！！！
# CharField及其子类(比如EmailField等)
max_length 最大长度
min_lenght 最小长度
allow_blank 是否允许为空
trim_whitespace 是否截断空白字符
---------------------------------
# IntegerField
max_value 最小值
min_value 最大值
---------------------------------
# 所有字段类都有的
required 表明该字段在反序列化时必须输入，默认True
default 反序列化时使用的默认值
allow_null 表明该字段是否允许传入None，默认False
validators 该字段使用的验证器
----看一眼忘掉-----
error_messages 包含错误编号与错误信息的字典
label 用于HTML展示API页面时，显示的字段名称
help_text 用于HTML展示API页面时，显示的字段帮助提示信息
---------------------------------
# 重点：
read_only 表明该字段仅用于序列化输出，默认False
write_only 表明该字段仅用于反序列化输入，默认False
--------------------------------------------
## 总结：反序列化校验执行流程
-1 先执行字段自己的校验规则----》最大长度,最小长度,是否为空,是否必填...
-2 validators=[方法，] ----》单独给这个字段加校验规则
例如这样的 name=serializers.CharField(validators=[方法,])
-3 局部钩子校验规则
-4 全局钩子校验规则
.
.
.
2 序列化高级用法之source(了解)
# 创建关联表
class Book(models.Model):
name = models.CharField(max_length=32)
price = models.CharField(max_length=32)
publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
authors = models.ManyToManyField(to='Author')
class Publish(models.Model):
name = models.CharField(max_length=32)
addr = models.CharField(max_length=32)
class Author(models.Model):
name = models.CharField(max_length=32)
phone = models.CharField(max_length=11)
# 迁移，录入数据
.
.
.
2.1 序列化 定制字段名字的显示形式
# 重点：source可以指定序列化字段的名字
自有字段，直接写字段名字
name_real = serializers.CharField(max_length=8, source='name')
关联字段，一对多的关联，直接点外键字段再继续点关联表里面的字段名
publish = serializers.CharField(source='publish.name')
-多对多，搞不了,source不能用
-authors=serializers.CharField() # 前端返回的结果是app01.Author.None
-authors=serializers.CharField(source='authors.all')
前端返回的结果是一个queryset列表，里面是对应的一个个作者对象
----------------------------------------------
# 序列化类
class BookSerializer(serializers.Serializer):
# 自有字段，直接写字段名字
# 也可以通过source指定哪个字段
name_real = serializers.CharField(max_length=8, source='name')
real_price = serializers.CharField(source='price')
# 关联字段，一对多的关联
# 因为序列化的是book对象，所以'publish.name'实际上就是
# 'book.publish.name'就变成了出版社对象的字段名了
publish = serializers.CharField(source='publish.name')
#多对多，搞不了,source不能用
authors=serializers.CharField()
source的用法是不改变序列化的情况下，定制字段的名字，也就是给在前端展示的字段名换了个别名，本质还是原来的字段名！！
source必须等于Book对象里面的字段名，不然就报错！！！而且起的别名不能和source等于的字段名起一样的，不然也报错！！
.
.
.
.
.
.
.
.
.
3 序列化高级用法之 定制字段的两种方式
3.1 SerializerMethodField定制
# 定制关联字段的值 的显示形式
-一对多的，显示字典
-多对多，显示列表套字典
-----------------------------------------
-----------------------------------------
序列化类里面写的这些字段，作用就是，当序列化对象点is_valid()方法的时候，
先执行字段校验，再执行钩子函数，走完这些后，当序列化对象再点data时候，
又会通过对应的模型表对象去点字段名，然后组织成字典返回出去
如果模型表对象点的字段不在表里面，如果是定制返回格式一这种样子
就会自动去执行下面的函数，然后将返回结果作为值，字段名作为键，组织成字典返回出去
换句话说，写一个模型表里面不存在的字段名，并且用方式一这种形式，
那么函数对应的返回值是什么，返回给前端的字典里面，该不不存在的字段名键对应的值就是什么
-----------------------------------------
-----------------------------------------
# 代码
class BookSerializer(serializers.Serializer):
name = serializers.CharField(max_length=8)
price = serializers.CharField()
# 定制返回格式---》方式一
publish_detail = serializers.SerializerMethodField()
def get_publish_detail(self, obj):
return {'name': obj.publish.name, 'addr': obj.publish.addr}
author_list = serializers.SerializerMethodField()
def get_author_list(self, obj):
l = []
for author in obj.authors.all():
l.append({'name': author.name, 'phone': author.phone})
return l
# 注意SerializerMethodField这个方法一定要配合下面的get_字段名的函数一起使用
# 对于不是序列化的表里面的字段名，我们可以改的，但是一改，下面对应的get_字段名的函数,函数名也要一起改！！！
.
return 返回啥，对应展示到前端的就是字段名对应啥，所以如果想让字段名对应的是字典或者列表，那么return 返回的就也要是字典或者列表
.
.
.
.
.
.
.
.
.
.
3.2 在表模型中定制
#### 表模型
class Book(models.Model):
name = models.CharField(max_length=32)
price = models.CharField(max_length=32)
publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
authors = models.ManyToManyField(to='Author')
@property
def publish_detail(self):
return {'name': self.publish.name, 'addr': self.publish.addr}
# 可以加可以不加@property，都会在对象点函数名的时候让类里面的函数正常运行
# 我们知道@property是将函数名伪装成属性，这样对象点该函数名是会自动将函数名加括号调用该函数
# 不加@property，对象点函数名的时候也会让函数运行，底层怎么实现的暂时不知道
@property
def author_list(self):
l = []
for author in self.authors.all():
l.append({'name': author.name, 'phone': author.phone})
return l
# 序列化类
class BookSerializer(serializers.Serializer):
name = serializers.CharField(max_length=8)
price = serializers.CharField()
# publish_detail = serializers.CharField()
这样写被伪装的函数返回值字典会被转成字符串，所以不能这么写
publish_detail = serializers.DictField()
author_list = serializers.ListField()
# 因为要序列化的模型表对象会点序列化类里面的字段名，
# 由于我们在模型层book表里面伪装了函数，所以在序列化类里面，
# 模型表对象book点被伪装的函数名，实际上就直接触发了该函数的运行！！！
# 被伪装的函数运行就返回了对应的字典与列表了！！
.
.
.
.
.
.
.
4 多表关联反序列化保存
4.1 新增图书接口
# 新增图书接口
前端传入的数据格式应该是这样的形式：
{"name":"红楼梦","price":19,"publish":1,"authors":[1,2]}
.
# 视图类
class BookView(APIView):
def post(self, request):
ser = BookSerializer(data=request.data) # 将前端传传入的数据通过request.data拿到字典，传给data参数
if ser.is_valid():
ser.save()
# 调用ser.save,自动触发咱们写在序列化类里面的的create方法，将数据用ORM保存到数据库
return Response({'code': 100, 'msg': '新增成功','result': ser.data})
else:
return Response({'code': 101, 'msg': ser.errors})
------------------------------------
# 序列化类
class BookSerializer(serializers.Serializer):
# name与price字段序列化与反序列化都用, 既读又写,不用加read_only
name = serializers.CharField(max_length=8)
price = serializers.CharField()
# 只用来做序列化 只读 read_only 放到ser.data里给前端展示的字段！！！
publish_detail = serializers.DictField(read_only=True)
author_list = serializers.ListField(read_only=True)
# 只用来做反序列化 只写 write_only 放到validated_data里准备写到数据库的字段！！
publish = serializers.CharField(write_only=True)
authors = serializers.ListField(write_only=True)
# 新增要重写create方法
def create(self, validated_data):
# validated_data 校验过后的数据，{"name":"红楼梦","price":19,"publish":1,"authors":[1,2]}
# 新增一本图书
book_obj = Book.objects.create(name=validated_data.get('name'), price=validated_data.get('price'),publish_id=validated_data.get('publish'))
# 多对多的表也要关联上
book_obj.authors.add(*validated_data.get('authors'))
# book.authors.add(1,2)
return book_obj
.
可以看到尽管前端传的是{"name":"红楼梦","price":19,"publish":1,"authors":[1,2]}
对于定制的字段加了read_only=True 就会放到ser.data里，变成了给前端展示的信息
"publish_detail":{"name":"南方出版社","addr":"南京"},"authors_detail":[{"name":"老刘","phone":"111"}]
.
.
.
可以看到括号里面啥都不写，就是既读又写，那么该字段也会就会放到ser.data里，变成了给前端展示的信息。
注意：写在序列化类里面的字段，只要是读的字段，都经历被模型表对象点的操作！！并且会将对应的信息放到ser.data里，这也是为什么最后在前端展示的信息里面有 "publish": "Publish object (1)" 的原因！！！
.
.
.
.
.
.
.
4.2 修改图书接口
# 修改图书接口
前端传入的数据格式应该是这样的形式：
{"name":"红楼梦","price":19,"publish":1,"authors":[1,2]}
只是前端输入的路由里面多了一个id的后缀
.
###视图类
class BookDetailView(APIView):
def put(self, request, pk):
book_obj = Book.objects.filter(pk=pk).first()
ser = BookSerializer(data=request.data, instance=book_obj)
if ser.is_valid():
ser.save() # 重写update方法
return Response({'code': 100, 'msg': '修改成功'})
else:
return Response({'code': 101, 'msg': ser.errors})
------------------------------------
# 序列化类
#### 反序列化的多表关联的保存
class BookSerializer(serializers.Serializer):
# name和price 既用来序列化，又用来反序列化 即写又读 ,不用加read_only，write_only
name = serializers.CharField(max_length=8)
price = serializers.CharField()
# 只用来做反序列化 只写 write_only
publish = serializers.CharField(write_only=True)
authors = serializers.ListField(write_only=True)
# 修改要重写update
def update(self, instance, validated_data):
# validated_data 校验过后的数据，{name:红楼梦,price:19,publish:1,authors:[1,2]}
instance.name = validated_data.get('name')
instance.price = validated_data.get('price')
instance.publish_id = validated_data.get('publish')
# 先清空，再add
authors = validated_data.get('authors')
instance.authors.clear()
instance.authors.add(*authors)
instance.save()
return instance
.
.
.
.
.
.
.
5 反序列化字段的校验规则
该校验是在序列化类的对象调用is_valid时，开始运行校验的，校验都走完后，
走save保存的，运行 create或update函数，将放在validated_data里面的数据，利用ORM保存！！！
# 共4层
-1 字段自己的：举例：name = serializers.CharField(max_length=8, error_messages={'max_length': '太长了'})
-2 validators=[方法，] 忽略掉
-3 局部钩子
-4 全局钩子
.
.
site-packages>>>django>>>conf>>>urls>>>global_settings里面有可以支持的文字配置
想要改一下将报错的提示信息，英文变成中文的配置！！！
.
.
.
# 这几个可以当固定配置，放到配置文件里面去
LANGUAGE_CODE = 'zh-hans'
TIME_ZONE = 'Asia/Shanghai'
USE_I18N = True
USE_L10N = True
USE_TZ = False
.
.
.
.
.
.
6 ModelSerializer使用
# ModelSerializer 继承自Serializer，帮咱们完成了很多操作
-跟表模型强关联
-大部分情况下,不用写create和update方法了！！！
-------------------------------------------
# 如何使用
### ModelSerializer的使用
class BookSerializer(serializers.ModelSerializer):
class Meta:
model = Book # 这样一写,序列化类就和Book表(模型类)建立了关联
# fields = '__all__'
# 序列化Book表中所有的字段 id name price publish authors
# fields = ['name', 'price'] # 序列化Book表中的name和price字段字段
fields = ['name', 'price', 'publish_detail', 'author_list', 'publish', 'authors']
# 定制name字段反序列化时，校验规则，比如字符最长不能超过8
# extra_kwargs = {'name': {'max_length': 8}}
# 给字段类加属性,如果反序列化的时候会应用这个属性（方式一）
extra_kwargs = {'name': {'max_length': 8},
'publish_detail': {'read_only': True},
'author_list': {'read_only': True},
'publish': {'write_only': True},
'authors': {'write_only': True},
}
# 如果Meta类里面 写了fields =__all__ ,本质就相当于,复制了模型表的所有字段，放在了 Meta类的外面，做了个映射。
# 就变成了像下面这样了models变成了serializers
# name = serializers.CharField(max_length=32)
# price = serializers.CharField(max_length=32)
# 一旦使用了这种映射之后，想在括号里面加max_length这些属性，就需要使用extra_kwargs去做了！！！会把extra_kwargs里面键对应的值替换到括号里面去，就变成了这样了 name = serializers.CharField(max_length=8)
# 如果在Meta类的外面，重写name字段，优先用重写的字段，会把映射的那个字段给顶掉！！
# name = serializers.CharField(max_length=9)
# 这就是给字段类加属性的(方式二)
# 同理，所有的read_only和wirte_only都可以通过重写或使用extra_kwargs传入!!!
# 终极，把这个序列化类写成跟之前一模一样效果
# publish_detail = serializers.SerializerMethodField(read_only=True)
# def get_publish_detail(self, obj):
# return {'name': obj.publish.name, 'addr': obj.publish.addr}
# author_list = serializers.SerializerMethodField(read_only=True)
# def get_author_list(self, obj):
# l = []
# for author in obj.authors.all():
# l.append({'name': author.name, 'phone': author.phone})
# return l
# 局部钩子和全局钩子跟之前完全一样
def validate_name(self, name):
# 这个name是前端传进来的name对应的值
if name.startwith('sb'):
# 校验不通过，抛异常
raise ValidationError('不能以sb开头')
else:
return name
# 全局钩子
def validate(self, attrs):
# attr是 前端传入的数据，走完局部钩子校验后的数据是个字典！
if attrs.get('name') == attrs.get('publish'):
raise ValidationError('书名跟出版社名字不能一样')
else:
return attrs
注意：假如我的序列化类继承的ModelSerializer，那么将模型表里面的字段映射过来后，
模型表里面的多对多字段映射过来自动就变成ListField类型了
模型表里面的一对多字段映射过来自动就变成int类型了
.
.
.
可以看到fields =all 这个方法不能将模型表中伪装成属性的定制化字段函数映射到该序列化表里面来，我们可以看到publish_detail与authors_detail两个定制化字段并没有在前端展示出来
.
.
.
所以不如 fields = [] 用的不方便，把所有字段往列表里面一放就行了！！
.
定制化字段要么在模型表里面写，要么在序列化类里面写，写一个就行了
一定不要忘了把定制化的字段名放到列表里fields = []
.
.
.
.
.
.
.
.
作业
#1 Serializer的方式1book,author,authordetail,publish
-book的查询所有，查询单个
{
"name": "红楼梦",
"price": "66",
"publish_detail": {
"name": "北京出版社",
"addr": "北京"
},
"author_list": [
{
"name": "lqz",
"phone": "1234455"，
"gender":男
},
{
"name": "罗贯中",
"phone": "12342412"，
"gender":男
}
]
},
-新增和修改写完
# 2 继承ModelSerializer 把上面再写一遍
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· DeepSeek 开源周回顾「GitHub 热点速览」
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET 10首个预览版发布：重大改进与新特性概览！
· AI与.NET技术实操系列（二）：开始使用ML.NET
· .NET10 - 预览版1新功能体验（一）