DRF

Django Rest_Framework

1.web应用模式

在开发web应用中,有两种应用模式:

前后端不分离

前后端分离

2.API接口

为了在团队内部形成共识,防止个人习惯差异引起的混乱,我们需要找到一种大家都觉的很好的接口实现规范,而且这种规范能够让后端写的接口用途一目了然,减少双方之间的合作成本。

目前市面上大部分公司开发人员使用的接口服务架构主要有:restful,rpc

rpc:翻译成中文:远程过程调用[远程服务调用]

接口多了,对应函数名和参数就多了,前端在请求api接口时,就会比较难找,容易出现重复的接口

restful:翻译成中文:资源状态转换

把后端所有的数据/文件都看成资源

那么接口请求数据,本质上来说就是对资源的操作

web项目中操作资源,无非就是增删改查,所以要求在地址栏中声明要操作的资源是什么,然后通过http请求

动词来说明对资源进行哪一种操作。

3.RESTful API规范

REST全称是Representational State Transfer,中文意识是表述性状态转移。它首次出现在2000年Roy Fielding的博士论文中。

RESTful是一种定义web API接口的设计风格,尤其是适用于前后端分离的应用模式中。

这种风格的理念认为后端开发任务就是提供数据的,对外提供的是数据资源的访问接口,所以在定义接口时,客户端访问的URL路径就表示这种要操作的数据资源。

而对于数据资源分别使用POST,DELETE,GET,UPDATE等请求动作来表达对数据的增删改查

请求方法	请求地址	后端操作
GET	/students	获取所有学生
POST	/students	增加学生
GET	/students/	获取编号为pk的学生
PUT	/students/	修改编号为pk的学生
DELETE	/students/	删除编号为pk的学生

事实上,我们可以使用任何一个框架都可以实现符合restful规范的API接口

参考文档:http://www.runoob.com/w3cnote/restful-architecture.html

4.序列化

api接口开发,最核心最常见的一个过程就是序列化,所谓序列化就是把数据转换格式,序列化可以分两个阶段:

序列化:把我们识别的数据转换成指定格式提供给别人。

例如:我们在django中获取到的数据默认是模型对象,但是模型对象数据无法直接提供给前端或别的平台使用,所以我们需要把数据进行序列化,变成字符串或json数据,提供给别人。

反序列化:把别人提供的数据转换/还原成我们需要的格式

例如:前端js提供过来的json数据,对于python而言就是字符串,我们需要进行反序列化转换成模型类对象数据,这样我们才能把数据保存到数据库中。

5.Django Rest_Framework

核心思想:缩减编写api接口的代码量(drf)

Django REST framework是一个建立在Django基础上的Web应用开发框架,可以快速的开发REST API接口应用。在REST framework中,提供了序列化器Serializer的定义,可以帮助我们简化序列化与反序列化的过程,不仅如此,还提供了丰富的类视图,扩展类,视图集来简化视图的编写工作,REST framework还提供了认证,权限,限流,过滤,分页,接口文档等功能支持,REST framework提供了一个API的Web可视化界面来方便查看测试接口

中文文档：https://q1mi.github.io/Django-REST-framework-documentation/#django-rest-framework

github: https://github.com/encode/django-rest-framework/tree/master

英文文档：https://www.django-rest-framework.org/

特点

提供了定义序列化器Serializer的方法,可以快速根据Django ORM 或者其他库自动序列化/反序列化;
提供丰富的类视图,Mixin扩展类,简化视图的编写;
丰富的定制层级:函数视图,类视图,视图集合,到自动生成API,满足各种需要
多种身份认证和权限认证方式的支持
内置了限流系统
直观的API web界面
可扩展性,插件丰富

6. 环境安装与配置

DRF需要以下环境依赖:

python(2.7, 3.2, 3.3, 3.4, 3.5, 3.6)
Django(1.10,1.11,2.0)

DRF是以Django扩展应用的方式提供的,所以我们可以直接利用已有的Django环境而无需重新创建(若没有Django环境,需要先创建环境安装Django)

6.1 安装DRF

pip3 install django==2.2
pip3 install djangorestframework

6.1.1创建django项目

cd ~/Desktop
django-admin startproject drfemo

也可以直接在pycharm中创建django项目

6.2 添加rest_framework应用

在settings.py配置文件中的INSTALLED_APPS中添加'rest_framework'

INSTALLED_APPS = [
    ...
    'rest_framework',
]

接下来就可以使用DRF提供的功能进行api接口开发了,在项目中如果使用rest_framework框架实现API接口,主要有以下三个步骤:

将请求的数据(如JSON格式)转换为模型类对象
操作数据库
将模型类对象转换为相应的数据(如JSON格式)

6.3 DRF简写代码的过程

6.3.1 创建模型操作类

models.py

class Student(models.Model):
    # 模型字段
    name = models.CharField(max_length=100,verbose_name="姓名",help_text='提示文本：不能为空')
    sex = models.BooleanField(default=1,verbose_name="性别")
    age = models.IntegerField(verbose_name="年龄")
    class_null = models.CharField(max_length=5,verbose_name="班级编号")
    description = models.TextField(max_length=1000,verbose_name="个性签名")

    class Meta:
        db_table="tb_student"	
        verbose_name = "学生"
        verbose_name_plural = verbose_name

mysql中创建一个数据库方便测试

create database drf01 charset utf8;

6.3.1.1 执行数据迁移

新建的应用要添加到INSTALL_APPS中去

初始化数据库连接

安装pymysql
pip install pymysql

主项目的__init__.py中设置使用pymysql作为数据库驱动

import pymysql
pymysql.install_as_MySQLdb()

在settings.py配置文件中设置mysql的账号密码

DATABASES = {
    # 'default': {
    #     'ENGINE': 'django.db.backends.sqlite3',
    #     'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    # },
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': "students",   # 数据库名称
        "HOST": "127.0.0.1",	
        "PORT": 3306,
        "USER": "root",
        "PASSWORD":"123",
    }
}

pycharm或终端下执行数据迁移

python mamage.py makemigrations
python manage.py migrate

错误列表

# 执行数据迁移  python manage.py makemigrations 报错如下:

解决方案:

注释掉 python/site-packages/django/db/backends/mysql/base.py中的35和36行代码。

执行数迁移发生以下错误:

解决方法:

backends/mysql/operations.py146行里面新增一个行代码：

6.3.2 创建序列化器

创建一个新应用

python manage.py startapp students

在students应用目录中新建serializers.py用于保存该应用的序列化器

from rest_framework import serializers
from app01 import models

class StudentSerializer(serializers.ModelSerializer):

	class Meta:
		model = models.Student
		fields = "__all__"
		extra_kwargs = {
			'id':{'read_only':True},
			'age':{'write_only':True},
		}

model指明该序列化器处理的数据字段从模型类Student参考生成
fields指明该序列化器包含模型类中的哪些字段,all指明包含所有字段

6.3.3 编写视图

在students应用的views.py中创建视图StudentView,这是一个视图集合

from django.shortcuts import render
from rest_framework.views import APIView
# Create your views here.
from app01 import models
from rest_framework import status
from .serializers import StudentSerializer,Student1Serializer
from rest_framework.response import Response

class Students1View(APIView):
	# 获取所有数据借口
	def get(self,request):
		all_data = models.Student.objects.all()
		serializer = StudentSerializer(instance=all_data,many=True)
		return Response(serializer.data)

	# 添加一条记录的接口
	def post(self,request):
		data = request.data
		serializer = StudentSerializer(data=data)
		if serializer.is_valid():
			instance = serializer.save()
			serializer = StudentSerializer(instance=instance)
			return Response(serializer.data,status=status.HTTP_201_CREATED)

		else:
			return Response({'xxx':'有字段错误'})

6.3.4 定义路由

students应用中urls.py中定义路由信息

from django.urls import path,re_path
from app01 import views

urlpatterns = [
	path('students1/',views.Students1View.as_view()),
	#re_path('students1/(?P<pk>\d+)/',views.Student1View.as_view()),
]

总路由urls.py的配置

from django.contrib import admin
from django.urls import path,re_path,include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('stu/',include('students.urls'))
]

6.3.5 运行测试

运行当前程序(与运行Django一样)

python manage.py runserver 端口号

在浏览器中输入网址127.0.0.1:8000/stu，可以看到DRF提供的API Web浏览页面：

在浏览器中输入网址127.0.0.1:8000/stu/students1/

就可以对数据库内容进行增删改查的操作了,很简单

7.序列化器

作用:

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

7.1 定义序列化器

Django REST framework中的Serializer使用类来定义，须继承自rest_framework.serializers.Serializer

from rest_framework import serializers

# 声明序列化器，所有的序列化器都要直接或者间接继承于 Serializer
# 其中，ModelSerializer是Serializer的子类，ModelSerializer在Serializer的基础上进行了代码简化
class StudentSerializer(serializers.Serializer):
    """学生信息序列化器"""
    # 1. 需要进行数据转换的字段
    id = serializers.IntegerField()
    name = serializers.CharField()
    age = serializers.IntegerField()
    sex = serializers.BooleanField()
    description = serializers.CharField()

    # 2. 如果序列化器集成的是ModelSerializer，则需要声明调用的模型信息

    # 3. 验证提交的数据的代码

    # 4. 编写添加和更新模型的代码

注意:serializer不是只能为数据库模型类定义,也可以为非数据库模型类的数据定义,serializer是独立于数据库之外的存在

常用字段类型:

字段	字段构造方式
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=)

选项参数：

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

通用参数：

参数名称	说明
read_only	表明该字段仅用于序列化输出，默认False
write_only	表明该字段仅用于反序列化输入，默认False
required	表明该字段在反序列化时必须输入，默认True
default	反序列化时使用的默认值
allow_null	表明该字段是否允许传入None，默认False
validators	该字段使用的验证器
error_messages	包含错误编号与错误信息的字典
label	用于HTML展示API页面时，显示的字段名称
help_text	用于HTML展示API页面时，显示的字段帮助提示信息

