Day 61Django_反序列化、模型类序列化器

电玩女神 2023-08-17 15:29 166阅读 0赞

# 1.反序列化 #

\# 当我们接受到客户端POST请求或者PUT请求的时候

## 1.1 反序列化-数据校验 ##

使用序列化器进行反序列化时，需要对数据进行验证后，才能获取验证成功的数据或保存成模型类对象。

在获取反序列化的数据前，必须调用**is\_valid()**方法进行验证，验证成功返回True，否则返回False。

*  验证失败，可以通过序列化器对象的**errors**属性获取错误信息，返回字典，包含了字段和字段的错误。is\_valid()方法还可以在验证失败时抛出异常serializers.ValidationError，可以通过传递**raise\_exception=True**参数开启。
 *  验证成功，可以通过序列化器对象的**validated\_data**属性获取数据。

在定义序列化器时，指明每个字段的序列化类型和选项参数，本身就是一种验证行为。

ser应用下的serializers.py文件：

"""
      在drf中，对于客户端提供的数据，往往需要验证数据的有效性，这部分代码是写在序列化器中的。
      在序列化器中，已经提供三个地方给我们针对客户端提交的数据进行验证。
      1. 内置选项，字段声明的小圆括号中，以选项存在作为验证提交
      2. 自定义方法，在序列化器中作为对象方法来提供验证[ 这部分验证的方法，必须以"validate_<字段>" 或者 "validate" 作为方法名 ]
      3. 自定义函数，在序列化器外部，提前声明一个验证代码，然后在字段声明的小圆括号中，通过 "validators=[验证函数１,验证函数２...]"
    """
    
    def check_user(data):
        if data == "oldboy":
            raise serializers.ValidationError("用户名不能为oldboy！")
        return data
    
    class Student3Serializer(serializers.Serializer):
        # 声明序列化器
        # 1. 字段声明[ 要转换的字段，当然，如果写了第二部分代码，有时候也可以不用写字段声明 ]
        name = serializers.CharField(max_length=10, min_length=4, validators=[check_user])
        sex = serializers.BooleanField(required=True)
        age = serializers.IntegerField(max_value=150, min_value=0)
    
        # 2. 可选[ 如果序列化器继承的是ModelSerializer，则需要声明对应的模型和字段, ModelSerializer是Serializer的子类 ]
    
        # 3. 可选[ 用于对客户端提交的数据进行验证 ]
        """验证单个字段值的合法性"""
        def validate_name(self, data):
            if data == "root":
                raise serializers.ValidationError("用户名不能为root！")
            return data
    
        def validate_age(self, data):
            if data < 18:
                raise serializers.ValidationError("年龄不能小于18")
            return data
    
        """验证多个字段值的合法性"""
        def validate(self, attrs):
            name = attrs.get('name')
            age = attrs.get('age')
    
            if name == "alex" and age == 22:
                raise serializers.ValidationError("alex在22时的故事。。。")
    
            return attrs

ser应用下的urls.py文件：

urlpatterns = [

# 使用序列化将多个对象(多条记录)序列化成字典，并转化为json数据展示在前端

path("students/", views.Student2View.as_view()),
    　　　# 使用序列化将单个对象序列化成字典，并转化为json数据展示在前端
        re_path(r"^student/(?P<pk>\d+)/$", views.Student1View.as_view()),
        # 对数据提交时，进行校验
        path('student3/', views.Student3View.as_view()),
    ]

ser应用下的views.py文件：

\# Student3Serializer中只是传入 了一个data那么在用户就行POST请求的时候，调用序列化器Student3Serializer中的create方法。（也就是合法的话，就去调用create方法，如果这样传递参数）

类似于form表单中的，输入的信息就行校验，才能

class Student3View(View):
    
        def post(self, request):
            data = request.body.decode()
            # 反序列化用户提交的数据
            data_dict = json.loads(data)
            print(data_dict)
    
            # 调用序列化器进行实例化
    　　　　
            serializer = Student3Serializer(data=data_dict)
    
            # is_valid在执行的时候，会自动先后调用 字段的内置选项,自定义验证方法，自定义验证函数
            # 调用序列化器中写好的验证代码
            # raise_exception=True 抛出验证错误信息，并阻止代码继续往后运行
            # 验证结果
            print(serializer.is_valid(raise_exception=True))
    
            # 获取验证后的错误信息
            print(serializer.errors)
    
            # 获取验证后的客户端提交的数据
            print(serializer.validated_data)

serializer.save()# 触发update中的create方法

# return HttpResponse(serializer.validated_data) return JsonResponse(serializer.validated_data

