Django框架之drf

目录

一、APIView执行流程

基于APIView+JsonResponse接口

通常在使用django编写CBV的视图类的时候我们都是直接继承View，但在drf内我们会继承drf提供的APIView

# view视图函数
    from rest_framework.views import APIView
    from .models import Book
    from django.http import JsonResponse


    class BookView(APIView):

        def get(self, request):
            book_all_queryset = Book.objects.all()
            book_data_dict = [{'name': book_queryset.name, 'price': book_queryset.price, 'publish': book_queryset.publish}
                              for book_queryset in book_all_queryset]
            return JsonResponse(book_data_dict, safe=False)

基于APIView+Response写接口

# view视图函数
    from rest_framework.response import Response
    from rest_framework.views import APIView
    from .models import Book
    from django.http import JsonResponse


    class BookView(APIView):
        def get(self, request):
            book_all_queryset = Book.objects.all()
            book_data_dict = [{'name': book_queryset.name, 'price': book_queryset.price, 'publish': book_queryset.publish}
                              for book_queryset in book_all_queryset]
            return Response(book_data_dict)
            # return JsonResponse(book_data_dict, safe=False

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

1、API执行流程总结（重点）

  • 去除了所有的csrf校验
  • 包装了新的request，以后在视图类中使用的request是新的request
    • Request类对象是，不是django原生的对象
    • 原生的对象：request._request
  • 在只执行视图类的方法前，执行了3大认证
    • 如果3大认证或视图函数方法执行过程中出现了错误，会异常捕获

2、补充

在我们使用的装饰器时会在需要添加功能的函数头上装饰语法糖，其实其本质就是将需要添加功能的函数当作参数，传入装饰器中

def auth()  # 装饰器
	pass
def add()   # 函数
	pass

# 使用auth装饰add函数
@auth   #  本质是  add=auth(add)
def add()

# 以后再使用add，其实就是在使用 auth(add)  的返回结果

二、Response源码剖析

# 新的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--->这是个方法，包装成了数据属性
    	-前端提交过来的文件，从这里取

1、Response类总结（重点）

  • 新的response用起来和以前一模一样，新的response取不到会触发双下getattr方法，该方法会执行老的response中的方法
  • response.data :所有的编码格式都可以在这里取，只要是body内的数据都可以取
  • request.query_params 就是原来的request._request.GET
  • 上传的文件从request.FILES中取

三、序列化器的介绍和使用

1、序列化

序列化查找多条数据

  • 在app下创建py文件（serializer）用于创建序列化类
# 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)  # 无论是列表还是字典都可以序列化

序列化查找单条数据

  • 之前创建的serializer.py文件不需要修改
# 视图类---》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.py中新增路由
    urlpatterns = [
        path('book/<int:pk>/', views.BookDetailView.as_view()),
    ]

2、反序列化

反序列化的新增

# serializer.py（序列化类）
    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
    
# view.py(视图类)
    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})

反序列化的修改

# serializer.py(视图类)
    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  # 不要忘了把修改后的对象，返回
        
 # view.py(视图类)
    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组件

局部钩子

​ 校验单个字段

from rest_framework import serializers
from rest_framework.exceptions import ValidationError
from .models import Book


class BookSerializer(serializers.Serializer):
    name = serializers.CharField()
    price = serializers.IntegerField()
    publish = serializers.CharField()

    def create(self, validated_data):
        new_book_queryset = Book.objects.create(**validated_data)
        return new_book_queryset

    def update(self, instance, validated_data):
        instance.name = validated_data.get('name')
        instance.price = validated_data.get('price')
        instance.publish = validated_data.get('publish')
        instance.save()
        return instance

     def validate_name(self, name):
         if not len(name) < 3:
             return name
         raise ValidationError('书名不能低于三个字符')

全局钩子

​ 校验所有字段

from rest_framework import serializers
from rest_framework.exceptions import ValidationError
from .models import Book


class BookSerializer(serializers.Serializer):
    name = serializers.CharField()
    price = serializers.IntegerField()
    publish = serializers.CharField()

    def create(self, validated_data):
        new_book_queryset = Book.objects.create(**validated_data)
        return new_book_queryset

    def update(self, instance, validated_data):
        instance.name = validated_data.get('name')
        instance.price = validated_data.get('price')
        instance.publish = validated_data.get('publish')
        instance.save()
        return instance
    
    def validate(self, attrs):
        if len(attrs.get('name')) < 3:
            raise ValidationError('书名不能低于三个字符')
        try:
            float(attrs.get('price'))
        except Exception:
            raise ValidationError('价格只能是整数或小数')
        finally:
            if len(attrs.get('publish')) < 3:
                raise ValidationError('书名不能低于三个字符')
        return attrs

/