DRF-序列化对象-1-实例化Serializer序列化类（在APIViewhi图中实例化）

Serializer序列化类的实例化

1、author模型序列化器：

class AuthorSerializer(serializers.Serializer):
    id = serializers.IntegerField(read_only=True)
    name = serializers.CharField(label='author name')
    address = serializers.CharField(label='author address')
    phone = serializers.CharField(
        label='author phone',
        max_length=11,min_length=11,
        error_messages={
                        	'max_length':'len of phonemunber must 11'
                        })
	#Serializer必须重写create方法
    def create(self, validated_data):
        try:
            author = models.Auhtor.objects.create(**validated_data)
            return author
        except Exception as e:
            raise ValidationError(str(e))
	#Serializer必须重写update方法
    def update(self, instance, validated_data):
        if instance:
            #判断搜索的id是否在数据库中存在
            try:
                #全部更新和部分更新都通过这个
                instance.update(**validated_data)
                return instance.first()
                #返回的是更新后的数据
            except Exception as e:
                raise ValidationError(str(e))
        else:
            raise ValidationError('the data not exist,can be updated')

    def validate(self, attrs):
        #全局钩子，可以检验多个字段
        print(attrs)
        return attrs
    def validate_phone(self,value):
        #局部钩子，检验单个字段
        if re.findall('^1[3456789]\d{9}$', value):
            return value
        raise ValidationError('type of phone is error')

2.1、序列化时：

序列化现象：从数据库拿数据给前端

单个数据：get请求

class AUthorPKAPIView(APIView):
    def get(self,request,pk):
        instance = model.Author.objects.filter(id=pk).first()
        if instance:
            ser = AuthorSerializer(instance=instance)
            return Response(data={'data':ser.data},status=200)
        return Response(data={'error':"查询不到数据"},status=404)
    

多个数据：get请求

class AUthorAPIView(APIView):
    def get(self,request):
        instances = model.Author.objects.all()
        if instances:
            ser = AuthorSerializer(instance=instances,many=True)
            #要序列化多个模型对象时，在实例化序列化类时，需要传递参数many=True
            return Response(data={'data':ser.data},status=200)
        return Response(data={'error':"查询不到数据"},status=404)

总结：

1、当序列化的是一个模型对象时，在实例化序列化类时，只需要传递参数： instance = 模型对象

2、当序列化的是多个模型对象时，在实例化序列化类时，需要传递参数：instance=数据集，many=True

2.2、反序列化时：

反序列化现象：将前端传递的数据，写到数据库

新建一个数据，入库：post请求

class AUthorAPIViewPK(APIView):
    def post(self,request):
        ser = AuthorSerializer(data=request.data)
        ser.is_valid(raise_exception=True)
        ser.save()
        return Response(data={'data':ser.data},status=200)

更新数据库存在的数据：全部更新 put请求

class AUthorPKAPIViewPK(APIView):
    def put(self,request,pk):
        #拿到要操作的模型对象
        intance = models.Author.objects.filter(id=pk).first()
        ser = AuthorSerializer(instance=instance,data=request.data)
        ser.is_valid(raise_exception=True)
        ser.save()
        return Response(data={'data':ser.data},status=200)

更新数据库存在的数据：部分更新 patch请求

class AUthorPKAPIViewPK(APIView):
    def put(self,request,pk):
        #拿到要操作的模型对象
        intance = models.Author.objects.filter(id=pk).first()
        ser = AuthorSerializer(instance=instance,data=request.data,partial=True)
        ser.is_valid(raise_exception=True)
        ser.save()
        return Response(data={'data':ser.data},status=200)

删除数据库中的某条记录：使用delete请求[删除操作与序列化器没有关系]

class AUthorPKAPIViewPK(APIView):
    def delete(self,request,pk):
        ret = models.Auhtor.objects.filter(id=pk).delete()
        if ret[1]:
            return Response(data={"data": "delete data success"}, status=200)
        else:
            return Response(data={'error': "data is not exist,can`t be delete"}, status=400)

总结：

1、新建数据，实例化序列化类时，传递的参数：data=request.data

#序列化类实例化时 ，只传递data=request.data参数，
#调用ser.sve()时，会去调用序列化对象中的create方法

2、更新数据-全部更新,实例化序列化类时，传递的参数：instance = 模型对象，data=request.data

#序列化类实例化时，传递参数 instance = 模型对象，data=request.data
#调用ser.save()时，会去调用序列化对象中的update方法

3、更新数据-部分更新，实例化序列化类时，传递的参数：instance = 模型对象，data=request.data，partial=True

#序列化类实例化时，传递参数 instance = 模型对象，data=request.data，partial=True
#partial=True:告诉序列化类，只序列化传递进来的字段，对没有传递的字段不做操作（该字段是required=True，不传也不会抛异常）
#调用ser.save()时，会去调用序列化对象中的update方法

3、路由总结

1、get/post请求，放到一个视图类中，使用同一条路由

class AUthorAPIView(APIView):
    def get(self,request):
        #获取数据表所有数据
        pass
    def post(self,request):
        #新建一条数据库记录
        pass
path('v1/api/author/',views.AuthorAPIView.as_view())

2、get/put/patch/delete请求，放到一个视图类中，使用同一条路由

class AUthorAPIViewPK(APIView):
    def get(self,request,pk):
        #获取数据表单个数据
        pass
    def put(self,request,pk):
        #全部更新一条记录
        pass
     def patch(self,request,pk):
        #部分更新一条记录
        pass
    def delete(self,request,pk):
        #删除某条记录
        pass
path('v1/api/author/<int:pk>/',views.AuthorAPIViewPK.as_view())