zoukankan      html  css  js  c++  java

  • 序列化器

    1.序列化使用

    settings.py 注册App

    1
    2
    3
    4
    5
    INSTALLED_APPS = [
     
        'rest_framework',
        'users',
    ]

    　　

    urls.py 定义总路由

    1
    2
    3
    4
    5
    6
    7
    from django.contrib import admin
    from django.urls import path,re_path,include
     
    urlpatterns = [
        path('admin/', admin.site.urls),
        re_path(r'users/',include(('users.urls', 'users'), namespace='users'))
    ]

    　　

    users/urls.py

    1
    2
    3
    4
    5
    6
    7
    8
    #! /usr/bin/env python
    # -*- coding: utf-8 -*-
    from django.urls import path,re_path
    from users import views
     
    urlpatterns = [
        re_path(r'^info/$', views.UserInfoViewSet.as_view(), name='userinfo'),
    ]

    　　

    users/models.py

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    from django.db import models
     
    class UserInfo(models.Model):
        name = models.CharField(max_length=64,unique=True)
        ut = models.ForeignKey(to='UserType', on_delete=models.CASCADE)
        gp = models.ManyToManyField(to='UserGroup')
     
        def __str__(self):
            return self.name
     
    class UserType(models.Model):
        type_name = models.CharField(max_length=64,unique=True)
     
        def __str__(self):
            return self.type_name
     
    class UserGroup(models.Model):
        group = models.CharField(max_length=64)
     
        def __str__(self):
            return self.group

    　　

    users/views.py

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    from rest_framework.views import APIView
    from rest_framework.views import Response
    import json
     
    from users import serializers
    from users import models as users_model
     
    class UserInfoViewSet(APIView):
        # 查询用户信息
        def get(self, request, *args, **kwargs):
            # 一对多、多对多查询都是一样的语法
            obj = users_model.UserInfo.objects.all()
            ser = serializers.UserInfoSerializer(instance=obj,many=True)  # 关联数据多个
            # ser = serializers.UserInfoSerializer(instance=obj[0])   # 关联数据一个
            return Response(ser.data, status=200)
     
        # 创建用户
        '''创建用户'''
        def post(self,request):
            ser = serializers.UserInfoSerializer(data=request.data)
            if ser.is_valid():
                ser.save()
                return Response(data=ser.data, status=201)
            return Response(data=ser.errors,status=400)
     
        # 更新用户信息
        def put(self, request):
            pk = request.data.get('pk')
            userinfo = users_model.UserInfo.objects.get(id = pk)
            # 创建序列化对象，并将要反序列化的数据传递给data构造参数，进而进行验证
            ser = serializers.UserInfoSerializer(userinfo,data=request.data)
            if ser.is_valid():
                ser.save()
                return Response(data=ser.data, status=201)
            return Response(data=ser.errors,status=400)

    　　

    users/serializers.py

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    from rest_framework import serializers
    from users.models import UserInfo
     
     
    class UserInfoSerializer(serializers.Serializer):
        name = serializers.CharField(min_length=3,max_length=20)                # 显示普通字段
        ut_id = serializers.IntegerField(write_only=True)                      # 外键约束，关联字段要定义
        ut = serializers.CharField(source='ut.type_name',required=False)      # 显示一对多字段名称
        gp = serializers.SerializerMethodField(read_only=True)                 # 自定义显示（显示多对多）
        xxx = serializers.CharField(source='name',required=False)              # 也可以自定义显示字段名称
     
        '''PrimaryKeyRelatedField和StringRelatedField：可以用对 一对多 和 多对多 关联对象序列化'''
        # gp = serializers.PrimaryKeyRelatedField(read_only=True, many=True)
        # gp = serializers.StringRelatedField(read_only=True,many=True)
     
        class Meta:
            model = UserInfo
     
        # 自定义显示 多对多 字段
        def get_gp(self,row):
            '''row: 传过来的正是 UserInfo表的对象'''
            gp_obj_list = row.gp.all().values('id','group')  # 获取用户所有组
            return gp_obj_list
     
        # 定义创建语法
        def create(self, validated_data):
            return UserInfo.objects.create(**validated_data)
     
        # 定义更新方法
        def update(self, instance, validated_data):
            if validated_data.get('name'):
                instance.name = validated_data['name']
            if validated_data.get('ut_id'):
                instance.ut_id = validated_data['ut_id']
            instance.save()
            return instance
     
        # 定义单一字段验证的方法
        def validate_name(self, value):
            if value == 'root':
                raise serializers.ValidationError('不能创建root管理员账号')
            return value
     
        # 定义多字段验证方法
        def validate(self, attrs):
            if attrs['name'] == 'admin':
                raise serializers.ValidationError('不能创建admin用户')
            return attrs
     
     
    # 一对多序列化（反向查找）
    class UserTypeSerializer(serializers.Serializer):
        type_name = serializers.CharField()
        # 法1一对多关联对象序列化：此字段将被序列化为关联对象的主键
        userinfo_set = serializers.PrimaryKeyRelatedField(read_only=True, many=True)
     
        # 法2一对多关联对象序列化：此字段将被序列化为关联对象的字符串表示方式（即__str__方法的返回值）
        # userinfo_set = serializers.StringRelatedField(read_only=True,many=True)
        # 法3一对多关联对象序列化：使用关联对象的序列化器
        # userinfo_set = UserInfoSerializer(many=True)
     
     
    # 多对多序列化（反向）
    class UserGroupSerializer(serializers.Serializer):
        group = serializers.CharField()
        # 法1一对多关联对象序列化：此字段将被序列化为关联对象的主键
        # userinfo_set = serializers.PrimaryKeyRelatedField(read_only=True, many=True)
     
        # 法2一对多关联对象序列化：此字段将被序列化为关联对象的字符串表示方式（即__str__方法的返回值）
        # userinfo_set = serializers.StringRelatedField(read_only=True,many=True)
        # 法3一对多关联对象序列化：使用关联对象的序列化器
        # userinfo_set = UserInfoSerializer(many=True)

    　　

    2.序列化（serializers,Serializer）

    　　1)序列化（正向查找）

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    from rest_framework import serializers
    from users.models import UserInfo
     
    class UserInfoSerializer(serializers.Serializer):
        name = serializers.CharField(min_length=3,max_length=20)               # 显示普通字段
        ut = serializers.CharField(source='ut.type_name',required=False)       # 显示一对多字段名称
        gp = serializers.SerializerMethodField(read_only=True)                 # 自定义显示（显示多对多）
        xxx = serializers.CharField(source='name',required=False)              # 也可以自定义显示字段名称
        ut_id = serializers.IntegerField(write_only=True)                      # 一对多关联字段定义(外键约束)
     
        '''PrimaryKeyRelatedField和StringRelatedField：可以用对 一对多 和 多对多 关联对象序列化'''
        # gp = serializers.PrimaryKeyRelatedField(read_only=True, many=True)
        # gp = serializers.StringRelatedField(read_only=True,many=True)
     
        class Meta:
            model = UserInfo
     
        # 自定义显示 多对多 字段
        def get_gp(self,row):
            '''row: 传过来的正是 UserInfo表的对象'''
            gp_obj_list = row.gp.all().values('id','group')  # 获取用户所有组
            return gp_obj_list

    　　

    　　2)序列化（反向查找）

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    ''' 一对多序列化（反向查找）'''
    class UserTypeSerializer(serializers.Serializer):
        type_name = serializers.CharField()
        # 法1一对多关联对象序列化：此字段将被序列化为关联对象的主键
        userinfo_set = serializers.PrimaryKeyRelatedField(read_only=True, many=True)
     
        # 法2一对多关联对象序列化：此字段将被序列化为关联对象的字符串表示方式（即__str__方法的返回值）
        # userinfo_set = serializers.StringRelatedField(read_only=True,many=True)
        # 法3一对多关联对象序列化：使用关联对象的序列化器
        # userinfo_set = UserInfoSerializer(many=True)

    　　

    　　3)视图函数中使用序列化

    1
    2
    3
    4
    5
    6
    7
    class UserInfoViewSet(APIView):
        def get(self, request, *args, **kwargs):
            # 一对多、多对多查询都是一样的语法
            obj = users_model.UserInfo.objects.all()
            ser = serializers.UserInfoSerializer(instance=obj,many=True)  # 关联数据多条
            # ser = serializers.UserInfoSerializer(instance=obj[0])       # 关联数据一条
            return Response(ser.data, status=200)

    　　

    3.反序列化

    　　1)使用反序列化保存数据

    1
    2
    3
    4
    5
    6
    7
    '''创建用户'''
    def post(self,request):
        ser = serializers.UserInfoSerializer(data=request.data)
        if ser.is_valid():
            ser.save()
            return Response(data=ser.data, status=201)
        return Response(data=ser.errors,status=400)

    　　

    　　2)反序列化定义创建和更新方法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    # 定义创建语法
    def create(self, validated_data):
        return UserInfo.objects.create(**validated_data)
     
    # 定义更新方法
    def update(self, instance, validated_data):
        if validated_data.get('name'):
            instance.name = validated_data['name']
        if validated_data.get('ut_id'):
            instance.ut_id = validated_data['ut_id']
        instance.save()
        return instance
     
    # 定义单一字段验证的方法
    def validate_name(self, value):
        if value == 'root':
            raise serializers.ValidationError('不能创建root管理员账号')
        return value
     
    # 定义多字段验证方法
    def validate(self, attrs):
        if attrs['name'] == 'admin':
            raise serializers.ValidationError('不能创建admin用户')
        return attrs

    　　

    4.序列化使用举例（serializers.ModelSerializer）

    　　1.ModelSerializer本质是继承了Serielizer类添加了部分功能

    　　2.在使用ModelSerializer可以使用    fields = '__all__'

     

    serializers.ModelSerializer使用

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    '''users/serializers/userinfo_serializers.py'''
     
    from rest_framework import serializers
    from users.models import UserInfo
     
    class UserInfoSerializer(serializers.ModelSerializer):
        # name = serializers.CharField()                       # 显示普通字段
        ut = serializers.CharField(source='ut.type_name')     # 显示一对多字段
        gp = serializers.SerializerMethodField()               # 自定义显示（显示多对多）
        xxx = serializers.CharField(source='name')             # 也可以自定义显示字段名称
     
        class Meta:
            model = UserInfo
            # fields = "__all__"
            fields = ["name",'ut','gp','xxx']  # 定义显示那些字段
     
        def get_gp(self,row):
            '''row: 传过来的正是 UserInfo表的对象'''
            gp_obj_list = row.gp.all()  # 获取用户所有组
            ret = []
            for item in gp_obj_list:
                ret.append({'id':item.id,'gp':item.group})
            return ret

    　　

    5.使用serializers.ModelSerializer

    users/views.py

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    from rest_framework.views import APIView
    from users.serializers.userinfo_serializers import UserInfoSerializer
    from users.models import UserInfo
     
    class UserInfoViewSet(APIView):
        def get(self, request, *args, **kwargs):
            obj = UserInfo.objects.all()
            ser = UserInfoSerializer(instance=obj,many=True)
            ret = json.dumps(ser.data,ensure_ascii=False)
            return HttpResponse(ret)
     
        def post(self, request, *args, **kwargs):
            ser = UserInfoSerializer(data=request.data)          # 验证，对请求发来的数据进行验证
            if ser.is_valid():
                print(ser.validated_data)  # post请求数据字典
            else:
                print(ser.errors)  # form验证错误信息
            return HttpResponse(json.dumps({'status':True}))

    　　

    users/serializers/userinfo_serializers.py

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    '''users/serializers/userinfo_serializers.py'''
     
    from rest_framework import serializers
    from django.core.exceptions import ValidationError
    from users.models import UserInfo
     
    class UserInfoSerializer(serializers.ModelSerializer):
        name = serializers.CharField(min_length=10, error_messages={'required': '该字段必填'})                       # 显示普通字段
        ut = serializers.CharField(source='ut.type_name',required=False)     # 显示一对多字段
        gp = serializers.SerializerMethodField(required=False)               # 自定义显示（显示多对多）
        xxx = serializers.CharField(source='name', required=False)             # 也可以自定义显示字段名称
     
        class Meta:
            model = UserInfo
            # fields = "__all__"
            fields = ["name",'ut','gp','xxx']  # 定义显示那些字段
     
        # 局部钩子:
        def validate_name(self, value):  # value 是name字段提交的值
            if value.startswith('sb'):  # 不能以sb开头
                raise ValidationError('不能以sb开头')
            else:
                return value
     
        # 全局钩子找到了
        def validate(self, value):  # value是所有校验通过数据的字典
            name = value.get('name')
            if False:
                raise ValidationError('全局钩子引发异常')
            return value

    　　

    1
    2
    3
    4
    5
    6
    7
    8
    '''1、ser.is_valid()'''
    # 验证post请求中数据是否合法
     
    '''2、全局校验钩子'''
    def validate(self, value):        # value是所有校验通过数据的字典
     
    '''3、局部钩子'''
    def validate_name(self, value):   # value 是name字段提交的值
  • 相关阅读:
    初识python
    文件操作
    初识python
    pycharm IDE
    初识python
    初识Python
    python之网络编程-多线程
    python之并发编程-进程之间的通信
    python之并发编程-多进程
    python之并发编程-操作系统
  • 原文地址：https://www.cnblogs.com/ngngng/p/13805205.html
Copyright © 2011-2022 走看看