【DRF框架】利用序列化组件操作

使用序列化组件进行操作

不带参数：查+增

带参数：查、改、删

不带参数的操作

# url路由
url(r'^book_list/$',Search_book.as_view()),

# views.py
from utils.serializers import BookSerializer
from .models import Book
from rest_framework.response import Response
from rest_framework.views import APIView

class Search_book(APIView):
    # 查询数据，GET请求
    def get(self,request):
        book_queryset = Book.objects.all()

        # 使用序列化器进行序列化,返回序列化对象
        ser_obj = BookSerializer(book_queryset,many=True)    # 多个queryset对象使用many=True

        # 返回数据
        return Response(ser_obj.data)           # 序列化好的数据都在 序列化对象.data

    # 新增数据，POST请求
    def post(self,request):

        # 对提交的数据进行反序列化，返回一个序列化对象
        ser_obj = BookSerializer(data=request.data)

        # 对序列化对象进行校验
        if ser_obj.is_valid():
            # 校验通过,新增数据
            ser_obj.save()      # 调用序列化器的create()方法
            return Response(ser_obj.data)  # 返回新增的数据

        else:
            # 校验不通过
            return Response(ser_obj.errors)

# 序列化器
# serializers.py
from rest_framework import serializers   # 导入框架的序列化器
from SerDemo.models import Book

# 外键字段的序列化器
class PublisherSerializer(serializers.Serializer):
    # 根据外键模型的字段定义字段进行匹配
    id = serializers.IntegerField()
    title = serializers.CharField(max_length=32)

# 多对多字段的序列化器
class AuthorSerializer(serializers.Serializer):
    # 根据多对多字段模型的字段定义字段进行匹配
    id = serializers.IntegerField()
    name = serializers.CharField(max_length=32)

# 自定义验证器
def my_validate(value):
    if "xxx" in value:
        raise serializers.ValidationError("该字段包含敏感词!!!")
    else:
        return value

class BookSerializer(serializers.Serializer):
    # 定义模型中需要序列化的字段,匹配的上的进行序列化，匹配不上的丢弃
    id = serializers.IntegerField(required=False)           # 反序列化不匹配该字段
    title = serializers.CharField(max_length=32,validators=[my_validate,])             # 使用自定义验证器
    category = serializers.CharField(source='get_category_display',read_only=True)     # source通过ORM操作获得CHOICES的值
    category_post = serializers.IntegerField(write_only=True)                          # 用于反序列化的字段
    pub_time = serializers.DateField()

    # 外键字段，先声明外键字段的序列化器再实例化
    publisher = PublisherSerializer(read_only=True)             # 仅在正序列化匹配该字段
    publisher_id = serializers.IntegerField(write_only=True)    # 仅在反序列化匹配该字段

    # 多对多字段，先声明多对多字段的序列化器再实例化
    authors = AuthorSerializer(read_only=True,many=True)       # 多个模型对象使用many=True，正序列化匹配该字段
    authors_list = serializers.ListField(write_only=True)      # 反序列化匹配该字段

    # 新增对象调用create方法
    def create(self, validated_data):
        # validated_data 是数据的字典

        # 创建对象
        book_obj = Book.objects.create(
            title=validated_data.get('title'),
            category=validated_data.get('category_post'),
            pub_time = validated_data.get('pub_time'),
            publisher_id = validated_data.get('publisher_id'),
        )
        book_obj.authors.add(*validated_data['authors_list'])       # 多对多字段使用add
        book_obj.save()
        return book_obj

带参数的操作

# url路由
url(r'^book_list/(?P<id>\d+)/$',EditBookView.as_view())

from django.shortcuts import render

from utils.serializers import BookSerializer
from .models import Book
from rest_framework.response import Response
from rest_framework.views import APIView

# 带id的查询、更新、删除
class EditBookView(APIView):
    # 根据id查看数据
    def get(self,request,id):
        # 根据ip找到模型对象
        book_obj = Book.objects.filter(pk=id).first()

        # 对模型对象进行序列化，返回序列化对象
        ser_obj = BookSerializer(book_obj)

        # 返回序列化对象的数据
        return Response(ser_obj.data)

    # 根据id更新数据
    def put(self,request,id):
        # 根据ip找到模型对象
        book_obj = Book.objects.filter(pk=id).first()

        # 将获取的数据根据模型对象进行序列化，返回序列化对象
        ser_obj = BookSerializer(instance=book_obj,data=request.data,partial=True)
        # partial=True 部分匹配
        # data=request.data 前端提交的数据
        # instance=book_obj根据id找到的实例化对象

        # 对实例化对象进行校验
        if ser_obj.is_valid():
            # 校验通过,调用save进行更新
            ser_obj.save()      # 内部调用序列化器的update方法
            return Response(ser_obj.data)
        else:
            return Response(ser_obj.errors)     # 返回错误信息

    # 根据id删除数据
    def delete(self,request,id):
        # 根据ip找到模型对象
        book_obj = Book.objects.filter(pk=id).first()

        if book_obj:
            book_obj.delete()
            return Response("删除成功")
        else:
            return Response("删除失败")

# serializers.py
from rest_framework import serializers   # 导入框架的序列化器
from SerDemo.models import Book

# 外键字段的序列化器
class PublisherSerializer(serializers.Serializer):
    # 根据外键模型的字段定义字段进行匹配
    id = serializers.IntegerField()
    title = serializers.CharField(max_length=32)

# 多对多字段的序列化器
class AuthorSerializer(serializers.Serializer):
    # 根据多对多字段模型的字段定义字段进行匹配
    id = serializers.IntegerField()
    name = serializers.CharField(max_length=32)

# 自定义验证器
def my_validate(value):
    if "xxx" in value:
        raise serializers.ValidationError("该字段包含敏感词!!!")
    else:
        return value

class BookSerializer(serializers.Serializer):
    # 定义模型中需要序列化的字段,匹配的上的进行序列化，匹配不上的丢弃
    id = serializers.IntegerField(required=False)           # 反序列化不匹配该字段
    title = serializers.CharField(max_length=32,validators=[my_validate,])             # 使用自定义验证器
    category = serializers.CharField(source='get_category_display',read_only=True)     # source通过ORM操作获得CHOICES的值
    category_post = serializers.IntegerField(write_only=True)                          # 用于反序列化的字段
    pub_time = serializers.DateField()

    # 外键字段，先声明外键字段的序列化器再实例化
    publisher = PublisherSerializer(read_only=True)             # 仅在正序列化匹配该字段
    publisher_id = serializers.IntegerField(write_only=True)    # 仅在反序列化匹配该字段

    # 多对多字段，先声明多对多字段的序列化器再实例化
    authors = AuthorSerializer(read_only=True,many=True)       # 多个模型对象使用many=True，正序列化匹配该字段
    authors_list = serializers.ListField(write_only=True)      # 反序列化匹配该字段

    # 更新对象调用update()方法
    def update(self, instance, validated_data):
        # instance就是传入的模型对象
        # validated_data就是序列化的数据组成的字典

        # 如果更新的数据存在多对多的字段，就调用set方法
        if validated_data.get('authors_list',None):
            instance.authors.set(validated_data['authors_list'])

        # 根据字段取值，取不到就用对象的值
        instance.title=validated_data.get('title',instance.title)
        instance.save()

        # 返回对象
        return instance