Django之drf2

最新推荐文章于 2024-07-10 09:20:10 发布

辉辉辉辉辉辉辉辉辉辉辉

最新推荐文章于 2024-07-10 09:20:10 发布

阅读量62

点赞数

分类专栏： DRF 文章标签： django python

本文链接：https://blog.csdn.net/weixin_47035302/article/details/130727199

版权

DRF 专栏收录该内容

10 篇文章 1 订阅

订阅专栏

一、Request类源码分析

1.1通过源码我们可以得出

-老的request在新的request._request
-照常理来讲，如果取method，应该request._request.method,但是现在可以request.method

总结：

1 新的request有个data属性，以后只要是在请求body体中的数据，无论什么编码格式，无论什么请求方式
2 取文件还是从：request.FILES
3 取其他属性，跟之前完全一样 request.method ....
-原理是：新的Request重写了__getattr__，通过反射获取老的request中的属性
4 request.GET 现在可以使用 request.query_params
@property
def query_params(self):
return self._request.GET

补充：

魔法方法之 __getattr__, . 拦截，对象.属性当属性不存在时，会触发类中 __getattr__的执行

get请求能不能在body体中带数据：
-能，但是我们都不这么做

2 序列化组件介绍

1. 序列化,序列化器会把模型对象（queryset，单个对象）转换成字典,经过response以后变成json字符串
2. 反序列化,把客户端发送过来的数据,经过request.data以后变成字典,序列化器可以把字典转成模型
3. 反序列化,完成数据校验功能

3 序列化类的基本使用

3.1 通过创建book表模型，来举例说明
3. 2 写查询所有图书的接口：APIVie+序列化类+Response

查询所有和查询单条

views.py

class BookView(APIView):
    def get(self, request):
        book_list = Book.objects.all()
        # 使用序列化类，完成序列化  两个很重要参数： instance实例，对象      data：数据
        # 如果是多条many=True  如果是queryset对象，就要写
        # 如果是单个对象 many=False，默认是False
        serializer = BookSerializer(instance=book_list, many=True)
        # serializer.data  # 把qs对象，转成列表套字典  ReturnList
        # print(serializer.data)
        # print(type(serializer.data))
        # return Response(serializer.data)
        return Response({'code': 100, 'msg': '成功', 'data': serializer.data})


class BookDetailView(APIView):
    def get(self, request, pk):
        book = Book.objects.all().get(pk=pk)
        serializer = BookSerializer(instance=book)
        return Response({'code': 100, 'msg': '成功', 'data': serializer.data})

urls.py

urlpatterns = [
    path('books/', views.BookView.as_view()),
    path('books/<int:pk>/', views.BookDetailView.as_view()),
]

序列化类

from rest_framework import serializers

class BookSerializer(serializers.Serializer):
    # 要序列化的字段
    # id = serializers.IntegerField()
    name = serializers.CharField()
    # price = serializers.IntegerField()

总结：

# 序列化类的使用
1 写一个类，继承serializers.Serializer
2 在类中写字段，要序列化的字段
3 在视图类中使用：（多条，单条）
    serializer = BookSerializer(instance=book_list, many=True)
    serializer = BookSerializer(instance=book)

4 常用字段类和参数

4.1 常用字段类

