Django REST Framework(DRF)_第一篇

认识RESTful
- REST是设计风格而不是标准,简单来讲REST规定url是用来唯一定位资源，而http请求方式则用来区分用户行为.
- REST接口设计规范
  - HTTP常用动词
    - GET /books：列出所有书籍返回数据类型-->[{},{}]
    - GET /books/ID：获取某个指定书籍的信息 -->{单本书籍}
    - POST /books：新建一本书籍 -->{新增的数据}
    - PUT /books/ID：更新某本指定书籍的信息（提供该书籍的全部信息） -->{修改后的数据}
    - PATCH /books/ID：更新某本指定书籍的信息（提供该书籍的部分信息） -->{修改后的数据}
    - DELETE /books/ID：删除某本书籍 -->返回空
  - 错误消息规范
    - { error: "Invalid API key" }
APIView请求流程(源码剖析)
- from rest_framework.views import APIView(导入APIView)
- 启动django后,加载settings及各个组件(视图,路由等)
- 加载的时候urls中views.HomeView.as_view(),会执行as_view()类方法,这里APIView继承了View的as_view方法,所以最后返回的还是view函数,实际上此时django内部就已经帮我们做了一层url和视图函数的关系绑定
- 以访问首页为例,找到url对应的视图函数,执行view(request),返回APIView中的dispatch()并执行该方法
- 找到对应的get或者post等方法并执行,最终将结果返回给浏览器
解析器组件
- 解析器组件的使用
  - request.data(通过该方法得到处理完的字典数据)
- 解析器请求流程(源码剖析)
  - 简单的讲解析器就是根据不同的content-type来解析数据,最终返回字典格式的数据
  - 在执行view函数时,首次将request传入,执行APIView中的dispatch()方法
  - 在dispatch()中将原来的request对象传递给初始化函数: request = self.initialize_request(request, *args, **kwargs)
  - 执行APIView中的initialize_request,返回Request(request,parsers=self.get_parsers(),..)
  - from rest_framework.request import Request,从这里可以看出,Request是一个类,所以Request()是一个实例化对象
  - 而我们通过request.data触发解析方法,此时调用Request实例的data方法(这里用了@property)
  - 在data方法里面,执行self.load_data_and_files(),此时self指的是Request的实例化对象,所以执行Request中的load_data_and_files()方法
  - 在load_data_and_files中,执行Request中的self.parse()方法
  - 在self._parse()方法中,首先media_type = self.content_type,获取了content_type,并执行了parser = self.negotiator.select_parser(self, self.parsers),这里传入了self.parsers,而Request实例化的时候传入了parsers=self.get_parsers(),所以这里要看下self.get_parsers()该方法
  - 在APIView中执行get_parsers()方法,return [parser() for parser in self.parser_classes],返回了一个列表推导式,而parser_classes = api_settings.DEFAULT_PARSER_CLASSES,那api_settings是啥呢?
  - from rest_framework.settings import api_settings,从这里我们可以知道是从settings中导入的,在settings中api_settings = APISettings(None, DEFAULTS, IMPORT_STRINGS),APISettings是一个类,所以api_settings是APISettings的实例化对象
  - 实例化对象后,要执行api_settings.DEFAULT_PARSER_CLASSES,但是APISettings类中并没有该属性或方法,则执行getattr方法, if attr in self.import_strings: val = perform_import(val, attr),这里动态导入,最后返回的是parser_classes 就等于[<class 'rest_framework.parsers.JSONParser'>,<class 'rest_framework.parsers.FormParser'>, <class 'rest_framework.parsers.MultiPartParser'>]
  - parser() for parser in self.parser_classes中parser()是实例化各个类,parsers=self.get_parsers(),parser = self.negotiator.select_parser(self, self.parsers),所以最后这个一执行就触发前面的一步一步执行
  - 最终self.data, self.files = self.parse(),将self.parse()的返回值赋给self.data,再将self.full_data = self.data,最终返回了self.full_data

序列化组件

