序列化组件

from django.http import HttpResponse, JsonResponse
from django.core import serializers
class BookView(View):
	
	 # 第一版 json
	 def get(self, request):
		book_list = Book.objects.values("id", "title", "put_time", "category", "publisher")
		# querset [{}, {}]
		book_list = list(book_list)
		ret = json.dumps(book_list, ensure_ascii=False)
		return HttpResponse(ret)
	

	
	#第二版 JsonResponse
	def get(self, request):
		book_list = Book.objects.values("id", "title", "put_time", "category", "publisher")
		# querset [{}, {}]
		book_list = list(book_list)
		for book in book_list:
			publisher_obj = Publisher.objects.filter(id=book["publisher"]).first()
			# 手动给每个book对象添加其对应的外键出版社
			book["publisher"] = {
				"id": publisher_obj.id,
				"title": publisher_obj.title
			}
		return JsonResponse(book_list, safe=False, json_dumps_params={"ensure_ascii": False})
	
	

	#第三版 serialize
	用django的serialize方法 外键依然不能够被序列化 取出来的依然是id
	 def get(self, request):
		book_list = Book.objects.all()
		ret = serializers.serialize("json", book_list, ensure_ascii=False)
		return HttpResponse(ret)    
	

　　

使用rest_framework提供的序列化组件serializers

1,声明一个序列化器. 2,视图类继承APIView或其子类

第四版  使用serializers.Serializer

#自己写的serializers.py文件	
from rest_framework import serializers
from .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)

book_obj = {
    "title": "xxx",
    "category": 1,
    "publisher": 1,
    "authors": [1, 2]
}

# (read_only, write_only)
class BookSerializer(serializers.Serializer):
    id = serializers.IntegerField(required=False) # required=False反向序列化的时候不进行验证了,
    title = serializers.CharField(max_length=32)
    CHOICES = ((1, "Python"), (2, "Linux"), (3, "go"))
    category = serializers.CharField(max_length=32, source="get_category_display", read_only=True) #使用source参数后就可以使用orm中的指令了,source后的内容就是对应orm的指令  #read_only表示只进行正向序列化,从视图到前端,处理的是get请求
    post_category = serializers.ChoiceField(choices=CHOICES, write_only=True)#write_only表示你只进行反向序列化,从前端到视图,处理的是post请求
    put_time = serializers.DateField()

    publisher = PublisherSerializer(read_only=True)    #将出版社的Serializer对象传给publisher字段作为外键
    authors = AuthorSerializer(many=True, read_only=True) #同样的将作者的Serializer对象列表传给authors字段,作为多对多的关联,这里因为是多对多的关系,所以需要有一个many=True的参数

    publisher_id = serializers.IntegerField(write_only=True)  # 这里是用于反序列化时的读取,为了区别正向序列化,和前端约定起另外的字段名
    author_list = serializers.ListField(write_only=True)

    def create(self, validated_data): #validated_data是通过验证后的数据
        # 执行ORM的新增数据的操作
        book_obj = Book.objects.create(title=validated_data["title"], category=validated_data["post_category"],
                            put_time=validated_data["put_time"], publisher_id=validated_data["publisher_id"])
        book_obj.authors.add(*validated_data["author_list"])
        print(validated_data["author_list"])
        return book_obj

    def update(self, instance, validated_data):
        # 使用update的可以提交局部数据,当然也要是json格式的,注意最后面不要加逗号,加了逗号不符合json规范  { "title": "旭哥再次再次升职记"}
        # 有就更新没有就取默认的
        instance.title = validated_data.get("title", instance.title)
        instance.category = validated_data.get("post_category", instance.category)
        instance.put_time = validated_data.get("put_time", instance.put_time)
        instance.publisher_id = validated_data.get("publisher_id", instance.publisher_id)
        if validated_data.get("author_list"):
            instance.authors.set(validated_data["author_list"])
        instance.save()   #更新需要保存instance,因为instance=book_obj是从数据库取出来的数据,当然保存操作也可以在views中进行,直接保存 book_obj.save()
        return instance

　　

# 视图函数
from rest_framework.views import APIView
from rest_framework.response import Response
from .models import Book
from .serializers import BookSerializer