字段	字段构造方式
BooleanField	BooleanField()
NullBooleanField	NullBooleanField()
CharField	CharField(max_length=None, min_length=None, allow_blank=False, trim_whitespace=True)
EmailField	EmailField(max_length=None, min_length=None, allow_blank=False)
RegexField	RegexField(regex, max_length=None, min_length=None, allow_blank=False)
SlugField	SlugField(maxlength=50, min_length=None, allow_blank=False) 正则字段，验证正则模式 [a-zA-Z0-9-]+
URLField	URLField(max_length=200, min_length=None, allow_blank=False)
UUIDField	UUIDField(format=’hex_verbose’) format: 1) `'hex_verbose'` 如`"5ce0e9a5-5ffa-654b-cee0-1238041fb31a"` 2） `'hex'` 如 `"5ce0e9a55ffa654bcee01238041fb31a"` 3）`'int'` - 如: `"123456789012312313134124512351145145114"` 4）`'urn'` 如: `"urn:uuid:5ce0e9a5-5ffa-654b-cee0-1238041fb31a"`
IPAddressField	IPAddressField(protocol=’both’, unpack_ipv4=False, **options)
IntegerField	IntegerField(max_value=None, min_value=None)
FloatField	FloatField(max_value=None, min_value=None)
DecimalField	DecimalField(max_digits, decimal_places, coerce_to_string=None, max_value=None, min_value=None) max_digits: 最多位数 decimal_palces: 小数点位置
DateTimeField	DateTimeField(format=api_settings.DATETIME_FORMAT, input_formats=None)
DateField	DateField(format=api_settings.DATE_FORMAT, input_formats=None)
TimeField	TimeField(format=api_settings.TIME_FORMAT, input_formats=None)
DurationField	DurationField()
ChoiceField	ChoiceField(choices) choices与Django的用法相同
MultipleChoiceField	MultipleChoiceField(choices)
FileField	FileField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)
ImageField	ImageField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)
ListField	ListField(child=, min_length=None, max_length=None)
DictField	DictField(child=)

IntegerField 
CharField  
DateTimeField  
DecimalField
ListField
DictField
比较重要

4.2 字段参数(校验数据来用的)

选项参数：（CharField,IntegerField）

参数名称	作用
max_length	最大长度
min_lenght	最小长度
allow_blank	是否允许为空
trim_whitespace	是否截断空白字符
max_value	最小值
min_value	最大值

通用参数：

参数名称	说明
read_only	表明该字段仅用于序列化输出，默认False
write_only	表明该字段仅用于反序列化输入，默认False
required	表明该字段在反序列化时必须输入，默认True
default	反序列化时使用的默认值
allow_null	表明该字段是否允许传入None，默认False

read_only   write_only  #  很重要

5 反序列化之校验

反序列化，有三层校验

-1 字段自己的（写的字段参数：required max_length 。。。）
-2 局部钩子：写在序列化类中的方法，方法名必须是 validate_字段名

def validate_name(self, name):
     if 'sb' in name:
     # 不合法，抛异常
        raise ValidationError('书名中不能包含sb')
      else:
        return name

-3 全局钩子：写在序列化类中的方法方法名必须是 validate

def validate(self, attrs):
   price = attrs.get('price')
   name = attrs.get('name')
   if name == price:
      raise ValidationError('价格不能等于书名')
   else:
      return attrs

只有三层都通过，在视图类中：

ser.is_valid():  才是True，才能保存

6 反序列化之保存

新增接口：

#  -序列化类的对象，实例化的时候：
ser = BookSerializer(data=request.data)

-数据校验过后----》调用序列化类.save()--->但是要在序列化类中重写 create方法

def create(self, validated_data):
   book=Book.objects.create(**validated_data)
   return book

修改接口：

#  序列化类的对象，实例化的时候：
ser = BookSerializer(instance=book,data=request.data)

-数据校验过后----》调用序列化类.save()--->但是要在序列化类中重写 update方法

def update(self, book, validated_data):
   for item in validated_data:  # {"name":"jinping","price":55}
       setattr(book, item, validated_data[item])  # 映射，将循环的值分配
        # 等同于下面
        # setattr(book,'name','jinping')
        # setattr(book,'price',55)
        # 等同于
        # book.name = validated_data.get('name')
        # book.price = validated_data.get('price')
       book.save()
       return book

# 研究了一个问题
	在视图类中，无论是保存还是修改，都是调用序列化类.save()，底层实现是根据instance做一个判断

7 5个接口代码

路由

urlpatterns = [
    path('books/', views.BookView.as_view()),
    path('books/<int:pk>/', views.BookDetailView.as_view()),
]

视图

from .models import Book
from .serializer import BookSerializer


