基于APIView&ModelSerializer写接口

​ 引言，首先路由写法还是不变、视图层的视图类写法不变，在序列化类要改变写法、慢慢的靠近序列化器组件；而且需要创建关联表，因为现实生活当中不可能仅仅建单表，会使用大量的多表关联的表数据。好吧！咱们上干货把，首先准备一下路由吧，毕竟就两条代码而且配好就逻辑写完可以马上测试接口了。本篇文章重点介绍了序列化定制字段的多种方法，也演示了序列化重要字段DictField()、ListField()的用法和反序列化重要参数read_only=True和write_only=True

一、首先准备前提工作

1.模型代码

from django.db import models


class Book(models.Model):
    name = models.CharField(verbose_name='书名', max_length=32)
    price = models.CharField(verbose_name='价格', max_length=32)

    # 外键 书跟出版社是一对多
    publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
    # 外键 书跟作者是多对多
    authors = models.ManyToManyField(to='Author')


class Publish(models.Model):
    name = models.CharField(verbose_name='出版社名称', max_length=32)
    address = models.CharField(verbose_name='出版社地址', max_length=32)


class Author(models.Model):
    name = models.CharField(verbose_name='作者姓名', max_length=32)
    phone = models.CharField(verbose_name='电话号码', max_length=11)

录入数据的顺序不能乱来，因为有外键关系、那么小编在这里详细的列出录入数据的过程
先在Author表录入两条

再在publish表录入两条

然后在book表录入两条

最后在关联表添加数据

2.路由代码

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()),
    path('books/<int:pk>/', views.BookDetailView.as_view()),
]

3.视图代码

from django.shortcuts import render
from rest_framework.views import APIView
from .models import Book
from .serializer import BookSerializer
from rest_framework.response import Response


class BookView(APIView):
    def get(self, request):  # 查询所有
        # 查询所有数据
        books = Book.objects.all()
        # 序列化数据
        ser = BookSerializer(instance=books, many=True)
        return Response(ser.data)

    def post(self, request):
        ser = BookSerializer(data=request.data)
        if ser.is_valid():
            ser.save()
            return Response({'code': 100, 'msg': '新增成功', 'result': ser.data})
        else:
            return Response({'code': 101, 'msg': ser.errors})


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':'修改成功'})
        else:
            return Response({'code':101, 'msg':ser.errors})

    def get(self, request, pk):
        book = Book.objects.filter(pk=pk)
        ser = BookSerializer(instance=book)
        return Response(ser.data)

    def delete(self, request, pk):
        Book.objects.filter(pk=pk).delete()
        return Response('删除成功')

二、继承Serializer序列化定制字段的三种方法

1.通过source关键词定制

# 用source关键字定制字段的代码

from rest_framework import serializers

class BookSerializer(serializers.Serializer):
    real_name = serializers.CharField(source='name')
    real_price = serializers.CharField(source='price')
    publish = serializers.CharField(source='publish.name')
    authors = serializers.CharField()

第一个解决方案是在模型表中写下面的方法

第二种解决方案在序列化类处理看下面代码框

2.SerializerMethodField定制

该方法能够序列化定制所有的任何的字段先想好定制成什么样子，之后新字段名跟get_后面即可，记得定制一个就一定要配合一个get_方法，可以自定义返回格式，就说明个性化能力强。

"""关键字段SerializerMethodField定制"""

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

    publish_detail = serializers.SerializerMethodField()

    def get_publish_detail(self, obj):
        return {'name':obj.publish.name, 'address':obj.publish.address}

    author_list = serializers.SerializerMethodField()

    def get_author_list(self, obj):
        list =[]
        for author in obj.authors.all():
            list.append({'name':author.name, 'phone':author.phone})
            return list

3.在模型表中写方法来定制

这个方法其实算不上方法，因为逻辑是一样的，只不过把方法写到模型表里面，而序列化类里面只需要写新定制字段，所以相当于做了所谓的解耦合吧，但是我感觉完全没这个必要，毕竟要序列化，那么属性和方法统一写到一个位置比较省心。当然这是我的个人想法，仅供参考。

# 序列化类代码
class BookSerializer(serializers.Serializer):
    name = serializers.CharField()
    price = serializers.CharField()
    publish_detail = serializers.DictField()
    author_list = serializers.ListField()

# 模型表写定制方法代码
def publish_detail(self):
    return {'name': self.publish.name, 'address': self.publish.address}

def author_list(self):
    list = []
    for author in self.authors.all():
        list.append({'name': author.name, 'phone': author.phone})
        return list

三、继承Serializer反序列化

当然定制字段的方法也要写，不管在序列化类里写还是模型表里写，但凡涉及到定制字段就要写定制方法，因为涉及到反序列化所以要重写create方法和update方法，而且也要写数据校验，毕竟不能前端传什么就录入，一定要有校验机制的

class BookSerializer(serializers.Serializer):
    # 如果一个字段既用来序列化又用来反序列化就不用写参数read_only或write_only
    name = serializers.CharField(max_length=8, error_messages={'max_length':'太长了'})
    price = serializers.CharField()

    # 只用来序列化 写参数read_only=True
    publish_detail = serializers.DictField(read_only=True)
    author_list = serializers.ListField(read_only=True)

    # 只用来反序列化 写参数write_only=True
    publish = serializers.CharField(write_only=True)
    author = serializers.ListField(write_only=True)

    # 反序列化要重写create方法和update方法
    def create(self, validated_data):
        # 新增一本书
        book = Book.objects.create(name=validated_data.get('name'),
                                   price=validated_data.get('price'),
                                   publish_id=validated_data.get('publish'))
        # 关联作者
        book.authors.add(*validated_data.get('author'))
        # 返回book
        return book

    def update(self, instance, validated_data):
        # 序列出数据
        instance.name = validated_data.get('name')
        instance.price = validated_data.get('price')
        instance.publish_id = validated_data.get('publish')
        # 先清空数据在add
        authors = validated_data.get('author')
        print(validated_data)
        instance.authors.clear()
        instance.authors.add(*authors)
        # 修改完保存
        instance.save()
        # 返回数据
        return instance


    # 修改要重写update
    def update(self, instance, validated_data):
        # validated_data 校验过后的数据，{name:红楼梦,price:19,publish:1,authors:[1,2]}
        instance.name = validated_data.get('name')
        instance.price = validated_data.get('price')
        instance.publish_id = validated_data.get('publish')

        # 先清空，再add
        authors = validated_data.get('authors')
        instance.authors.clear()
        instance.authors.add((*authors)

        instance.save()

        return instance

四、用ModelSerializer进行序列化与反序列化

"""ModelSerializer的用法"""


class BookSerializer(serializers.ModelSerializer):
    class Meta:
        # 跟book表关联
        model = Book
        # fields = ['写需要序列化的字段名',[]···]
        # 如果fields = '__all__'这样写就表明序列化所有字段
        fields = '__all__'
        # extra_kwargs = {'字段名': {'约束条件': 约束参数},是反序列化字段
        extra_kwargs = {'name': {'max_length': 8},
                        'publish_detail': {'read_only': True},
                        'authors_list': {'read_only': True},
                        'publish': {'write_only': True},
                        'authors': {'write_only': True}
                        }

    def validate_name(self, name):
        if name.startswith('sb'):
            raise ValidationError('书名不能以sb开头')
        else:
            return name

展示效果如下

__EOF__