class BookAPIView(APIView):
    def get(self, request):
        book_list = Book.objects.all()
        ser_obj = BookSerializer(book_list, many=True)
        # return Response("DRF接口测试ok")
        return Response(ser_obj.data)

    def post(self, request):
        book_obj = request.data  #request.data接收post请求提交的数据,封装好了,不再使用request.POST.get()
        print(request.data)
        ser_obj = BookSerializer(data=book_obj)
        if ser_obj.is_valid():
            print(ser_obj.validated_data)
            ser_obj.save() # save()方法调用了我们在BookSerializer重写的creat方法
            return Response(ser_obj.validated_data)
        else:
            return Response(ser_obj.errors)


class BookEditView(APIView):
    def get(self, request, id):
        book_obj = Book.objects.filter(id=id).first()
        ser_obj = BookSerializer(book_obj)
        return Response(ser_obj.data)

    def patch(self, request, id):
        book_obj = Book.objects.filter(id=id).first()
        ser_obj = BookSerializer(instance=book_obj, data=request.data, partial=True)  #partial=True局部等于true,允许部分验证
        if ser_obj.is_valid():
            ser_obj.save() # post里的save()方法调用了我们在BookSerializer重写的update方法,这可以在源码中看,点进去看很明显
            # book_obj.save()  可以在这里保存,也可以在BookSerializer里进行保存
            return Response(ser_obj.validated_data)
        else:
            return Response(ser_obj.errors)

　　

第五版 使用serializers.ModelSerializer

# 自己写的serializers.py文件
from rest_framework import serializers
from .models import Book

class BookSerializer(serializers.ModelSerializer):
    # 正序和反序列化不同的字段
    category_display = serializers.SerializerMethodField(read_only=True)
    publisher_info = serializers.SerializerMethodField(read_only=True)
    authors_info = serializers.SerializerMethodField(read_only=True)

    def get_category_display(self, obj):
        return obj.get_category_display()

    def get_publisher_info(self, obj):
        return {"id": obj.publisher.id, "title": obj.publisher.title}

    def get_authors_info(self, obj):
        # 列表生成式循环获得每个作者信息
        return [{"id": author.id, "name": author.name} for author in obj.authors.all()]


    class Meta:
        model = Book
        fields = "__all__"
        extra_kwargs = {"category": {"write_only": True}, "publisher": {"write_only": True},
                        "authors": {"write_only": True}}	

　　

# 视图函数
from .serializers import BookSerializer
from rest_framework.views import APIView
from rest_framework.response import Response
from .models import Book, User
class BookView(APIView):
    # authentication_classes = [MyAuth, ] 这个是认证先不用管

    def get(self, request):
        # 查看所有的图书
        queryset = Book.objects.all()
        ser_obj = BookSerializer(queryset, many=True)
        return Response(ser_obj.data)

    def post(self, request):
        # 新增图书
        ser_obj = BookSerializer(data=request.data)
        if ser_obj.is_valid():
            ser_obj.save()
            return Response(ser_obj.validated_data)

class BookEditView(APIView):
    def get(self, request, pk):
        book_obj = Book.objects.filter(id=pk).first()
        ser_obj = BookSerializer(book_obj)
        return Response(ser_obj.data)

    def put(self, request, pk):
        book_obj = Book.objects.filter(id=pk).first()
        ser_obj = BookSerializer(instance=book_obj, data=request.data, partial=True)
        if ser_obj.is_valid():
            ser_obj.save()
            return Response(ser_obj.validated_data)
        else:
            return Response(ser_obj.errors)

    def delete(self, request, pk):
        book_obj = Book.objects.filter(id=pk).first()
        if not book_obj:
            return Response({"code": 1001, "error": "删除的数据不存在"})
        else:
            book_obj.delete()
            return Response("")	

　　

 

# 在序列化组件中进行验证
def my_validate(value):
    print("my_validate")
    # 对敏感信息进行过滤
    if "马化腾" in value.lower():
        raise serializers.ValidationError("不能含有敏感词汇")
    else:
        return value	
