drf入门——APIView执行流程、Request对象源码分析、序列化器、反序列化及其校验

drf入门——APIView执行流程、Request对象源码分析、序列化器、反序列化及其校验

• drf入门——APIView执行流程、Request对象源码分析、序列化器、反序列化及其校验
  • APIView执行流程
  • Request对象源码分析
  • 序列化器介绍和快速使用
  • 反序列化
  • 反序列化的校验

APIView执行流程

# 基于APIView与JsonResponse编写接口
	原来基于django原生的view编写接口，现在drf提供一个类，以后使用drf编写视图类都是继承这个类及其子类，APIView本身就是继承了django原生的View。
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)  # 不管是列表还是字典都可以序列化

# APIView执行流程
路由中写的： 
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):
    # 调用父类的as_view，父类是django原生的View
    # 把djagno原生View的as_view方法中的闭包函数view拿出来了
    view = super().as_view(**initkwargs)
    # csrf_exempt 排除所有csrf的认证
    # 相当于在所有的方法上面加了这个装饰器
    return csrf_exempt(view)
    
路由匹配成功，执行 csrf_exempt(view)(requets)
--->View的as_view中的闭包函数view
--->self.dispatch
--->self是视图类的对象
--->BookiView
--->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类	的对象，不是原生的了。原生的在：新的requets._request
3、在执行视图类的方法之前，执行了3大认证
4、如果在3大认证或视图函数方法执行过程中出了错，会有异常捕获(全局异常捕获)
5、以后视图类方法中的request都是新的了

"""
# 补充：装饰器的基本原理
def auth()  # 装饰器
def add()   # 函数

# 使用auth装饰add函数
@auth   # 本质是add=auth(add)
def add()
# 以后再使用add，其实就是在使用 auth(add)的返回结果
"""

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.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__：对象.属性，如果属性不存在，会触发它的执行

序列化器介绍和快速使用

在写接口时，需要序列化、反序列化并且反序列化的过程中需要做数据校验。drf直接提供了固定写法，只要根据固定写法使用就能完成这三个需求。

# drf提供两个类(Serializer、ModelSerializer)
	以后只用写自己的类，继承drf提供的序列化类，使用其中的某些方法就能完成上面的操作。
# 使用APIView+序列化类+Response 完成接口的编写

# 序列化类基本使用，序列化多条
# —— serializer.py--BookSerializer类
from rest_framework import serializers

class BookSerializer(serializers.Serializer):
    # 序列化某些字段，这里写要序列化的字典
    name = serializers.CharField()  
    # serializer下大致跟models下的类是对应的
    # price=serializers.CharField()
    publish = serializers.CharField()
    
# views.py--BookView类
class BookView(APIView):
    def get(self, request):
        # 获取所有图书
        books = Book.objects.all()
        book_list = []  # 组成列表for循环
        for book in books:
            book_list.append({'name': book.name, 'price': book.price, 'publish': book.publish})
        return Response(book_list)  # 不管是列表还是字典都可以序列化
    
# 序列化单条

# 序列化类--不变
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()),
]

反序列化

# 反序列化的新增
# 序列化类
class BookSerializer(serializers.Serializer):
    # 序列化某些字段，这里写要序列化的字典
    name = serializers.CharField()  # serializer下大致跟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 post(self, request):
        # request.data 前端提交的要保存的数据(获取、检验、保存)
        ser = BookSerializer(data=request.data)
        # 把前端传入的需要保存的数据给data这个参数
        # 校验数据
        if ser.is_valid():
        # 保存（需要自己写，要在序列化类BookSerializer中写，可调用create方法）
            ser.save()
            return Response({'code': 100, 'msg': '新增成功', 'result': ser.data})
        else:
            return Response({'code': 101, 'msg': ser.errors})

# 反序列化的修改
# 序列化类
class BookSerializer(serializers.Serializer):
    # 序列化某些字段，这里写要序列化的字典
    name = serializers.CharField()  # serializer下大致跟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})
    
# 删除单条
# 视图类
class BookDetailView(APIView):
    def delete(self, request, pk):
        Book.objects.filter(pk=pk).delete()
        return Response({'code': 100, 'msg': '删除成功'})

反序列化的校验

# 序列化类反序列化，数据校验功能--->类比forms组件
	-局部钩子
    -全局钩子

class BookSerializer(serializers.Serializer):
    # 序列化某些字段，这里写要序列化的字典
    name = serializers.CharField()  # serializer下大致跟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  # 不要忘了把修改后的对象返回

    # 反序列化校验的局部钩子
    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