通用视图2

序列化器

模型类的序列化---(Serializer)

1.通过serializers 指定类属性的类型，基本的校验约束min length/max length/allow null 是否为空/trim whitespace 去掉两边的空格
2.自定义校验器 I 
2.1 基本的校验参数
2.2 自己定义类内部的局部校验 或者 全局校验
2.3 指定validators参数如validators=[test]然后定义test函数，完成校验规则
2.4 验证通过，返回该值;验证失败，抛出异常ValidationError

序列化器使用

作用：

1.进行数据的校验-----反序列 2.将模型类的对象转换为字典---序列化 3.减少代码量，提高编码效率----序列化器

序列化定义：

将模型类对象转为字典，然后经过Response转为json字符串--------称为序列化

反序列化定义：

将网络中的json字符串经过Request对象，转为字典或者类字典，然后经过序列化器转为模型类的对象------称为反序列化

定义模型类的序列化器，需继承

rest_framework.serializers.Serializer ---序列化器

rest_framework.serializers.ModelSerializer ---模型类的序列化器

Serializer使用方式

反序列化插入数据时，必须重写create方法；反序列化更新数据时，必须重写update方法。

模型类序列化器

from rest_framework import serializers
from rest_framework.exceptions import ValidationError,AuthenticationFailed
from .models import *
import re

# 部门的序列化器
class DepartmentSer(serializers.Serializer):
    id = serializers.IntegerField(label="部门编号",read_only=True)
    name = serializers.CharField(label="部门名称",max_length=50,min_length=1,allow_null=True,trim_whitespace=True)

    # 全局校验
    def validate(self, data):
        print("正在进行全局校验",data)
        ...
        return data

        # 校验不通过
        # reise ValidationError

    # 重写create方法
    def create(self,validated_data):
        # 保存数据
        dep = Department.objects.create(**validated_data)
        return dep

    # 重写update方法
    def update(self, instance, validated_data):
        # instance 要修改的对象
        instance.name = validated_data.get('name')
        instance.save()

        return instance


def a(name):
    return name


# 职责的序列化器
class DutySer(serializers.Serializer):
    id = serializers.IntegerField(label="职责编号",read_only=True)
    name = serializers.CharField(label="职责名称",max_length=50,min_length=1,allow_null=False,trim_whitespace=True,
                                 validators=[a,])


# 局部校验
    def validate_name(self,name):
        if re.findall(r"^[A-Z]$",name):
            return name

        else:
            raise  ValidationError("职责名称不符合规则")
# 全局校验
    def validate(self, data):
        # 校验所有的数据 data
        return data



# 员工的序列化器
class StaffSer (serializers.Serializer):
    SEX_CHOICE = (
        (1,"男"),
        (0,"女")
    )
    id = serializers.IntegerField(label="员工ID",read_only=True)
    name = serializers.CharField(label="员工姓名",max_length=50,min_length=1,trim_whitespace=True)
    sex = serializers.ChoiceField(choices=SEX_CHOICE,default=1)
    phone = serializers.CharField(label="手机号",max_length=11,min_length=1,trim_whitespace=True)
    email = serializers.CharField(label="邮箱",max_length=50)

    department = serializers.PrimaryKeyRelatedField(queryset=Department.objects.all())
    duty = serializers.PrimaryKeyRelatedField(queryset=Duty.objects.all())

ModelSerializer与常规的Serializer相同，但提供了：

• 基于模型类自动生成一系列字段

• 基于模型类自动生成validators

• 默认实现create()和update()方法，不需重写

 ModelSerializer使用

class DepartmentModelSerializer(serializers.ModelSerializer): 
    class Meta:
        model = Department  # 指定要序列化的模型类
        fields = '__all__'  # 指定要序列化的字段，__all__所有字段


class DutyModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = Duty
        fields = ("name",)  # 指定需要的字段