7.2 创建serializer对象

定义好serializer类后,就可以创建serializer对象了

serializer的构造方法为

serializer(instance=None,data=empty,**kwargs)

说明:

用于序列化时,将模型类对象传入instance参数
用于反序列化时,将要被反序列化的数据传入data参数

除了instance和data参数外,在构造serializer对象时,还渴通过context参数额外添加数据

serializer = AccountSerializer(account,context={'request':request})

通过context参数附加的数据,可以通过serializer对象的context属性获取

注意点"

1. 使用序列化器的时候一定要注意,序列化器声明了以后,不会自动执行,需要我们在视图中进行调用才可以
2. 序列化器无法直接接收数据,需要我们在视图中创建序列化器对象时把使用的数据传递过来
3. 序列化器的字段声明类似于表单系统
4. 开发restful api时,序列化器会帮我们把模型数据转换成字典
5. drf提供的视图会帮我们把字典转换成json,或者客户端发送过来的数据转换成字典

7.3 序列化器的使用

7.3.1序列化

1 在应用中创建一个py文件,比如叫做serializers.py

from rest_framework import serializers
class StudentSerizlizer(serializers.Serializer):

    name = serializers.CharField()
    age = serializers.IntegerField()
    class_null = serializers.CharField()
    description = serializers.CharField()

2 在视图中使用

from django.shortcuts import render,HttpResponse
from django.http import JsonResponse
from students import models
# Create your views here.
from django.views import View
from .serializers import StudentSerizlizer

class StudentView(View):

    def get(self,request):
        # all = models.Student.objects.all()  #quseryset   model
        one = models.Student.objects.get(id=1)  #quseryset   model
        # serializer = StudentSerizlizer(all,many=True)
        # serializer = StudentSerizlizer(all)  #结果为：[{},{}]形式
        serializer = StudentSerizlizer(one)  #得到的结果为字典 data
        print(serializer.data)  #{'name': 'chao', 'age': 18, 'class_null': '31', 'description': 'xxxxx'}


        return JsonResponse(serializer.data,safe=False,json_dumps_params={'ensure_ascii':False})

3 应用配置文件

INSTALLED_APPS = [
	...
    'students.apps.StudentsConfig',
    'rest_framework',
    'ser'
]
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'drf01',
        'HOST':'127.0.0.1',
        'PORT':3306,
        'USER':'root',
        'PASSWORD':'123456'
    }
}

7.3.2反序列化功能

1 创建反序列化组件

在应用中创建一个py文件,比如叫做serializers.py

from rest_framework import serializers

# 自定义校验函数
def check666(val):
    if '666' in val:
        raise serializers.ValidationError('不能光喊6666啊，没有用')
    else:
        return val

class StudentSerizlizer(serializers.Serializer):

    name = serializers.CharField(max_length=4,validators=[check666,])
    age = serializers.IntegerField(max_value=18)
    class_null = serializers.CharField()
    # description = serializers.CharField(required=False,allow_null=True)
    # required=False,allow_null=True允许字段为空，也就是不用传递过来这个data
    description = serializers.CharField(allow_blank=True)
    #allow_blank=True 允许只为空字符串

2 视图中使用

class Student(View):
    def get..
    	...
        
    def post(self,request):
        # content-type
        # if content-type == 'urlencoded':
        #     #username=chao&password=123&a=1
        #     request.POST['username'] = 'chao'
        # elif content-type == 'form-data':
        #     # 分片接受数据
        #     request.FILES
        # django没有自带解析json数据的解析器，所以需要我们手动的解析，但是drf中已经有了
        # content - type == 'application/json'
        #
        print(request.POST)
        data = {
            'name':request.POST.get('name'),
            'age':request.POST.get('age'),
            'class_null':request.POST.get('class_null'),
            'description':request.POST.get('description'),
        }

        ser = StudentSerizlizer(data=data)
        print(ser.is_valid())  #校验，全部通过得到True，一个字段错了都是得到False
        print(ser.errors)  #所有字段的错误信息
		
        # print(request.body)

        return HttpResponse('ok')

7.4 全局钩子和局部钩子的使用

ser/serializers.py

class StudentSerizlizer(serziliers.Serializer)
	
    #定义局部钩子 :单个属性的校验
	def validate_name(self,val): # 固定写法 校验哪个字段后面就写哪个字段
        print('xxxx>>>',val)
        if '777' in val:
            raise serializers.ValidationError('不能有777') # 有错误信息就不会往数据库中存储数据,可以把添加数据的代码注掉看报错信息
        
        return val # 如果没有错误,要返回这个了数据
    
    # 全局钩子 : 主要是针对多个属性进行校验
    def validate(self,data)
		print(data)
        age = data.get('age')
        class_null = data.get('class_null')
        if age == class_null:
            raise serializers.ValidationError('age和class_null不能相等')
        
        return data # 如果没有错误,全局钩子需要return所有数据

# 执行顺序
# 执行is_valid()方法时,先校验序列化器类中的所有属性Field(CharField(参数))参数对应的校验规则
# 再执行局部钩子
# 举例: 比如有name和age两个属性,先执行name属性的参数校验,再执行name的局部钩子
(validate_name(self,val)),然后 在执行age属性的参数校验,再执行age的局部钩子,最后所有属性的参数校验和局部钩子校验完成之后,执行全局钩子

# 最后执行全局钩子

视图部分

   def post(self,request):
        #
        print(request.POST)
        data = {
            'name':request.POST.get('name'),
            'age':request.POST.get('age'),
            'class_null':request.POST.get('class_null'),
            'description':request.POST.get('description'),
        }

        ser = StudentSerizlizer(data=data)

        if ser.is_valid():
            
            print(request.body)
            print(ser.validated_data) #返回验证成功后的数据
            ret = models.Student.objects.create(
                **ser.validated_data
            )
    		# 按照接口规范,如果post请求提交保存了一条数据,那么要将新添加的数据再响应回去
            serializer = StudentSerizlizer(instance=ret)
            print(serializer.data)  #得到的是教研成功之后的所有正确数据
    
    
            return JsonResponse(serializer.data,safe=False,json_dumps_params={'ensure_ascii':False})
        # return JsonResponse({'xx':'xx'})

        else:
            return JsonResponse({'error':'有字段错误'})

常用字段类型：

字段	字段构造方式
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=)

选项参数：

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

通用参数：

参数名称	说明
read_only	表明该字段仅用于序列化输出，默认False
write_only	表明该字段仅用于反序列化输入，默认False
required	表明该字段在反序列化时必须输入，默认True
default	反序列化时使用的默认值
allow_null	表明该字段是否允许传入None，默认False
validators	该字段使用的验证器
error_messages	包含错误编号与错误信息的字典
label	用于HTML展示API页面时，显示的字段名称
help_text	用于HTML展示API页面时，显示的字段帮助提示信息

raise_exception参数

等于True会主动抛异常

serializer.is_valid(raise_exception=True)

保存数据

方式1  直接在视图中保存

        if ser.is_valid():

            # print(request.body)
            ret = models.Student.objects.create(
                **ser.validated_data
            )
            
            serializer = StudentSerizlizer(instance=ret)

            return JsonResponse(serializer.data,safe=False,json_dumps_params={'ensure_ascii':False})

        else:
            print(ser.errors)
            return JsonResponse({'error':'有字段错误'})


方式2
在序列化器中定义create方法来数据的保存
class StudentSerizlizer(serializers.Serializer):
    # <QueryDict: {'name': ['c777'], 'age': ['6'], 'description': ['123'], 'class_null': ['1']}>
    name = serializers.CharField(max_length=4,validators=[check666,])
 	...
    
    def create(self, validated_data):

        # self.validated_data
        # validated_data
        # print('>>',self.validated_data)
        print('>>',validated_data)
        ret = models.Student.objects.create(
            **validated_data
        )
        return ret

更新数据

在序列化器中定义update方法来数据的更新
class StudentSerizlizer(serializers.Serializer):
    # <QueryDict: {'name': ['c777'], 'age': ['6'], 'description': ['123'], 'class_null': ['1']}>
    name = serializers.CharField(max_length=4,validators=[check666,])
 	...
    # 做更新动作
    def update(self, instance, validated_data):

        # print(instance)
        # print(validated_data)
        instance.name = validated_data['name']
        instance.age = validated_data['age']
        instance.class_null = validated_data['class_null']
        instance.description = validated_data['description']
        instance.save()
        return instance

视图
	   def put(self,request):

        data = {
            'id': 2,
            'name':'xx',
            'age':8,
            'sex':0,
            'class_null':'9',
            'description':'xx',

        }
        obj = models.Student.objects.get(id=data.get('id'))
        s_obj = StudentSerizlizer(instance=obj,data=data)  # 实例化序列化器类时,传入instance参数
        if s_obj.is_valid():
            s_obj.save()  #触发序列化器类的update方法

        else:
            return JsonResponse({'error':'数据错误'})

read_only和write_only参数的区别

from rest_framework import serializers

class StudentSerizlizer(serializers.Serializer):
    id = serializers.IntegerField(read_only=True)
    # read_only=True，序列化时序列化出该字段数据，反序列化校验时不要校验这个数据
    name = serializers.CharField(max_length=4,)

    age = serializers.IntegerField(max_value=18,write_only=True)
    # write_only=True，序列化时不序列化这个字段数据，反序列校验时，需要客户端传递这个数据过来进行校验
    class_null = serializers.CharField()

    description = serializers.CharField(allow_blank=True)

视图部分