django原生序列化步骤
- 导入模块 from django.core.serializers import serialize
- 获取queryset (data = Book.objects.all())
- 对queryset进行序列化 serialize_data = (serialize("json", data))
- 将序列化之后的数据，响应给客户端,返回serialize_data
APIView说明
- APIView继承了View,并在内部将request重新赋值变成了Request()的实例化对象,因此继承APIView后
- 获取get请求数据要通过,request.query_params
- 获取post请求要通过request.data

序列化组件使用

Get接口设计(序列化):

声明序列化器

导入模块：from rest_framework import serializers

建立一个序列化类 (写在一个独立的文件中): class BookSerializer(serializers.Serializer):字段自定义,最好跟model的一致

from rest_framework import serializers


class PublishSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    name = serializers.CharField(max_length=32)


class AuthorSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    name = serializers.CharField(max_length=32)


class BookSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    title = serializers.CharField(max_length=32)
    # 字段中的通用属性source可以进行数据库操作,get_xxx_display取choice字段的value.(source只能用于序列化)
    category = serializers.CharField(source="get_category_display")
    pub_time = serializers.DateField()
    # 外键,通过id找到publish对象并传入PublishSerializer(publish对象),最终得到id和title,因为这里返回的是单个对象,所以不用写many,而多对多返回的是一个queryset所以多个需要写many=True,内部会循环遍历
    publish = PublishSerializer()
    # 多对多,记得有many=True
    authors = AuthorSerializer(many=True)

使用自定义的序列化器序列化queryset(将模型对象放入序列化器进行字段匹配,匹配上的就进行序列化,匹配不上的就丢弃)

序列化完成的数据在序列化返回值的data中(serializer_data.data)

from django.shortcuts import render,HttpResponse
from django.views import View
from django.http import JsonResponse

import json

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

from .models import Book
from .serializerses import BookSerializer



class BookView(APIView):
    """书籍相关视图"""
    def get(self, request):
        book_queryset = Book.objects.all()
        # 使用自定义的序列化器序列化queryset
        serializer_data = BookSerializer(book_queryset, many=True)
        # 注意这里是取序列化返回值.data
        return Response(serializer_data.data)

注意:外键关系的序列化是嵌套的序列化对象,多对多有many=True,还有如果需要在浏览器访问请求的话需要在settings中INSTALLED_APPS下加入'rest_framework'.

上面是get所有数据,如果是请求单条数据,urls可以设计book/1,这样的话需要重新定义View,序列化的时候因为是单个book_obj,所以也不用写many=True了,默认是False

Post接口设计(反序列化):

步骤如下:

首先先确定新增的数据结构(跟前端沟通达成一致)
定义序列化器
- 正序和反序字段不统一,部分需要重新定义
- required=False, 只序列化不走校验
- read_only=True, 只序列化用
- write_only=True, 只反序列化用
- 重写create方法,参数有验证通过的数据validated_data
验证通过返回ser_obj.validated_data,不通过则返回ser_obj.errors
还有些细节注意在代码中,请看下面代码.

serializerses.py文件内容

from rest_framework import serializers

from app01.models import Book


class PublishSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    name = serializers.CharField(max_length=32)


class AuthorSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    name = serializers.CharField(max_length=32)


class BookSerializer(serializers.Serializer):
    id = serializers.IntegerField(required=False)
    title = serializers.CharField(max_length=32)
    # 字段中的通用属性source可以进行数据库操作,get_xxx_display取choice字段的value
    category = serializers.CharField(source="get_category_display", read_only=True)
    pub_time = serializers.DateField()
    # 外键
    publish = PublishSerializer(read_only=True)
    # 多对多,记得有many=True
    authors = AuthorSerializer(many=True, read_only=True)

    category_id = serializers.IntegerField(write_only=True)
    publish_id = serializers.IntegerField(write_only=True)
    # 多对多传入的是[],所以用ListField
    author_list = serializers.ListField(write_only=True)

    # 将通过验证的validated_data数据插入数据库
    def create(self, validated_data):
        # 先将作者列表从字典中剔除
        author_list = validated_data.pop('author_list')
        book_obj = Book.objects.create(title=validated_data['title'],category=validated_data['category_id'], pub_time = validated_data['pub_time'],publish_id=validated_data['publish_id'])
        book_obj.authors.add(*author_list)
        return book_obj

