昨日回顾
# 1.web的两种开发模式
# 2.web api
# 3.posman的使用(路径必须完全正确)
# 4.restful规范 10条
# 5.drf的安装和使用
# 6.cbv源码分析
-视图类,必须继承View(读View的源码)
-在类里写get,post方法就可以了,只要get请求来,就会走get方法(方法跟之前的fbv写法完全一样)
-路由:views.Books.as_view()---这个函数执行完一定是一个内存地址---》view(闭包函数)内层函数的地址
-请求来了,路由匹配上执行view(request)--->self.dispatch(request, *args, **kwargs)
-dispatch-->把请求方法转成小写---》通过反射,去对象中找,有没有get方法,有就加括号执行,并且把request传进去了
#7.APIView源码分析(drf提供的,扩展了View的功能)
-视图类,继承APIView(读APIView的源码)
-在类里写get,post方法就可以了,只要get请求来,就会走get方法(方法跟之前的fbv写法完全一样)
-路由:views.Books.as_view()---这个函数执行完一定是一个内存地址---》view(闭包函数)内存函数的地址,解除了csrf校验,所有请求就都没有csrf校验了
-请求来了,路由匹配上--->view(request)--->self.dispatch(request, *args, **kwargs),现在这个dispatch不是View中的dispatch,而是APIView中的dispatch
-def dispatch(self, request, *args, **kwargs):
self.args = args
self.kwargs = kwargs
# self.initialize_request(request, *args, **kwargs) request是当次请求的request
# request = self.initialize_request request是一个新的Request对象
request = self.initialize_request(request, *args, **kwargs)
self.request = request
self.headers = self.default_response_headers # deprecate?
try:
# 三大认证模块(request是新的request)
self.initial(request, *args, **kwargs)
# Get the appropriate handler method
if request.method.lower() in self.http_method_names:
handler = getattr(self, request.method.lower(),
self.http_method_not_allowed)
else:
handler = self.http_method_not_allowed
# 响应模块
response = handler(request, *args, **kwargs)
except Exception as exc:
# 异常模块
response = self.handle_exception(exc)
# 渲染模块
self.response = self.finalize_response(request, response, *args, **kwargs)
return self.response
今日内容
1.序列化组件介绍
1.序列化,序列化器会把模型对象转换成字典,经过response以后变成json字符串
2.反序列化,把客户端发送过来的数据,经过request以后变成字典,序列化器可以把字典转成模型
3.反序列化,完成数据校验功能
# 注意:serializer不是只能为数据库模型类定义,也可以为非数据库模型类的数据定义。serializer是独立于数据库之外的存在。
2.查询数据(序列化)
# get请求: 从后端拿数据 (python对象 --序列化--> json)
# 过程:
1.写一个序列化的类,继承Serializer
2.在类中写要序列化的字段 (想序列化哪个字段,就在类中写哪个字段)
3.在视图类中使用,导入--》实例化得到序列化类的对象,把要序列化的对象传入
4.序列化类的对象.data 是一个字典
5.把字典返回,如果不使用rest_framework提供的Response,就得使用JsonResponse
# ser.py
from rest_framework import serializers
class BookSerializer(serializers.Serializer):
# id = serializers.CharField()
name = serializers.CharField()
# price=serializers.DecimalField()
price = serializers.CharField()
author = serializers.CharField()
publish = serializers.CharField()
# views.py
from rest_framework.view import APIView
from rest_framework.response import Response
from app01 import models
class BookView(APIView):
def get(self,request,pk):
book = models.Book.objects.filter(id=pk).first()
# 用一个类,毫无疑问,一定要实例化
# 要序列化谁,就把谁传过来
book_ser = BookSerializer(book) # 默认:序列化单条数据
# book_ser.data 序列化对象.data就是序列化后的字典 (还不是json格式)
# drf的Response,会自动将返回的数据json.dumps() 转json格式
return Response(book_ser.data)
# 故 视图类中返回的数据两种处理方式:
1.采用drf的Response() 自动转json格式 但需要setting中配置 app='rest_framework' # 推荐使用
2.直接使用django原生的 JsonResponse 转json格式
# urls.py
re_path('books/(?P<pk>\d+)', views.BookView.as_view()),
3.字段类型
有很多,不需要都记住
# 只需要记住:CharField,IntegerField,DateField。。。
字段类型
字段 | 字段构造方式 |
---|---|
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(max_length=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=) |
4.修改数据(反序列化)
# put请求: 修改数据 前端传数据给后端 ( json --反序列化--> python对象)
# 过程:
1.写一个反序列化的类,继承Serializer
2.在类中写要反序列化的字段、字段的属性(max_lenth等来校验数据) 以及重写update() 方法进行数据的保存
3.在类中写数据校验规则 (1.字段属性 2.钩子函数 3.字段函数 具体见下)
4.在视图类中使用,导入--》实例化得到反序列化类的对象,把 要修改的对象传入 与 修改的数据 传入
book_ser=BookSerializer(book,request.data)
book_ser=BookSerializer(instance=book,data=request.data)
5.进行数据校验 if book_ser.is_valid():
6.如果校验通过,就保存
book_ser.save() # 注意不是book.save()
7.如果不通过,逻辑自己写
"""
数据校验规则(三种):
1.序列化类 字段的选项参数 来校验 (最基本的校验)
max_length 最大长度
min_lenght 最小长度
allow_blank 是否允许为空
trim_whitespace 是否截断空白字符
max_value 最小值 针对数据类型
min_value 最大值
2.写钩子函数(局部和全局) # 推荐使用
# 局部钩子:如果价格小于10,就校验不通
def validate_price(self, data): # validate_字段名 接收一个参数data 就是该局部钩子字段对应的值
# print(type(data)) # str
# print(data) # 33.10
if float(data)>10:
return data
else:
# 校验失败,抛异常
raise ValidationError('价格太低')
# 全局钩子:作者名字跟出版社不能一样
def validate(self, validate_data): # validate 接收一个参数validate_data 就是验证通过的数据字典
print(validate_data)
author=validate_data.get('author')
publish=validate_data.get('publish')
if author == publish:
raise ValidationError('作者名字跟出版社一样')
else:
return validate_data
3.使用字段的选项参数: validators=[校验函数地址] 来校验数据 # 通常不使用这种,知道就行
# author=serializers.CharField(validators=[check_author])
- 1.自定义写一个普通校验函数
def check_author(data):
if data.startswith('sb'):
raise ValidationError('作者名字不能以sb开头')
else:
return data
- 2. 配置在字段的选项参数中:
validators=[check_author]
"""
# models.py
class Book(models.Model):
id=models.AutoField(primary_key=True)
name=models.CharField(max_length=32)
price=models.DecimalField(max_digits=5,decimal_places=2)
author=models.CharField(max_length=32)
publish=models.CharField(max_length=32)
# ser.py
from rest_framework import serializers
from rest_framework.exceptions import ValidationError
# 普通校验函数 放 字段的选项参数 来校验数据
def check_author(data):
if data.startswith('sb'):
raise ValidationError('作者名字不能以sb开头')
else:
return data
class BookSerializer(serializers.Serializer):
name=serializers.CharField(max_length=16,min_length=4)
price=serializers.CharField()
author=serializers.CharField(validators=[check_author]) # validators=[] 列表中写函数内存地址 这种了解就行
publish=serializers.CharField()
# 局部钩子:如果价格小于10,就校验不通过
def validate_price(self, data): # validate_字段名 参数data 就是该局部钩子字段对应的值
# print(type(data)) # str
# print(data) # 33.10
if float(data)>10:
return data
else:
# 校验失败,抛异常
raise ValidationError('价格太低')
# 全局钩子:作者名字跟出版社不能一样
def validate(self, validate_data): # validate 参数validate_data 就是验证通过的数据字典
# print(validate_data)
author=validate_data.get('author')
publish=validate_data.get('publish')
if author == publish:
raise ValidationError('作者名字跟出版社一样')
else:
return validate_data
# 必须 重写保存方法 (原因:1.因为父类接口的规定--接口的规范与统一 2.数据保存时也需要和校验通过的字段名一一对应上)
def update(self, instance, validated_data):
# instance是book这个对象
# validated_data是校验后的数据
instance.name=validated_data.get('name')
instance.price=validated_data.get('price')
instance.author=validated_data.get('author')
instance.publish=validated_data.get('publish')
instance.save() # 实质就是book.save() 由django的orm提供的对象.save()
return instance
# views.py
class BookView(APIView):
def put(self,request,pk):
response_msg={'status':100,'msg':'成功'}
# 找到需要修改的对象
book = Book.objects.filter(id=pk).first()
# 得到一个序列化类的对象
# book_ser=BookSerializer(book,request.data)
book_ser=BookSerializer(instance=book,data=request.data)
# 进行数据验证(对照form组件的验证)
if book_ser.is_valid(): # 返回True 表示前端传递的数据验证通过
book_ser.save() # 注意:不是对象.save() 是序列化对象.save()
response_msg['data']=book_ser.data
else:
response_msg['status']=101
response_msg['msg']='数据校验失败'
response_msg['data']=book_ser.errors
return Response(response_msg)
# urls.py
re_path('books/(?P<pk>\d+)', views.BookView.as_view()),
5.字段选项参数
校验参数:是反序列化时,进行数据的校验
参数名称 | 作用 |
---|---|
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页面时,显示的字段帮助提示信息 |
6.字段通用参数
read_only 表明该字段仅用于序列化输出,默认False, 如果设置成True,postman中查询时可看到该字段,修改时,不需要传该字段
write_only 表明该字段仅用于反序列化输入,默认False,如果设置成True,postman中查询时看不到该字段,修改时,该字段需要传
# 以下的了解
required 表明该字段在反序列化时必须输入,默认True
default 反序列化时使用的默认值
allow_null 表明该字段是否允许传入None,默认False
validators 该字段使用的验证器
error_messages 包含错误编号与错误信息的字典
7.查询所有(序列化)
# views.py
# 最好新建视图 View 因为restful规范,查询都是get请求,虽然也可以都写在get氢气 再根据参数判断,但写在一起比较混乱
class BooksView(APIView):
def get(self,request):
response_msg = {'status': 100, 'msg': '成功'}
books=Book.objects.all()
book_ser=BookSerializer(books,many=True) # 序列化多条, 如果序列化一条,不需要写
response_msg['data']=book_ser.data
return Response(response_msg)
#urls.py
path('books/', views.BooksView.as_view()),
8.新增数据(反序列化)
# views.py
class BooksView(APIView):
# 新增
def post(self,request):
response_msg = {'status': 100, 'msg': '成功'}
# 修改、查询才有instance,新增没有instance,只有data
book_ser = BookSerializer(data=request.data)
# book_ser = BookSerializer(request.data) # 这个会按位置传request.data会给instance,就报错了
# 校验字段
if book_ser.is_valid():
book_ser.save()
response_msg['data']=book_ser.data
else:
response_msg['status']=102
response_msg['msg']='数据校验失败'
response_msg['data']=book_ser.errors
return Response(response_msg)
# ser.py 序列化类重写 create方法
def create(self, validated_data):
instance=Book.objects.create(**validated_data)
return instance
# urls.py
path('books/', views.BooksView.as_view()),
9.删除一个数据
# 删除数据,就不需要用序列化组件
# 直接使用orm 对象.delete() 根据pk 删除就行
# views.py
class BookView(APIView):
def delete(self,request,pk):
Book.objects.filter(pk=pk).delete()
return Response({'status':100,'msg':'删除成功'})
# urls.py
re_path('books/(?P<pk>\d+)', views.BookView.as_view()),
10.模型类序列化器
form rest_framework import serializers
class BookModelSerializer(serializers.ModelSerializer):
class Meta:
model=Book # 对应上models.py中的模型
fields='__all__' # 序列 model表所有字段
fields=('name','price','id','author') # 只序列化指定的字段
exclude=('name',) # 跟fields不能都写,写谁,就表示排除谁
# read_only_fields=('price',)
# write_only_fields=('id',) # 该字段已弃用了
# 使用extra_kwargs,来给字段添加选项参数
# 类似于这种形式name=serializers.CharField(max_length=16,min_length=4)
extra_kwargs = {
'price': {'write_only': True},
}
# 这里试一试 id字段是否可以
# 其他使用一模一样
# 不需要重写create和updata方法了
11.源码分析
many=True的实际用途
# 序列化多条,需要传many=True
book_ser=BookModelSerializer(books,many=True)
print(type(book_ser)) # <class 'rest_framework.serializers.ListSerializer'>
book_one_ser=BookModelSerializer(book)
print(type(book_one_ser)) # <class 'app01.ser.BookModelSerializer'>
# 对象的生成:
--》1.先调用类的__new__方法,生成空对象 # 由类的__new__方法 控制对象的生成
--》2.对象=类名(name=lqz),触发类的__init__()
# 源码:肯定是根据many=True进行处理,触发生成不同类的对象
def __new__(cls, *args, **kwargs):
if kwargs.pop('many', False): # 字典.pop(key, default) 要删除的键值 如果没有 key,返回default值
return cls.many_init(*args, **kwargs)
# 没有传many=True,走下面,正常的对象实例化
return super().__new__(cls, *args, **kwargs)
Serializer的高级用法
# source的选项参数使用--指向来自哪个表的哪个字段
# 作用:
# 1.字段名字可以自定义,不用再和表字段名对应上
xxx=serializers.CharField(source='title')
# 2.通过'.' 跨表 可指向关联表的字段
publish=serializers.CharField(source='publish.email')
# 3.可以执行models中表的方法,使得 字段 对应 该方法的返回值
# test是Book表模型中的方法
pub_date=serializers.CharField(source='test')
# SerializerMethodField() 字段的使用--定制化字段的返回值
# 它需要有个配套方法,方法名叫get_字段名,返回值就是返回给前端的 该字段的对应值
authors=serializers.SerializerMethodField()
def get_authors(self,instance):
# instance 就是使用该序列化类时,传入的对象
authors=instance.authors.all() # 取出所有作者
ll=[]
for author in authors:
ll.append({'name':author.name,'age':author.age})
return ll
# 测试 如果不使用SerializerMethodField() 怎么展示 作者字段:[{作者1.name 作者1.age},{作者2.name 作者2.age}]
# 思路,在view中 自己根据 orm操作数据库,把关联数据找出来,再自定义样式,最后放进book_ser.data 中
# 1.获取外键字段author的详细数据
authors_obj_set = models.Author.objects.filter(book=book_obj).all()
# 2.包装成指定的样式
authors = []
for author_obj in authors_obj_set:
authors.append({'name': author_obj.name, 'age': author_obj.age})
# 3.修改book_ser.data 中对应的字段 'authors'
book_ser.data['authors'] = authors
print(book_ser.data)
# 结果:失败,book_ser.data 是内部封装好的字典,不能进行修改、添加或删除数据
补充
1.如果有这个错(把rest_framework在app中注册一下)
2.补充自己封装Respons对象
# 在实际中,除了使用框架封装好的方法,也会自己写一些方法工具
# 例如:因为需要重复返回这个字典: response_msg={'status':100,'msg':'成功'}
# 将字典 封装成一个 类, 使用时,就可以'.'操作,修改'status'或'msg' 和 新增 data
class MyResponse():
def __init__(self):
self.status=100 # 初始化,封装对象两个属性
self.msg='成功'
@property
def get_dict(self):
return self.__dict__ # 返回的对象.__dict__
if __name__ == '__main__':
res=MyResponse()
res.status=101
res.msg='查询失败'
res.data={'name':'lqz'}
print(res.get_dict)
3.你在实际开发中碰到的问题及如何解决的
write_only_fields 不能使用了,使用extra_kwargs解决了
extra_kwargs = {
'id': {'write_only': True},
}
作业:
# 1.图书的5个接口写完(使用序列化组件)
# 2.尝试修改一下返回的字段名字