from django.shortcuts import render
from django.views import View
# Create your views here.
from students import models
from .serializers import StudentSerizlizer
from django.http import JsonResponse
class StudentView(View):

    def get(self,request):
        all = models.Student.objects.all()
        serializer = StudentSerizlizer(instance=all, many=True)

        return JsonResponse(serializer.data, safe=False, json_dumps_params={'ensure_ascii':False})

    def post(self,request):

        print(request.POST)

        data = {
            'name':request.POST.get('name'),
            'sex':request.POST.get('sex'),
            'age':request.POST.get('age'),
            'class_null':request.POST.get('class_null'),
            'description':request.POST.get('description'),
        }
        serializer = StudentSerizlizer(data=data)
        serializer.is_valid()
        print(serializer.errors)
        print('正确数据：',serializer.validated_data)


        return JsonResponse({'xx':'xx'})

partial参数:默认为False

   def put(self,request):
        data = {
            'name':'chao',
            'age':18
        }
        serializer = StudentSerizlizer(data=data,partial=True)
        # partial=True:只需要校验传入给序列化器的数据，适用于部分数据更新
        serializer.is_valid()
        print(serializer.errors)
        print('正确数据：', serializer.validated_data)
        
        return JsonResponse({'ss': 'kk'})

modelSerializer的使用(自动帮我们保存数据不需要在写 create,update等方法)

序列化和反序列化的使用

定义如下的类(从数据库中获取约束属性自动生成serlializers的字段)

from rest_framework import serializers
from students import models
class StudentModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.Student
        fields = '__all__'
        # fields =  ['id', 'name', 'age']
        # fields =  ['id', 'name', 'age']
        # exclude = ['name','age']
        extra_kwargs = {
            'id':{'read_only':True,},
            'age':{'write_only':True,}
        }

        '''
            id
            name = models.CharField(max_length=100,verbose_name="姓名",help_text='提示文本：不能为空')
            sex = models.BooleanField(default=1,verbose_name="性别")
            age = models.IntegerField(verbose_name="年龄")
            class_null = models.CharField(max_length=5,verbose_name="班级编号")
            description = models.TextField(max_length=1000,verbose_name="个性签名")
        
        '''
        '''
                id = serializers.IntegerField(read_only=True)
                name = serializers.CharField(max_length=6,)  # name char(6)
                age = serializers.IntegerField(max_value=18,write_only=True)
                sex = serializers.BooleanField()
                class_null = serializers.CharField()
                description = serializers.CharField(allow_blank=True)
        
        '''

视图当中使用

from django.shortcuts import render
from django.http import JsonResponse
# Create your views here.
from django.views import View
from .serializers import StudentModelSerializer
from students import models
class StudentView(View):

    def get(self,request):
        all = models.Student.objects.all()

        model_ser = StudentModelSerializer(instance=all,many=True)
        print()

        return JsonResponse(model_ser.data, safe=False, json_dumps_params={'ensure_ascii':False})

    def post(self,request):
        print(request.POST)
        obj = StudentModelSerializer(data=request.POST)

        if obj.is_valid():
            print(obj.validated_data)
            obj.save()  #自动能够帮我们进行数据保存
            return JsonResponse({'msg':'success'})
        print(obj.errors)
        print(obj.validated_data)
        return JsonResponse({'xx':'ssssss'})

modelserializer进行数据保存时的问题

8. 视图相关

rest framework 提供了众多的通用视图基类与扩展类,以简化视图的编写

8.1 两个视图基类

8.1.1 APIView类

from rest_framework.views import APIView

APIView是REST framework提供的所有视图的基类,继承自Django的View父类。

APIVIew与View的不同知促在于:

传入到视图方法中的是REST framework的Request对象,而不是Django的HttpRequest对象
视图方法可以返回REST framework的Response对象,视图会为响应数据设置符合前端要求的格式
任何APIException异常都会被捕获到,并且处理成合适的响应信息
在进行dispatch()分发前,会对请求进行身份认证,权限检查,流量控制

支持定义的类属性

authentication_classes列表或元组,身份认证类
permission_classes列表或元组,权限检查类
throttle_classes列表或元组,流量控制类

APIView的request对象

from rest_framework.views import APIView

class UserView(APIView):

    def get(self,request):
        print(request.GET)
        print(request.query_params)
		# request.GET和request.query_params是等价的

        return JsonResponse({'xx':'xxxxx'})



    def post(self,request):
        print(request)
        # 当发送的数据格式为..urlencoded类型时,request.POST和request.data等价
        # print(request.POST.getlist('hobby')) #<QueryDict: {'name': ['小林2'], 'age': ['6']}>
        # 当发送过来的是json类型数据时,我们使用request.data属性能够获取到数据
        print(request.data) #{'username': 'xxxx', 'password': '123'},普通字典类型
        # request.data能够获取到客户端发送过来的json类型数据，但是得到的结果为普通字典类型，但是如果是多选数据，不能使用getlist方法获取

        return JsonResponse({'xx': 'xxxxx'})

response对象

查看drf的默认配置
from rest_framework import settings

引入response
from rest_framework.response import Response

Response默认响应的是json数据类型

当用浏览器访问时看到页面效果.


用户配置替换drf内部配置的写法
REST_FRAMEWORK = {
    'DEFAULT_RENDERER_CLASSES': (  # 默认响应渲染类
        'rest_framework.renderers.JSONRenderer',  # json渲染器
        'rest_framework.renderers.BrowsableAPIRenderer',  # 浏览器API渲染器
    )
}

response的方法的相关参数

Response(data, status=None, template_name=None, headers=None, content_type=None)

响应状态码

from rest_framework import status

# return Response({'xx':'xxxxx'}, status=201)
return Response({'xx':'xxxxx'}, status=status.HTTP_201_CREATED)

所有状态码

HTTP_100_CONTINUE = 100
HTTP_101_SWITCHING_PROTOCOLS = 101
HTTP_200_OK = 200
HTTP_201_CREATED = 201
HTTP_202_ACCEPTED = 202
HTTP_203_NON_AUTHORITATIVE_INFORMATION = 203
HTTP_204_NO_CONTENT = 204
HTTP_205_RESET_CONTENT = 205
HTTP_206_PARTIAL_CONTENT = 206
HTTP_207_MULTI_STATUS = 207
HTTP_208_ALREADY_REPORTED = 208
HTTP_226_IM_USED = 226
HTTP_300_MULTIPLE_CHOICES = 300
HTTP_301_MOVED_PERMANENTLY = 301
HTTP_302_FOUND = 302
HTTP_303_SEE_OTHER = 303
HTTP_304_NOT_MODIFIED = 304
HTTP_305_USE_PROXY = 305
HTTP_306_RESERVED = 306
HTTP_307_TEMPORARY_REDIRECT = 307
HTTP_308_PERMANENT_REDIRECT = 308
HTTP_400_BAD_REQUEST = 400
HTTP_401_UNAUTHORIZED = 401
HTTP_402_PAYMENT_REQUIRED = 402
HTTP_403_FORBIDDEN = 403
HTTP_404_NOT_FOUND = 404
HTTP_405_METHOD_NOT_ALLOWED = 405
HTTP_406_NOT_ACCEPTABLE = 406
HTTP_407_PROXY_AUTHENTICATION_REQUIRED = 407
HTTP_408_REQUEST_TIMEOUT = 408
HTTP_409_CONFLICT = 409
HTTP_410_GONE = 410
HTTP_411_LENGTH_REQUIRED = 411
HTTP_412_PRECONDITION_FAILED = 412
HTTP_413_REQUEST_ENTITY_TOO_LARGE = 413
HTTP_414_REQUEST_URI_TOO_LONG = 414
HTTP_415_UNSUPPORTED_MEDIA_TYPE = 415
HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE = 416
HTTP_417_EXPECTATION_FAILED = 417
HTTP_418_IM_A_TEAPOT = 418
HTTP_422_UNPROCESSABLE_ENTITY = 422
HTTP_423_LOCKED = 423
HTTP_424_FAILED_DEPENDENCY = 424
HTTP_426_UPGRADE_REQUIRED = 426
HTTP_428_PRECONDITION_REQUIRED = 428
HTTP_429_TOO_MANY_REQUESTS = 429
HTTP_431_REQUEST_HEADER_FIELDS_TOO_LARGE = 431
HTTP_451_UNAVAILABLE_FOR_LEGAL_REASONS = 451
HTTP_500_INTERNAL_SERVER_ERROR = 500
HTTP_501_NOT_IMPLEMENTED = 501
HTTP_502_BAD_GATEWAY = 502
HTTP_503_SERVICE_UNAVAILABLE = 503
HTTP_504_GATEWAY_TIMEOUT = 504
HTTP_505_HTTP_VERSION_NOT_SUPPORTED = 505
HTTP_506_VARIANT_ALSO_NEGOTIATES = 506
HTTP_507_INSUFFICIENT_STORAGE = 507
HTTP_508_LOOP_DETECTED = 508
HTTP_509_BANDWIDTH_LIMIT_EXCEEDED = 509
HTTP_510_NOT_EXTENDED = 510
HTTP_511_NETWORK_AUTHENTICATION_REQUIRED = 511

template_name,用于自定制浏览器的响应页面,了解

headers定制响应头键值对

 return Response({'xx':'xxxxx'}, status=status.HTTP_201_CREATED,headers={'xx':'oo'})

在APIView中仍一常规的类视图定义方法来实现get,post()或者其他请求方式的方法

举例:常见一个应用,写5个接口

from django.shortcuts import render
from rest_framework.views import APIView
# Create your views here.
from students import models
from .serializers import StudentModelSerializer
from rest_framework.response import Response
from rest_framework import status

class StudentsAPIView(APIView):

    def get(self,request):
        """
        获取所有学生数据
        :param request:
        :return:
        """
        """
            简单总结：
                1 获取一个数据，传instance参数
                    获取多条数据，传instance,many=True参数
                2 更新数据，传instance和data参数
                    部分字段更新，可以增加partial=True参数
                3 添加数据，传data参数
                4 删除数据，不需要使用序列化器
        """
        data_list = models.Student.objects.all()
        serializer = StudentModelSerializer(instance=data_list,many=True)

        return Response(serializer.data)

    def post(self,request):
        """
        添加学生信息
        :param requeset:
        :return:
        """
        data = request.data
        serializer = StudentModelSerializer(data=data)
        serializer.is_valid(raise_exception=True)

        instance = serializer.save()
        # 将添加的新的数据返回给客户端，可以使用我们的序列化组件先序列化一下
        serializer = StudentModelSerializer(instance=instance)

        return Response(serializer.data)