## 1.2反序列化-保存数据 ##

ser应用下的serializers.py文件：

# 4. 可选[ 用于把通过验证的数据进行数据库操作，保存到数据库 ]
        def create(self, validated_data):
            """接受客户端提交的新增数据"""
            name = validated_data.get('name')
            age = validated_data.get('age')
            sex = validated_data.get('sex')
            instance = Student.objects.create(name=name, age=age, sex=sex)
            # instance = Student.objects.create(**validated_data)
            print(instance)
            return instance
    
        def update(self, instance, validated_data):
            """用于在反序列化中对于验证完成的数据进行保存更新"""
            name = validated_data.get('name')
            age = validated_data.get('age')
            sex = validated_data.get('sex')
            instance.name = name
            instance.age = age
            instance.sex = sex
    
            instance.save()
    
            return instance

实现了上述两个方法后，在反序列化数据的时候，就可以通过save()方法返回一个数据对象实例了

ser应用下views.py文件：

# save 表示让序列化器开始执行反序列化代码。create和update的代码
            serializer.save()

如果创建序列化器对象的时候，没有传递instance实例，则调用save()方法的时候，create()被调用，相反，如果传递了instance实例，则调用save()方法的时候，update()被调用。

\# 在视图中使用的的是Student3Serializer反序列化器，然后传入的参数是instance加上data那么，会调用Student3Serializer中的update方法。

class Student4View(View):
        def put(self, request, pk):
            data = request.body.decode()
            import json
            data_dict = json.loads(data)
    
            student_obj = Student.objects.get(pk=pk)
            # 有instance参数，调用save方法，就会调用update方法。
            serializer = Student3Serializer(instance=student_obj, data=data_dict)
    # 其中传入的stuent_obj方便我们找到该对象，然后就行一个更新，更新的内容就是前端发给我们的数据，先就行解码，然后反序列化得到我们要的字典
    
    
            serializer.is_valid(raise_exception=True)
    
            serializer.save()  # 触发序列器中的update方法
    
            return JsonResponse(serializer.validated_data)

ser应用下的urls.py文件：

urlpatterns = [
    # 多条数据序列化成字典，并以json的格式返回给前端
        path("students/", views.Student2View.as_view()),
    # 单条数据序列化成字典， 并通过JsonResponse()返回json数据的格式返回给前端
        re_path(r"^student/(?P<pk>\d+)/$", views.Student1View.as_view()),
        #对数据就行反序列话，进行校验，通过校验之后，保存到数据库中，在使用序列化器的时候，只用一个参数data
        path('student3/', views.Student3View.as_view()),
        # 反序化，对数据就行修改需要传入2个参数，data和instance，data是要修改的对象
        re_path(r'^student4/(?P<pk>\d+)/$', views.Student4View.as_view()),
    ]

## 1.3 序列化和反序列化的一起使用 ##

序列化器ser中的代码，serializers.py

"""
    开发中往往一个资源的序列化和反序列化阶段都是写在一个序列化器中的
    所以我们可以把上面的两个阶段合并起来，以后我们再次写序列化器，则直接按照以下风格编写即可。
    """
    
    
    class Student5Serializer(serializers.Serializer):
        id = serializers.IntegerField(read_only=True)
        name = serializers.CharField(max_length=10, min_length=4, validators=[check_user])
        sex = serializers.BooleanField(required=True)
        age = serializers.IntegerField(max_value=150, min_value=0)
        class_null = serializers.CharField(read_only=True)
        description = serializers.CharField(read_only=True)
    
        # 2. 可选[ 如果序列化器继承的是ModelSerializer，则需要声明对应的模型和字段, ModelSerializer是Serializer的子类 ]
    
        # 3. 可选[ 用于对客户端提交的数据进行验证 ]
        """验证单个字段值的合法性"""
        def validate_name(self, data):
            if data == "root":
                raise serializers.ValidationError("用户名不能为root！")
            return data
    
        def validate_age(self, data):
            if data < 18:
                raise serializers.ValidationError("年龄不能小于18")
            return data
    
        """验证多个字段值的合法性"""
        def validate(self, attrs):
            name = attrs.get('name')
            age = attrs.get('age')
    
            if name == "alex" and age == 22:
                raise serializers.ValidationError("alex在22时的故事。。。")
    
            return attrs
    
        # 4. 可选[ 用于把通过验证的数据进行数据库操作，保存到数据库 ]
        def create(self, validated_data):
            """接受客户端提交的新增数据"""
            name = validated_data.get('name')
            age = validated_data.get('age')
            sex = validated_data.get('sex')
            instance = Student.objects.create(name=name, age=age, sex=sex)
            # instance = Student.objects.create(**validated_data)
            print(instance)
            return instance
    
        def update(self, instance, validated_data):
            """用于在反序列化中对于验证完成的数据进行保存更新"""
            name = validated_data.get('name')
            age = validated_data.get('age')
            sex = validated_data.get('sex')
            instance.name = name
            instance.age = age
            instance.sex = sex
    
            instance.save()
    
            return instance

