目录
APIView执行流程
基于APIView+JsonResponse编写接口
原来基于django原生的view编写接口
drf提供给咱们的一个类，以后使用drf写视图类，都是集成这个类及其子类，APIView本身就是集成了Django原生的View
代码展示：
from rest_framework.views import APIView
from .models import Book
from django.http import JsonResponse
class BookView(APIView):
def get(self, request):
# 拿到所有的数据
books = Book.objects.all()
# 缺点是还要自己for循环放到列表
book_list = []
for book in books:
book_list.append({'name': book.name, 'price': book.price, 'publish': book.publish})
# 序列化不支持列表，需要填写参数
return JsonResponse(book_list, safe=False)
基于APIView+Response写接口
from rest_framework.views import APIView
from .models import Book
from rest_framework.response import Response
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})
# 相对于JsonResponse来说，不需要再写参数，列表同样可以序列化
return Response(book_list)
APIView的执行流程
"""
首先复习对象名字的查找顺序，先在对象自己的内部名称空间，然后到产生对象的类，在到产生对象的类的父类中查找，每一次查找名字都是按照这样的顺序去找
"""
路由中写的： path('books/', views.BookView.as_view()),---》请求来了，执行views.BookView.as_view()()----->现在的as_view是APIView的as_view，因为我们自己写的类没有这个as_view这个方法，所以要从父类中寻找，现在我们的父类是APIView
class APIView(View):
# 这里我们可以看到APIView其实继承的还是django原生的View
@classmethod # 这句话标识是绑定给类的方法，那么调用这个as_view会直接将类传入，我们是自己写的类在路由层调用了该方法，所以会将我们自己写的类作为第一个参数传入，也就是参数的cls
def as_view(cls, **initkwargs):
# APIView的as_view方法：view还是原来的view，但是以后再也没有csrf认证了
view = super().as_view(**initkwargs)
# 上面这句话表示子类调用父类的方法，也就是调用View类的as_view方法，然后拿到了里面的闭包函数view
view.cls = cls
view.initkwargs = initkwargs
# csrf_exempt是装饰器，这样写其实就是装饰器语法糖作用在view这个函数上直接将函数作为参数传入,那么执行view这个函数就全程不会校验scrf了
return csrf_exempt(view)
# 路由匹配成功，执行csrf_exempt(view)(requets)--->在执行view这个函数也就是在View类中的as_view中的闭包函数view---》这个函数会返回执行self.dispatch---->self是视图类的对象---->BookView---->然后对象点dispatch方法，首先从对象自己找然后再找产生对象的类也就是BookView都没有再从父类里面找也就是APIView里面的dispatch方法，找到了
def dispatch(self, request, *args, **kwargs):
# request是django原生的request，老的request
# 把老的request包装成了新的request，这个是drf提供的Request类的对象
request = self.initialize_request(request, *args, **kwargs)
# 到此以后，这个request就是新的了，老的request在哪？
# request._request 这是老的
# 把新的request放到了self对象【BookView的对象】
self.request = request
try:
# 执行了三大认证【认证，频率，权限】，使用新的request，不读
self.initial(request, *args, **kwargs)
# 跟之前一毛一样
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传入了，视图类的方法中get的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类的对象，不是原生的了
-原生的在新的request._request
3.在执行视图类的方法之前，执行了3大认证
4.如果在3大认证或者视图函数方法执行过程中出了错，就会有异常捕获---》全局异常捕获
5.以后视图类方法中的request都是新的了
Request对象源码分析
新的Request----》区别于老的
老的：django.core.handlers.wsgi.WSGIRequest
新的:from rest_framework.request import Request
新的request._request 就是老的
Request源码
-方法 __getattr__
-在视图类的方法中，执行request.method，新的request是没有method方法的，就出发了新的Request的__getattr__方法执行
def __getattr__(self, attr):
try:
# 从老的request中反射出 要取得属性
return getattr(self._request, attr)
except AttributeError:
return self.__getattribute__(attr)
所以我们使用新的request点method的时候其实拿到的是老的request.method的结果
request.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中取
序列化器介绍和快速使用
因为我们在写接口时，需要序列化和反序列化，而且反序列化的过程中要做数据校验---》drf直接提供了固定的写法，只要按照固定写法使用，就能完成上面的三个需求
# 提供了两个类 Serializer ModelSerializer
-以后只需要写自己的类，集成drf提供的序列化类，使用其中的某些方法，就能完成上面的操作
# 使用APIView+序列化类+Response完成接口的编写
序列化类基本使用，序列化多条
Serializer.py--BookSerializer类
from rest_framework import serializers
class BookSerializer(serializers.Serializer):
# 序列化某些字段，这里要写序列化的字段
name = serializers.CharField()
price = serializers.CharField()
publish = serializers.CharField()
views.py-->BookView类
from rest_framework.views import APIView
from .models import Book
from rest_framework.response import Response
from .Serializer import BookSerializer
class BookView(APIView):
def get(self, request):
print(request.method) # GET
print(request._request.method) # GET
print(self.request._request.method) # GET
# 拿到所有的数据
books = Book.objects.all()
# 使用序列化类来完成序列化
# instance是要序列化的数据boos queryset对象
# many=True 只要是queryset对象要穿many=True，如果是单个对象就不用传
ser = BookSerializer(instance=books,many=True)
return Response(ser.data) # 无聊是列表还是字典都可以序列化
序列化单条
序列化类没动
from rest_framework import serializers
class BookSerializer(serializers.Serializer):
# 序列化某些字段，这里要写序列化的字段
name = serializers.CharField()
price = serializers.CharField()
publish = serializers.CharField()
视图类重新写一个新的
from rest_framework.views import APIView
from .models import Book
from rest_framework.response import Response
from .Serializer import BookSerializer
class BooksView(APIView):
def get(self, request, *args, **kwargs):
book = Book.objects.filter(pk=kwargs.get('pk')).first()
# 序列化,单条不用写many=True
ser = BookSerializer(instance=book)
return Response(ser.data)
url添加新的路由
urlpatterns = [
path('book/<int:pk>/', views.BooksView.as_view()),
]
反序列化
反序列化的新增
序列化类写一个create方法
def create(self, validated_data):
# 保存的逻辑
# validated_date是校验过后的数据
# 保存到数据库
book = Book.objects.create(**validated_data)
# 一定要返回新增的对象
return book
视图类
def post(self, request):
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})
return Response({'code': 101, 'msg': ser.errors})
序列化的修改
序列化类写一个修改的方法
def update(self, instance, validated_data):
# instance要修改的对象,也就是我们数据库中原来的orm对象
# 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 # 把修改后的对象返回出去
视图类
def put(self, request, **kwargs):
# 获取要修改的数据对象
book = Book.objects.filter(pk=kwargs.get('pk')).first()
# 把要修改的数据对象和前端的传来的数据都传给序列化类
ser = BookSerializer(data=request.data, instance=book)
if ser.is_valid():
ser.save() # 调用save方法自动调用我们写的update方法
return Response({'code': 100, 'msg': '修改成功', 'result': ser.data})
return Response({'code': 101, 'msg': ser.errors})
删除单条
def delete(self, request, pk):
Book.objects.filter(pk=pk).delete()
return Response({'code': 100, 'msg': '删除成功'})
反序列化的校验
序列化反序列化，数据校验功能----》类比forms组件
局部钩子和全局钩子
from rest_framework import serializers
from .models import Book
from rest_framework.exceptions import ValidationError
class BookSerializer(serializers.Serializer):
# 序列化某些字段，这里要写序列化的字段
name = serializers.CharField()
price = serializers.CharField()
publish = serializers.CharField()
def create(self, validated_data):
# 保存的逻辑
# validated_date是校验过后的数据
# 保存到数据库
book = Book.objects.create(**validated_data)
# 一定要返回新增的对象
return book
def update(self, instance, validated_data):
# instance要修改的对象,也就是我们数据库中原来的orm对象
# 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 # 把修改后的对象返回出去
# 局部钩子
def validate_name(self, name):
# 校验name是否合法
if name.startswith('sb'):
# 校验不通过，抛异常
raise ValidationError('不能以sb开头')
else:
return name
# 全局钩子
def validate(self, attrs):
# attrs就是前端传来的数据
if attrs.get('name') == attrs.get('publish'):
raise ValidationError('书名跟出版社名字不能一致')
else:
return attrs