Django REST Framework框架

概述

Django REST Framework（简称DRF）是基于Django Web框架的一个开源的Web API框架。它提供了一组用于快速构建Web API的工具和库，包括序列化器、认证、权限、视图、路由和文档化等功能。

DRF的主要特点包括：

提供了强大的序列化器，可以将模型对象序列化为JSON等格式，并支持反序列化

提供了多种认证方式，包括基本认证、Token认证、OAuth认证等

提供了多种权限校验方式，包括基于角色的权限校验、基于对象的权限校验等

提供了多种视图类，包括基于函数的视图、基于类的视图、通用视图等

提供了路由功能，可以轻松地将URL映射到对应的视图

可扩展性，插件丰富

DRF官方：https://www.django-rest-framework.org/

GitHub：https://github.com/encode/django-rest-framework

安装DRF框架

DRF框架依赖于Django，需先安装Django环境。

pip install djangorestframework

注册DRF

在Django项目中使用DRF框架进行开发时，需要将rest_framework在INSTALLED_APPS中进行注册。

INSTALLED_APPS = [
    'rest_framework',
]

字段类型与选项参数

字段类型

选项参数

max_length和min_length是针对字符串类型的参数；max_value和min_value是针对数字类型的参数。

无论哪种字段类型都可以使用以下可选参数。

定义序列化器类的字段时，如果没有指定read_only和write_only，则这两个参数默认值都为False，表明对应的字段既在序列化时使用，也在反序列化时使用

序列化器的定义与使用

定义序列化器类

序列化器类的定义格式：

from rest_framework import serializers

class 序列化器类名(serializers.Serializer):
    # 序列化器字段 = serializers.字段类型(选项参数)

新建serializers.py文件保存某应用的序列化器类

from rest_framework import serializers

# 用户类
class User(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age


# 用户序列化器类：UserSerializer。其可以针对User进行数据的序列化和反序列化操作
class UserSerializer(serializers.Serializer):
    name = serializers.CharField()
    age = serializers.IntegerField()

基本使用

序列化

if __name__ == '__main__':
    # 创建User对象
    user = User(name='test', age=22)

    # 将user对象序列化为：{'name': 'test', 'age': 22}
    serializer = UserSerializer(user)

    # 获取序列化之后的数据
    serializerData = serializer.data
    print(serializerData)

反序列化与数据校验

if __name__ == '__main__':
    data = {'name': 'test', 'age': 22}

    # 对data的数据进行反序列化
    serializer = UserSerializer(data=data)

    # 调用is_valid进行数据校验，成功返回True，失败返回False
    valid = serializer.is_valid()
    print(valid)
    
    # 获取校验失败之后的错误提示信息
    errors = serializer.errors
    print(errors)

    # 获取校验通过之后的数据
    user = serializer.validated_data
    print(user)

序列化操作

Django初始化

编辑子应用下的tests.py文件，需要使用Django的东西，添加Django初始化代码

# 设置Django运行所依赖的环境变量
import os

from django.test import TestCase

from apps.user.models import User
from apps.user.serializers import UserSerializer

if not os.environ.get('DJANGO_SETTINGS_MODULE'):
    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'drf_demo.settings')

# 让Django进行一次初始化
import django

序列化单个对象

class User(models.Model):
    name = models.CharField(max_length=6, unique=True, verbose_name='姓名')
    age = models.IntegerField(default=0, verbose_name='年龄')

    class Meta:
        db_table = 'tb_users'
        verbose_name = '用户'
        verbose_name_plural = verbose_name

# 用户序列化器类：UserSerializer。其可以针对User进行数据的序列化和反序列化操作
class UserSerializer(serializers.Serializer):
    name = serializers.CharField(label='姓名', max_length=6)
    age = serializers.IntegerField(label="年龄")

# 设置Django运行所依赖的环境变量
import os

from django.test import TestCase

from apps.user.models import User
from apps.user.serializers import UserSerializer

if not os.environ.get('DJANGO_SETTINGS_MODULE'):
    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'drf_demo.settings')

# 让Django进行一次初始化
import django

django.setup()