views.py内容

from django.shortcuts import render,HttpResponse

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

from .models import Book
from .serializerses import BookSerializer
'''
前端提交的格式如下:
{
        "title": "西游1",
        "category_id": 3,
        "pub_time": "2019-04-22",
        "publish_id": 1,
        "author_list": [1,2]
    }
'''

class BookView(APIView):
    """书籍相关视图"""
    def get(self, request):
        book_queryset = Book.objects.all()
        serializer_data = BookSerializer(book_queryset, many=True)
        return Response(serializer_data.data)

    def post(self, request):
        # 获取前端提交的请求数据
        book_obj = request.data
        # 通过data来表示是反序列化
        ser_obj = BookSerializer(data=book_obj)
        # 数据校验
        if ser_obj.is_valid():
            # save()方法返回self.instance = self.create(validated_data)
            # 然后就会调用BookSerializer中create方法保存通过校验的数据
            # 最后 save()会返回self.instance,而self.instance就是create的返回数据book_obj(插入的书本对象)
            ser_obj.save()
            # 给前端返回新增成功的数据
            return Response(ser_obj.validated_data)
        return Response(ser_obj.errors)

Put接口和单个get设计:

通过book/id去请求

在views中,记得put需要传入要修改的book对象,还有修改的数据和设置部分字段校验partial=True.并且定义update方法

class BookEditView(APIView):
    def get(self, request, book_id):
        book_obj = Book.objects.filter(id=book_id).first()
        ser_obj = BookSerializer(book_obj)
        return Response(ser_obj.data)

    def put(self, request, book_id):
        book_obj = Book.objects.filter(id=book_id).first()
        # 针对单本书籍对象进行修改,所以instance是单本书籍对象,data是传入的书籍信息,partial为True表示只校验提交的字段,也就是部分字段校验
        ser_obj = BookSerializer(instance=book_obj, data=request.data, partial=True)
        if ser_obj.is_valid():
            ser_obj.save()
            return Response(ser_obj.validated_data)
        return ser_obj.errors

在序列化器中定义update方法

 def update(self, instance, validated_data):
        # instance表示更新的book_obj对象,validated_data是校验通过的数据
        # 给每一个字段逐一赋值,如果没有就用原来的值
        instance.title = validated_data.get('title', instance.title)
        instance.category = validated_data.get('category_id', instance.category)
        instance.pub_time = validated_data.get('pub_time', instance.pub_time)
        instance.category = validated_data.get('category_id', instance.category)
        if validated_data.get('author_list'):
            instance.authors.set(validated_data.get('author_list'))
        # 基于对象操作,保存需要save一下
        instance.save()
        return instance

序列化接口字段校验

 # 类似于form局部钩子验证,针对单个属性
    def validate_title(self, value):
        # 对书籍标题进行验证,假设标题不能为纯数字
        if value.isdigit():
            raise serializers.ValidationError("标题不能为纯数字!")
        return value

    # 多个属性校验
    def validate(self, attrs):
        # 对标题和出版社进行校验
        if attrs['title'].isdigit() or not attrs['publish_id'].isdigit():
            raise serializers.ValidationError("标题不能为纯数字,出版社必须是数字")
        return attrs

上面是单个属性和多个属性校验,下面还有个自定义校验,然后绑定到字段上的用法

def my_validata(value):
    # 自定义规则
    if '敏感信息' in value:
        raise serializers.ValidationError("标题不能包含敏感信息")
    return value
# 通过validators使用,可以有多个自定义校验规则
 title = serializers.CharField(max_length=32, validators=[my_validata,])

有没有发现上面的序列化和反序列化都非常繁琐,所以我们在真实开发中一般都用下面的这种

ModelSerializer序列化及反序列化

modelSerializers文件内容

