DRF 03
APIVew执行流程
基于APIView + JSONResponse编写接口
原来基于django原生的view编写接口
# drf给我们提供了一个类，以后使用drf写视图类，都是继承这个类极其子类，APIView本身就是继承了django原生的view
在导入rest_framework模块类可以通过想要导入的是什么方法就直接，拼该方法的单词
from rest_framework.views import APIView
from rest_framework.request import Request
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})
return JsonResponse(book_list,safe=False)
基于APIView + 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})
return Response(book_list)
以上两种的书写方式的效果都是一样的，只不过我们既然已经继承了APIViews，就使用它自己的Response来进行数据的返回会比较简洁方便。
API接口的执行流程
之前使用api都是使用jsonresponse返回数据，现在继承的是apiview的response返回，还是需要序列化，但是不需要safe，指定格式。
- 首先我们需要在路由中编写：
path('books/', views.BookView.as_view()),-->请求来了就执行
views.BookView.as_view()()--->现在的as_view是APIView的as_view
APIView的as_view方法：view还是原来的view，但是以后在也没有csrf认证了，以后我们会编写自己的认证方法
@classmethod
def as_view(cls, **initkwargs):
# 1.通过调用父类的as_view，父类就是django原生的view
#2.把django原生view的as_view（就是上面as_view加了括号）方法中的闭包函数view拿出来
view = super().as_view(**initkwargs)
# csrf_exempt排除所有的csrf的认证
# 这里的view就是要执行的视图类里面的方法
return csrf_exempt(view) # 在所有的方法上面加上了这个装饰器
路由匹配成功，就会执行csrf_exempt(view)(requets)再到>> View的as_view中的闭包函数view （虽然它加上了这个装饰器，但是它的本质还是这个view） >>>就执行 self.dispatch >>> self是视图类的对象>>> 再到BookiView>>> 找不到就再到 APIView的dispatch找到
# 1. 路由匹配成功，请求来了就会执行这个dispatch
def dispatch(self, request, *args, **kwargs):
# request是django原生的request，老的request
# 2.把老的request包装成了新的request，这个是drf提供的Request类的对象
request = self.initialize_request(request, *args, **kwargs)
# 到此以后，这个request就是新的了，老的request在哪？
# request._request 这是老的 被存放到Request里面
#3. 把新的request放到了self对象【BookView的对象】
self.request = request
try:
# 4.执行了三大认证【认证，频率，权限】，使用新的request
self.initial(request, *args, **kwargs)
# 跟之前的一样，假如我是get请求就执行 getview的get功能
# 5. 在这里用try来包住的意思就是当我们在执行请求的时候，出了异常就会被捕获到，然后处理了异常再把它给返回
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
# 回顾知识
在使用装饰器的时候，被装饰的函数就是装饰器把被装饰函数传入括号内加括号调用
func(index)()
以后在使用index功能函数，其实就是在使用func(index)()的返回结果
总结：APIView的执行过程
- 1.去除了所有的csrf
- 2.包装了新的request，以后在视图类中使用的request是新包装的request， Request类的对象，不在是原生的request了
- 原生的在：
新的request._request
- 原生的在：
- 3.在执行视图类的方法之前，执行了3大认证
- 4.如果在3大认证或函数方法执行的过程中出了错。会有异常捕获>>>>全局异常捕获
- 5.以后视图类方法中的request都是新的了
Request对象源码分析（了解）
-新的Request >>>区别于老的Request
-老的：django.core.handerls.wsgi.WSGIRequest
- 新的：from rest_framework.request import Request
-新的request._request 包含着老的
# Request源码
-方法__getattr__
-在视图类的方法中，执行request.method,新的request是没有method的，就会触发Request的__getattr方法的执行
def __getattr__(self, attr):
try:
# 从老的request中反射出 要取得属性
# 就是上面将method传进来，就是取老的里面取出来，加上这这就是，老的里面有什么，新的里面就有什么
return getattr(self._request, attr)
except AttributeError:
# 老的里面也没有就报错
return self.__getattribute__(attr)
-request.data >>>:这是一个方法，包装成了数据属性
以后无论是post,put ... 只要是放在body中的数据都在这里面取，取出来的格式是字典
无论里面的是哪种编码格式 (取它，反序列化就可以了，至于怎么来的，可以看源码)
- request.query_params >>>:这是一个方法，包装成了数据属性
-GET请求携带的参数，以后就从这里面取
-query_params的意思：查询参数， 而restful规范中请求地址中携带查询参数（也可以叫过滤参数）
以后在取request.GET中携带的参数，上面的两种方法都可以使用
- request.FILES >>>>:这是方法，包装了属性
- 前端提交过来的属性就到这里取，
Request总结：
- 新的request用起来，跟之前的一模一样，因为新的取不到，就会到老的里面取__getattr__
- request.data 无论什么样的编码格式，什么请求方式，只要是在body中的数据，就在这里面取，取出来的结果是字典
- request.query_params 就是原来的request._request.GET
- 上传文件还是在request.FIELS，但是还有很多的功之后补充
关于__ getattr __方法：
序列化器介绍和使用（5个接口）
在我们写接口的时候，需要序列化、反序列化，而且反序列化的过程中要做数据校验--->drf直接提供了固定的写法，只要按照固定的写法使用，就能完成上面的三个需求
# 提供了两个类 Serializer ModelSerializer
以后只要写自己的类，继承drf提供的序列化类，使用其中的某种方法，就能完成上面的操作
# 只用APIView + 序列化 +Request 完成接口的编写
- 这是DRF框架的功能
- Serializer序列化器
- 视图
- 认证、权限、限流、过滤、排序、分页、异常处理、自动生成接口文档
- 在一个功能业务逻辑中可以包含序列化和反序列化
使用方法
- 定义Serrilizer 定义方法
Django Rest_framework中的Serializer使用类来定义，须继承自rest_framework.serializers.Serializer。
serializer不是只能为数据库模型类定义，也可以为非数据库模型类的数据定义。serializer是独立于数据库之外的存在。
- 序列化过程
- 创建serializer.py文件
- 继承serializers.Serializer创建类
- 指定序列化器返回字段
- 查询数据
- 创建序列化器对象，传入查询集
- JSONResponse（）返回
- 返回多个数据对象时
- 序列化器对象创建时需写关键字参数many=True
- JSONResponse（）中需要写入关键字参数safe= False
创建Serializer对象
定义好Serializer类后，就可以创建Serializer对象了
Serializer(instance=None,data=empty,**kwargs)
说明：
- 用于序列化时，将模型类对象传入instance参数
- 用于反序列化时，将要被反序列化的数据传入data参数
- 除了instance和data参数往外，在构造Serializer对象时，还可以通过context参数额外添加数据，如下：
serializer= AccountSerializer(account, context={'request': request})
通过context参数附加的数据，可以通过Serializer对象的context属性获取
data 方法的说明
data是一个方法，根据序列化器中接受到的查询集构造字典形式的数据
代码：
serializer.py -- BookSerializer类
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) # 无论是列表还是字典都可以序列化
序列化单条
序列化类（不用动）
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)
序列化多条
class BookDetailView(APIView):
def get(self,request,*args,**kwargs):
book= Book.objects.all()
# 将数据序列化
# instance要序列化的数据books queryset对象
# many=True 只要是queryset对象传入就加上，如果的那个对象就不用many
ser=BookSerializer(instance=book,many=True)
return Response(ser.data)
路由中添加了新的路由
urlpatters=[
path('books/<int:pk>/',views.BookDetailView.as_view())
]
反序列化
反序列化的新增
序列化类
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})
修改功能
序列化类
class BookSerializer(serializers.Serializer):
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})
删除功能
视图类
class BookDetailView(APIView):
def delete(self, requset, pk):
Book.objects.filter(pk=pk).delete()
return Response({'code': 100, 'msg': '删除成功'})
反序列化的校验
- 序列化类反序列化，数据的校验功能，就像是forms组件
- 全局钩子和局部钩子
from rest_framework.exceptions import ValidationError
# 反序列化校验的局部钩子
def validate_name(self,name):
# 校验name是否合规
if name.startswith('xxx'):
# 校验不通过抛异常
raise ValidationError('不拿能够以xxx作为开头')
else:
return name
# 反序列化校验全局钩子
def validate(self, attrs):
# 校验过后的数据，书名根出版社名字不一致
if attrs.get('name')==attrs.get('publish'):
raise ValidationError('书名跟出版社名不能一样')
else:
return attrs
浙公网安备 33010602011771号