class BookSerializer(serializers.ModelSerializer):
    category_dis= serializers.SerializerMethodField(read_only=True)
    publisher_info = serializers.SerializerMethodField(read_only=True)
    author_info = serializers.SerializerMethodField(read_only=True)

    def get_author_info(self, obj):
        # 通过obj拿到authors
        # 构建想要的数据结构返回
        authors = obj.authors.all()
        ret = []
        for author in authors:
            ret.append({
                "id": author.id,
                "name": author.name
            })
        return ret


    def get_category_dis(self, obj):
        return obj.get_category_display()

    def get_publisher_info(self, obj):
        # 序列化的Book对象
        # 通过Book对象找到我们的publisher对象
        # 就可以拿到我们想要的字段
        # 拼接成自己想要的数据结构
        ret = {
            "id": obj.publisher.id,
            "title": obj.publisher.title
        }
        return ret

    class Meta:
        model = Book
        # fields = ["id", "title", "put_time"]
        fields = "__all__"
        # depth = 1  # 自动寻找一层外键的字段,depth=2就寻找两层外键的字段, 当时会让你这些外键关系的字段变成read_only = True  一般不建议用,
        extra_kwargs = {"category": {"write_only": True},"publisher": {"write_only": True},
                        "authors":{"write_only": True},"title": {"validators": [my_validate]}}	

　　

序列化组件类的相互引用

# 序列化组件间的相互引用
from rest_framework import serializers
from course.models import Course,CourseDetail


class CourseSerializer(serializers.ModelSerializer):
    course_type_display = serializers.SerializerMethodField(read_only=True)
    level_display = serializers.SerializerMethodField(read_only=True)
    status_display = serializers.SerializerMethodField(read_only=True)
    category_info = serializers.SerializerMethodField(read_only=True)
    price_policy = serializers.SerializerMethodField(read_only=True)

    def get_course_type_display(self, obj):
        return obj.get_course_type_display()

    def get_level_display(self, obj):
        return obj.get_level_display()

    def get_status_display(self, obj):
        return obj.get_status_display()

    def get_category_info(self, obj):
        return {'id': obj.category.id, 'title': obj.category.title}

    def get_price_policy(self, obj):
        ret = [{
            'id': price_obj.id,
            'valid_price_display': price_obj.get_valid_period_display(),
            "price": price_obj.price}
            for price_obj in obj.price_policy.all()]

        return ret

    class Meta:
        model = Course
        fields = "__all__"
        # depth = 1
        extra_kwargs = {"course_type": {"write_only": True}, "level": {"write_only": True},
                        "status": {"write_only": True}, "category": {"write_only": True}}

class CourseDetailSerializer(serializers.ModelSerializer):
    course_info=serializers.SerializerMethodField(read_only=True)   
    def get_course_info(self,obj):
        # print(obj.course,type(obj.course))
        # 这里引用了CourseSerializer,就不用再重复写了
        course_queryset= Course.objects.filter(id=obj.id)
        return CourseSerializer(course_queryset,many=True).data[0]   # 这样得到是字典,不然是列表,多对多的关系中应该用列表

    class Meta:
        model=CourseDetail
        fields = '__all__'
        extra_kwargs = {"course": {"write_only": True},}

　　

这是model.py表关系

from django.db import models

# Create your models here.

from django.db import models
from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
from django.contrib.contenttypes.models import ContentType

# Create your models here.
__all__ = ["Category", "Course", "CourseDetail", "Teacher", "DegreeCourse", "CourseChapter",
           "CourseSection", "PricePolicy", "OftenAskedQuestion", "Comment", "Account", "CourseOutline"]


class Category(models.Model):
    """课程分类表"""
    title = models.CharField(max_length=32, unique=True, verbose_name="课程的分类")

    def __str__(self):
        return self.title

    class Meta:
        verbose_name = "01-课程分类表"
        db_table = verbose_name
        verbose_name_plural = verbose_name


