python之路61 drf从入门到成神 2 APIView执行流程、Request对象源码分析、序列化器介绍和快速使用、基于序列化器编写5个接口、反序列化的校验(钩子函数)

连接sqlite数据库的一个小问题

# 使用pycharm打开sqlite的问题
     sqlite文件---》文件(xxx.mp4,xx.txt) ---->是一样的
     我们选择什么软件打开它，看到的东西是不一样的

     解决：
         1  干脆不用pycharm打开，使用navicate打开(复制绝对路径地址)
         2  使用pycharm正常连接

1.APIView执行流程(难，了解)

1.1基于APIView+JsonResponse编写接口

#原来基于django原生的View编写接口
#drf提供给咱们的一个类，以后使用drf写视图类，都是继承这个类及其子类，APIView本身就是继承了Django原生的View
先在models.py里写字段
from django.db import models
class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.CharField(max_length=32)
    publish = models.CharField(max_length=32)

进行数据库迁移

在view里面写代码

from rest_framework.views import APIView
from .models import Book
from django.http import JsonResponse # 先用原生的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) 

1.2基于APIView+Response

from rest_framework.response import Response
from rest_framework.views import APIView
from .models import Book

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) # 无论是列表还是字典都可以序列化

1.3APIView的执行流程

# 路由中写的： 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
        # 把django原生View的as_view方法中的闭包函数view拿出来了
        view = super().as_view(**initkwargs)
        # csrf_exempt 排除所有csrf的认证
        # 相当于在所有的方法上面加了这个装饰器
        return csrf_exempt(view)  # csrf_exempt校验器必须加在dispatch上才起作用

# 路由匹配成功，执行 csrf_exempt(view)(request)--->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)

            # 跟之前一毛一样(上一篇cbv源码分析)
            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都是新的了




# 补充：装饰器的基本原来

def auth()  # 装饰器

def add()   # 函数

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

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

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

基于序列化器编写5个接口

3.序列化器介绍和快速使用

# 因为咱么在写接口时，需要序列化，需要反序列化，而且反序列化的过程中要做数据校验---》drf直接提供了固定的写法，只要按照固定写法使用，就能完成上面的三个需求

# 提供了两个类 Serializer ModelSerializer
     以后咱们只需要写自己的类，继承drf提供的序列化类，使用其中的某些方法，就能完成上面的操作



# 使用APIView+序列化类+Response 完成接口的编写

3.1序列化类基本使用，序列化多条

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类
from .serializer import BookSerializer

class BookView(APIView):
    def get(self, request):
        # 只是为了验证之前讲过的
        print(request.method)  # GET
        print(request._request)   # <WSGIRequest: GET '/books/'>
        print(type(self.request))  # <class 'rest_framework.request.Request'>

        books = Book.objects.all()
        # 使用序列化类来完成---》得有个序列化类
        # instance要序列化的数据books queryset对象
        # many = True 只要是queryset对象要传many=True 如果是单个对象就不用传
        ser = BookSerializer(instance=books, many=True)
        return Response(ser.data)  # 因为是继承的APIView 所以urlencoded或form-data或json三种编码方式的数据都可以正常序列化

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反序列化的新增

序列化类

from rest_framework import serializers
from .models import Book

class BookSerializer(serializers.Serializer):
    name = serializers.CharField()
    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):
        # request.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反序列化的修改

序列化类

from rest_framework import serializers
from .models import Book

class BookSerializer(serializers.Serializer):
    name = serializers.CharField()
    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()
            return Response({'code': 100, 'msg': '修改成功', 'result': ser.data})
        else:
            return Response({'code': 101, 'msg': ser.errors})

4.3删除单条

视图类

class BookDetailView(APIView):

    def delete(self, requset, pk):
        Book.objects.filter(pk=pk).delete()
        return Response({'code': 100, 'msg': '删除成功'})

6.反序列化的校验

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

类比forms组件校验 校验钩子写在序列化类里面

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


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

    # 全局钩子
    # attrs 是前端执行完局部钩子校验后的 所有数据的字典
    def validate(self, attrs):
        # 校验过后的数据,书名跟出版社名字不能一致
        if attrs.get('name') == attrs.get('publish'):
            raise ValidationError('书名不能和出版社名一致')
        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

根据老师讲的自己抄了个publish的5个接口

先在models.py里写字段
from django.db import models
class Publish(models.Model):
    name = models.CharField(max_length=32)
    address = models.CharField(max_length=32)

记得迁移

序列化类
from .models import Publish
from rest_framework import serializers
from rest_framework.exceptions import ValidationError

class PublishSerializer(serializers.Serializer):
    name = serializers.CharField()
    address = serializers.CharField()

    def create(self, validated_data):
        # 保存到数据库
        publish = Publish.objects.create(**validated_data)
        # 一定不要忘记返回新增的对象
        return publish

    def update(self, instance, validated_data):
        instance.name = validated_data.get('name')
        instance.address = validated_data.get('address')
        instance.save()
        return instance
    # 局部钩子
    def validate_name(self, name):
        if len(name) < 3:
            raise ValidationError('出版社名不能少于3个字符')
        if name.startswith('sb'):
            raise ValidationError('出版社名称不能以sb开头')
        else:
            return name
    # 全局钩子
    def validate(self, attrs):
        if len(attrs.get('name')) < 3:
            raise ValidationError('出版社名不能少于3个字符')
        if attrs.get('name') == attrs.get('address'):
            raise ValidationError('出版社名不能和地址一样')
        else:
            return attrs

视图类
from .serializer import PublishSerializer
from .models import Publish
from rest_framework.views import APIView
from rest_framework.response import Response

class PublishView(APIView):
    # 查所有
    def get(self, request):
        publish = Publish.objects.all()
        sers = PublishSerializer(instance=publish, many=True)
        return Response(sers.data)
    # 新增
    def post(self, request):
        sers = PublishSerializer(data=request.data)
        if sers.is_valid():
            sers.save()
            return Response({'code': 100, 'msg': '新增成功', 'result': sers.data})
        else:
            return Response({'code': 101, 'msg': sers.errors})


class PublishEditView(APIView):
    # 查单个
        def get(self, request, *args, **kwargs):
        publish = Publish.objects.filter(pk=kwargs.get('pk')).first()
        if not publish:
            return Response({'code': 101, 'msg': f'id为{kwargs.get("pk")}的数据不存在'})
        # 序列化
        sers = PublishSerializer(instance=publish)
        return Response(sers.data)
        # 序列化
        sers = PublishSerializer(instance=publish)
        return Response(sers.data)
    # 修改
    def put(self, request, pk):
        publish = Publish.objects.filter(pk=pk).first()
        if not publish:
            return Response({'code': 101, 'msg': f'id为{pk}的数据不存在'})
        sers = PublishSerializer(data=request.data, instance=publish)
        if sers.is_valid():
            sers.save()
            return Response({'code': 100, 'msg': '修改成功', 'result': sers.data})
        else:
            return Response({'code': 101, 'msg': sers.errors})
    # 删除
    def delete(self, request, pk):
        Publish.objects.filter(pk=pk).delete()
        return Response({
            'code': 100,
            'msg': '删除成功'
        })