class MyTest(TestCase):
    # 查询User
    user = User.objects.get(id=1)
    # 使用序列化器对象
    serializer = UserSerializer(user)
    # 获取序列化后的数据
    data = serializer.data
    print(data)

{'name': 'Django', 'age': 20}

序列化多个对象

当要被序列化的是包含多条数据的查询集QuerySet或list，可以通过添加many=True参数说明。

class MyTest(TestCase):
    # 查询User
    user = User.objects.all()
    # 使用序列化器对象
    serializer = UserSerializer(user, many=True)
    # 获取序列化后的数据
    data = serializer.data
    print(data)

[OrderedDict([('name', 'Django'), ('age', 20)]), OrderedDict([('name', 'Python'), ('age', 30)])]

关联对象嵌套序列化

如果在序列化对象数据时，需要将其关联的对象一并序列化，则定义序列化器类的字段时，需要定义对应的关联对象嵌套序列化字段。对于关联字段，有3种定义方式。

如果一个对象关联的对象有多个，在序列化器类中定义嵌套序列化字段时，需要多添加一个many=True参数。

from django.db import models

# Create your models here.
class User(models.Model):
    name = models.CharField(max_length=6, unique=True, verbose_name='姓名')
    age = models.IntegerField(default=0, verbose_name='年龄')

    class Meta:
        db_table = 'tb_user'
        verbose_name = '用户'
        verbose_name_plural = verbose_name


class Car(models.Model):
    TYPE_CHOICES = (
        (0, '轿车'),
        (1, 'SUV')
    )
    name = models.CharField(max_length=8, unique=True, verbose_name='名称')
    price = models.DecimalField(max_digits=5, decimal_places=2, default=0, verbose_name='价格')
    type = models.SmallIntegerField(choices=TYPE_CHOICES, verbose_name='类型')
    user = models.ForeignKey(to=User, on_delete=models.CASCADE, verbose_name="用户")

    class Meta:
        db_table = 'tb_car'
        verbose_name = '车辆'
        verbose_name_plural = verbose_name

# 用户序列化器类：UserSerializer
class UserSerializer(serializers.Serializer):
    name = serializers.CharField(label='姓名', max_length=6)
    age = serializers.IntegerField(label="年龄")
    
# 车辆序列化器类
class CarSerializer(serializers.Serializer):
    TYPE_CHOICES = (
        (0, 'male'),
        (1, 'female')
    )
    id = serializers.IntegerField(label='ID', read_only=True)
    name = serializers.CharField(label='名字', max_length=8)
    price = serializers.DecimalField(label='价格', max_digits=5, decimal_places=2, default=0)
    type = serializers.ChoiceField(choices=TYPE_CHOICES, label='类型', required=False)

PrimaryKeyRelatedField

将关联对象序列化为关联对象的主键。指明字段时需要包含read_only=True或者queryset参数：

1.指定read_only=True参数时，该字段仅在序列化时使用。

car_set = serializers.PrimaryKeyRelatedField(label='拥有车辆', read_only=True,many=True)

class MyTest(TestCase):
    # 查询User
    user = User.objects.get(id=1)
    # user对象序列化
    serializer = UserSerializer(user)
    # 获取序列化之后的数据
    serializerData = serializer.data
    print(serializerData)

{'name': 'Django', 'age': 22, 'car_set': [1, 2]}

2.指定queryset参数时，将被用作反序列化时参数校验使用。

#car_set = serializers.PrimaryKeyRelatedField(label='拥有车辆', read_only=True,many=True)
car_set = serializers.PrimaryKeyRelatedField(label='拥有车辆', queryset=Car.objects.all(),many=True)

{'name': 'Django', 'age': 22, 'car_set': [1, 2]}

使用关联对象的序列化器

使用指定的序列化器类将关联对象进行序列化。

class CarSerializer(serializers.Serializer):
    TYPE_CHOICES = (
        (0, 'male'),
        (1, 'female')
    )
    id = serializers.IntegerField(label='ID', read_only=True)
    name = serializers.CharField(label='名字', max_length=8)
    price = serializers.DecimalField(label='价格', max_digits=5, decimal_places=2, default=0)
    type = serializers.ChoiceField(choices=TYPE_CHOICES, label='类型', required=False)