class StaffModelSerializer(serializers.ModelSerializer):
    # 外键， 指定queryset时，只用于反序列化输入
    # 		指定read_only=True，只用于序列化输出
    department = serializers.PrimaryKeyRelatedField(label="部门", queryset=Department.objects.all(), many=True)
    duty = serializers.PrimaryKeyRelatedField(label="职责", queryset=Duty.objects.all(), many=True)
    
    class Meta:
        model = Staff
        fields = ("id", "name", "sex", "phone", "department", "duty") #外键要特殊处理
        read_only_fields = ("id",)
        write_only_fields = ("email",)

GenericAPIView的使用

GenericAPIView是什么

GenericAPIView继承自 APIVIew，增加了对于列表视图和详情视图可能用到的通用支持方法，可搭配一个或多个Mixin扩展类，来实现其他更加高级的功能。

from rest_framework.generics import GenericAPIView

这个类内置了如下一些属性，这些属性可以帮助我们进行序列化及反序列化的操作。

---

列表视图与详情视图通用属性：

• queryset 列表视图的查询集

• serializer_class 视图使用的序列化器

列表视图使用：

• pagination_class分页控制类

• filter_backends过滤控制后端，对字段过滤

详情页视图使用：

• lookup_field 查询单一数据对象时使用的条件字段，默认为'pk'

• lookup_url_kwarg 查询单一数据时URL中的关键字参数，默认与look_field相同

---

列表与详情视图通用方法

• get_queryset(self)

  • 返回视图使用的查询集，是列表视图与详情视图获取数据的基础

  • 默认返回queryset属性，支持重写

• get_serializer_class(self)

  • 返回序列化器类，默认返回serializer_class，可以重写

• get_serializer(self, *args, **kwargs)

  • 返回序列化器对象

---

详情视图单独方法

• get_object(self)

  • 返回详情视图所需的模型类数据对象，默认使用lookup_field参数来过滤queryset。

  • 若详情访问的模型类对象不存在，会返回404，如果访问到多个重复，也会报错，默认使用get方法进行ORM查询

  • Department.objects.get(id=pk)

  • 该方法会默认使用 APIView 提供的check_object_permissions方法检查当前对象是否有权限被访问

 获取全部部门数据

from rest_framework.generics import GenericAPIView
from rest_framework.response import Response

from .models import Department
from .serializer import DepartmentModelSerializer


class DepartmentListView(GenericAPIView):
    queryset = Department.objects.all()  # 指定查询集
    serializer_class = DepartmentModelSerializer  # 指定序列化器类

    def get(self, request):
        department_list = self.get_queryset()  # 获取查询集数据
        dep_serializer = self.get_serializer(department_list, many=True)
        return Response(dep_serializer.data)

 获取单个数据对象

from rest_framework.generics import GenericAPIView
from rest_framework.response import Response

from .models import Department
from .serializer import DepartmentModelSerializer

#路由  path("/<int:pk>/", DepDetailView.as_view())
class DepDetailView(GenericAPIView):
    queryset = Department.objects.all()  # 指定查询集
    serializer_class = DepartmentModelSerializer  # 指定序列化器类
   
    lookup_field = 'pk'  # 过滤的orm参数

    def get(self, request, pk):
        department = self.get_object()  # 获取单条数据
        dep_serializer = self.get_serializer(department)
        return Response(dep_serializer.data)

反序列化 添加数据

class DepartmentListView(GenericAPIView):
    queryset = Department.objects.all()  # 指定查询集
    serializer_class = DepartmentModelSerializer  # 指定序列化器类

    def post(self, request):
        # 接收网页发送的数据
        name = request.data.get('name')
        # 获取部门对象，用来判断部门是否存在
        department_obj = Department.objects.filter(name=name)
        # 判断部门是否存在，如果存在，返回部门存在
        if department_obj:
            return Response({'msg': '部门存在', 'code': 400})
        # 不存在时，反序列化添加部门
        dep_serializer = self.get_serializer(data=request.data)
        # 校验
        if dep_serializer.is_valid():
            # 校验通过，保存数据
            dep_serializer.save()
            # 返回
            return Response({'msg': '添加成功', 'code': 200})
        # 校验失败，返回错误消息
        else:
            return Response({'error': dep_serializer.errors, 'code': 400})

混入扩展类

ListModelMixin

