标签：序列化 请求 request instance 总览 data Response
Ⅰ drf学习总览概述
# 1 请求和响应
request：请求对象：请求方式，请求携带的数据，request.GET,request.POST,requset.body,request.META:请求头中得
四件套:操作响应体
HTTPResponse('sdfs') # 若是要携带请求头和响应状态码 应该是 return HTTPResponse('sdfs', status=201, headers={"xx":"yy"})
JsonResponse(字典列表)
render(request,模板文件)
drf有自己的请求和响应
request
Response 的对象
# 2 序列化类：Serializer 用途
1.做序列化
2.做反序列化的
3.反序列化的校验
# 3 视图类：drf提供了非常多 视图类可以继承
# 4 路由
# 5 认证：登录认证
# 6 权限
# 7 频率限制
# 9 统一返回错误
# 10 jwt：登录认证用
# 11 基于角色的访问控制
Ⅱ http请求不同编码格式，请求体什么样子
【一】get请求能不能再请求体中携带数据？
能
一般都是post或put请求在请求体中带数据
【二】get请求和post请求区别？
GET：主要用于获取服务器上的资源。GET请求通常用于查询数据，不应当引起服务器上的任何状态变化。
POST：主要用于向服务器发送要被处理的数据（例如，表单数据、文件上传等）。
GET：由于数据附加在URL中，因此GET请求的数据大小受到URL长度限制，通常限制在1024字节左右。
POST：数据包含在请求体中，理论上没有大小限制，可以发送大量数据。相对更安全
总结来说，GET请求更适合用于获取数据，而POST请求更适合用于发送数据
【三】总结
django视图类或视图函数的request
request.POST:只针对于 post请求的urlencoded编码格式 才有数据 # 重点
request.GET:请求地址栏中得参数：get，post，delete，put
# <QueryDict: {'key': ['key', '99']}>
类字典：取出key的值
只取一个:request.GET.get('key')
两个都取:request.GET.getlist('key')
request.body:无论什么请求， 无论什么编码格式，都在里面
http不同编码格式
urlencoded：在请求体中是 key=value&key=value
json:在请求体中是 {"name":"lqz","age":19}
form-data: asdfasdf-------数据部分 asdfasdfasdf-----文件部分
Ⅲ 新的Request对象和Response
【一】 Request
# 1 以后全是cbv，继承一个基类--> drf的APIView【也继承了Django的View】及子类
# 2 继承APIView后， 以后响应统一用 drf的响应 : Response
# !!!!!!! 如果想用 Response 要在 settings里面 将 rest_framework 放进去 否则会报错
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'app01.apps.App01Config',
'rest_framework',
]
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from django.views import View
from rest_framework.request import Request
class BookView(APIView):
def get(self, request):
'''
1 request 请求对象：http请求的所有内容，都会在这个对象中
2 继承APIView后的request对象，不是之前的request对象了
原来的：django.core.handlers.wsgi.WSGIRequest
新的： rest_framework.request.Request
3 用起来跟之前一样
print(request.method)
print(request.POST)
print(request.GET)
print(request.get_full_path())
4 request.data
无论那种编码格式，请求体的数据，都在这里面
urlencoded,form-data:是QueryDict的对象
json：是普通字典对象
但是，都当字典用即可
5 request.FILES
前端传的文件从这里取
6 request.query_params # 查询参数
request.GET
7 老的request在
requset._request
'''
# print(type(request))
# print(request.method)
# print(request.POST)
# print(request.GET)
# print(request.get_full_path())
print(request.data)
print(request.query_params)
print(request._request)
# return JsonResponse({'code':100,'msg':'请求成功'})
# 如果使用postman访问，返回json，如果使用浏览器访问，会返回好看的样式界面，使用Response必须注册app
return Response('ok', status=status.HTTP_404_NOT_FOUND, headers={'xx': 'yy'})
【二】Response
from rest_framework.response import Response
【1】如何用
直接放字典，列表或字符串
Response('ok')
放在响应体中了
【2】如何放状态码
Response('ok',status=201)
【3】如何放响应头
Response('ok',status=201,headers={'xx':'yy'})
【4】总结 Response
data=None # 响应体：可以传 字典，列表或字符串
status=None# http响应 状态码-->drf封装了所有常量 HTTP_200_OK = 200 从from rest_framework import status看 CTRL加鼠标右键 点击status看
template_name=None# 忽略掉-->指定使用浏览器访问返回的模板，没写用默认模板
headers=None # 响应头
exception=False# 异常
content_type=None # 响应编码格式，一般不动，都用json
- template_name=None
- 在源码中看，最后是好看的模板样式
- 如果使用postman访问，返回json，如果使用浏览器访问，会返回好看的样式界面
Ⅳ 序列化类
【一】序列化类介绍
# 序列化类的作用
前端传json格式字符串 给 后端 -->后端需要 保存到数据库---> 这就需要反序列化
后端从数据库查出来的 对象--->以json格式字符串的形式给前端--> 这就需要序列化
serializer就是为了完成上面的操作
序列化
反序列化
反序列化校验
【二】快速使用
from django.db import models
class Student(models.Model):
name = models.CharField(max_length=32)
age = models.IntegerField()
gender = models.IntegerField(choices=((1, '男'), (2, '女'), (0, '未知')))
from django.urls import path,include
urlpatterns = [
path('api/v1/', include('app01.urls')),
]
from .views import BookView,BookDetailView,StudentView,StudentDetailView
from django.urls import path
urlpatterns = [
path('students/', StudentView.as_view()),
path('students/<int:pk>/', StudentDetailView.as_view()),
]
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
import json
from django.http import JsonResponse, HttpResponse
from .serializer import StudentSerializer
from .models import Student
# 查询所有数据
class StudentView(APIView):
def get(self,request):
# 查出所有学生
# 得到的是 queryset对象
result = Student.objects.all()
# 序列化
# 第一种方法
# 序列化 -->笨办法 -->自己拼接，麻烦一些
# lli=[]
# for student in result:
# lli.append({'id':student.pk,'name':student.name,'age':student.age,'gender':student.get_gender_display()})
# 第二种
# 2 drf提供的序列化类完成序列化:instance要序列化的对象，如果是多条 many=True
serializer = StudentSerializer(instance=result, many=True)
# 返回
# return JsonResponse(result,safe=False) # Object of type QuerySet is not JSON serializable
# return Response(result) # no such table: app01_student 这个报错是由于还没有迁移数据库
# return Response(result) # Object of type Student is not JSON serializable
return Response(serializer.data)
# 查询单条数据
class StudentDetailView(APIView):
def get(self, request, pk):
# 1 根据id查出对象
obj = Student.objects.filter(pk=pk).first()
# 2 序列化
serializer = StudentSerializer(instance=obj)
# 3 返回
return Response(serializer.data)
from rest_framework import serializers
'''
使用步骤：
1 定义一个类，继承Serializer
2 在类中写要序列化的字段:字段类，跟models中得一一对应
3 在视图类中使用
'''
from .models import Student
class StudentSerializer(serializers.Serializer):
id = serializers.IntegerField(required=False)
name = serializers.CharField(required=True) # 不想在postman上展示那个字段 只需要注销即可
age = serializers.IntegerField(required=True)
gender = serializers.IntegerField(required=False,default=0)
【三】常用字段
# 记住-->跟models中得 model.字段类， 一一对应
# 具体有哪些-->了解
# 常用的一些字段 用# 标记出
BooleanField
NullBooleanField
CharField #
EmailField
RegexField
SlugField
URLField
UUIDField
IPAddressField
IntegerField #
FloatField
DecimalField
DateTimeField #
DateField #
TimeField #
ChoiceField
MultipleChoiceField
FileField
ImageField
# --------两个特殊的，很重要----
ListField
DictField
# 大绝招：如果不知道models和Serializer如何对应
序列化类统一用 CharField
【四】 常用字段参数
# 序列化的 字段类在实例化时，传参数
-作用是：为了反序列化校验用
# 有哪些字段参数-->了解
# 只针对于：CharField
max_length 最大长度
min_lenght 最小长度
allow_blank 是否允许为空
trim_whitespace 是否截断空白字符
# 只针对于：IntegerField
max_value 最小值
min_value 最大值
# 只针对于：DateTimeField
format：序列化时，显示的格式
DateTimeField(format='Y-m-d')
或者 DateTimeField(format='Y/m/d')...
# 所有字段类都用
required：是否必填
default ：反序列化时使用的默认值
allow_null 表明该字段是否允许传入None，默认False
# 两个重点
read_only 表明该字段仅用于序列化输出，默认False
write_only 表明该字段仅用于反序列化输入，默认False
Ⅴ 反序列化保存
【一】新增
# 使用步骤：
1. 写个序列化类，继承Serializer
2. 在序列化类中写字段，和字段参数[校验用的]
3. 在视图类中使用
def post(self, request):
# 1 取出前端传入的数据-->无论什么编码格式，无论什么请求方式 request.data
serializer = StudentSerializer(data=request.data)
# 2 反序列化校验，保存到数据库
if serializer.is_valid():
# 校验通过，保存,会报错, 所以在序列化类中重写create方法
serializer.save()
# 3 返回给前端成功
# return Response(serializer.data) # 把新增的数据，序列化一下，返回
return Response({'code': 100, 'msg': '保存成功'})
else:
# 4 返回给前端失败
return Response({'code': 101, 'msg': '数据校验失败'})
4.要在序列化类中重写create
def create(self, validated_data):
# validated_data:前端传入，校验过后的数据
student=Student.objects.create(**validated_data)
return student # 不要忘了，返回新增的对象--->后期调用serializer.data 时，会使用它序列化
【二】修改
# 使用步骤：
1. 写个序列化类，继承Serializer
2. 在序列化类中写字段，和字段参数[校验用的]
3. 在视图类中使用
def put(self, request, pk):
# 1 查出要修改的对象
obj = Student.objects.filter(pk=pk).first()
# 2 拿到前端传入的数据--修改成的数据
serializer = StudentSerializer(instance=obj, data=request.data)
# 3 校验数据是否合法
if serializer.is_valid():
# 4 修改 在序列化类中重写 update
serializer.save()
return Response({'code': 100, 'msg': '修改成功'})
else:
# 4 返回给前端失败
return Response({'code': 101, 'msg': '修改失败，因为数据校验失败'})
4.要在序列化类中重写update
def update(self, instance, validated_data):
# validated_data:前端传入，校验过后的数据
# instance:待修改的对象
# 1 笨办法
# instance.name=validated_data.get('name')
# instance.age=validated_data.get('age')
# instance.gender=validated_data.get('gender')
# 2 高级办法
for key in validated_data: # 循环拿到字典的一个个key
# 等同于 instance.name=validated_data.get('name')
setattr(instance,key,validated_data.get(key))
instance.save()
return instance #不要忘了，返回修改的对象--->后期调用serializer.data 时，会使用它序列
【三】源码
# 1 为什么要重写 update和create
因为执行serializer.save--->会触发self.create或self.update执行
我们没写-->找父亲-->找父亲-->找到了
def create(self, validated_data):
raise NotImplementedError('`create()` must be implemented.')
# 2 为什么调用的都是save，但是最后触发的序列化类中得方法是不同的？
因为内部判断了 instance 是否为None
# 阅读源码
serializer.save()-->序列化类对象【自己写的StudentSerializer，没有save】 调用save，会触发父类的save-->Serializer中也没有save--->继续找父类BaseSerializer 有save方法
save源码
# self 是咱们写的序列化类的对象
# 如果是修改，instance 有值
if self.instance is not None:
# self.update 自己重写了，调用自己的
self.instance = self.update(self.instance, validated_data)
else:
self.instance = self.create(validated_data)
return self.instance
标签：序列化,
请求,
request,
instance,
总览,
data,
Response
From： https://www.cnblogs.com/zyb123/p/18324159