class StudentAPIView(APIView):

    def get(self,request,pk):
        """获取单条数据"""
        instance = models.Student.objects.get(pk=pk)
        serializer = StudentModelSerializer(instance=instance)
        return Response(serializer.data)
    def put(self,request,pk):
        """更新学生信息"""
        #由于更新操作，我们需要找到被更新的是哪条记录，所以需要客户端给我们传一个id过来，并且以后我们会用到获取一条数据，删除一条数据，都需要用到一个id值，所以我们把上面的get和post方法写成一个类，更新、获取单条数据和删除数据我们再单独写一个类
        data = request.data
        student = models.Student.objects.get(id=pk)

        #可能提交过来的是部分数据，所以加上一个partial=True参数,只验证提交过来的数据
        serializer = StudentModelSerializer(instance=student,data=data,partial=True)

        serializer.is_valid(raise_exception=True)

        instance = serializer.save()
        # 将修改后的数据返回给客户端
        serializer = StudentModelSerializer(instance=instance)

        return Response(serializer.data)


    def delete(self,request,pk):
        """删除一条数据,用不到我们的序列化器"""

        ret = models.Student.objects.get(id=pk).delete()

        return Response(None,status=status.HTTP_204_NO_CONTENT)

对应的urls.py

from django.urls import path,re_path
from . import views
urlpatterns = [
    path(r'students/',views.StudentsAPIView.as_view()),
    re_path(r'students/(?P<pk>\d+)/',views.StudentAPIView.as_view()),
]

下面来看一下rest_framework提供的其他功能,如何简化我们的代码

8.1.2 GenericAPIView(通用视图类)

from rest_framework.generics import GenericAPIView

继承自APIView,主要增加了操作序列化器和数据库查询的方法,作用是为下面Mixin扩展类的执行提供方法支持,通常在使用时,可搭配一个或多个Mixin扩展类

8.1.2.1提供的关于序列化器使用的属性与方法:

属性:
- serializer_class指明视图使用的序列化器
方法:
- get_serializer_class(self)
当出现一个视图类中调用多个序列化器时,那么可以通过条件判断在get_serializer_class方法中通过返回不同的序列化器类名就可以让视图方法执行不同的序列化器对象了

返回

序列化器类,默认返回serializer_class
```
def get_serializer_class(self):
    """重写获取序列化器类的方法"""
    if self.request.method == "GET":
        return StudentModel2Serializer
    else:
        return StudentModelSerializer
```
- get_serializer()
返回序列化器对象,主要用来给Mixin扩展类使用,若果我们在视图中想要获取序列化器对象,也可以直接调用此方法

注意:该方法在提供序列化器对象的时候,会想序列化器对象的context属性补充三个数据:request,format,view,这三个数据对象可以在定义序列化器时使用

比如:
```
serializer = serlf.get_serializer(instance=self.get_object(),context={'pk':pk})
```

下面的request和view后面会用到

1.request当前视图的请求对象

2.view当前请求的类视图对象

3.format 当前请求期望返回的数据格式

8.1.2.2提供的关于数据库查询的属性与方法

属性:
- queryset指明使用的数据查询集
方法:
- get_queryset(self)
  
  返回视图使用的查询集,主要用来提供给Minx扩展类使用,是列表视图与详情视图获取数据的基础,默认返回queryset属性,可以重写,例如:
```
def get_queryset(self):
    user = self.request.user
    return user.accounts.all()
```
- get_object(self)
  
  返回详情视图所需的模型数据对象,主要来提供给Mixin扩展类使用
  
  在视图中可以调用该方法获取详情信息的模型类对象
  
  若详情访问的模型类对象不存在,会返回404
  
  该方法会默认使用APIView提供的check_object_permissions方法检查当前对象是否有权限被访问
```
# url(r'^books/(?P<pk>\d+)/$', views.BookDetailView.as_view()),
class BookDetailView(GenericAPIView):
    queryset = BookInfo.objects.all()
    serializer_class = BookInfoSerializer

    def get(self, request, pk):
        book = self.get_object() # get_object()方法根据pk参数查找queryset中的数据对象
        serializer = self.get_serializer(book)
        return Response(serializer.data)
```

8.1.2.3其他可以设置的属性

pagination_class指明分页控制类
filter_backends指明过滤控制后端(查询一些数据的过滤条件等等)

新建一个子应用,来使用来一下GenericAPIView通用视图类

python manage.py startapp app02

from rest_framework.generics import GenericAPIView

from students.models import Student
from .serializers import StudentModelSerializer, StudentModel2Serializer
from rest_framework.response import Response

class StudentsGenericAPIView(GenericAPIView):
    # 本次视图类中要操作的数据[必填] 
    queryset = Student.objects.all() #基本上是固定的，查询就这么写
    # 本次视图类中要调用的默认序列化器[选填]
    serializer_class = StudentModelSerializer

    def get(self, request):
        """获取所有学生信息"""
        serializer = self.get_serializer(instance=self.get_queryset(), many=True)

        return Response(serializer.data)

    def post(self,request):

        data = request.data

        serializer = self.get_serializer(data=data)

        serializer.is_valid(raise_exception=True)

        instance = serializer.save()

        serializer = self.get_serializer(instance=instance)

        return Response(serializer.data)


class StudentGenericAPIView(GenericAPIView):
    queryset = Student.objects.all()
    serializer_class = StudentModelSerializer

    #一个视图中使用多个序列化类的方法，目前的例子是：get请求获取数据时，我们只给他两个字段数据，其他方法时我们给他所有字段数据，定义了这个get_serializer_class方法之后(其实是对父类的方法进行了重写)，其实上面的serializer_class就可以不同写了
    def get_serializer_class(self):
        """重写获取序列化器类的方法"""
        if self.request.method == "GET":
            return StudentModel2Serializer
        else:
            return StudentModelSerializer

    #在使用GenericAPIView实现获取操作单个数据时，我们试图方法中的参数变量pk最好是pk名，别叫id什么的，不然还需要进行一些其他的配置，比较麻烦一些了，简单看一下源码就知道了
    def get(self,request,pk):
        """获取一条数据"""
        serializer = self.get_serializer(instance=self.get_object())

        return Response(serializer.data)

    def put(self,request,pk):

        data = request.data

        serializer = self.get_serializer(instance=self.get_object(),data=data)

        serializer.is_valid(raise_exception=True)

        serializer.save()

        serializer = self.get_serializer(instance=self.get_object())

        return Response(serializer.data)

新建一个serializers.py文件里面写序列化器类

from rest_framework import serializers
from app01 import models

class StudentSerializer(serializers.ModelSerializer):

	class Meta:
		model = models.Student
		fields = "__all__"
		extra_kwargs = {
			'id':{'read_only':True},
			'age':{'write_only':True},
		}

class Student1Serializer(serializers.ModelSerializer):

	class Meta:
		model = models.Student
		fields = ['name','class_null']
		extra_kwargs = {
			'id':{'read_only':True},
			'age':{'write_only':True}
		}

其实GenericaAPIView只是帮我们把数据库查询和调用序列化器类进行了一步封装,目的是将一些公共性质的代码挑出去封装一下,公共性质的代码都不要我们写了,看下面几个扩展类来增强GenericAPIView的作用

8.2 5个视图扩展类

作用:

提供了几种后端视图(对数据资源进行增删改查)处理流程的实现,可以通过继承相应的扩展类来复用代码,减少自己编写的代码量

这5个扩展类需要搭配GenericAPIView父类,因为5个扩展类的实现需要调用GenericAPIView提供的序列化器与数据库查询的方法

8.2.1 ListModelMixin

获取多条数据的列表视图扩展类,提供list(request,*args,**kwargs)方法快速实现列表视图,返回200状态码(相当于get方法)

该Mixin的list方法会对数据进行过滤和分页

源代码:

class ListModelMixin(object):
    """
    List a queryset.
    """
    def list(self, request, *args, **kwargs):
        # 过滤
        queryset = self.filter_queryset(self.get_queryset())
        # 分页
        page = self.paginate_queryset(queryset)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)
        # 序列化
        serializer = self.get_serializer(queryset, many=True)
        return Response(serializer.data)

举例:

from rest_framework.mixins import ListModelMixin

class BookListView(ListModelMixin, GenericAPIView):
    queryset = BookInfo.objects.all()
    serializer_class = BookInfoSerializer

    def get(self, request):
        return self.list(request)

8.2.2 CreateModelMixin

添加数据的创建视图扩展类,提供create(request,*args,**kwargs)方法快速实现创建资源的视图,成功返回201状态码(相当于post方法)

如果序列化器对前端发送数据验证失败,返回400错误码

源代码:

class CreateModelMixin(object):
    """
    Create a model instance.
    """
    def create(self, request, *args, **kwargs):
        # 获取序列化器
        serializer = self.get_serializer(data=request.data)
        # 验证
        serializer.is_valid(raise_exception=True)
        # 保存
        self.perform_create(serializer)
        headers = self.get_success_headers(serializer.data)
        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)

    def perform_create(self, serializer):
        serializer.save()

    def get_success_headers(self, data):
        try:
            return {'Location': str(data[api_settings.URL_FIELD_NAME])}
        except (TypeError, KeyError):
            return {}

示例:

def post(self,request):
  
  return self.create(requset)

8.2.3 RetrieveModelMixin

获取单条数据,详情视图扩展类,提供retrieve(request,*args,**kwargs)方法,可以快速实现返回一个存在的数据对象(获取单条数据)