在ser应用下views.py文件：

class Student5View(View):
        def get(self, request):
            # 获取所有数据
            student_list = Student.objects.all()
            serializer = Student5Serializer(instance=student_list, many=True)
    
            return JsonResponse(serializer.data, safe=False)
    
        def post(self, request):
            data = request.body.decode()
            data_dict = json.loads(data)
    　　　　# 用户请求中只有data参数，data_dict即是前端传递过来的参数，那么会调用serializer中的create方法
            serializer = Student5Serializer(data=data_dict)
    
            serializer.is_valid(raise_exception=True)
    
            instance = serializer.save()
    
            return JsonResponse(serializer.data)

def put(self, request, pk):
            data = request.body.decode()
            import json
            data_dict = json.loads(data)
    
            student_obj = Student.objects.get(pk=pk)
            # 有instance参数，调用save方法，就会调用update方法。
            serializer = Student3Serializer(instance=student_obj, data=data_dict)
    
            serializer.is_valid(raise_exception=True)
    
            serializer.save()  # 触发序列器中的update方法
    
            return JsonResponse(serializer.validated_data)

## 1.4 模型类序列化器 ##

如果我们想要使用序列化器对应的是Django的模型类，DRF为我们提供了ModelSerializer模型类序列化器来帮助我们快速创建一个Serializer类。

在ser应用下serializers.py文件定义模型类序列化器：

其中内部继承的父类中有create方法update方法，所以不需要写。

"""
    我们可以使用ModelSerializer来完成模型类序列化器的声明
    这种基于ModelSerializer声明序列化器的方式有三个优势：
    1. 可以直接通过声明当前序列化器中指定的模型中把字段声明引用过来
    2. ModelSerializer是继承了Serializer的所有功能和方法，同时还编写update和create
    3. 模型中同一个字段中关于验证的选项，也会被引用到序列化器中一并作为选项参与验证
    """
    
    
    class StudentModelSerializer(serializers.ModelSerializer):
    
        class Meta:
            model = Student
            # fields = "__all__"  # 表示引用所有字段
            fields = ["id", "name", "age", "class_null", "is_18"]  # is_18 为自定制字段，需要在models里自定义方法。
            # exclude = ["age"]  # 使用exclude可以明确排除掉哪些字段, 注意不能和fields同时使用。
            # 传递额外的参数，为ModelSerializer添加或修改原有的选项参数
            extra_kwargs = {
                "name": {
        "max_length": 10, "min_length": 4, "validators": [check_user]},
                "age": {
        "max_value": 150, "min_value": 0},
            }
    
        def validate_name(self, data):
            if data == "root":
                raise serializers.ValidationError("用户名不能为root！")
            return data
    
        def validate(self, attrs):
            name = attrs.get('name')
            age = attrs.get('age')
    
            if name == "alex" and age == 22:
                raise serializers.ValidationError("alex在22时的故事。。。")
    
            return attrs

在ser应用下的urls.py文件：

urlpatterns = [
        path("students/", views.Student2View.as_view()),
        re_path(r"^student/(?P<pk>\d+)/$", views.Student1View.as_view()),
        # 对数据提交时，进行校验
        path('student3/', views.Student3View.as_view()),
        # 反序列化阶段
        re_path(r'^student4/(?P<pk>\d+)/$', views.Student4View.as_view()),
        # 一个序列化器同时实现序列化和反序列化
        path('student5/', views.Student5View.as_view()),
        # 使用模型类序列化器
        path('student6/', views.Student6View.as_view()),
    ]

在ser应用下views.py文件：

class Student6View(View):
        def get(self, request):
            # 获取所有数据
            student_list = Student.objects.all()
    
            serializer = StudentModelSerializer(instance=student_list, many=True)
    
            return JsonResponse(serializer.data, safe=False)
    
        def post(self, request):
            data = request.body.decode()
            data_dict = json.loads(data)
    
            serializer = StudentModelSerializer(data=data_dict)
    
            serializer.is_valid(raise_exception=True)
    
            serializer.save()
    
            return JsonResponse(serializer.data)

转载于:https://www.cnblogs.com/longerandergou/p/11232129.html