class Course(models.Model):
    """课程表"""
    title = models.CharField(max_length=128, unique=True, verbose_name="课程的名称")
    course_img = models.ImageField(upload_to="course/%Y-%m", verbose_name='课程的图片')
    category = models.ForeignKey(to="Category", verbose_name="课程的分类")
    COURSE_TYPE_CHOICES = ((0, "付费"), (1, "vip专享"), (2, "学位课程"))
    course_type = models.SmallIntegerField(choices=COURSE_TYPE_CHOICES)
    degree_course = models.ForeignKey(to="DegreeCourse", blank=True, null=True, help_text="如果是学位课程，必须关联学位表")

    brief = models.CharField(verbose_name="课程简介", max_length=1024)
    level_choices = ((0, '初级'), (1, '中级'), (2, '高级'))
    level = models.SmallIntegerField(choices=level_choices, default=1)
    status_choices = ((0, '上线'), (1, '下线'), (2, '预上线'))
    status = models.SmallIntegerField(choices=status_choices, default=0)
    pub_date = models.DateField(verbose_name="发布日期", blank=True, null=True)
    order = models.IntegerField("课程顺序", help_text="从上一个课程数字往后排,尽量间隔几个数字")
    study_num = models.IntegerField(verbose_name="学习人数", help_text="只要有人买课程，订单表加入数据的同时给这个字段+1")

    # order_details = GenericRelation("OrderDetail", related_query_name="course")
    # coupon = GenericRelation("Coupon")
    # 只用于反向查询不生成字段
    price_policy = GenericRelation("PricePolicy")
    often_ask_questions = GenericRelation("OftenAskedQuestion")
    course_comments = GenericRelation("Comment")

    def save(self, *args, **kwargs):
        if self.course_type == 2:
            if not self.degree_course:
                raise ValueError("学位课必须关联学位课程表")
        super(Course, self).save(*args, **kwargs)

    def __str__(self):
        return self.title

    class Meta:
        verbose_name = "02-课程表"
        db_table = verbose_name
        verbose_name_plural = verbose_name


class CourseDetail(models.Model):
    """课程详细表"""
    course = models.OneToOneField(to="Course")
    hours = models.IntegerField(verbose_name="课程时长", default=7)
    # course_slogan = models.CharField(max_length=125, blank=True, null=True, verbose_name="课程口号")
    video_brief_link = models.CharField(max_length=255, blank=True, null=True)
    summary = models.TextField(max_length=2048, verbose_name="课程概述")
    why_study = models.TextField(verbose_name="为什么学习这门课程")
    what_to_study_brief = models.TextField(verbose_name="我将学到哪些内容")
    career_improvement = models.TextField(verbose_name="此项目如何有助于我的职业生涯")
    prerequisite = models.TextField(verbose_name="课程先修要求", max_length=1024)
    recommend_courses = models.ManyToManyField("Course", related_name="recommend_by", blank=True)
    teachers = models.ManyToManyField("Teacher", verbose_name="课程讲师")

    def __str__(self):
        return self.course.title

    class Meta:
        verbose_name = "03-课程详细表"
        db_table = verbose_name
        verbose_name_plural = verbose_name


class Teacher(models.Model):
    """讲师表"""
    name = models.CharField(max_length=32, verbose_name="讲师名字")
    brief = models.TextField(max_length=1024, verbose_name="讲师介绍")

    def __str__(self):
        return self.name

    class Meta:
        verbose_name = "04-教师表"
        db_table = verbose_name
        verbose_name_plural = verbose_name


class DegreeCourse(models.Model):
    """
    字段大体跟课程表相同，哪些不同根据业务逻辑去区分
    """
    title = models.CharField(max_length=32, verbose_name="学位课程名字")

    def __str__(self):
        return self.title

    class Meta:
        verbose_name = "05-学位课程表"
        db_table = verbose_name
        verbose_name_plural = verbose_name


class CourseChapter(models.Model):
    """课程章节表"""
    course = models.ForeignKey(to="Course", related_name="course_chapters")
    chapter = models.SmallIntegerField(default=1, verbose_name="第几章")
    title = models.CharField(max_length=32, verbose_name="课程章节名称")

    def __str__(self):
        return self.title

    class Meta:
        verbose_name = "06-课程章节表"
        db_table = verbose_name
        verbose_name_plural = verbose_name
        unique_together = ("course", "chapter")


