drf-03

目录

• 序列化与反序列化
  • 常用字段及字段参数
  • 序列化类之高级用法-source
  • 序列化类高级用法之定制序列化字段
    • 使用SerializerMethodField
    • 表模型中写方法
  • 模型类序列化器使用Serializer与ModelSerializer
  • 反序列化之数据校验
  • 反序列化数据校验源码分析
• 拓展

序列化与反序列化

常用字段及字段参数

1.常用字段

序号	字段
1	CharField	CharField(max_length=None, min_length=None, allow_blank=False, trim_whitespace=True)
2	BooleanField	BooleanField()
3	IntegerField	IntegerField(max_value=None, min_value=None)
4	DecimalField	DecimalField(max_digits, decimal_places, coerce_to_string=None, max_value=None, min_value=None)
5	EmailField	EmailField(max_length=None, min_length=None, allow_blank=False)
6	FloatField	FloatField(max_value=None, min_value=None)
8	DateTimeField	DateTimeField(format=api_settings.DATETIME_FORMAT, input_formats=None)
9	DateField	DateField(format=api_settings.DATE_FORMAT, input_formats=None)
10	TimeField	TimeField(format=api_settings.TIME_FORMAT, input_formats=None)
11	ChoiceField	ChoiceField(choices) choices与Django的用法相同
12	FileField	FileField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)
13	ImageField	ImageField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)
14	RegexField	RegexField(regex, max_length=None, min_length=None, allow_blank=False)
15	SlugField	SlugField(maxlength=50, min_length=None, allow_blank=False) 正则字段，验证正则模式 [a-zA-Z0-9-]+
16	URLField	URLField(max_length=200, min_length=None, allow_blank=False)
17	UUIDField	UUIDField(format=’hex_verbose’) format: 1) 'hex_verbose' 如"5ce0e9a5-5ffa-654b-cee0-1238041fb31a" 2）
18	IPAddressField	IPAddressField(protocol=’both’, unpack_ipv4=False, **options)
19	DurationField	DurationField()
20	MultipleChoiceField	MultipleChoiceField(choices)
21	ListField
22	DictField	{name:'lqz',age:19,wife:{'name':'刘亦菲','age':33}}

2.常见参数

	参数	作用
给CharField字段类使用的参数	max_length	最大长度
	min_length	最小长度
	allow_blank	是否允许为空
	trim_whitespace	是否截断空白字符
给IntegerField字段类使用的参数	max_value	最小值
	min_valu	最大值
通用参数：放在哪个字段类上都可以的	required	表明该字段在反序列化时必须输入，默认True
	default	反序列化时使用的默认值
	allow_null	表明该字段是否允许传入None，默认False
	validators	该字段使用的验证器
	error_messages	包含错误编号与错误信息的字典
	label	用于HTML展示API页面时，显示的字段名称
	help_text	用于HTML展示API页面时，显示的字段帮助提示信息
重点掌握	read_only	表明该字段仅用于序列化输出，默认False
	write_only	表明该字段仅用于反序列化输入，默认False

序列化类之高级用法-source

 1.source方法使用场景：
  1.1 指定序列化的字段并对原字段名做更改(不更改报错)重命名
  错误：name = serializers.CharField(min_length=3, max_length=8, source='name')
  正确：book_name = serializers.CharField(min_length=3, max_length=8, source='name')
  1.2 指定方法用于重命名
  1.3 做跨表查询

序列化类高级用法之定制序列化字段

使用SerializerMethodField

1. 第一种在【序列化类】中使用SerializerMethodField

1.在原有查询的表数据里添加其余表数据
序列化类：
    # 在序列化类中写SerializerMethodField
    class BookSerializers(serializers.Serializer):
        # 序列化字段
        book_name = serializers.CharField(min_length=3, max_length=20, source='name')
        price = serializers.DecimalField(max_digits=4, decimal_places=2)
        # publish = serializers.CharField()
        publish = serializers.SerializerMethodField()

        def get_publish(self, obj):
            return {'name': obj.publish.name, 'city': obj.publish.city, 'email': obj.publish.email}
视图层：
  class BooksView(APIView):
    # 查询所有
    def get(self, request):
        book_list_obj = models.Book.objects.all()
        ser = serializers.BookSerializers(instance=book_list_obj, many=True)
        return Response(ser.data)
 路由层：path('books/', views.BooksView.as_view()),

表模型中写方法

2. 第二种在【表模型中】写方法