如果存在,返回200,不存在返回404

源代码:

class RetrieveModelMixin(object):
    """
    Retrieve a model instance.
    """
    def retrieve(self, request, *args, **kwargs):
        # 获取对象，会检查对象的权限
        instance = self.get_object()
        # 序列化
        serializer = self.get_serializer(instance)
        return Response(serializer.data)

举例:

class BookDetailView(RetrieveModelMixin, GenericAPIView):
    queryset = BookInfo.objects.all()
    serializer_class = BookInfoSerializer

    def get(self, request, pk):
        return self.retrieve(request,pk)
        return self.retrieve(request) #pk也可以不传

8.2.4 UpdateModelMixin

更新视图扩展类,提供update(request,*args,**kwargs)方法,可以快速实现更新一个存在的数据对象

同时也提供partial_update(request,*args,**kwargs)方法,可以实现局部更新

成功返回200,序列化器校验数据失败时,返回400错误

源代码:

class UpdateModelMixin(object):
    """
    Update a model instance.
    """
    def update(self, request, *args, **kwargs):
        partial = kwargs.pop('partial', False)
        instance = self.get_object()
        serializer = self.get_serializer(instance, data=request.data, partial=partial)
        serializer.is_valid(raise_exception=True)
        self.perform_update(serializer)

        if getattr(instance, '_prefetched_objects_cache', None):
            # If 'prefetch_related' has been applied to a queryset, we need to
            # forcibly invalidate the prefetch cache on the instance.
            instance._prefetched_objects_cache = {}

        return Response(serializer.data)

    def perform_update(self, serializer):
        serializer.save()

    def partial_update(self, request, *args, **kwargs):
        kwargs['partial'] = True
        return self.update(request, *args, **kwargs)

示例:

def put(self,request,pk):
  """更新一条数据"""
  return self.update(request,pk)

8.2.5 DestroyModelMixin

删除视图扩展类,提供destroy(request,*args,**kwargs)方法,可以快速实现删除一个存在的数据对象

成功返回204,不存在返回404

源代码:

class DestroyModelMixin(object):
    """
    Destroy a model instance.
    """
    def destroy(self, request, *args, **kwargs):
        instance = self.get_object()
        self.perform_destroy(instance)
        return Response(status=status.HTTP_204_NO_CONTENT)

    def perform_destroy(self, instance):
        instance.delete()

示例:

def delete(self,request,pk):
        """删除一条数据"""
        return self.destroy(request,pk)

使用GenericAPIView和视图扩展类,实现api接口,代码:

"""GenericAPIView结合视图扩展类实现api接口"""
from rest_framework.mixins import ListModelMixin,CreateModelMixin
class Students2GenericAPIView(GenericAPIView,ListModelMixin,CreateModelMixin):
    # 本次视图类中要操作的数据[必填]
    queryset = Student.objects.all()
    # 本次视图类中要调用的默认序列化器[选填]
    serializer_class = StudentModelSerializer

    def get(self, request):
        """获取多个学生信息"""
        return self.list(request)

    def post(self,request):
        """添加学生信息"""
        return self.create(request)


from rest_framework.mixins import RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin
class Student2GenericAPIView(GenericAPIView,RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin):
    queryset = Student.objects.all()

    serializer_class = StudentModelSerializer

    # 在使用GenericAPIView视图获取或操作单个数据时,视图方法中的代表主键的参数最好是pk
    def get(self,request,pk):
        """获取一条数据"""
        return self.retrieve(request,pk)

    def put(self,request,pk):
        """更新一条数据"""
        return self.update(request,pk)

    def delete(self,request,pk):
        """删除一条数据"""
        return self.destroy(request,pk)

8.3 GenericAPIView的视图子类

8.3.1 CreateAPIView

提供 post 方法

继承自： GenericAPIView、CreateModelMixin

8.3.2 ListAPIView

提供 get 方法

继承自：GenericAPIView、ListModelMixin

8.3.3 RetrieveAPIView

提供 get 方法

继承自: GenericAPIView、RetrieveModelMixin

8.3.4 DestoryAPIView

提供 delete 方法

继承自：GenericAPIView、DestoryModelMixin

8.3.5 UpdateAPIView

提供 put 和 patch 方法

继承自：GenericAPIView、UpdateModelMixin

8.3.6 RetrieveUpdateAPIView

提供 get、put、patch方法

继承自： GenericAPIView、RetrieveModelMixin、UpdateModelMixin

8.3.7 RetrieveUpdateDestoryAPIView

提供 get、put、patch、delete方法

继承自：GenericAPIView、RetrieveModelMixin、UpdateModelMixin、DestoryModelMixin

简化代码:

###############  基于视图子类的接口   #########################################
from rest_framework.generics import ListAPIView,CreateAPIView,RetrieveAPIView,UpdateAPIView,DestroyAPIView

class Students4View(ListAPIView,CreateAPIView):
	queryset = models.Student.objects.all()
	serializer_class = StudentSerializer

class Student4View(RetrieveAPIView,UpdateAPIView,DestroyAPIView):
	queryset = models.Student.objects.all()
	serializer_class = StudentSerializer

8.4 视图集基类

8.4.1 ViewSet

继承自APIView与ViewSetMixin作用也与APIView基本类似提供类身份认证,权限校验流量管理等

ViewSet主要通过继承ViewSetMixin来实现在调用as_view()时传入字典如{'get':'list'}的映射工作

在ViewSet中,没有提供任何action方法,需要我们自己实现action方法

使用视图集ViewSet，可以将一系列逻辑相关的动作放到一个类中：

list() 提供一组数据
retrieve() 提供单个数据
create() 创建数据
update() 保存数据
destory() 删除数据

代码:

from rest_framework.viewsets import ViewSet,GenericViewSet

class Students5View(ViewSet):
	# 获取所有数据接口
	def get_all_student(self,request):
		all_data = models.Student.objects.all()
		serializer = StudentSerializer(instance=all_data,many=True)
		return Response(serializer.data)

	# 添加一条记录的接口
	def add_student(self,request):
		data = request.data
		serializer = StudentSerializer(data=data)
		if serializer.is_valid():
			instance = serializer.save()
			serializer = StudentSerializer(instance=instance)
			return Response(serializer.data,status=status.HTTP_201_CREATED)
		else:
			return Response({'msg':'有错误'})

	# 获取单条数据
	def get_one(self,request,pk):
		stu_obj = models.Student.objects.get(pk=pk)
		serializer = StudentSerializer(instance=stu_obj)
		return Response(serializer.data)

urls.py(路由设置)

from django.urls import path,re_path
from app01 import views
urlpatterns = [
    path('students5/', views.Students5View.as_view({'get':'get_all_student','post':'add_student'})),
	re_path('students5/(?P<pk>\d+)/', views.Students5View.as_view({'get':'get_one'})),
]

改善代码:

"""发挥下ViewSet的作用"""
from rest_framework.viewsets import ViewSet
from rest_framework.generics import ListAPIView,CreateAPIView,RetrieveAPIView
class Student2ViewSet(ViewSet,ListAPIView,CreateAPIView,RetrieveAPIView):
    queryset = Student.objects.all()
    serializer_class = StudentModelSerializer
    def get_all_student(self,request):
        """获取所有学生信息"""
        return self.list(request)

    def add_student(self,request):

        return self.create(request)

    def get_one(self,request,pk):
        """获取一个学生信息"""
        return self.retrieve(request)

8.4.2 GenericViewSet

使用ViewSet通常并不方便，因为list、retrieve、create、update、destory等方法都需要自己编写，而这些方法与前面讲过的Mixin扩展类提供的方法同名，所以我们可以通过继承Mixin扩展类来复用这些方法而无需自己编写。但是Mixin扩展类依赖于GenericAPIView，所以还需要继承GenericAPIView。

GenericViewSet就帮助我们完成了这样的继承工作，继承自GenericAPIView与ViewSetMixin，在实现了调用as_view()时传入字典（如{'get':'list'}）的映射处理工作的同时，还提供了GenericAPIView提供的基础方法，可以直接搭配Mixin扩展类使用。

举例：

from rest_framework.viewsets import ViewSet,GenericViewSet
from rest_framework.mixins import ListModelMixin,CreateModelMixin,UpdateModelMixin,RetrieveModelMixin,DestroyModelMixin

class Students7View(GenericViewSet,ListModelMixin,CreateModelMixin,UpdateModelMixin,RetrieveModelMixin,DestroyModelMixin):
	queryset = models.Student.objects.all()
	serializer_class = StudentSerializer

	# 获取所有数据接口
	def get_all_student(self,request):
		return self.list(request)

	# 添加一条记录的接口
	def add_student(self,request):
		return self.create(request)

	# 获取单条数据
	def get_one(self,request,pk):
		return self.retrieve(request,pk)

	# 更新单条数据
	def update_one(self,request,pk):
		return self.update(request,pk)

	# 删除单条数据
	def delete_one(self,request,pk):
		return self.destroy(request,pk)

urls.py

path('students7/', views.Students7View.as_view({'get':'get_all_student','post':'add_student'})),
    re_path('students7/(?P<pk>\d+)/', views.Students7View.as_view({'get':'get_one','put':'updat_one','delete':'delete_one'})),

简化代码:

from rest_framework.viewsets import ViewSet,GenericViewSet
from rest_framework.mixins import ListModelMixin,CreateModelMixin,UpdateModelMixin,RetrieveModelMixin,DestroyModelMixin

class Students7View(GenericViewSet,ListModelMixin,CreateModelMixin,UpdateModelMixin,RetrieveModelMixin,DestroyModelMixin):
	queryset = models.Student.objects.all()
	serializer_class = StudentSerializer

urls.py

	path('students7/', views.Students7View.as_view({'get':'list','post':'create'})),
    re_path('students7/(?P<pk>\d+)/', views.Students7View.as_view({'get':'retrieve','put':'update','delete':'destroy'})),

