rest-framework-----初识, 解析器组件 及 序列化组件

一,初识

前后端开发分离,就要借助API,API简单说就是开发人员提供编程接口被其他人调用,他们调用之后会返回数据供其使用,

那么什么是rest呢?,我们用一句话总结为: 用url唯一定位资源，用Http请求方式（GET, POST, DELETE, PUT)描述用户行为

rest接口规范:  不能包含动词

#接口设计规范
GET    127.0.0.1:8000/books/        # 获取所有数据
GET    127.0.0.1:8000/books/{id}/   # 获取单条数据
POST   127.0.0.1:8000/books/        # 添加一条数据
DELETE 127.0.0.1:8000/books/{id}/   # 删除一条数据
PUT    127.0.0.1:8000/books/{id}/   # 修改一条数据
            
class BookView(View):
    def get(self, request):
        pass
                
    def post(self, request):
        pass

            
class BookSingleView(View):
    def get(self, request, nid):
        pass
                
    def delete(self, request, nid):
        pass
                
    def put(self, request, nid):
        pass


#返回数据规范
GET    127.0.0.1:8000/books/        # 获取所有数据 [{}, {}, {}, {}, {}]
GET    127.0.0.1:8000/books/{id}/   # 获取单条数据 {}
POST   127.0.0.1:8000/books/        # 添加一条数据 {}新增的数据
DELETE 127.0.0.1:8000/books/{id}/   # 删除一条数据 返回空
PUT    127.0.0.1:8000/books/{id}/   # 修改一条数据 {}


#错误消息规范
{ "error": "error_message" }

安装:

新建一个Django项目
安装restframework
>>> pip install django
>>> pip install djangorestframework

二,restframework的解析器组件

解析器组件的使用:

from django.http import JsonResponse

from rest_framework.views import APIView
from rest_framework.parsers import JSONParser, FormParser
# Create your views here.


class LoginView(APIView):
    parser_classes = [FormParser]

    def get(self, request):
        return render(request, 'parserver/login.html')

    def post(self, request):
        # request是被drf封装的新对象，基于django的request
        # request.data是一个property，用于对数据进行校验
        # request.data最后会找到self.parser_classes中的解析器
        # 来实现对数据进行解析
        
        print(request.data)  # {'username': 'alex', 'password': 123}

        return JsonResponse({"status_code": 200, "code": "OK"})

使用方式非常简单，分为如下两步：

• from rest_framework.views import APIView
• 继承APIView
• 直接使用request.data就可以获取Json数据

 

三,restframework的序列化组件

序列化用于对用户请求数据进行验证和数据进行序列化(主要为了解决queryset序列化的问题)

序列化就是把对象转换成字符串,反序列化就是把字符串转换成对象

开发我们的Web API的第一件事是为我们的Web API提供一种将代码片段实例序列化和反序列化为诸如json之类的表示形式的方式。我们可以通过声明与Django forms非常相似的序列化器（serializers）来实现

(1),序列化组件GET接口:

models:

from django.db import models

# Create your models here.


class Publish(models.Model):
    nid = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)
    city = models.CharField(max_length=32)
    email = models.EmailField()

    def __str__(self):
        return self.name


class Author(models.Model):
    nid = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)
    age = models.IntegerField()

    def __str__(self):
        return self.name


class Book(models.Model):
    title = models.CharField(max_length=32)
    publishDate = models.DateField()
    price = models.DecimalField(max_digits=5, decimal_places=2)
    publish = models.ForeignKey(to="Publish", to_field="nid", on_delete=models.CASCADE)
    authors = models.ManyToManyField(to="Author")

    def __str__(self):
        return self.title

urls:

from django.contrib import admin
from django.urls import path

from app01 import views

urlpatterns = [
    path('admin/', admin.site.urls),
    path('books/',views.BookView.as_view())
]

views:

from django.shortcuts import render,HttpResponse

# Create your views here.
from rest_framework.views import APIView
from rest_framework.response import Response

from app01.models import Book
from app01.serializers import BookSerializer


class BookView(APIView):
    def get(self,request):
        books_list = Book.objects.all()
        serialized_books = BookSerializer(books_list,many=True)

        return Response(serialized_books.data)

我们已经通过序列化组件定义了一个符合标准的接口，定义好model和url后，使用序列化组件的步骤如下：

• 导入序列化组件：from rest_framework import serializers
• 定义序列化类，继承serializers.Serializer(建议单独创建一个专用的模块用来存放所有的序列化类)：class BookSerializer(serializers.Serializer):pass
• 定义需要返回的字段(字段类型可以与model中的类型不一致，参数也可以调整)，字段名称必须与model中的一致
• 在GET接口逻辑中，获取QuerySet
• 开始序列化：将QuerySet作业第一个参数传给序列化类，many默认为False，如果返回的数据是一个列表嵌套字典的多个对象集合，需要改为many=True
• 返回：将序列化对象的data属性返回即可