序列化类：
class BookSerializers(serializers.Serializer):
    # 序列化字段
    book_name = serializers.CharField(min_length=3, max_length=20, source='name')
    price = serializers.DecimalField(max_digits=4, decimal_places=2)
    publish_detail = serializers.DictField()  # 需要接收类中写的方法数据 进行序列化
模型层：
# 图书表
class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=4, decimal_places=2)
    create_time = models.DateField(null=True)

    publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
    authors = models.ManyToManyField(to='Author')

    class Meta:
        verbose_name_plural = '图书'

    def publish_detail(self):
        return {'name': self.publish.name, 'city': self.publish.city, 'email': self.publish.email}

    def __str__(self):
        return self.name
视图层：
class BooksView(APIView):
    # 查询所有
    def get(self, request):
        book_list_obj = models.Book.objects.all()
        ser = serializers.BookSerializers(instance=book_list_obj, many=True)
        return Response(ser.data)
 路由层：path('books/', views.BooksView.as_view()),

模型类序列化器使用Serializer与ModelSerializer

1.模型类序列化器（Serializer）的使用

1.缺点：
  1.1 在序列化中每个字段都要写，无论序列化还是反序列化
  1.2 如果存在新增或修改 在序列化类中都需要重写create与update方法    
class BookSerializers(serializers.Serializer):
    # 序列化字段
    book_name = serializers.CharField(min_length=3, max_length=20, source='name')
    price = serializers.DecimalField(max_digits=4, decimal_places=2)
    publish = serializers.CharField()

    def create(self, validated_data):
        book = models.Book.objects.create(name=validated_data.get('name'),
                                          price=validated_data.get('price'),
                                          create_time=validated_data.get('create_time'),
                                          publish_id=validated_data.get('publish'))
        authors = validated_data.get('authors')
        book.authors.add(*authors)
        return book
    def update(self, instance, validated_data):
        book = models.Book.objects.update(
            name=validated_data.get('name'),
            price=validated_data.get('price'),
            create_time=validated_data.get('create_time'),
            publish_id=validated_data.get('publish'))

        authors = validated_data.get('authors')
        book.authors.add(*authors)
        return book

2.模型类序列化器（ModelSerializer）的使用

1.优点：
  1.1 在序列化中不需要写每个字段，无论序列化还是反序列化
  1.2 如果存在新增或修改 在序列化类中不需要重写create与update方法
序列化类：
    class BookSerializers(serializers.ModelSerializer):
         # 在表模型中写方法
    	publish_detail = serializers.DictField()
        class Meta:
            model = models.Book
            # fields = '__all__'            # 查询所有字段
             fields = ['name', 'price', 'create_time', 'publish', 'authors', 'publish_detail']  # 列表中写几个字段就查询几个字段
        extra_kwargs = {'publish': {'write_only': True}}  
        publish_detail = serializers.SerializerMethodField(read_only=True)    # 列表中写几个字段就查询几个字段           
视图层：
    class BooksView(APIView):
        # 查询所有
        def get(self, request):
            book_list_obj = models.Book.objects.all()
            ser = serializers.BookSerializers(instance=book_list_obj, many=True)
            return Response(ser.data)
路由层： path('books/', views.BooksView.as_view()),

反序列化之数据校验

class BookSerializers(serializers.ModelSerializer):
    # 在表模型中写方法
    # publish_detail = serializers.DictField()
    class Meta:
        model = models.Book
        fields = '__all__'
        # fields = ['name', 'price', 'create_time', 'publish', 'authors', 'publish_detail']  # 列表中写几个字段就查询几个字段
        extra_kwargs = {'name': {'min_length': 3},
                        'error_messages': {'min_length': '太短啦'},
                        'price': {'min_value': 9, 'max_value': 199}
                        # 'publish': {'write_only': True}
                        }
        # publish_detail = serializers.SerializerMethodField(read_only=True)

    # 局部钩子
    def validate_name(self, name):
        if name.startswith('sb'):
            # 不能以sb开头 等于抛异常
            raise ValidationError('不能以sb开头')
        else:
            return name

反序列化数据校验源码分析

1.先校验字段自己的规则---局部钩子---全局钩子
  局部：validate_name  全局：validate
