189 8069 5689
QuerySet 对象 ：queryset_obj = models.Book.objects.all()
为枞阳等地区用户提供了全套网页设计制作服务，及枞阳网站建设行业解决方案。主营业务为成都网站设计、成都网站制作、枞阳网站设计，以传统方式定制建设网站，并提供域名空间备案等一条龙服务，秉承以专业、用心的态度为用户提供真诚的服务。我们深信只要达到每一位用户的要求，就会得到认可，从而选择与我们长期合作。这样，我们也可以走得更远！
单个对象：book = models.Book.objects.all().first()
QuerySet 对象、单个 book 对象）转成字典，在经过 response 的时候序列化成 json 格式返回给前端。request之变成程字典（request.data），序列化器再把字典转成模型，存到数据库中。首先得在序列化器模块中书写序列化类。
然后在视图函数模块中书写 CBV 的get方法（获取数据）
序列化类的书写步骤和使用流程：
第一步：写一个类：必须继承drf中的Serializer及其子类
第二步：在类中写要序列化的字段-->要序列化哪些，就写哪些，不序列化的不写
第三步：使用序列化类，视图类中用
第四步：视图函数中得到序列化类对象 对象.data,通过Response返回给前端
模型类(models.py)：
class Book(models.Model):
name = models.CharField(max_length=32)
price = models.DecimalField(decimal_places=2, max_digits=5)
author = models.CharField(max_length=32)
序列化类(ser.py)：
from rest_framework import serializers
from .models import Book
class BookSerializer(serializers.Serializer):
# max_length=32,min_length=3 反序列化保存校验数据的时候用
name = serializers.CharField(max_length=8, min_length=3)
price=serializers.CharField() # models中使用了DecimalField，这个位置使用了CharField会把小数类型转成字符串
author = serializers.CharField()
视图层类（views.py）
class BookView(APIView):
def get(self,request):
# 查出来的数据做序列化
book_list=Book.objects.all()
# instance:要序列化的对象 qs，单个对象
# many:如果是qs对象，many=True，如果是单个对象many=False
ser=BookSerializer(instance=book_list,many=True) # 传入初始化的参数instance=None, data=empty
# ser.data使用模型类对象序列化后的字典
return Response(ser.data) # 字典，列表，字符串都行
路由：
from app01 import views
urlpatterns = [
path('admin/', admin.site.urls),
path('books/', views.BookView.as_view()),
]
需要记忆：
CharField
IntegerField
FloatField
DecimalField
DateTimeField
DateField
了解：
反序列化时，前端发送进来的json数据中，也有值是列表或者字典的时候，那么这种数据我们需要用什么字段来反序列化？
{name:lqz,age:19,hobby:[篮球,足球],wife:{name:lyf,age:38}}
ListField 反序列化列表值DictField 反序列化字典值| 字段 | 字段构造方式 |
|---|---|
| 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-fb31a" 2） 'hex' 如 "5ce0e9a55ffa654bcee0fb31a" 3）'int' - 如: "" 4）'urn' 如: "urn:uuid:5ce0e9a5-5ffa-654b-cee0-fb31a" |
| 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 是限制数据的字符长度
重点记忆：
read_only ：该字段只能序列化，后端发送给前端看write_only：该字段只能反序列化，由前端发送到后端保存例子：
# 什么都不写，表示 name 字段既序列化，又反序列化
name=serializers.CharField(max_length=32,min_length=3)
# 只反序列化，author 字段只能由前端把作者信息发到后端保存
author=serializers.CharField(write_only=True)
# 这是错误写法，write_only=True,read_only=True 逻辑矛盾
price=serializers.CharField(write_only=True,read_only=True)
选项参数：
| 参数名称 | 作用 |
|---|---|
| max_length | 最大长度（CharField） |
| min_lenght | 最小长度（CharField） |
| allow_blank | 是否允许为空（CharField） |
| trim_whitespace | 是否截断空白字符（CharField） |
| max_value | 最小值 （IntegerField） |
| min_value | 最大值（IntegerField） |
通用参数：
| 参数名称 | 说明 |
|---|---|
| read_only | 表明该字段仅用于序列化输出，默认False |
| write_only | 表明该字段仅用于反序列化输入，默认False |
| required | 表明该字段在反序列化时必须输入，默认True |
| default | 反序列化时使用的默认值 |
| allow_null | 表明该字段是否允许传入None，默认False |
| validators | 该字段使用的验证器(不太用) |
| error_messages | 包含错误编号与错误信息的字典 |
| label | 用于HTML展示API页面时，显示的字段名称 |
| help_text | 用于HTML展示API页面时，显示的字段帮助提示信息 |
方式一：在序列化类中写
使用 serializers的SerializerMethodField()来定制，但必须配合一个方法,方法名get_字段名，方法返回什么，字段就是什么，obj是当前序列化到的模型类中的单个对象（queryset 或 单个 book）
from rest_framework import serializers
from .models import Book
class BookSerializer(serializers.Serializer):
name = serializers.CharField(max_length=8, min_length=3)
price=serializers.CharField()
author = serializers.CharField()
# 在序列化后返回给前端时，前端就可以多看到一个 price_info 值
price_info = serializers.SerializerMethodField()
def get_price_info(self, obj): # obj是当前序列化到的单个对象
return "价格是："+str(obj.price)
方式二：在模型类中写
表模型中写方法，并且把方法包装成数据属性，在序列化类中使用的时候把该方法当作普通字段
class Book(models.Model):
name = models.CharField(max_length=32)
price = models.DecimalField(decimal_places=2, max_digits=5)
author = models.CharField(max_length=32)
@property # 把方法包装成数据属性
def price_info(self):
return "价格是：" + str(self.price)
在序列化类中使用：
只能给前端看，前端不能传送该字段的值（只序列化）
price_info=serializers.CharField(read_only=True) # 只用来做序列化
反序列化同时可以进行数据校验
具体步骤如下：
第一步：把前端传入的数据，放到Serializer对象中:ser=BookSerializer(data=request.data)
第二步：校验数据：ser.is_valid():
第三步：保存，ser.save()---》必须重写create，在序列化类中
# 校验通过的数据都存放在 validated_data 中
def create(self, validated_data):
book=Book.objects.create(**validated_data)
return book
如果instance为None，调用save本质会调用create，父类create是直接抛异常的，所以我们要重写
视图层类：
class BookView(APIView):
def post(self,request):
# 反序列化,保存---》使用data参数
ser=BookSerializer(data=request.data) #
# 校验数据
if ser.is_valid(): # 如果是true表示数据校验通过，通过，就保存
ser.save() # 就会保存,重写create方法，如果不重写，我们不知道存到哪个表中
return Response(ser.data)
return Response({'code':101,'msg':'数据校验失败','err':ser.errors})
序列化类：
注意：重写 create 方法后 不要忘记返回book对象
from rest_framework import serializers
from .models import Book
# drf提供的类：Serializer
class BookSerializer(serializers.Serializer):
name = serializers.CharField(max_length=8, min_length=3)
price=serializers.CharField()
author = serializers.CharField()
price_info=serializers.CharField(read_only=True) # 只用来做序列化
def create(self, validated_data):
# validated_data校验过后的数据
# 手动存到book表中
book=Book.objects.create(**validated_data)
# book=Book.objects.create(name=validated_data.get('name'))
return book # 不要忘记返回book对象
视图层类：
写 put 方法，与 get 方法很像，但 put 方法序列化器中要有 instance 参数
class BookDetailView(APIView):
def put(self, request, pk):
# 修改：用什么数据，修改哪个对象？
book = Book.objects.filter(pk=pk).first()
# 既有instance，又有data，表示修改
ser = BookSerializer(instance=book, data=request.data)
if ser.is_valid():
# 重写update方法
ser.save() # 调用save---》内部根据instance判断是触发create还是update
return Response(ser.data)
return Response({'code': 102, 'msg': '修改出错', 'err': ser.errors})
序列化类：
修改，需要重写 序列化类 中的update 方法，否则和新增一样也会报错
from rest_framework import serializers
from .models import Book
class BookSerializer(serializers.Serializer):
name = serializers.CharField(max_length=8, min_length=3)
price=serializers.CharField()
author = serializers.CharField()
def update(self, instance, validated_data):
# validated_data校验过后的数据,instance 是要修改的对象
instance.name = validated_data.get('name')
instance.price = validated_data.get('price')
instance.author = validated_data.get('author')
instance.save() # 模型对象自带的save，保存到数据库中
return instance # 要忘记返回instance对象
与 forms 组件类中的校验局部钩子全局钩子书写方法几乎一样。
需要在序列化类中书写局部和全局钩子
from rest_framework import serializers
from .models import Book
class BookSerializer(serializers.Serializer):
name = serializers.CharField(max_length=8, min_length=3)
price=serializers.CharField()
author = serializers.CharField()
# 局部钩子
# 字段有自己的校验：max_length .... ,再校验，就可以写局部钩子
def validate_name(self, attr):
# attr就是前端传入的数据
# 名字不能以sb开头
if attr.startswith('sb'):
raise ValidationError("名字不能以sb开头")
else:
return attr # 没有问题，正常返回
# 先走字段自己规则，再走局部钩子，再走全局钩子
# 全局钩子
def validate(self, attrs):
# attrs校验过后的数据
if attrs.get('name') == attrs.get('author'):
raise ValidationError('作者名不能等于书名')
else:
return attrs
以后我们在实际开发中会使用ModelSerializer跟表模型做绑定比较多，不需要重写update和create方法了
序列化类：
class BookSerializer2(serializers.ModelSerializer):
class Meta:
model = Book # 跟哪个表有关系
fields='__all__' # 所有字段
# id是从表模型中映射过来的，auto，它会不要求你传
# price_info：它不是数据库中字段
# 即便扩写的字段，也要在fields中注册
# fields = ['id', 'name', 'price', 'author', 'price_info']
# 重写字段
# 局部和全局钩子跟之前一样
class BookSerializer2(serializers.ModelSerializer):
class Meta:
model = Book
fields = ['id', 'name', 'price', 'author', 'price_info']
# 原来的字段参数，通过extra_kwargs传进去
extra_kwargs = {
'name': {'write_only': True, 'max_length': 8, 'min_length': 3}
}
图书表：跨表查询出版社表和作者表
定制序列化字段：
注意：在 sqlite 这中数据库中如果存时间字段，查询时会报错
class Book(models.Model):
name = models.CharField(max_length=32)
price = models.DecimalField(max_digits=5, decimal_places=2)
publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
authors = models.ManyToManyField(to='Author')
def __str__(self):
return self.name
@property
def publish_detail(self): # 定制序列化字段，想查询什么就返回什么结果
return {'name': self.publish.name, 'addr': self.publish.city}
@property
def author_list(self):
l = []
print(self.authors.all()) # 查询改图书对应的作者对象
for author in self.authors.all():
print(author.author_detail)
l.append({'name': author.name,'age':author.age,'addr':author.author_detail.addr})
return l
作者表、作者详情表、出版社表：
class Author(models.Model):
name = models.CharField(max_length=32)
age = models.IntegerField()
author_detail = models.OneToOneField(to='AuthorDatail', on_delete=models.CASCADE)
# OneToOneField 就是ForeignKey+unique=True
class AuthorDatail(models.Model):
telephone = models.BigIntegerField()
# birthday = models.DateField()
addr = models.CharField(max_length=64)
class Publish(models.Model):
name = models.CharField(max_length=32)
city = models.CharField(max_length=32)
email = models.EmailField()
图书表的序列化类：
class BookSerializer(serializers.ModelSerializer):
class Meta:
model = Book
fields = ['id', 'name', 'price', 'authors', 'publish', 'publish_detail', 'author_list']
# depth=1 # 尽量不要用，关联表一层全部取出来
extra_kwargs = {
'publish': {'write_only': True}, # 这两个字段数据只能反序列化
'authors': {'write_only': True},
}
class AuthorSerialzier(serializers.ModelSerializer):
class Meta:
model = Author
fields = '__all__'
class AuthorDetailSerialzier(serializers.ModelSerializer):
class Meta:
model = AuthorDatail
fields = '__all__'
class PublishSerialzier(serializers.ModelSerializer):
class Meta:
model = Publish
fields = '__all__'
不需要传入参数 pk 的操作：获取所有资源（get 请求）、新增一个资源（post）请求
class BookView(APIView):
def get(self, request):
book_list = Book.objects.all()
ser = BookSerializer(instance=book_list, many=True)
return Response(ser.data)
def post(self, request):
ser = BookSerializer(data=request.data)
if ser.is_valid():
ser.save()
return Response({"code": 100, 'msg': '新增成功', 'data': ser.data})
return Response({"code": 101, 'msg': '新增出错', 'err': ser.errors})
需要传入 pk 参数，并且只操作单个资源对象的操作：获取单个资源（get请求）、修改资源（put请求）、删除资源（delete请求）
class BookDetailView(APIView):
def get(self, request, pk):
book = Book.objects.all().filter(pk=pk).first()
ser = BookSerializer(instance=book)
return Response(ser.data)
def put(self, request, pk):
book = Book.objects.all().filter(pk=pk).first()
ser = BookSerializer(instance=book, data=request.data)
if ser.is_valid():
ser.save()
return Response({"code": 100, 'msg': '修改成功', 'data': ser.data})
return Response({"code": 101, 'msg': '修改出错', 'err': ser.errors})
def delete(self, request, pk):
Book.objects.filter(pk=pk).delete()
return Response({"code": 100, 'msg': '删除成功'})
urlpatterns = [
path('admin/', admin.site.urls),
path('books/', views.BookView.as_view()),
path('books/', views.BookDetailView.as_view()),
]
新增测试：