列表视图扩展类，提供list(request, *args, **kwargs)方法快速实现列表视图，返回200状态码。

该Mixin的list方法会对数据进行过滤和分页。

源码：

class ListModelMixin(object):
    """
    List a queryset.
    """
    def list(self, request, *args, **kwargs):
        # 过滤
        queryset = self.filter_queryset(self.get_queryset())
        # 分页
        page = self.paginate_queryset(queryset)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)
        # 序列化
        serializer = self.get_serializer(queryset, many=True)
        return Response(serializer.data)

示例：

from rest_framework.generics import GenericAPIView
from rest_framework.mixins import ListModelMixin

from .models import Department
from .serializer import DepartmentModelSerializer


class DepartmentListView(GenericAPIView, ListModelMixin):
    """
    部门展示
    """
    queryset = Department.objects.all()
    serializer_class = DepartmentModelSerializer

    def get(self, request, *args, **kwargs):
        return self.list(request, *args, **kwargs)

CreateModelMixin

创建视图扩展类，提供create(request, *args, **kwargs)方法快速实现创建资源的视图，成功返回201状态码。

如果序列化器对前端发送的数据验证失败，返回400错误。

源码：

class CreateModelMixin(object):
    """
    Create a model instance.
    """
    def create(self, request, *args, **kwargs):
        # 获取序列化器
        serializer = self.get_serializer(data=request.data)
        # 验证
        serializer.is_valid(raise_exception=True)
        # 保存
        self.perform_create(serializer)
        headers = self.get_success_headers(serializer.data)
        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)

    def perform_create(self, serializer):
        serializer.save()

    def get_success_headers(self, data):
        try:
            return {'Location': str(data[api_settings.URL_FIELD_NAME])}
        except (TypeError, KeyError):
            return {}

示例：

from rest_framework.generics import GenericAPIView
from rest_framework.mixins import CreateModelMixin

from .models import Department
from .serializer import DepartmentModelSerializer


class DepartmentCreateView(GenericAPIView, CreateModelMixin):
    """
    部门添加
    """
    serializer_class = DepartmentModelSerializer
    
    def post(self, request, *args, **kwargs):
        return self.create(request, *args, **kwargs)

RetrieveModelMixin

详情视图扩展类，提供retrieve(request, *args, **kwargs)方法，可以快速实现返回一个存在的数据对象。

如果存在，返回200， 否则返回404。

源码：

class RetrieveModelMixin(object):
    """
    Retrieve a model instance.
    """
    def retrieve(self, request, *args, **kwargs):
        # 获取对象，会检查对象的权限
        instance = self.get_object()
        # 序列化
        serializer = self.get_serializer(instance)
        return Response(serializer.data)

示例：

class DepartmentRetrieveView(GenericAPIView, RetrieveModelMixin):
    """
    部门单个获取
    """
    queryset = Department.objects.all()
    serializer_class = DepartmentModelSerializer
    
    lookup_field = 'pk'  # 过滤的orm参数
    
    def get(self, request, *args, **kwargs):
        return self.retrieve(request, *args, **kwargs)

UpdateModelMixin

更新视图扩展类，提供update(request, *args, **kwargs)方法，可以快速实现更新一个存在的数据对象。

成功返回200，序列化器校验数据失败时，返回400错误。

源码：

class UpdateModelMixin(object):
    """
    Update a model instance.
    """
    def update(self, request, *args, **kwargs):
        partial = kwargs.pop('partial', False)
        instance = self.get_object()
        serializer = self.get_serializer(instance, data=request.data, partial=partial)
        serializer.is_valid(raise_exception=True)
        self.perform_update(serializer)
		...
     
        return Response(serializer.data)

    def perform_update(self, serializer):
        serializer.save()

示例：

class DepartmentUpdateView(GenericAPIView, UpdateModelMixin):
    """
    部门修改
    """
    queryset = Department.objects.all()
    serializer_class = DepartmentModelSerializer
    
    lookup_field = 'pk'  # 过滤的orm参数

    def put(self, request, *args, **kwargs):
        return self.update(request, *args, **kwargs)