8.4.3 ModelViewSet

继承GenericViewSet,同时包括了ListModelMixin、RetrieveModelMixin、CreateModelMixin、UpdateModelMixin、DestoryModelMixin。

示例:

"""使用ModelViewSet简写上面的继承代码，最终版"""
from rest_framework.decorators import action
from rest_framework.viewsets import ModelViewSet

class Students8View(ModelViewSet):
	queryset = models.Student.objects.all()
	serializer_class = StudentSerializer

urls.py

path('students8/', views.Students8View.as_view({'get':'list','post':'create'})),
    re_path('students8/(?P<pk>\d+)/', views.Students8View.as_view({'get':'retrieve','put':'update','delete':'destroy'})),

总结:

继承视图集父类必须在url中.as_view()中配置action,如{'get':'list'}

8.4.4 视图集中定义附加action动作

在视图集中,除了上述默认的方法动作外,还可以添加自定义动作,进行扩展

举例,比如做一个登录方法login:

from rest_framework.viewsets import ModelViewSet,ReadOnlyModelViewSet
class StudentModelViewSet(ModelViewSet):
    queryset = Student.objects.all()
    serializer_class = StudentModelSerializer

    def login(self,request):  #这个就可以称为自定义的action动作
        """学生登录功能"""
        return Response({"message":"登录成功"})

ulrs.py

urlpatterns = [
    path("students8/", views.StudentModelViewSet.as_view({"get": "list", "post": "create"})),
    re_path("students8/(?P<pk>\d+)/",
            views.StudentModelViewSet.as_view({"get": "retrieve", "put": "update", "delete": "destroy"})),

    path("students8/login/",views.StudentModelViewSet.as_view({"get":"login"}))

]

8.4.5 action属性

在视图集中,我们可以通过action对象属性来获取当前请求视图集时的action动作是哪个

举例:

from rest_framework.viewsets import ModelViewSet
from students.models import Student
from .serializers import StudentModelSerializer
from rest_framework.response import Response
class StudentModelViewSet(ModelViewSet):
    queryset = Student.objects.all()
    serializer_class = StudentModelSerializer

    def get_new_5(self,request):
        """获取最近添加的5个学生信息"""
        # 操作数据库
        print(self.action) # 获取本次请求的视图方法名
        
        
通过路由访问到当前方法中.可以看到本次的action就是请求的方法名

9.路由Routers

对于视图集ViewSet,我们除了可以自己手动指明请求方式与动作action之间的对应关系;外,还可以使用Routers来帮助我们快速实现路由信息

REST framework提供了两个router

SimpleRouter
DefaultRouter

9.1 使用方法

1) 创建router对象,并注册视图集

from rest_framework import routers

router = routers.DefaultRouter()
router.register(r'router_stu', StudentModelViewSet, base_name='student')
get  login
#但是注意：路由对象只会按照modelviewset中的五个接口生成对应的访问地址而已，上面的login这种自定义动作就不能访问到了

register(prefix,viewset,base_name)

prfix该视图集的路由前缀
viewset视图集
base_name路由别名的前缀

2) 添加路由数据

方式一(简单常用)

urlpatterns = [
    ...
]
urlpatterns += router.urls

方式二

urlpatterns = [
    ...
    url(r'^', include(router.urls))
]

使用路由类给视图集生成了路由地址

from rest_framework.viewsets import ModelViewSet,ReadOnlyModelViewSet
class StudentModelViewSet(ModelViewSet):
    queryset = Student.objects.all()
    serializer_class = StudentModelSerializer

    def login(self,request):
        """学生登录功能"""
        print(self.action)
        return Response({"message":"登录成功"})

路由代码:

from django.urls import path, re_path
from . import views
urlpatterns = [
    ...
]

"""使用drf提供路由类router给视图集生成路由列表"""
# 实例化路由类
# drf提供一共提供了两个路由类给我们使用,他们用法一致,功能几乎一样
from rest_framework.routers import DefaultRouter
router = DefaultRouter()

# 注册视图集
# router.register("路由前缀",视图集类)
router.register("router_stu",views.StudentModelViewSet)

# 把生成的路由列表追加到urlpatterns
print( router.urls )
urlpatterns += router.urls

上面的代码只是生成了路由地址[增/删/改/查一条/查多条的功能],但是不会自动帮我们生成在视图集中自定义方法的路由,要给自定义方法生成路由,需要进行action动作的声明

9.2 视图集中附加action声明

在视图集中使用rest_framework.decorators.action装饰器

以action装饰器装饰的方法名会作为action动作名,与list,retrieve等同

action装饰器可以接受两个参数:

methods声明该action对应的请求方式,列表传递
detail:声明该action的路径是否与单一资源对应
```
xxx/<pk>/action方法名/
```
- True 表示路径格式是xxx/<pk>/action方法名/
- False表示路径格式是xxx/action方法名/

举例:

from rest_framework.viewsets import ModelViewSet
from rest_framework.decorators import action

class StudentModelViewSet(ModelViewSet):
    queryset = Student.objects.all()
    serializer_class = StudentModelSerializer

    # methods 设置当前方法允许哪些http请求访问当前视图方法
    # detail 设置当前视图方法是否是操作一个数据
    # detail为True，表示路径名格式应该为 router_stu/{pk}/login/
    @action(methods=['get'], detail=True)
    def login(self, request,pk):
        """登录"""
        ...

    # detail为False 表示路径名格式应该为 router_stu/get_new_5/
    @action(methods=['put'], detail=False)
    def get_new_5(self, request):
        """获取最新添加的5个学生信息"""
        ...

小结:

DefaultRouter与SimpleRouter的区别是,DefaultRouter会多附带一个默认的API根视图,返回一个包含所有列表视图的超链接响应数据,比如使用DefaultRouter是访问一下`http://127.0.0.1:8001/router_stu/`会看到一个页面,而SimpleRouter会报错,一般都需要有个查看所有接口的页面,所以基本用的都是DefaultRouter

DRF框架的扩展功能

使用django自带的admin认证

创建一个新的应用

python manage.py startapp app02

因为接下来的功能需要使用到登录功能,所以我们使用django内置admin站点并创建一个管理员

python manage.py createsuperuser
填一下用户名,邮箱和密码
root
2468688808@qq.com

创建管理员后,访问admin站点,先修改站点的语言配置settings.py

LANGUAGE_CODE = 'zh-hans'

from rest_framework import settings

在admin.py文件中,简单使用

from django.contrib import admin

# Register your models here.

from app01 import models

class StudentAdmin(admin.ModelAdmin):
	list_display = ['id','name','age','class_null']
	list_editable = ['name','age']

admin.site.register(models.Student,StudentAdmin)

1. 认证Authentication

可以在配置文件中配置全局默认的认证方案

from rest_framework import settings # 可以看到默认使用的
# 在settings配置文件中,我们可以进行下面的配置来覆盖默认配置
REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES':(
        # 哪个写在前面,优先使用哪个认证
    'rest_framework.authentication.SessionAuthentication',
    # session认证,admin后台其实就使用的session认证,其实接口开发很少用到session认证,所以我们通过配置可以改为其他认证,比如后面项目里用到的jwt,JSON,WEB,TOKEN认证或者一些配合redis的认证
     'rest_framework.authentication.BasicAuthentication',
     # 基本认证, 工作当中可能一些测试人员参与的话,会将一些认证数据保存在内存中,然后验证,开发用不上
    )
}

也可以在每个视图中通过设置authentication_classes属性来设置,比如说我们很多接口的数据都是可以让别人获取数据的,但是有可能有些接口是调用给别人网站的,有可能就需要我们做一些单独的认证了。

from rest_framework.authentication import SessionAuthentication, BasicAuthentication
from rest_framework.views import APIView

class ExampleView(APIView):
    # 类属性
    authentication_classes = [SessionAuthentication, BasicAuthentication] #也可以写成元祖形式的,到时候我们使用我们自己开发的认证组件的时候，就需要自己写一个认证组件类，然后写在列表中来使用
    ...

认证失败会有两种可能的返回值:

401 Unauthorized未认证
403 Permission Denied权限被禁止

示例1: 自定义认证组件

写一个认证类

from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed
class Auth(BaseAuthentication):

	def authenticate(self, request):

		# request.POST.get('username')
		username = 'root'
		if username == 'root':

			return 'yunchao','oo'  # request.user = 'root'  , request.auth ='oo'
		else:
			return AuthenticationFailed('denglu renzheng shibai')

全局使用就在settings配置文件中使用

REST_FRAMEWORK = {
    # 'DEFAULT_RENDERER_CLASSES': [
    #         'rest_framework.renderers.JSONRenderer',
    #         'rest_framework.renderers.BrowsableAPIRenderer',
    # ],

    'DEFAULT_AUTHENTICATION_CLASSES': (

        #'app01.utils.auth.Auth',  # 全局配置,所有的接口请求过来,都会执行这个类
        'rest_framework.authentication.SessionAuthentication',
        'rest_framework.authentication.BasicAuthentication'
    ),
}

局部视图中可以给单独的数据接口配置认证

from rest_framework.authentication import SessionAuthentication, BasicAuthentication
from app01.utils.auth import Auth
class Students1View(APIView):

	authentication_classes = [Auth,]

	# 获取所有数据借口
	def get(self,request):
		print(request.user)
		print(request.auth)
		all_data = models.Student.objects.all()
		serializer = StudentSerializer(instance=all_data,many=True)
		return Response(serializer.data)

	# 添加一条记录的接口
	def post(self,request):
		data = request.data
		serializer = StudentSerializer(data=data)
		if serializer.is_valid():
			instance = serializer.save()
			serializer = StudentSerializer(instance=instance)
			return Response(serializer.data,status=status.HTTP_201_CREATED)

		else:
			return Response({'xxx':'有字段错误'})

class UserAuth():
　　 def authenticate_header(self,request):
         pass
