drf : 序列化器Serializer

序列化器Serializer

作用：

1. 序列化，序列化器会把模型对象转换成字典，经过request以后变成json字符串
2. 反序列化，把客户端发送过来的数据，经过request以后变成字典(request.data)，序列化器(类)可以把字典转成模型
3. 反序列化，完成数据校验功能

本质就是写一个类，继承基类。

可以完成序列化，反序列化和数据校验。

读取数据为序列化，新增为反序列化。

通过serizlizer实现五个接口，此为第一步。

查询所有接口，新增数据接口

serizlizer.py

"""
与表没有关系，需要自己建关系
from rest_framework.serializers import Serializer
"""
from rest_framework import serializers

# 需要序列化和反序列化Book表，可称呼为序列化类
class BoookSerializers(serializers.Serializer):
    # 写字段(需要序列化，反序列化的字段)
    name = serializers.CharField()
    price = serializers.IntegerField()
    publish = serializers.CharField()
    
    # 新增需要重写create
    def create(self, validated_data):
        # {'name': '新增2', 'price': 10, 'publish': '测试出版社'}
        # print(validated_data)
        book = Books.objects.create(**validated_data)
        # Books object (7)
        # print(book)
        return book

views.py，发序列化新增，序列化读取。

"""
drf使用方式：CBV，继承的类，是drf提供的类，APIView
使用drf 多了一个Response类
"""
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.request import Request
from .serizlizer import BoookSerializers
from .models import Books


class BookAPIView(APIView):
    # 查询所有的接口
    def get(self, request, *args, **kwargs):
        # 从数据库中把所有的数据取出,取出Books所有的queryset对象
        book_list = Books.objects.all()
        # <QuerySet [<Books: Books object (1)>, <Books: Books object (3)>]>
        print(book_list)
        """
        类实例化得到对象(ser),并转为字典，此处为序列化过程，把queryset转成字典
        BookSerializers（
                        需要序列化的queryset对象,
                        data=None可以不传,
                        如果序列化多条数据需要加many=True）
        """
        ser = BoookSerializers(instance=book_list, many=True)
        """
        字典
        [
        OrderedDict([('name', '葫芦娃'), ('price', 10), ('publish', '测试出版社')]), 
        OrderedDict([('name', '互撸娃'), ('price', 10000), ('publish', '娃哈哈出版社')])
        ]
        """
        print(ser.data)
        # <class 'rest_framework.utils.serializer_helpers.ReturnList'>
        print(type(ser.data))
        # ser.data 序列化转成字典
        return Response(ser.data)
      
    # 新增
    def post(self,request,*args, **kwargs):
        # <rest_framework.request.Request: POST '/books/'>
        print(request)
        # {'name': '新增8', 'price': 10, 'publish': '测试出版社'}
        print(request.data)
        ser = BookSerializers(data=request.data)
        if ser.is_valid():
            ser.save()
            return Response(ser.data)

url.py

from django.contrib import admin
from django.urls import path
from app01 import views
# from rest_framework.routers import SimpleRouter


urlpatterns = [
    path('admin/', admin.site.urls),

    # drf 继承APIView 的路由，向books地址发送请求，将所有图书返回
    path('books/', views.BookAPIView.as_view())

]

查询单个接口，删除单个接口，修改

Serializers.py

from rest_framework import serializers


# 需要序列化和反序列化Book表
class BookSerializers(serializers.Serializer):
    # 写字段(需要序列化，反序列化的字段)
    name = serializers.CharField()
    price = serializers.IntegerField()
    publish = serializers.CharField()

    # 如果要更新，一定要重写updata方法
    def update(self, instance, validated_data):
        # Books object (1)
        print(instance)
        instance.name = validated_data.get('name')
        # jajajaj 修改的数据
        print(instance.name)
        instance.price = validated_data.get('price')
        instance.publish = validated_data.get('publish')
        # 保存
        instance.save()
        # 返回
        return instance

url.py

from django.contrib import admin
from django.urls import path
from app01 import views
# from rest_framework.routers import SimpleRouter


urlpatterns = [
    path('admin/', admin.site.urls),

    # drf 继承APIView 的路由，向books地址发送请求，将所有图书返回
    path('books/', views.BookAPIView.as_view()),
    # <int:pk> 转换器,int为定义类型,数据类型可自定义。
    path('books/<int:pk>', views.BookDetilAPIView.as_view()),
]

views.py

class BookDetilAPIView(APIView):
    # 查询单个接口
    def get(self,request,pk):
        book = Books.objects.filter(pk=pk).first()
        # Books object (1)
        # print(book)
        # <class 'app01.models.Books'>
        # print(type(book))
        """
        此处为序列化过程，把queryset转成字典
        many=True 需要改为False，此时为查询单条数据，不写，many默认为False，
        """
        ser = BookSerializers(instance=book)
        return Response(ser.data)

    # 删除单个接口
    def delete(self,request,pk):
        Books.objects.filter(pk=pk).delete()
        return Response()

    # 修改单条数据
    def put(self,request,pk):
        # <rest_framework.request.Request: PUT '/books/1'>
        # print(request)
        book = Books.objects.filter(pk=pk).first()
        # {'name': '哈哈哈', 'price': 10, 'publish': '测试出版社'},内部自动返序列化
        # print(request.data)
        ser = BookSerializers(instance=book,data=request.data)
        # 校验数据
        if ser.is_valid():
            ser.save()
            return Response(ser.data)