2.入口：校验 ser.is_valid()
  	-BaseSerializer内的is_valid()方法
	    def is_valid(self, *, raise_exception=False):
            if not hasattr(self, '_validated_data'):
                try:
                    # 真正的走校验，如果成功，返回校验过后的数据
                    self._validated_data = self.run_validation(self.initial_data)
                except ValidationError as exc:
            return not bool(self._errors)
    
    -内部执行了：self.run_validation(self.initial_data)---》本质执行的Serializer的
    	-如果你按住ctrl键，鼠标点击，会从当前类中找run_validation，找不到会去父类找
    	-这不是代码的执行，代码执行要从头开始找，从自己身上再往上找
    	    def run_validation(self, data=empty):
                #局部钩子的执行
                value = self.to_internal_value(data)
                try:
                    # 全局钩子的执行，从根上开始找着执行，优先执行自己定义的序列化类中得全局钩子
                    value = self.validate(value)
                except (ValidationError, DjangoValidationError) as exc:
                    raise ValidationError(detail=as_serializer_error(exc))

                return value
  -全局钩子看完了，局部钩子---》 self.to_internal_value---》从根上找----》本质执行的Serializer的
     def to_internal_value(self, data):
        for field in fields: # fields：序列化类中所有的字段，for循环每次取一个字段对象
            # 反射：去self：序列化类的对象中，反射 validate_字段名 的方法
            validate_method = getattr(self, 'validate_' + field.field_name, None)
            try:
                # 这句话是字段自己的校验规则（最大最小长度）
                validated_value = field.run_validation(primitive_value)
                # 局部钩子
                if validate_method is not None:
                    validated_value = validate_method(validated_value)
            except ValidationError as exc:
                errors[field.field_name] = exc.detail

        return ret

拓展

1.写出book表（带关联关系）5 个接口

1.1 使用 Serializer

1.查询所有
视图层：
from rest_framework.views import APIView
from app01 import models, serializers
from rest_framework.response import Response

class BooksView(APIView):
    # 查询所有
    def get(self, request):
        book_list_obj = models.Book.objects.all()
        ser = serializers.BookSerializers(instance=book_list_obj, many=True)
        return Response(ser.data)
路由层：path('books/', views.BooksView.as_view()),
序列化类：
        from rest_framework import serializers
        from app01 import models
        from rest_framework.validators import ValidationError

        class BookSerializers(serializers.Serializer):
            # 序列化字段
            book_name = serializers.CharField(min_length=3, max_length=20, source='name')
            price = serializers.DecimalField(max_digits=4, decimal_places=2)
            publish = serializers.CharField()
2.新增
视图层：
    from rest_framework.views import APIView
    from app01 import models, serializers
    from rest_framework.response import Response

    class BooksView(APIView):
        # 添加图书
        def post(self, request):
            # 获取添加的图书数据 并校验
            ser = serializers.BookSerializers(data=request.data)
            if ser.is_valid():
                ser.save()
                return Response({'code': 100, 'msg': '添加成功'})
            else:
                return Response({'code': 101, 'msg': ser.errors})
路由层：path('books/', views.BooksView.as_view()),
序列化类：
        from rest_framework import serializers
        from app01 import models
        from rest_framework.validators import ValidationError

        class BookSerializers(serializers.Serializer):
            # 序列化字段
            book_name = serializers.CharField(min_length=3, max_length=20, source='name')
            price = serializers.DecimalField(max_digits=4, decimal_places=2)
            publish = serializers.CharField()
                # 局部钩子
            def validate_name(self, name):
                if name.startswith('sb'):
                    # 不能以sb开头 等于抛异常
                    raise ValidationError('不能以sb开头')
                else:
                    return name
			# 重写新增方法
            def create(self, validated_data):
                book = models.Book.objects.create(name=validated_data.get('name'),
                                                  price=validated_data.get('price'),
                                                  create_time=validated_data.get('create_time'),
                                                  publish_id=validated_data.get('publish'))
                authors = validated_data.get('authors')
                book.authors.add(*authors)
                return book
 3.查询单条：
视图层：
class BookView(APIView):
    # 查询单条
    def get(self, request, pk):
        # 获取单挑数据
        book = models.Book.objects.filter(pk=pk).first()
        ser = serializers.BookSerializers(instance=book)
        return Response(ser.data)
路由层：path('book/<int:pk>', views.BookView.as_view())
序列化类：
      	from rest_framework import serializers
        from app01 import models
        from rest_framework.validators import ValidationError

        class BookSerializers(serializers.Serializer):
            # 序列化字段
            book_name = serializers.CharField(min_length=3, max_length=20, source='name')
            price = serializers.DecimalField(max_digits=4, decimal_places=2)
            publish = serializers.CharField()