Response对象，它是DRF重新封装的响应对象。该对象在返回响应数据时会判断客户端类型（浏览器或POSTMAN），如果是浏览器，它会以web页面的形式返回，如果是POSTMAN这类工具，就直接返回Json类型的数据。

序列化类中的字段名也可以与model中的不一致，但是需要使用source参数来告诉组件原始的字段名,例如:

BookTitle = serializers.CharField(max_length=128, source="title")

对于多对多的字段,我们获取到的数据并不是我们想要的,我们需要通过以下方式获取

authors_list = serializers.SerializerMethodField()

def get_authors_list(self, authors_obj):
        authors = list()
        for author in authors_obj.authors.all():
            authors.append(author.name)

        return authors
#请注意，get_必须与字段名称一致，否则会报错

(2),序列化接口的POST接口

根据接口规范，我们不需要新增url，只需要在视图类中定义一个POST方法即可，序列化类不需要修改，如下：

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

# 当前app中的模块
from .models import Book
from .app_serializer import BookSerializer

# Create your views here.


class BookView(APIView):
    def get(self, request):
        origin_books = Book.objects.all()
        serialized_books = BookSerializer(origin_books, many=True)

        return Response(serialized_books.data)

    def post(self, request):
        verified_data = BookSerializer(data=request.data)

        if verified_data.is_valid():
            book = verified_data.save()
            # 可写字段通过序列化添加成功之后需要手动添加只读字段
            authors = Author.objects.filter(nid__in=request.data['authors'])
            book.authors.add(*authors)

            return Response(verified_data.data)
        else:
            return Response(verified_data.errors)

POST接口的实现方式，如下：

• url定义：需要为post新增url，因为根据规范，url定位资源，http请求方式定义用户行为
• 定义post方法：在视图类中定义post方法
• 开始序列化：通过我们上面定义的序列化类，创建一个序列化对象，传入参数data=request.data（application/json）数据
• 校验数据：通过实例对象的is_valid()方法，对请求数据的合法性进行校验
• 保存数据：调用save()方法，将数据插入数据库
• 插入数据到多对多关系表：如果有多对多字段，手动插入数据到多对多关系表
• 返回：将插入的对象返回

因为多对多关系字段是我们自定义的，而且必须这样定义，返回的数据才有意义，而用户插入数据的时候，serializers.Serializer没有实现create，我们必须手动写create和update方法来修改数据

    def create(self, validated_data):
        # {'title': 'Python666', 'price': Decimal('66.00'), 'publish': '2'}
        validated_data['publish_id'] = validated_data.pop('publish')
        book = Book.objects.create(**validated_data)

        return book

    def update(self, instance, validated_data):
        # 更新数据会调用该方法
        instance.title = validated_data.get('title', instance.title)
        instance.publishDate = validated_data.get('publishDate', instance.publishDate)
        instance.price = validated_data.get('price', instance.price)
        instance.publish_id = validated_data.get('publish', instance.publish.nid)

        instance.save()

        return instance

以上方式比较繁琐,我们还有更简单数书写方式,如下:

class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book

        fields = ('title',
                  'price',
                  'publish',
                  'authors',
                  'author_list',
                  'publish_name',
                  'publish_city'
                  )
        extra_kwargs = {
            'publish': {'write_only': True},
            'authors': {'write_only': True}
        }

    publish_name = serializers.CharField(max_length=32, read_only=True, source='publish.name')
    publish_city = serializers.CharField(max_length=32, read_only=True, source='publish.city')

    author_list = serializers.SerializerMethodField()

    def get_author_list(self, book_obj):
        # 拿到queryset开始循环 [{}, {}, {}, {}]
        authors = list()

        for author in book_obj.authors.all():
            authors.append(author.name)

        return authors

 

(3),序列化组件的PUT接口

url:

re_path(r'books/(\d+)/$', views.BookFilterView.as_view()),

view:

class BookFilterView(APIView):

    def put(self, request, nid):
        book_obj = Book.objects.get(pk=nid)

        serialized_data = BookSerializer(data=request.data, instance=book_obj)

        if serialized_data.is_valid():
            serialized_data.save()
        else:
            return Response(serialized_data.errors)

序列化类还是使用的之前的类

PUT接口逻辑的设计，分为如下几个步骤：

• url设计：re_path(r’books/(\d+)/$’, views.BookFilterView.as_view())
• 视图类：重新定义一个视图类
• put方法：在视图类中定义一个put方法
• 序列化：在序列化的过程中，需要传入当前修改的数据行，参数名为instance
• 序列化类：不需要修改
• url路径：请求时，发送的url必须与urls.py中定义的url完全匹配

(4),序列化组件的DELETE接口

url不变,在view里面增加一个delete方法,跟put方法同属于一个类

    def delete(self,request,nid):
        book_obj = Book.objects.filter(pk=nid).delete()
        
        return Response('111')

 

(5),单条数据的接口设计

url不变,在view里面添加一个单条数据的方法

def get(self, request, nid):
        book_obj = Book.objects.get(pk=nid)

        serialized_data = BookSerializer(book_obj, many=False)

        return Response(serialized_data.data)