class UserSerializer(serializers.Serializer):
    name = serializers.CharField(label='姓名', max_length=6)
    age = serializers.IntegerField(label="年龄")
	car_set = CarSerializer(many=True)    

{'name': 'Django', 'age': 22, 'car_set': [OrderedDict([('id', 1), ('name', '奥迪'), ('price', '99.00'), ('type', 1)]), OrderedDict([('id', 2), ('name', '宝马'), ('price', '88.00'), ('type', 2)])]}

StringRelatedField

将关联对象序列化为关联对象模型类__str__方法的返回值。

class Car(models.Model):
    TYPE_CHOICES = (
        (0, '轿车'),
        (1, 'SUV')
    )
    name = models.CharField(max_length=8, unique=True, verbose_name='名称')
    price = models.DecimalField(max_digits=5, decimal_places=2, default=0, verbose_name='价格')
    type = models.SmallIntegerField(choices=TYPE_CHOICES, verbose_name='类型')
    user = models.ForeignKey(to=User, on_delete=models.CASCADE, verbose_name="用户")

    class Meta:
        db_table = 'tb_car'
        verbose_name = '车辆'
        verbose_name_plural = verbose_name

    def __str__(self):
        return "name:%s price:%s" % (self.name, self.price)

class UserSerializer(serializers.Serializer):
    name = serializers.CharField(label='姓名', max_length=6)
    age = serializers.IntegerField(label="年龄")
    car_set = serializers.StringRelatedField(label='拥有车辆', many=True)

{'name': 'Django', 'age': 22, 'car_set': ['name:奥迪 price:99.00', 'name:宝马 price:88.00']}

反序列化操作

数据校验

数据校验可以调用is_valid()方法，会根据对应序列化类字段的类型以及一些选项参数对data中的数据进行校验。

调用is_valid进行数据校验时，除了一些基本的默认验证行为，还可以补充一些验证行为，有以下三种方法。

is_valid()

if __name__ == '__main__':
    # User
    user = {'name': 'test', 'age': 22}

    # 创建序列化器对象,将{'name': 'test', 'age': 22}进行反序列化
    serializer = UserSerializer(data=user)

    # 数据校验：成功返回True，失败返回False
    # 会根据对应序列化类字段的类型以及一些选项参数对data中的数据进行校验
    valid = serializer.is_valid()
    print(valid)

    errors = serializer.errors
    print(errors)
    
    # 获取校验成功之后的数据
    data = serializer.validated_data
    print(data)

validators

针对指定序列化器字段添加validators选项参数补充校验

def age_validator(value):
    if value < 18:
        raise serializers.ValidationError("未成年用户禁止操作")


# 用户序列化器类：UserSerializer。其可以针对User进行数据的序列化和反序列化操作
class UserSerializer(serializers.Serializer):
    name = serializers.CharField(label='姓名', max_length=6, )
    age = serializers.IntegerField(label="年龄", validators=[age_validator])


if __name__ == '__main__':
    # User
    user = {'name': 'test', 'age': 17}

    # 创建序列化器对象,将{'name': 'test', 'age': 22}进行反序列化
    serializer = UserSerializer(data=user)

    # 数据校验：成功返回True，失败返回False
    valid = serializer.is_valid()
    print(valid)

    errors = serializer.errors
    print(errors)

    # 获取校验成功之后的数据
    data = serializer.validated_data
    print(data)

False
{'age': [ErrorDetail(string='未成年用户禁止操作', code='invalid')]}
{}

validate_<field_name>

在序列化器类中定义特定方法validate_<field_name>，针对特定字段进行补充验证

class UserSerializer(serializers.Serializer):
    name = serializers.CharField(label='姓名', max_length=6, )
    age = serializers.IntegerField(label="年龄")

    def validate_age(self, value):
        if value < 18:
            raise serializers.ValidationError("未成年用户禁止操作")
        return value