#authenticate方法固定的,并且必须有个参数，这个参数是新的request对象，不信，看源码
    def authenticate(self,request):
				print('搞事情')
        if 1:
        #源码中会发现，这个方法会有两个返回值，并且这两个返回值封装到了新的request对象中了，request.user-->用户名 和 request.auth-->token值，这两个值作为认证结束后的返回结果
            return "chao","asdfasdfasdf"

class BookView(APIView):
    #认证组件肯定是在get、post等方法执行之前执行的，还记得源码的地方吗，这个组件是在dispatch的地方调用的,我们是上面写个UserAuth类
    authentication_classes = [UserAuth,] #认证类可以写多个，一个一个的顺序验证
    def get(self,request):
        '''
        查看所有书籍
        :param request:
        :return:
        '''
        #这样就拿到了上面UserAuth类的authenticate方法的两个返回值
        print(request.user)  
        print(request.auth)
        book_obj_list = models.Book.objects.all()
        s_books = BookSerializers(book_obj_list,many=True)
        return Response(s_books.data)

2. 权限Permissions

权限控制可以限制用户对于视图的访问和对于具体数据对象的访问

在执行视图的dispatch()方法之前,会先进行视图访问权限的判断
在通过get_obj()获取具体对象时,会进行模型对象访问权限的判断

使用:

可以在配置文件中全局设置默认的权限管理类

REST_FRAMEWORK = {
    ....
    
    'DEFAULT_PERMISSION_CLASSES': (
        'rest_framework.permissions.IsAuthenticated', #登录状态下才能访问我们的接口，退出admin后台之后，就访问不了了
    )
}

如果没有特别指明,采用的是默认配置

from rest_framework import permissions
'DEFAULT_PERMISSION_CLASSES': (
   'rest_framework.permissions.AllowAny', #表示任何人都可以进行任何的操作，没做限制
)

也可以在具体的视图中通过permission_classes属性来设置

from rest_framework.permissions import IsAuthenticated
from rest_framework.views import APIView

class ExampleView(APIView):
    permission_classes = (IsAuthenticated,)
    ...

提供的权限

AllowAny 允许所有用户
IsAuthenticated 仅通过认真的用户
IsAdminUser 仅管理员用户
IsAuthenticatedOrReadOnly 已经登录认证的用户可以对数据进行增删改查操作,没有登录认证的只能查看数据

2.1 自定义权限

如需自定义权限,需继承rest_framework.permissions.BasePermission父类,并实现以下两个任何一个方法或全部

has_permission(self,request,view)

是否可以访问视图,view表示当前视图对象
has_object_permission(self,request,view,obj)

是否可以访问数据对象,view表示当前视图,obj为数据对象

例如:

在当前子应用下,创建一个权限文件permissions.py中声明自定义权限类

from rest_framework.permissions import BasePermission

class MyPermission(BasePermission):
	def has_permission(self,request,view):
		print(request,view)
		print(request.user)	# 未登录,AnonymousUser,匿名用户

		if (request.user.type == 'svip'):
			return True
		else:
			return False

局部配置权限

from rest_framework.permissions import IsAuthenticated
from app01.utils.auth import Auth,MyPermission
class Students1View(APIView):
	# permission_classes = [IsAuthenticated]
	# permission_classes = [MyPermission]
	# authentication_classes = [Auth,]

全局配置权限

REST_FRAMEWORK = {

    'DEFAULT_PERMISSION_CLASSES': [
        'app01.utils.auth.MyPermission' # 全局配置
        # 'rest_framework.permissions.IsAuthenticated',
    ],
}

3. 限流Throttling

可以对接口访问的频次进行限制,以减轻服务器压力

一般用于付费购买次数,投票等场景使用

3.1使用

可以在配置文件中,使用DEFAULT_THROTTLE_CLASSES和DEFAULT_THROTTLE_RATES进行全局配置

REST_FRAMEWORK = {
  
    'DEFAULT_THROTTLE_CLASSES': (
        'rest_framework.throttling.AnonRateThrottle', #匿名用户，未登录的
        'rest_framework.throttling.UserRateThrottle' #经过登录之后的用户
    ),
    'DEFAULT_THROTTLE_RATES': {
        'anon': '100/day',
        'user': '1000/day'
    }
}

DEFAULT_THROTTLE_RATES可以使用second,minute,hour或day来指明周期

源码:

{'s': 1, 'm': 60, 'h': 3600, 'd': 86400} m表示分钟，可以写m，也可以写minute

也可以在具体视图中通过throttle_classes属性来配置

from rest_framework.throttling import UserRateThrottle
from rest_framework.views import APIView

class ExampleView(APIView):
    throttle_classes = (UserRateThrottle,)  #局部配置
    ...

3.2 可选限流类

AnonRateThrottle

限制所有匿名未认证用户,使用IP区分用户
UserRateThrottle

限制认证用户,使用User id来区分

使用DEFAULT_THROTTLE_RATES['user']来设置频次
ScopedRateThrottle(待定)

限制用户对于每个视图的访问频次,使用ip或user id,先找用户id,没有设置用户id的话就会使用ip地址

全局配置

REST_FRAMEWORK = {
  
    'DEFAULT_THROTTLE_CLASSES': (
        'rest_framework.throttling.AnonRateThrottle', #匿名用户，未登录的
        'rest_framework.throttling.UserRateThrottle' #经过登录之后的用户
    ),
    'DEFAULT_THROTTLE_RATES': {
        'anon': '100/day',
        'user': '1000/day'
    }
}

局部配置

REST_FRAMEWORK = {
  
    #'DEFAULT_THROTTLE_CLASSES': (
    #   'rest_framework.throttling.AnonRateThrottle', #匿名用户，未登录的
    #   'rest_framework.throttling.UserRateThrottle' #经过登录之后的用户
    #),
    'DEFAULT_THROTTLE_RATES': {
        'anon': '100/day',
        'user': '1000/day'
    }
}

views.py

from rest_framework.throttling import UserRateThrottle

class Students1View(APIView):
	
	throttle_classes = [UserRateThrottle]

4. 过滤Filtering

对于列表数据可能需要根据字段进行过滤,我们可以通过添加django-filter扩展

pip3 install django-filter
# 会自动把django升级,记得
pip3 uninstall django
pip3 install django==2.2

在配置文件中添加过滤后端的设置

INSTALLED_APPS = [
    ...
    'django_filters',  # 需要注册应用，
]

REST_FRAMEWORK = {
    ...
    'DEFAULT_FILTER_BACKENDS': ('django_filters.rest_framework.DjangoFilterBackend',)
}

在视图中添加filter_fields属性,指定可以过滤的字段

class Students8View(ModelViewSet):
	queryset = models.Student.objects.all()
	serializer_class = StudentSerializer
	filter_fields = ('name','age')

# 127.0.0.1:8000/four/students/?name=

5. 排序

对于列表数据,Rest framework提供了 OrderingFilter过滤器来帮助我们快速指明数据按照指定字段进行排序

5.1使用方法:

在类视图中设置filter_backends,使用rest_framework.filters.OrderingFilter过滤器,Rest framework会在请求的查询字符串参数中检查是否包含了ordering参数,如果包含了ordering参数,则按照ordering参数指明的排序字段对数据进行排序。

前端可以传递的ordering参数的可选字段值需要在ordering_fields中指明。

示例:

from rest_framework.filters import OrderingFilter
from django_filters.rest_framework import DjangoFilterBackend# 需要使用一下他才能让过滤和排序结合使用
class Students8View(ModelViewSet):
	queryset = models.Student.objects.all()
	serializer_class = StudentSerializer
	filter_backends = [OrderingFilter,DjangoFilterBackend]# 因为filter_backends是局部过滤配置,局部配置会覆盖全局配置,所以需要重新把过滤组件核心类再次声明 否则过滤功能会失效
	filter_fields = ('name','age')
	ordering_fields = ('id','age')
	# 针对的是继承的类中的list方法
    
    # http://127.0.0.1:8000/app01/dd/?age=18&ordering=-id

6. 分页

settings.py中设置全局的分页方式

REST_FRAMEWORK = {
  # 全局分页，一旦设置了全局分页，那么我们drf中的视图扩展类里面的list方法提供的列表页都会产生分页的效果。所以一般不用全局分页
    'DEFAULT_PAGINATION_CLASS':  'rest_framework.pagination.PageNumberPagination',
    'PAGE_SIZE': 100  # 每页最大数据量
}

也可以通过自定义Pagination类,来为视图添加不同的分页行为,在视图中通过pagination_class属性来指明

class LargeResultsSetPagination(PageNumberPagination):
    page_size = 1000  #每页显示多少条
    #127.0.0.1:8001/students/?page=5&page_size=10
    
    page_size_query_param = 'page_size'
    max_page_size = 10000
class BookDetailView(RetrieveAPIView):
    queryset = BookInfo.objects.all()
    serializer_class = BookInfoSerializer
    pagination_class = LargeResultsSetPagination

注意: 如果在视图内关闭分页功能,只需在视图内设置

pagination_class = None

6.1 可选分页器

6.1.1 PageNumberPagination

可以在子类中定义的属性"

page_size 每页显示的数量
page_query_param 客户端指定分页的关键字,默认为page
page_size_query_param 客户端自定义获取每页条数的关键字
max_page_size 客户端最多每页能获取的最大条数

示例:

from rest_framework.pagination import PageNumberPagination,LimitOffsetPagination
class LargeResultsSetPagination(PageNumberPagination):
	page_size = 2  # 每页显示多少条
	# 127.0.0.1:8001/students/?page=5&page_size=10
	page_query_param = 'pp' # 指定分页的关键字,默认为page
	page_size_query_param = 'size'# 客户端可以通过 size=10 来获取 10条数据
	max_page_size = 3 #  客户端最大获取的数量

    #http://127.0.0.1:8000/app01/dd/?pp=1&size=5