DestroyModelMixin

删除视图扩展类，提供destroy(request, *args, **kwargs)方法，可以快速实现删除一个存在的数据对象。

成功返回204，不存在返回404。

源码：

class DestroyModelMixin(object):
    """
    Destroy a model instance.
    """
    def destroy(self, request, *args, **kwargs):
        instance = self.get_object()
        self.perform_destroy(instance)
        return Response(status=status.HTTP_204_NO_CONTENT)

    def perform_destroy(self, instance):
        instance.delete()

示例：

子类视图简介

Django框架为了方便视图的编写，还提供了9个子类视图类。

 注：子类视图都在`from rest_framework.generics`模块中。

ListAPIView

提供get方法，可以获取多条数据

from rest_framework.generics import ListAPIView
                                    
from .models import Department
from .serializer import DepartmentModelSerializer


class DepListView(ListAPIView):
    queryset = Department.objects.all()
    serializer_class = DepartmentModelSerializer

CreateAPIView

提供post方法，可以创建一条数据

from rest_framework.generics import CreateAPIView
from .serializer import DepartmentModelSerializer


class DepCreateView(CreateAPIView):

    serializer_class = DepartmentModelSerializer

RetireveAPIView

提供get方法，获取某个具体数据的详情

from rest_framework.generics import RetrieveAPIView
from .models import Department
from .serializer import DepartmentModelSerializer


class DepDetailView(RetrieveAPIView):
    
    lookup_field = 'pk'  # 过滤的orm参数
    queryset = Department.objects.all()
    serializer_class = DepartmentModelSerializer

DestoryAPIView

提供 delete 方法，可以删除某条存在数据

from rest_framework.generics import DestroyAPIView
from .models import Department
from .serializer import DepartmentModelSerializer


class DepDestroyView(DestroyAPIView):
    
    lookup_field = 'pk'  # 过滤的orm参数
    queryset = Department.objects.all()

UpdateAPIView

提供 put 和 patch 方法，可以更新或者局部更新某条数据

from rest_framework.generics import UpdateAPIView
from .models import Department
from .serializer import DepartmentModelSerializer

class DepUpdateView(UpdateAPIView):
   
    lookup_field = 'pk'  # 过滤的orm参数
    queryset = Department.objects.all()
    serializer_class = DepartmentModelSerializer

ListCreateAPIView

提供 post 和 get 方法，可以创建一条数据，或获取列表数据

from rest_framework.generics import ListCreateAPIView
from .models import Department
from .serializer import DepartmentModelSerializer

class DepListCreateView(ListCreateAPIView):
     # 共用一个序列化器同时实现创建和数据展示
    queryset = Department.objects.all()
    serializer_class = DepartmentModelSerializer

RetrieveUpdateAPIView

提供 get、put、patch 方法，可以获取一条数据详情，也可以更新一条数据

from rest_framework.generics import RetrieveUpdateAPIView
from .models import Department
from .serializer import DepartmentModelSerializer


class DepRetrieveUpdateView(RetrieveUpdateAPIView):
    
    lookup_field = 'pk'  # 过滤的orm参数
    queryset = Department.objects.all()
    serializer_class = DepartmentModelSerializer

RetrieveDestroyAPIView

提供 get 和 delete 方法，可以获取和删除一条已存在数据

from rest_framework.generics import RetrieveDestroyAPIView
from .models import Department
from .serializer import DepartmentModelSerializer


class DepRetrieveDestroyView(RetrieveDestroyAPIView):
    
    lookup_field = 'pk'  # 过滤的orm参数
    queryset = Department.objects.all()
    serializer_class = DepartmentModelSerializer

RetrieveUpdateDestoryAPIView

提供 get、put、patch、delete 方法，啥也能干

from rest_framework.generics import RetrieveUpdateDestroyAPIView
from .models import Department
from .serializer import DepartmentModelSerializer

class DepartmentAll(RetrieveUpdateDestroyAPIView):
   
    lookup_field = 'pk'  # 过滤的orm参数
    queryset = Department.objects.all()
    serializer_class = DepartmentModelSerializer