class BookView(APIView):
    def get(self, request):
        book_list = Book.objects.all()
        # 使用序列化类，完成序列化  两个很重要参数： instance实例，对象      data：数据
        # 如果是多条many=True  如果是queryset对象，就要写
        # 如果是单个对象 many=False，默认是False
        serializer = BookSerializer(instance=book_list, many=True)
        # serializer.data  # 把qs对象，转成列表套字典  ReturnList
        # print(serializer.data)
        # print(type(serializer.data))
        # return Response(serializer.data)
        return Response({'code': 100, 'msg': '成功', 'data': serializer.data})

    # 新增
    def post(self, request):
        # 前端会传入数据，request.data--->把这个数据保存到数据库中
        # 借助于序列化类，完成 校验和反序列化
        # data 前端传入的数据 {"name":"三国演义","price":88}
        ser = BookSerializer(data=request.data)
        # 校验数据
        if ser.is_valid():  # 三层：字段自己的校验，局部钩子校验，全局钩子校验
            # 校验通过，保存
            print(ser.validated_data)  # validated_data：校验过后的数据
            # 如果没有save，如何保存，自己做
            # Book.objects.create(**ser.validated_data)
            ser.save()  # 会保存，但是会报错,因为它不知道你要保存到那个表中
            return Response({'code': 100, 'msg': '新增成功'})
        else:
            print(ser.errors)  # 校验失败的错误
            return Response({'code': 101, 'msg': '新增失败', 'errors': ser.errors})


class BookDetailView(APIView):
    def get(self, request, pk):
        book = Book.objects.all().get(pk=pk)
        serializer = BookSerializer(instance=book)
        return Response({'code': 100, 'msg': '成功', 'data': serializer.data})

    def put(self, request, pk):
        book = Book.objects.get(pk=pk)
        ser = BookSerializer(instance=book, data=request.data)
        if ser.is_valid():
            ser.save() # 也会报错，重写update
            return Response({'code': 100, 'msg': '修改成功'})
        else:
            return Response({'code': 101, 'msg': '修改失败', 'errors': ser.errors})

序列化类

# from rest_framework.serializers import Serializer
from rest_framework import serializers

from rest_framework.exceptions import ValidationError
from .models import Book


class BookSerializer(serializers.Serializer):
    # 要序列化的字段
    id = serializers.IntegerField(required=False)  # 前端传入数据，可以不填这个字段
    name = serializers.CharField(allow_blank=True, required=False, max_length=8,
                                 min_length=3, error_messages={'max_length': '太长了'})  # allow_blank: 这个字段传了，value值可以为空
    price = serializers.IntegerField(max_value=100, min_value=10, error_messages={'max_value': '必须小于100'})

    # price = serializers.CharField()

    # 局部钩子：给某个字段做个校验
    # 书名中不能包含sb
    # validate_字段名
    def validate_name(self, name):
        if 'sb' in name:
            # 不合法，抛异常
            raise ValidationError('书名中不能包含sb')
        else:
            return name

    def validate_price(self, item):
        if item == 88:
            raise ValidationError('价格不能等于88')
        else:
            return item

    # 全局钩子
    # 价格和书名不能一样  validate
    def validate(self, attrs):
        price = attrs.get('price')
        name = attrs.get('name')
        if name == price:
            raise ValidationError('价格不能等于书名')
        else:
            return attrs

    def create(self, validated_data):
        # validated_data校验过后的数据，字典
        book = Book.objects.create(**validated_data)
        return book

    # def update(self, book, validated_data):
    #     # instance 要修改的对象
    #     # validated_data：前端传入，并且校验过后的数据
    #     book.name = validated_data.get('name')
    #     book.price = validated_data.get('price')
    #     # 一定不要忘了
    #     book.save()
    #     return book
    def update(self, book, validated_data):

        for item in validated_data:  # {"name":"jinping","price":55}
            setattr(book, item, validated_data[item])
            # 等同于下面
            # setattr(book,'name','jinping')
            # setattr(book,'price',55)
            # 等同于
            #     book.name = validated_data.get('name')
            #     book.price = validated_data.get('price')
        book.save()
        return book

表模型

from django.db import models

# Create your models here.

class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.BigIntegerField()

# 面试题：BigIntegerField跟IntegerField有什么区别