class BookSerializers(serializers.Serializer):
  4.修改
视图层：
class BookView(APIView):
    # 修改数据
    def put(self, request, pk):
        update_book = models.Book.objects.filter(pk=pk)
        book_info = serializers.BookSerializers(instance=update_book, data=request.data)
        # 数据校验
        if book_info.is_valid():
            book_info.save()
            return Response(book_info.data)
        else:
            return Response(book_info.errors)
路由层： path('book/<int:pk>', views.BookView.as_view())
序列化类：
   from rest_framework import serializers
        from app01 import models
        from rest_framework.validators import ValidationError

        class BookSerializers(serializers.Serializer):
            # 序列化字段
            book_name = serializers.CharField(min_length=3, max_length=20, source='name')
            price = serializers.DecimalField(max_digits=4, decimal_places=2)
            publish = serializers.CharField()
class BookSerializers(serializers.Serializer):

    # 局部钩子
    def validate_name(self, name):
        if name.startswith('sb'):
            # 不能以sb开头 等于抛异常
            raise ValidationError('不能以sb开头')
        else:
            return name
        
    def update(self, instance, validated_data):
       instance.name = validated_data.get('name')
        instance.price = validated_data.get('price')
        instance.create_time = validated_data.get('create_time')
        instance.publish_id = validated_data.get('publish')
       	instance.authors.set(validated_data.get('authors'))
        instance.save()
        return instance
5.删除
视图层:
    class BookView(APIView):
        # 删除数据
        def delete(self, request, pk):
            # 获取删除书籍信息
            models.Book.objects.filter(pk=pk).delete()
            return Response({})
 路由层：path('book/<int:pk>', views.BookView.as_view())

1. 2 使用ModelSerializer

   1.查询所有
   序列化类：
       class BookSerializers(serializers.ModelSerializer):
           class Meta:
               model = models.Book
               fields = '__all__'
   视图层：
       class BooksView(APIView):
           # 查询所有
           def get(self, request):
               book_list_obj = models.Book.objects.all()
               ser = serializers.BookSerializers(instance=book_list_obj, many=True)
               return Response(ser.data)
   路由层： path('books/', views.BooksView.as_view()),
   2.新增
   序列化类：
       class BookSerializers(serializers.ModelSerializer):
           class Meta:
               model = models.Book
               fields = '__all__'
   视图层：
       from rest_framework.views import APIView
       from app01 import models, serializers
       from rest_framework.response import Response
   
       class BooksView(APIView):
           # 添加图书
           def post(self, request):
               # 获取添加的图书数据 并校验
               ser = serializers.BookSerializers(data=request.data)
               if ser.is_valid():
                   ser.save()
                   return Response({'code': 100, 'msg': '添加成功'})
               else:
                   return Response({'code': 101, 'msg': ser.errors})
   路由层：path('books/', views.BooksView.as_view()),
   3.修改：
   序列化类：
       class BookSerializers(serializers.ModelSerializer):
           class Meta:
               model = models.Book
               fields = '__all__'          
   路由层： path('book/<int:pk>', views.BookView.as_view())
   序列化类：
      from rest_framework import serializers
           from app01 import models
           from rest_framework.validators import ValidationError
   
           class BookSerializers(serializers.Serializer):
               # 序列化字段
               book_name = serializers.CharField(min_length=3, max_length=20, source='name')
               price = serializers.DecimalField(max_digits=4, decimal_places=2)
               publish = serializers.CharField()
   class BookSerializers(serializers.Serializer):
   
       # 局部钩子
       def validate_name(self, name):
           if name.startswith('sb'):
               # 不能以sb开头 等于抛异常
               raise ValidationError('不能以sb开头')
           else:
               return name
    def update(self, instance, validated_data):
          instance.name = validated_data.get('name')
           instance.price = validated_data.get('price')
           instance.create_time = validated_data.get('create_time')
           instance.publish_id = validated_data.get('publish')
          	instance.authors.set(validated_data.get('authors'))
           instance.save()
           return instance
   4.删除：
   视图层:
       class BookView(APIView):
           # 删除数据
           def delete(self, request, pk):
               # 获取删除书籍信息
               models.Book.objects.filter(pk=pk).delete()
               return Response({})
    路由层：path('book/<int:pk>', views.BookView.as_view())