if __name__ == '__main__':
    # User
    user = {'name': 'test', 'age': 17}

    # 创建序列化器对象,将{'name': 'test', 'age': 22}进行反序列化
    serializer = UserSerializer(data=user)

    # 数据校验：成功返回True，失败返回False
    valid = serializer.is_valid()
    print(valid)

    errors = serializer.errors
    print(errors)

    # 获取校验成功之后的数据
    data = serializer.validated_data
    print(data)

False
{'age': [ErrorDetail(string='未成年用户禁止操作', code='invalid')]}
{}

validate

在序列化器类中定义validate方法针对多个字段的内容进行补充验证，

class UserSerializer(serializers.Serializer):
    name = serializers.CharField(label='姓名', max_length=6, )
    age = serializers.IntegerField(label="年龄")

    def validate(self, attrs):
        age = attrs['age']
        if age < 18:
            raise serializers.ValidationError("未成年用户禁止操作")
        return attrs

# 设置Django运行所依赖的环境变量
import os

from django.test import TestCase

from apps.user.models import User
from apps.user.serializers import UserSerializer

if not os.environ.get('DJANGO_SETTINGS_MODULE'):
    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'drf_demo.settings')

# 让Django进行一次初始化
import django

django.setup()
class MyTest(TestCase):
    # User
    user = {'name': 'test', 'age': 17}

    # 创建序列化器对象,将{'name': 'test', 'age': 22}进行反序列化
    serializer = UserSerializer(data=user)

    # 数据校验：成功返回True，失败返回False
    valid = serializer.is_valid()
    print(valid)

    errors = serializer.errors
    print(errors)

数据保存

1.在数据校验通过后，想基于validated_data完成数据对象的创建，可以通过序列化器对象.save()进行数据的保存。

2.在save方法内部会调用序列化器类的create或update方法，可以在create方法中实现数据新增，update方法中实现数据更新。

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

# 用户序列化器类
class UserSerializer(serializers.Serializer):
    name = serializers.CharField(label='姓名', max_length=6, )
    age = serializers.IntegerField(label="年龄")

    # 新建
    def create(self, validated_data):
        user = User.objects.create(**validated_data)
        return user

    # 更新,instance:更新的对象实例
    def update(self, instance, validated_data):
        instance.name = validated_data.get('name', instance.name)
        instance.age = validated_data.get('age', instance.age)
        instance.save()
        return instance

# 设置Django运行所依赖的环境变量
import os

from django.test import TestCase

from apps.user.models import User
from apps.user.serializers import UserSerializer

if not os.environ.get('DJANGO_SETTINGS_MODULE'):
    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'drf_demo.settings')

# 让Django进行一次初始化
import django

django.setup()

class MyTest(TestCase):
    # 新增
    user = {'name': 'Django', 'age': 22}
    serializer = UserSerializer(data=user)
    serializer.is_valid()
    # 调用序列化器类的create方法，实现新增
    serializer.save()

class MyTest(TestCase):
    # 更新
    user = User.objects.get(id=2)
    data = {'name': 'Java', 'age': 20}
    serializer = UserSerializer(user, data=data)
    serializer.is_valid()
    # 调用序列化器类的update方法，实现更新
    serializer.save()

ModelSerializer的使用

如果序列化器类对应Django某个模型类，则定义序列化器类时，可直接继承ModelSerializer。

ModelSerializer是Serializer类的子类，相对于Serializer，提供额外功能：

基于模型类字段自动生成序列化器类的字段

包含默认的create()和update()方法的实现

基本使用

创建一个UserSerializer类

# 用户序列化器类
class UserSerializer(serializers.ModelSerializer):
    class Meta:
    	# model：指明序列化器类对应的模型类
        model = User
        # fields：指明依据模型类的哪些字段生成序列化器类的字段,__all__表明包含所有字段
        fields = '__all__'

执行python manage.py shell命令，进入shell窗口，执行如下命令查看序列化器对象自动生成的具体字段