from rest_framework import serializers
from app01.models import (
    Book, Publish, Author
)


class PublishModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = Publish
        fields = "__all__"


class AuthorModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = Author
        fields = "__all__"


class BookModelSerializer(serializers.ModelSerializer):
    # 这里定义的都是序列化的情况,所以都是read_only=True,而且都是通过自定义方法返回需要展示的字段
    category_info = serializers.SerializerMethodField(read_only=True)
    publish_info = serializers.SerializerMethodField(read_only=True)
    authors_info = serializers.SerializerMethodField(read_only=True)

    # get_字段名称,这个是固定搭配,该方法会return值给category_info字段,而且传入的是序列化的obj模型对象
    def get_category_info(self, obj):
        # 自定义需要展示的数据,这里展示课程的中文, choices类型
        return obj.get_category_display()

    def get_publish_info(self, obj):
        # 以字典形式展示的是出版社的id和name, 外键类型
        publish_obj = obj.publish
        return {"id":publish_obj.id, "name":publish_obj.name}

    def get_authors_info(self, obj):
        # 由于作者可能有多个,所以以列表包含多个字典形式展示,  多对多类型
        authors_querset = obj.authors.all()
        return [{"id":author.id, "name":author.name} for author in authors_querset]

    # 反序列化用原生的,部分序列化字段需要重新定义,记得不要和原生字段重名
    class Meta:
        model = Book
        fields = "__all__"
        # exclude = ["id"]      # 不包含id,但是fields和exclude只能有一个
        # 字段是有序的,根据下面的字段进行排序展示
        # fields = ["id", "pub_time","title", "category_info", "publish_info", "authors_info"]
        # depth=1是深度为1层,也就是把外键关系的第一层找出来,默认不写是不显示出版社名称和作者信息的,写了就找出了出版社的所有信息和作者所有信息
        # 注意:depth会让所有的外键关系字段都变成read_only=True,所以一般少用
        # depth = 1
        read_only_fields = ["id", ]         # 指明只读字段,可以写多个
        # 添加或修改原有参数,反序列化的个别字段只需要在反序列化看到
        extra_kwargs = {
            'category': {"write_only": True,},       # key为默认的字段名称, value是自定义的参数配置信息
            'publish': {"write_only": True},
            'authors': {"write_only": True},
        }

views文件:(跟之前一样)

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

from .models import Book
from .modelSerializers import BookModelSerializer

class BookView(APIView):
    """书籍相关视图"""
    def get(self, request):
        book_queryset = Book.objects.all()
        serializer_data = BookModelSerializer(book_queryset, many=True)
        return Response(serializer_data.data)

    def post(self, request):
        # 获取前端提交的请求数据
        book_obj = request.data
        # 通过data来表示是反序列化
        ser_obj = BookModelSerializer(data=book_obj)
        # 数据校验
        if ser_obj.is_valid():
            # save()方法返回self.instance = self.create(validated_data)
            # 然后就会调用BookSerializer中create方法保存通过校验的数据
            # 最后 save()会返回self.instance,而self.instance就是create的返回数据book_obj(插入的书本对象)
            ser_obj.save()
            # 给前端返回新增成功的数据
            return Response(ser_obj.validated_data)
        return Response(ser_obj.errors)


class BookEditView(APIView):
    def get(self, request, book_id):
        book_obj = Book.objects.filter(id=book_id).first()
        ser_obj = BookModelSerializer(book_obj)
        return Response(ser_obj.data)

    def put(self, request, book_id):
        book_obj = Book.objects.filter(id=book_id).first()
        # 针对单本书籍对象进行修改,所以instance是单本书籍对象,data是传入的书籍信息,partial为True表示只校验提交的字段,也就是部分字段校验
        ser_obj = BookModelSerializer(instance=book_obj, data=request.data, partial=True)
        if ser_obj.is_valid():
            ser_obj.save()
            return Response(ser_obj.validated_data)
        return Response(ser_obj.errors)

Django REST Framework(DRF)_第一篇

认识RESTful

APIView请求流程(源码剖析)

解析器组件