from rest_framework.viewsets import ModelViewSet
from rest_framework.filters import OrderingFilter
from django_filters.rest_framework import DjangoFilterBackend
class Students8View(ModelViewSet):
	queryset = models.Student.objects.all()
	serializer_class = StudentSerializer
	filter_backends = [OrderingFilter,DjangoFilterBackend]
	filter_fields = ('name','age')
	ordering_fields = ('id','age')
	#pagination_class = LargeResultsSetPagination
	pagination_class = LargePagination

6.1.2 LimitOffsetPagination

还可以通过偏移量来取数据

可以在子类中定义的属性：

default_limit 默认限制，每页数据量大小，默认值与PAGE_SIZE设置一致
limit_query_param limit参数名，默认'limit' ，可以通过这个参数来改名字
offset_query_param offset参数名，默认'offset' ，可以通过这个参数来改名字
max_limit 最大limit限制，默认None，无限制

from rest_framework.pagination import PageNumberPagination,LimitOffsetPagination
class LargePagination(LimitOffsetPagination):
	default_limit = 2
	limit_query_param = "size"  # 默认是limit
	offset_query_param = "start"  # 默认是offset

from rest_framework.viewsets import ModelViewSet
from rest_framework.filters import OrderingFilter
from django_filters.rest_framework import DjangoFilterBackend
class Students8View(ModelViewSet):
	queryset = models.Student.objects.all()
	serializer_class = StudentSerializer
	filter_backends = [OrderingFilter,DjangoFilterBackend]
	filter_fields = ('name','age')
	ordering_fields = ('id','age')
	#pagination_class = LargeResultsSetPagination
	pagination_class = LargePagination

7. 异常处理 Exceptions

7.1 自定义异常错误

Rest framework提供了异常处理,我们可以自定义异常处理函数

创建一个exceptions文件

from rest_framework.views import exception_handler
from app01.views import APIError
from rest_framework.response import Response

def myexception_handler(exc,context):
    # exc 错误对象
    # context 异常发生时的一些上下文信息
    # 先调用rest framework默认的异常处理方法获得标准错误响应对象
	ret = exception_handler(exc,context)# 这个函数是drf提供的,他处理了一些错误,但是如果它处理不了的,会返回None,所以,如果是None的话,我们需要自己来处理错误

	# print(exc,type(exc))
	if ret is None:
		if isinstance(exc,APIError):
			return Response('api错误')
		else:

			return ret

views.py

class APIError(Exception):
	pass

class Test(APIView):
	def get(self,request):
		try:
			models.Student.objects.get(pk=100)
		except models.Student.DoesNotExist:
			raise APIError('错啦错啦')
			return Response({'msg':'查询出错'})

		return Response({'msg':'xxxxx'})

settings.py,声明自定义的异常处理

REST_FRAMEWORK = {
    'EXCEPTION_HANDLER': 'app01.myexceptions.myexception_handler'
    # 如果未声明会采用默认的方式
    #'EXCEPTION_HANDLER': 'rest_framework.views.exception_handler'
}

urls.py

urlpatterns = [
	path('test/', views.Test.as_view()),
]

补充处理关于数据库的异常

from rest_framework.views import exception_handler as drf_exception_handler
from rest_framework import status
from django.db import DatabaseError

def exception_handler(exc, context):
    response = drf_exception_handler(exc, context)

    if response is None:
        view = context['view'] #出错的方法或者函数名称
        if isinstance(exc, DatabaseError):
            print('[%s]: %s' % (view, exc))
            response = Response({'detail': '服务器内部错误'}, status=status.HTTP_507_INSUFFICIENT_STORAGE)

    return response

7.2 rest framework定义的异常

APIException 所有的异常的父类
ParseError 解析错误
AuthenticationFailed 认证失败
NotAuthenticated 尚未认证
PermissionDenied 权限决绝
NotFound 未找到
MethodNotAllowed 请求方式不支持
NotAcceptable 要获取的数据格式不支持
Throttled 超过限流次数
ValidationError 校验失败

上面列处的异常不需要我们自行处理了,很多上面没有列出来的异常需要我们在自定义异常中自己处理

8. 自动生成接口文档

rest framework可以自动帮我们生成接口文档

接口文档以网页的方式呈现

自动接口文档能生成是继承自APIView及其子类的视图

8.1 安装依赖

rest framework生成接口文档需要coreapi库的支持

pip3 install coreapi

8.2 设置接口文档访问的路径

在总路由中添加接口文档路径

文档路由对应的视图配置为rest_framework.documentation.include_docs_urls,

参数title为接口文档网站的标题

from rest_framework.documentation import include_docs_urls

urlpatterns = [
    ...
    path('docs/', include_docs_urls(title='站点页面标题'))
]

settings.py配置

REST_FRAMEWORK = {
    ...
    'DEFAULT_SCHEMA_CLASS': "rest_framework.schemas.AutoSchema",

}

8.3 访问接口文档网页

浏览器访问 127.0.0.1:8000/docs/,即可看到自动生成的接口文档

两点说明:

视图集ViewSet的retrieve名称,在接口文档网站中叫做read
参数的description需要在模型类或序列化器类的字段中以help_text选项定义

class Student(models.Model):
    ...
    age = models.IntegerField(default=0, verbose_name='年龄', help_text='年龄')
    ...

9. Xadmin

xadmin是Django的第三方扩展插件,比使用Django的admin站点更强大,也更方便

文档：https://xadmin.readthedocs.io/en/latest/index.html

GitHub地址：https://github.com/sshwsfc/django-xadmin

9.1 安装

pip3 install https://codeload.github.com/sshwsfc/xadmin/zip/django2

在settings.py配置文件中注册如下应用:

INSTALLED_APPS = [
    ...
    'xadmin',
    'crispy_forms',
    'reversion',
    ...
]

# 修改使用中文界面
LANGUAGE_CODE = 'zh-Hans'

# 修改时区
TIME_ZONE = 'Asia/Shanghai'

xadmin有建立自己的数据库模型类,需要进行数据库迁移

python manage.py makemigrations
python manage.py migrate

在总路由中添加xadmin的路由信息

import xadmin
xadmin.autodiscover()

# version模块自动注册需要版本控制的Model
from xadmin.plugins import xversion
xversion.register_models()

urlpatterns = [
    path(r'xadmin/',xadmin.site.urls),
]

如果没有创建超级用户,则创建一下

python manage.py createsuperuser

9.2 使用

xadmin不在使用Django的admin.py,而是需要编写代码在adminx.py文件中,每一个应用都可以创建一个adminx.py对xadmin站点进行配置
xadmin的站点管理类不继承admin.ModelAdmin.而是直接继承object即可

在子应用中创建adminx.py文件

9.3站点的全局配置

import xadmin
from xadmin import views

class BaseSetting(object):
    """ xadmin的基本配置 """
    enable_themes = True # 开启主体切换功能
    use_bootswatch = True # 引导控制盘(左侧菜单栏)

xadmin.site.register(views.BaseAdminView,BaseSetting)

class GlobalSettings(object):
    """ xadmin的全局配置 """
    site_title = "海贼王团"  # 设置站点标题
    site_footer = "路飞学城有限公司"  # 设置站点的页脚
    menu_style = "accordion"  # 设置菜单折叠
    
xadmin.site.register(views.CommAdminView, GlobalSettings)

9.4 站点Model管理

xadmin可以使用的页面样式控制基本与Django原生的admin一样

可以在models类中定义__str__方法来定义对象显示成什么内容

list_display控制列表展示的字段

list_play = list_display = ['id','title','link','image_url']

search_fields控制可以通过搜索框搜索的字段名称,xadmin使用的是模糊查询
```
search_fields = ['id','title']
```
list_filter 可以进行过滤操作的列，对于分类、性别、状态
```
list_filter = ['is_delete']
```
ordering 默认排序的字段
```
ordering = ['-age',]  #-倒序
```
show_detail_fields 在列表页提供快速显示详情信息
```
show_detail_fields = ['id',]
```
list_editable 在列表页可以快速直接编辑的字段
```
list_editable = ['name','age',]
```

refresh_times 指定列表页的定时刷新

refresh_times = [5, 10,30,60]  # 设置允许后端管理人员按多长时间(秒)刷新页面,选好之后就能自动刷新了

list_export 控制列表页导出数据的可选格式

list_export = ('xls', 'json','csv')#写元祖或者列表都行   list_export设置为None来禁用数据导出功能
list_export_fields = ('id', 'btitle', 'bpub_date') #设置允许导出的字段

show_bookmarks 控制是否显示书签功能

show_bookmarks = True #False就隐藏了这个功能

data_charts 控制显示图表的样式

data_charts = {
        "order_amount": {  #随便写的名称order_amount
          'title': '图书发布日期表', 
          "x-field": "bpub_date", 
          "y-field": ('btitle',),
          "order": ('id',),
          
        },
    #    支持生成多个不同的图表
    #    "order_amount2": {
    #      'title': '图书发布日期表', 
    #      "x-field": "bpub_date", 
    #      "y-field": ('btitle',),
    #      "order": ('id',)
    #    },
    }

title 控制图标名称
x-field 控制x轴字段
y-field 控制y轴字段，可以是多个值
order 控制默认排序

model_icon 控制菜单的图标【图标的设置可以参考font-awesome的图标css名称】
```
model_icon = 'fa fa-gift'
```
readonly_fields 在编辑页面的只读字段
```
readonly_fields = ['name',]
```
exclude 在编辑页面隐藏的字段,比如判断这个数据是否删除的delete_status字段，一般就是用来标识一下字段是不是被删除了，但是数据库中不删除
```
exclude = ['name',]
```
这并不是所有功能，可以参看它的文档，它提供的一些功能我们可能还需要自定制，调整或者添加一些它没有的功能，后面再说

posted @ 2020-10-24 11:06 打酱油的阿超阅读(168) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部