基于APIView&ModelSerializer写接口

基于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

展示效果如下