>>> from apps.users.serializers import UserSerializer, CarSerializer
>>> data = UserSerializer()
>>> data
UserSerializer():
    id = IntegerField(label='ID', read_only=True)
    name = CharField(label='姓名', max_length=6, validators=[<UniqueValidator(queryset=User.objects.all())>])
    age = IntegerField(label='年龄', max_value=2147483647, min_value=-2147483648, required=False)

指定字段

1.使用fields指明依据模型类的哪些字段生成序列化器类的字段，__all__表明包含所有字段，也可以指明具体哪些字段

class UserSerializer(serializers.ModelSerializer):
	class Meta:
	    # model：指明序列化器类对应的模型类
	    model = User
	    # fields：指明依据模型类的哪些字段生成序列化器类的字段
	    fields = ('id', 'name')

执行quit()退出shell，再执行python manage.py shell命令，进入shell窗口，执行查看

>>> from apps.users.serializers import UserSerializer, CarSerializer
>>> data = UserSerializer()
>>> data
UserSerializer():
    id = IntegerField(label='ID', read_only=True)
    name = CharField(label='姓名', max_length=6, validators=[<UniqueValidator(queryset=User.objects.all())>])

2.使用exclude可以指明排除哪些字段

class UserSerializer(serializers.ModelSerializer):
	class Meta:
	    model = User
	    exclude = ('name',)      

3.通过read_only_fields指明只读字段，即仅用于序列化的字段。

class UserSerializer(serializers.ModelSerializer):
	class Meta:
	    model = User
	    fields = ('id', 'name', 'age')
	    read_only_fields = ('id', 'name')

添加额外参数

可以使用extra_kwargs参数为自动生成的序列化器类字段添加或修改原有的选项参数。

class UserSerializer(serializers.ModelSerializer):
	class Meta:
	    model = User
	    fields = ('id', 'name', 'age')
	    extra_kwargs = {
	        'name': {'max_length': 3, 'required': True},
	        'age': {'min_value': 18, 'required': True},
	    }

添加或修改原有的选项参数：

>>> from apps.users.serializers import UserSerializer, CarSerializer
>>> data = UserSerializer()
>>> data
UserSerializer():
    id = IntegerField(label='ID', read_only=True)
    name = CharField(label='姓名', max_length=3, required=True, validators=[<UniqueValidator(queryset=User.objects.all())>])
    age = IntegerField(label='年龄', max_value=2147483647, min_value=18, required=True)

使用示例

re_path(r'^test/$', views.TestView.as_view(), name='test'),

from django.http import JsonResponse
from apps.users.models import User
from apps.users.serializers import UserSerializer
from django_redis.serializers import json

class TestView(View):
    def get(self, request):
        queryset = User.objects.all()
        # 序列化
        serializer = UserSerializer(queryset, many=True)

        return JsonResponse(serializer.data, safe=False)

    def post(self, request):
        json_bytes = request.body
        json_str = json_bytes.decode()
        user_dict = json.loads(json_str)

        # 反序列化-数据校验
        serializer = UserSerializer(data=user_dict)
        serializer.is_valid(raise_exception=True)

        # 反序列化-数据保存
        serializer.save()

        return JsonResponse(serializer.data, status=201)

 re_path(r'^test/(?P<id>\d+)/$', views.TestView.as_view(), name='test'),

class TestView(View):

    def get(self, request, pk):
        try:
            user = User.objects.get(pk=pk)
        except User.DoesNotExist:
            raise Http404

        serializer = UserSerializer(user)

        return JsonResponse(serializer.data)

    def put(self, request, pk):
        try:
            user = User.objects.get(pk=pk)
        except User.DoesNotExist:
            return HttpResponse(status=404)

        json_bytes = request.body
        json_str = json_bytes.decode()
        user_dict = json.loads(json_str)

        # 反序列化-数据校验
        serializer = UserSerializer(user, data=user_dict)
        serializer.is_valid(raise_exception=True)

        # 反序列化-数据保存
        serializer.save()

        return JsonResponse(serializer.data)

    def delete(self, request, pk):
        try:
            user = User.objects.get(pk=pk)
        except User.DoesNotExist:
            return HttpResponse(status=404)

        user.delete()

        return HttpResponse(status=204)