Request类源码分析。序列化类的基本使用，反序列化效验和保存,5个接口
1 Request类源码分析
# APIView+Response写个接口
# 总结：
1 新的request有个data属性，以后只要是在请求body体中的数据，无论什么编码格式，无论什么请求方式
2 取文件还是从：request.FILES
3 取其他属性，跟之前完全一样 request.method ....
-原理是：新的Request重写了__getattr__，通过反射获取老的request中的属性
4 request.GET 现在可以使用 request.query_params
@property
def query_params(self):
return self._request.GET
# 源码中找出来
-老的request在新的request._request
-照常理来讲，如果取method，应该request._request.method,但是我现在可以request.method
# 魔法方法之 __getattr__, . 拦截，对象.属性 当属性不存在时，会触发 类中 __getattr__的执行
# get请求能不能在body体中带数据
-能，
-可能最新的允许带，但实际上我们不会在get里面向body体中放数据，咱要是放数据的话也是用post和put
2 序列化组件介绍
1. 序列化,序列化器会把模型对象（queryset，单个对象）转换成字典,经过response以后变成json字符串
2. 反序列化,把客户端发送过来的数据,经过request.data以后变成字典,序列化器可以把字典转成模型
3. 反序列化,完成数据校验功能
3 序列化类的基本使用
# 1 创建book表模型
# 2 写查询所有图书的接口：APIVie+序列化类+Response
3.1 查询所有和查询单条
views.py
class BookView(APIView):
def get(self, request):
book_list = Book.objects.all()
# 使用序列化类，完成序列化 两个很重要参数： instance实例，对象 data：数据
# 如果是多条many=True 如果是queryset对象，就要写
# 如果是单个对象 many=False，默认是False
serializer = BookSerializer(instance=book_list, many=True)
# serializer.data # 把qs对象，转成列表套字典 ReturnList
# print(serializer.data)
# print(type(serializer.data))
# return Response(serializer.data)
return Response({'code': 100, 'msg': '成功', 'data': serializer.data})
class BookDetailView(APIView):
def get(self, request, pk):
book = Book.objects.all().get(pk=pk)
serializer = BookSerializer(instance=book)
return Response({'code': 100, 'msg': '成功', 'data': serializer.data})
urls.py
urlpatterns = [
path('books/', views.BookView.as_view()),
path('books/<int:pk>/', views.BookDetailView.as_view()),
]
序列化类
from rest_framework import serializers
class BookSerializer(serializers.Serializer):
# 要序列化的字段
# id = serializers.IntegerField()
name = serializers.CharField()
# price = serializers.IntegerField()
总结
# 序列化类的使用
-序列化过程：
-写一个序列化类，继承Serializer，写一个个字段 CharField，写的字段表示要序列化和反序列化的字段
-视图类中：导入，实例化得到对象，对查出来的qs，单个对象序列化，传入instance参数，如果是qs，一定要传many=True
-序列化类对象 ser.data是把ser对象转成字典或列表然后经过返回Resonse得到json格式字符给前端
-序列化单条和序列化多条，路由不一样，写成了两个视图类，分别两个get方法
4 常用字段类和参数（了解）
4.1 常用字段类
# IntegerField CharField DateTimeField DecimalField
# ListField和DictField---》比较重要，但是后面以案例形式讲
4.2 字段参数(校验数据来用的)
选项参数：（CharField,IntegerField）
| 参数名称 | 作用 |
|---|---|
| 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 |
read_only write_only 很重要，后面以案例讲
5 反序列化之校验
# 反序列化，有三层校验
-1 字段自己的（写的字段参数：required max_length 。。。）
-2 局部钩子：写在序列化类中的方法，方法名必须是 validate_字段名
def validate_name(self, name):
if 'sb' in name:
# 不合法，抛异常
raise ValidationError('书名中不能包含sb')
else:
return name
-3 全局钩子：写在序列化类中的方法 方法名必须是 validate
def validate(self, attrs):
price = attrs.get('price')
name = attrs.get('name')
if name == price:
raise ValidationError('价格不能等于书名')
else:
return attrs
# 只有三层都通过，在视图类中：
ser.is_valid(): 才是True，才能保存
6 反序列化之保存
# 新增接口：
-序列化类的对象，实例化的时候：ser = BookSerializer(data=request.data)
-数据校验过后----》调用 序列化类.save()--->但是要在序列化类中重写 create方法
def create(self, validated_data):
book=Book.objects.create(**validated_data)
return book
# 修改接口
-序列化类的对象，实例化的时候：ser = BookSerializer(instance=book,data=request.data)
-数据校验过后----》调用 序列化类.save()--->但是要在序列化类中重写 update方法
def update(self, book, validated_data):
for item in validated_data: # {"name":"jinping","price":55}
setattr(book, item, validated_data[item])
#setattr(book,'name','jinping')
#setattr(book,'price',55)
book.save()
return book
# 研究了一个问题
在视图类中，无论是保存还是修改，都是调用序列化类.save()，底层实现是根据instance做一个判断
setattr
7 5个接口代码
路由
urlpatterns = [
path('books/', views.BookView.as_view()),
path('books/<int:pk>/', views.BookDetailView.as_view()),
]
视图
from .models import Book
from .serializer import BookSerializer
class BookView(APIView):
def get(self, request):
book_list = Book.objects.all()
# 使用序列化类，完成序列化 两个很重要参数： instance实例，对象 data：数据
# 如果是多条many=True 如果是queryset对象，就要写
# 如果是单个对象 many=False，默认是False
serializer = BookSerializer(instance=book_list, many=True)
# serializer.data # 把qs对象，转成列表套字典 ReturnList
# print(serializer.data)
# print(type(serializer.data))
# return Response(serializer.data)
return Response({'code': 100, 'msg': '成功', 'data': serializer.data})
# 新增
def post(self, request):
# 前端会传入数据，request.data--->把这个数据保存到数据库中
# 借助于序列化类，完成 校验和反序列化
# data 前端传入的数据 {"name":"三国演义","price":88}
ser = BookSerializer(data=request.data)
# 校验数据
if ser.is_valid(): # 三层：字段自己的校验，局部钩子校验，全局钩子校验
# 校验通过，保存
print(ser.validated_data) # validated_data：校验过后的数据
# 如果没有save，如何保存，自己做
# Book.objects.create(**ser.validated_data)
ser.save() # 会保存，但是会报错,因为它不知道你要保存到那个表中
return Response({'code': 100, 'msg': '新增成功'})
else:
print(ser.errors) # 校验失败的错误
return Response({'code': 101, 'msg': '新增失败', 'errors': ser.errors})
class BookDetailView(APIView):
def get(self, request, pk):
book = Book.objects.all().get(pk=pk)
serializer = BookSerializer(instance=book)
return Response({'code': 100, 'msg': '成功', 'data': serializer.data})
def put(self, request, pk):
book = Book.objects.get(pk=pk)
ser = BookSerializer(instance=book, data=request.data)
if ser.is_valid():
ser.save() # 也会报错，重写update
return Response({'code': 100, 'msg': '修改成功'})
else:
return Response({'code': 101, 'msg': '修改失败', 'errors': ser.errors})
序列化类
# from rest_framework.serializers import Serializer
from rest_framework import serializers
from rest_framework.exceptions import ValidationError
from .models import Book
class BookSerializer(serializers.Serializer):
# 要序列化的字段
id = serializers.IntegerField(required=False) # 前端传入数据，可以不填这个字段
name = serializers.CharField(allow_blank=True, required=False, max_length=8,
min_length=3, error_messages={'max_length': '太长了'}) # allow_blank: 这个字段传了，value值可以为空
price = serializers.IntegerField(max_value=100, min_value=10, error_messages={'max_value': '必须小于100'})
# price = serializers.CharField()
# 局部钩子：给某个字段做个校验
# 书名中不能包含sb
# validate_字段名
def validate_name(self, name):
if 'sb' in name:
# 不合法，抛异常
raise ValidationError('书名中不能包含sb')
else:
return name
def validate_price(self, item):
if item == 88:
raise ValidationError('价格不能等于88')
else:
return item
# 全局钩子
# 价格和书名不能一样 validate
def validate(self, attrs):
price = attrs.get('price')
name = attrs.get('name')
if name == price:
raise ValidationError('价格不能等于书名')
else:
return attrs
def create(self, validated_data):
# validated_data校验过后的数据，字典
book = Book.objects.create(**validated_data)
return book
# def update(self, book, validated_data):
# # instance 要修改的对象
# # validated_data：前端传入，并且校验过后的数据
# book.name = validated_data.get('name')
# book.price = validated_data.get('price')
# # 一定不要忘了
# book.save()
# return book
def update(self, book, validated_data):
for item in validated_data: # {"name":"jinping","price":55}
setattr(book, item, validated_data[item])
# 等同于下面
# setattr(book,'name','jinping')
# setattr(book,'price',55)
# 等同于
# book.name = validated_data.get('name')
# book.price = validated_data.get('price')
book.save()
return book
表模型
from django.db import models
# Create your models here.
class Book(models.Model):
name = models.CharField(max_length=32)
price = models.BigIntegerField()
# 面试题：BigIntegerField跟IntegerField有什么区别
一个是最大能有20亿的，Big最大2的63字方-1
浙公网安备 33010602011771号