class CourseSection(models.Model):
    """课时表"""
    chapter = models.ForeignKey(to="CourseChapter", related_name="course_sections")
    title = models.CharField(max_length=32, verbose_name="课时")
    section_order = models.SmallIntegerField(verbose_name="课时排序", help_text="建议每个课时之间空1至2个值，以备后续插入课时")
    section_type_choices = ((0, '文档'), (1, '练习'), (2, '视频'))
    free_trail = models.BooleanField("是否可试看", default=False)
    section_type = models.SmallIntegerField(default=2, choices=section_type_choices)
    section_link = models.CharField(max_length=255, blank=True, null=True, help_text="若是video，填vid,若是文档，填link")

    def course_chapter(self):
        return self.chapter.chapter

    def course_name(self):
        return self.chapter.course.title

    def __str__(self):
        return "%s-%s" % (self.chapter, self.title)

    class Meta:
        verbose_name = "07-课程课时表"
        db_table = verbose_name
        verbose_name_plural = verbose_name
        unique_together = ('chapter', 'section_link')


class PricePolicy(models.Model):
    """价格策略表"""
    # conten_type  指定表id
    content_type = models.ForeignKey(ContentType)  # 关联course or degree_course
    # 关联的表里的对象id
    object_id = models.PositiveIntegerField()
    #  关联的表里的那个对象
    content_object = GenericForeignKey('content_type', 'object_id')

    valid_period_choices = ((1, '1天'), (3, '3天'),
                            (7, '1周'), (14, '2周'),
                            (30, '1个月'),
                            (60, '2个月'),
                            (90, '3个月'),
                            (120, '4个月'),
                            (180, '6个月'), (210, '12个月'),
                            (540, '18个月'), (720, '24个月'),
                            (722, '24个月'), (723, '24个月'),
                            )
    # 周期
    valid_period = models.SmallIntegerField(choices=valid_period_choices)
    # 价格
    price = models.FloatField()

    def __str__(self):
        return "%s(%s)%s" % (self.content_object, self.get_valid_period_display(), self.price)

    class Meta:
        verbose_name = "08-价格策略表"
        db_table = verbose_name
        verbose_name_plural = verbose_name
        unique_together = ("content_type", 'object_id', "valid_period")


class OftenAskedQuestion(models.Model):
    """常见问题"""
    content_type = models.ForeignKey(ContentType)  # 关联course or degree_course
    object_id = models.PositiveIntegerField()
    content_object = GenericForeignKey('content_type', 'object_id')

    question = models.CharField(max_length=255)
    answer = models.TextField(max_length=1024)

    def __str__(self):
        return "%s-%s" % (self.content_object, self.question)

    class Meta:
        verbose_name = "09-常见问题表"
        db_table = verbose_name
        verbose_name_plural = verbose_name
        unique_together = ('content_type', 'object_id', 'question')


class Comment(models.Model):
    """通用的评论表"""
    content_type = models.ForeignKey(ContentType, blank=True, null=True)
    object_id = models.PositiveIntegerField(blank=True, null=True)
    content_object = GenericForeignKey('content_type', 'object_id')

    content = models.TextField(max_length=1024, verbose_name="评论内容")
    account = models.ForeignKey("Account", verbose_name="会员名")
    date = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.content

    class Meta:
        verbose_name = "10-评价表"
        db_table = verbose_name
        verbose_name_plural = verbose_name


class Account(models.Model):
    username = models.CharField(max_length=32, verbose_name="用户姓名")
    # head_img = models.CharField(max_length=256, default='/static/frontend/head_portrait/logo@2x.png',
    #                             verbose_name="个人头像")

    def __str__(self):
        return self.username

    class Meta:
        verbose_name = "11-用户表"
        db_table = verbose_name
        verbose_name_plural = verbose_name


class CourseOutline(models.Model):
    """课程大纲"""
    course_detail = models.ForeignKey(to="CourseDetail", related_name="course_outline")
    title = models.CharField(max_length=128)
    order = models.PositiveSmallIntegerField(default=1)
    # 前端显示顺序

    content = models.TextField("内容", max_length=2048)

    def __str__(self):
        return "%s" % self.title

    class Meta:
        verbose_name = "12-课程大纲表"
        db_table = verbose_name
        verbose_name_plural = verbose_name
        unique_together = ('course_detail', 'title')