drf入门到精通：APIView执行流程（难，了解）、Request对象源码分析（难，了解）、序列化器介绍和快速使用、反序列化、基于序列化器编写5个接口（重点）、反序列化的校验
目录
0 drf 整体内容
# 1 入门规范
-web开发模式
-api接口
-接口测试工具
-restful规范
-序列化反序列化
-drf快速使用
-APIView，Request类
-drf把django的好多东西都重写了
# 2 序列化组件(重要)
-基本序列化类
-模型类序列化类
-如何序列化
-如何反序列化
-反序列化的数据校验功能
# 3 请求与响应
-drf的request已经不是原来djagno的request了
-drf的reponse已经不是原来djagno的reponse了
-指定可以接收请求的编码方式
-指定响应格式
# 4 视图组件（重点） View
-两个视图基类
-5个视图扩展类
-9个视图子类
-视图集
# 5 路由
-自动生成路由
# 6 认证(登录认证)，权限，频率 （重点）
# 7 过滤，排序，分页（次重点）
# 8 自动生成接口文档
----------------------
# 9 JWT 登录认证的，区别与cookie和session，主流
# 10 后台管理美化（django原生的很丑，simpleui二次开发）
# 11 基于角色的访问控制，权限的控制
1 APIView执行流程（难，了解）
1.1 基于APIView+JsonResponse编写接口
# 原来基于django原生的View编写接口
# drf提供给咱们的一个类，以后使用drf写视图类，都是继承这个类及其子类，APIView本身就是继承了Django原生的View
from rest_framework.views import APIView
from django.http import JsonResponse # 原生的
from rest_framework.response import Response # drf提供的
from .models import Book
# 1 基于APIView+JsonResponse 写接口
class BookView(APIView):
def get(self, request):
books = Book.objects.all()
book_list = []
for book in books:
book_list.append({'name': book.name, 'price': book.price, 'publish': book.publish})
return JsonResponse(book_list, safe=False, json_dumps_params={'ensure_ascii': False})
1.2 基于APIView+Response 写接口
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.request import Request
class BookView(APIView): # APIView继承自django的View
def get(self, request):
# print(type(self.request)) # 新的request
# print(type(request))
print(request._request)
print(type(request._request)) #django.core.handlers.wsgi.WSGIRequest
# print(request.method) # get
# print(request.path) # /books/
# print(request.GET) # 原来的get请求提交的参数
# print(request.POST) # 原来post请求提交的参数
books = Book.objects.all()
# books是queryset对象不能直接序列化，只能通过for循环一个个拼成列表套字典的形式
book_list = []
for book in books:
book_list.append({'name': book.name, 'price': book.price, 'publish': book.publish})
return Response(book_list) # 无论是列表还是字典都可以序列化
1.3 APIView的执行流程
1.经过路由层的匹配成功自动执行'views.BookView.as_view()() '我们发现因为我们继承的是'APIView'这个类,此时会进入'APIView'里查看是否有'as_view'方法，进入查看是有的。而且是绑定给类的方法。
@classmethod
def as_view(cls, **initkwargs):
# 发现其内部super使用子类调用父类方法，因为APIView继承的是原生View,那就是调用了django原生的as_view方法。返回的是as_view内层函数view
"此时的view就是原生django as_view的内层函数view"
view = super().as_view(**initkwargs)
# csrf_exempt 就是排除了所有的csrf认证,把view传过去那么相当于给view加了个语法糖，view内部所有的方法都不用过csrf认证
"我们在执行视图类的各种请求方法其实都是通过了view的内部进行了反射拿到并执行"
return csrf_exempt(view)
2. 路由匹配成功后执行了上面的步骤最后'diango原生的view方法'返回的是'self.dispatch'方法. 我们通过名称空间的查找顺序此时的'self对象'是视图类'BookView'的对象那么我们先从自身查找发现并没有'dispatch'方法，那么去父类'APIView'里查找发现有这个方法，此时执行的是'APIView的dispatch'方法。
def dispatch(self, request, *args, **kwargs):
# 此时的request还是django原生的request,从下面这行代码包装后成为了drf的新的request，“initialize_request”反回了一个新的request
# 老的request被initialize_request方法内部的Response给了对象self._request
request = self.initialize_request(request, *args, **kwargs)
# 到此以后，这个request就是新的了，老的request在哪？
# request._request 这是老的
# 把新的request给了视图类BookView的对象
self.request = request
try:
"initial 三大认证【认证，频率，权限】"# 此时的request是新的request
self.initial(request, *args, **kwargs)
# 用反射拿到方法与原生的dispatch方法一致
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
# 新的request传入了视图方法此时视图类方法的request也是新的。
response = handler(request, *args, **kwargs)
except Exception as exc:
# 在执行3大认证和视图类中方法的过程中，如果出了异常，都能捕获到---》全局异常捕获
response = self.handle_exception(exc)
self.response = self.finalize_response(request, response, *args, **kwargs)
return self.response
总结:APIView的执行流程
1 去除了所有的csrf
2 包装了新的request，以后在视图类中用的request是新的request Request类的对象，不是原生的了
-原生的在：新的requets._request
3 在执行视图类的方法之前，执行了3大认证
4 如果在3大认证或视图函数方法执行过程中出了错，会有异常捕获----》全局异常捕获
5 以后视图类方法中的request都是新的了
补充：装饰器
def auth() # 装饰器
def add() # 函数
# 使用auth装饰add函数
@auth # 本质是 add=auth(add)
def add()
# 以后再使用add，其实就是在使用 auth(add) 的返回结果
2 Request对象源码分析（难，了解）
我们知道经过APIView类的各种方法处理后此时视图类的request是新的，那么老的request在哪里？
在APIView里发现
from rest_framework.request import Request
就是在dispatch内的initialize_request把request包装成了新的request,返回的Request，并在内部把老的给了self._request.那么此时新的request里面包含了老的request
request._request也能拿到老的。
此时又出现问题了，在视图类方法中执行request.method，研究源码发现新的Request他并没有method方法，但是有一个双下getattr方法，这个魔法方法在.一个不存在的名字时会触发。
def __getattr__(self, attr):
try:
# self._request此时去了老的request反射拿到方法
return getattr(self._request, attr)
except AttributeError:
return self.__getattribute__(attr)
request.data # data方法被伪装成了数据属性 不用加括号直接就可以的调用
"POST，PUT等等请求方法在body内提交的数据，都从request.data中取，取出来就是字典，无论是哪种编码格式"
request.query_params # 这是个方法，包装成了数据属性
"get请求携带的参数都从这里面取"
"query_params：查询参数--->restful规范请求地址中带查询参数"
request.FILES # 这是个方法，包装成了数据属性
"前端提交过来的文件，从这里面取"
Request类总结
-1 新的request用起来，跟之前一模一样，因为新的取不到，会取老的__getattr__
-2 request.data 无论什么编码，什么请求方式，只要是body中的数据，就从这里取，字典
-3 request.query_params 就是原来的request._request.GET
-4 上传的文件从request.FILES
python 中有很多魔法方法,在类中，某种情况下触发，会自动执行
__str__:打印对象会调用
__init__:类() 会调用
__call__: 对象() 会调用
__new__:
__getattr__：对象.属性，如果属性不存在，会触发它的执行
3 序列化器介绍和快速使用
因为在写接口时，需要序列化，需要反序列化，而且反序列化的过程中要做数据校验---》drf直接提供了固定的写法，只要按照固定写法使用，就能完成上面的三个需求
提供了两个类 Serializer ModelSerializer
-以后咱们只需要写自己的类，继承drf提供的序列化类，使用其中的某些方法，就能完成上面的操作
使用APIView+序列化类+Response 完成接口的编写
3.1 序列化类基本使用，序列化多条
serializer.py--BookSerializer类(在app01中创建一个新的py文件写即可)
from rest_framework import serializers
class BookSerializer(serializers.Serializer):
# 序列化某些字段，这里写要序列化的字典
name = serializers.CharField() # serializers下大致跟models下的类是对应的
price = serializers.CharField()
publish = serializers.CharField()
views.py--->BookView类
class BookView(APIView):
def get(self, request):
# 只是为了验证之前讲过的
print(request.method)
print(request._request)
print(type(self.request))
books = Book.objects.all()
# 使用序列化类来完成---》得有个序列化类
# instance要序列化的数据books queryset对象
# many=True 只要是queryset对象要传many=True，如果是单个对象就不用传
ser = BookSerializer(instance=books, many=True)
return Response(ser.data) # 无论是列表还是字典都可以序列化
3.1 序列化单条
序列化类---没有动
from rest_framework import serializers
class BookSerializer(serializers.Serializer):
# 序列化某些字段，这里写要序列化的字典
name = serializers.CharField() # serializers下大致跟models下的类是对应的
# price = serializers.CharField()
publish = serializers.CharField()
视图类---》BookDetailView
class BookDetailView(APIView):
# def get(self, request,pk):
def get(self, request, *args, **kwargs):
book = Book.objects.filter(pk=kwargs.get('pk')).first()
# 序列化
ser = BookSerializer(instance=book)
return Response(ser.data)
url加了新的路由
urlpatterns = [
path('books/<int:pk>/', views.BookDetailView.as_view()),
]
4 反序列化
4.1 反序列化的新增
序列化类
class BookSerializer(serializers.Serializer):
# 序列化某些字段，这里写要序列化的字典
name = serializers.CharField() # serializers下大致跟models下的类是对应的
price = serializers.CharField()
publish = serializers.CharField()
def create(self, validated_data):
# 保存的逻辑
# validated_data 校验过后的数据 {name,price,publish}
# 保存到数据库
book = Book.objects.create(**validated_data)
# 一定不要忘了返回新增的对象
return book
视图类
class BookView(APIView):
def post(self, request):
# requset.data # 前端提交的要保存的数据----》校验数据---》存
ser = BookSerializer(data=request.data) # 把前端传入的要保存的数据，给data参数
# 校验数据
if ser.is_valid():
# 保存---->需要自己写，要在序列化类BookSerializer中写----》create方法
ser.save() # 调用ser.save,自动触发咱们写的create，保存起来
return Response({'code': 100, 'msg': '新增成功', 'result': ser.data})
else:
return Response({'code': 101, 'msg': ser.errors})
4.2 反序列化的修改
序列化类
class BookSerializer(serializers.Serializer):
# 序列化某些字段，这里写要序列化的字典
name = serializers.CharField() # serializers下大致跟models下的类是对应的
price = serializers.CharField()
publish = serializers.CharField()
def create(self, validated_data):
# 保存的逻辑
# validated_data 校验过后的数据 {name,price,publish}
# 保存到数据库
book = Book.objects.create(**validated_data)
# 一定不要返回新增的对象
return book
def update(self, instance, validated_data):
# instance 要修改的对象
# validated_data 校验过后的数据
instance.name = validated_data.get('name')
instance.price = validated_data.get('price')
instance.publish = validated_data.get('publish')
instance.save() # orm的单个对象，修改了单个对象的属性，只要调用对象.save,就能把修改保存到数据库
return instance # 不要忘了把修改后的对象，返回
视图类
class BookDetailView(APIView):
def put(self, request, pk):
book = Book.objects.filter(pk=pk).first()
# 反序列化保存 ---借助于序列化类
ser = BookSerializer(data=request.data, instance=book)
if ser.is_valid():
ser.save() # 由于没有重写update，所以这报错
return Response({'code': 100, 'msg': '修改成功', 'result': ser.data})
else:
return Response({'code': 101, 'msg': ser.errors})
4.3 删除单条
视图类
class BookDetailView(APIView):
def delete(self, request, pk):
Book.objects.filter(pk=pk).delete()
return Response({'code': 100, 'msg': '删除成功'})
5 基于序列化器编写5个接口（重点）
上面写的就是
6 反序列化的校验
序列化类反序列化，数据校验功能--->类比forms组件
- 局部钩子
- 全局钩子
class BookSerializer(serializers.Serializer):
# 序列化某些字段，这里写要序列化的字典
name = serializers.CharField() # serializers下大致跟models下的类是对应的
price = serializers.CharField()
publish = serializers.CharField()
def create(self, validated_data):
# 保存的逻辑
# validated_data 校验过后的数据 {name,price,publish}
# 保存到数据库
book = Book.objects.create(**validated_data)
# 一定不要忘了返回新增的对象
return book
def update(self, instance, validated_data):
# instance 要修改的对象
# validated_data 校验过后的数据
instance.name = validated_data.get('name')
instance.price = validated_data.get('price')
instance.publish = validated_data.get('publish')
instance.save() # orm的单个对象，修改了单个对象的属性，只要调用对象.save,就能把修改保存到数据库
return instance # 不要忘了吧修改后的对象，返回
# 反序列化校验的局部钩子 ，名字不能以sb开头
def validate_name(self, name):
# 校验name是否合法
if name.startswith('sb'):
# 校验不通过，抛异常
raise ValidationError('不能以sb开头')
else:
return name
# 全局钩子
def validate(self, attrs):
# 校验过后的数据，书名跟出版社名字不能一致
if attrs.get('name') == attrs.get('publish'):
raise ValidationError('书名跟出版社名字不能一致')
else:
return attrs
