drf框架

web应用模式

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

  • 前后端不分离 ,客户端看到的内容和所有的页面效果都是服务端提供出来的,这种情况下,前端页面中会出现很多涉及到服务端的模板语法

8.drf框架 - 图1

  • 前后端分离,把前端页面的效果(html,css,js分离到一个项目中,python服务端只需要返回数据即可)前端形成一个独立的网站,服务端形成一个独立的网站

8.drf框架 - 图2

api接口

服务端对接客户端的接口,市面上常用的接口服务框架有,restful、rpc、soap。

  • rpc:远程过程调用,远程服务调用
    服务端提供统一的请求数据的api地址:http://api.xxx.cn
    客户端需要使用post请求
    api地址加参数,可以调用后端的函数如:action=get_all_student&class=301&sex=1
    优点:不需要关心当前操作是什么请求,也不需要操作url地址的编写,对接简单
    缺点:接口多了,对应的函数名和参数就多了,前端在请求api接口的时候,就会比较难找容易出现重复的接口
  • restful:资源状态转换
    把后端所有的数据/文件都看作是资源
    接口请求数据本质上来说就是对资源的操作了
    web项目中操作资源,无非就是增删改查,所以要求在地址栏中声明要操作的资源是什么,然后通过http请求方法来说明对资源进行哪一种操作。
    POST 添加 http://www.xxx.cn/api/students/
    GET 获取 http://www.xxx.cn/api/students/
    DELETE 删除某条信息 http://www.xxx.cn/api/students//
    PUT 修改一个学生全部信息 http://www.xxx.cn/api/students//
    PATCH 修改一个学生部分信息 http://www.xxx.cn/api/students//
    优点:维护开发简单,可以保证后期的开发不会出现太多重复的接口
    缺点:1.有部分接口不会有明确的增删改查的区分,会导致后期维护成本上升
    2.因为restful把对于资源的操作都理解成了增删改查,建议使用http,所以restful接口天生局限于web开发。

restful api接口规范

REST全程Representational State Transfer

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

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

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

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

文档链接:http://www.runoob.com/w3cnote/restful-architecture.html

接口实施过程中,会存在幂等性,所谓幂等性是指客户端发起多次请求是否对于服务端里面的资源产生不同结果,如果多次请求,服务端返回的结果还是一样,则属于幂等接口,如果多次请求,服务端产生的结果不一样,则属于非幂等接口,在http请求中,get/put/patch/delete都属于幂等性接口,post属于非幂等接口

考虑幂等性,主要是接口操作的安全性问题

具体规范举例:

  1. 域名
    应该尽量将API部署在专用域名下面
    https://api.example.com
    如果确定API很简单,不会有进一步的扩展,可以考虑放在主域名下面
    https://www.example.org/api/
  2. 版本 Versioning
    项目开发过程中都会对项目进行版本迭代,所以每一个版本的api接口肯定都有可能存在差异,因此应该将API本本号放入URL.
    http://www.example.com/api/1.0/
    http://www.example.com/api/1.1/
    http://www.example.com/api/2.0/
    另一种做法是,将版本号放在HTTP头部信息中,但是不如放在url中方便和直观
    因为是不同的版本,可以理解成同一种资源的不同表现形式,所以应该采用同一个URL,版本号可以在HTTP请求头信息的Accept字段进行区分
    Accept: vnd.example-com.foo+json; version=1.0
    Accept: vnd.example-com.foo+json; version=1.1
    Accept: vnd.example-com.foo+json; version=2.0
  3. 路径 Endpoint
    路径又称终点,表示API的具体网址,每个网闸代表一种资源(resource)
    资源作为网址,只能有名词不能有动词,而且所用的名词往往于数据库的表明对应
    不好的例子:
    /getProducts
    /listOrders
    /retreiveClientByOrder?orderId=1
    对于一个简介的结构,应该使用名词,此外利用HTTP方法可以分离网址中的资源名称的操作
    GET /products : 将返回所有产品清单
    POST /products : 将产品新建到集合
    GET /products/4 : 将获取产品 4
    PATCH(或)PUT /products/4 :将更新产品 4
    API中的名词应该使用复数,无论是子资源还是所有资源
    如:获取产品的API可以这样定义:
    获取单个产品:http://127.0.0.1:8080/AppName/rest/products/1
    获取所有产品: http://127.0.0.1:8080/AppName/rest/products
  4. HTTP动词
    对于资源的具体操作类型,有HTTP动词表示
    常见的HTTP动词有下面四个(括号里对相应sql命令)
    • GET(SELECT):从服务器取出资源(一项或多项)。
    • POST(CREATE):在服务器新建一个资源。
    • PUT(UPDATE):在服务器更新资源(客户端提供改变后的完整资源)。
    • DELETE(DELETE):从服务器删除资源。

三个不常用的HTTP动词

  • PATCH(UPDATE):在服务器更新(更新)资源(客户端提供改变的属性)。
  • HEAD:获取资源的元数据。
  • OPTIONS:获取信息,关于资源的哪些属性是客户端可以改变的。

举例:
GET /zoos:列出所有动物园
POST /zoos:新建一个动物园(上传文件)
GET /zoos/ID:获取某个指定动物园的信息
PUT /zoos/ID:更新某个指定动物园的信息(提供该动物园的全部信息)
PATCH /zoos/ID:更新某个指定动物园的信息(提供该动物园的部分信息)
DELETE /zoos/ID:删除某个动物园
GET /zoos/ID/animals:列出某个指定动物园的所有动物
DELETE /zoos/ID/animals/ID:删除某个指定动物园的指定动物

  1. 过滤信息 Filtering
    如果记录数量很多,服务器不可能都将他们返回给用户,API应提供参数,过滤返回结果
    下面是一些常见的参数,query_string 查询字符串,地址栏后面问号后面的数据,格式: name=xx&sss=xxx
    参数的设计允许存在冗余,即允许API路径和URL参数偶尔有重复。比如,GET /zoos/ID/animals 与 GET /animals?zoo_id=ID 的含义是相同的。

    1. 完整的URL地址格式:
    2. 协议://域名(IP):端口号/路径?查询字符串#锚点
    1. ?limit=10:指定返回记录的数量
    2. ?offset=10:指定返回记录的开始位置。
    3. ?page=2&per_page=100:指定第几页,以及每页的记录数。
    4. ?sortby=name&order=asc:指定返回结果按照哪个属性排序,以及排序顺序。
    5. ?animal_type_id=1:指定筛选条件
  2. 状态码 Status Codes
    http所有的请求 必有回应的协议
    服务器向用户返回的状态码和提示信息,常见的有以下(括号中是该状态码对应HTTP动词)

    1. 1xx 表示当前本次请求还是持续,没结束
    2. 2xx 表示当前本次请求成功
    3. 3xx 表示当前本次请求成功,但是服务器进行代理操作/重定向
    4. 4xx 表示当前本次请求失败,主要是客户端发生了错误
    5. 5xx 表示当前本次请求失败,主要是服务器发生了错误
    • 200 OK - [GET]:服务器成功返回用户请求的数据
    • 201 CREATED - [POST/PUT/PATCH]:用户新建或修改数据成功。
    • 202 Accepted - [*]:表示一个请求已经进入后台排队(异步任务)
    • 204 NO CONTENT - [DELETE]:用户删除数据成功。
    • 400 INVALID REQUEST - [GET/POST/PUT/PATCH]:用户发出的请求有错误,服务器没有进行新建或修改数据的操作
    • 401 Unauthorized - [*]:表示用户没有权限(令牌、用户名、密码错误)。
    • 403 Forbidden - [*] 表示用户得到授权(与401错误相对),但是访问是被禁止的。
    • 404 NOT FOUND - [*]:用户发出的请求针对的是不存在的记录,服务器没有进行操作,该操作是幂等的。
    • 406 Not Acceptable - [GET]:用户请求的格式不可得(比如用户请求JSON格式,但是只有XML格式)。
    • 410 Gone -[GET]:用户请求的资源被永久删除,且不会再得到的。
    • 422 Unprocesable entity - [POST/PUT/PATCH] 当创建一个对象时,发生一个验证错误。
    • 500 INTERNAL SERVER ERROR - [*]:服务器发生错误,用户将无法判断发出的请求是否成功。
    • 507 数据存储出错,往往数据库操作错误出错,服务器就返回这个
  3. 错误处理 Error handling
    如果状态码是4xx,服务器就应该向用户返回错误信息,一般来说,返回的信息中将error作为键名,出错信息作为值

    1. {
    2. error: "Invalid API key"
    3. }
  4. 返回结果
    针对不同操作,服务器向用户返回的结果应该符合以下规范。

    • GET /collection:返回资源对象的列表(数组)
    • GET /collection/ID:返回单个资源对象(json)
    • POST /collection:返回新生成的资源对象(json)
    • PUT /collection/ID:返回完整的资源对象(json)
    • DELETE /collection/ID:返回一个空文档(空字符串)
  5. 超媒体 Hypermedia API
    RESTful API最好做到Hypermedia ,就是返回结果中提供链接,连向其他API方法,这样可以让用户不查文档也知道下一步应该做什么
    比如,Github的API就是这种设计,访问api.github.com会得到一个所有可用API的网址列表。
    从上面可以看到,如果想获取当前用户的信息,应该去访问api.github.com/user,然后就得到了下面结果。
    上面代码表示,服务器给出了提示信息,以及文档的网址。

    1. {
    2. "current_user_url": "https://api.github.com/user",
    3. "authorizations_url": "https://api.github.com/authorizations",
    4. // ...
    5. }
    1. {
    2. "message": "Requires authentication",
    3. "documentation_url": "https://developer.github.com/v3"
    4. }
  6. 其他
    服务器返回的数据格式,应该尽量使用JSON,避免使用XML

序列化

api接口开发中,最常见核心的就是序列化,所谓序列化就是把数据格式进行转换,序列化可以分为两段

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

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

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

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

Django REST_Framework

Django REST_Framework是建立在Django基础之上的web应用开发框架,本质就是一个内置在django里面的子应用,可以快速的开发rest api接口应用

在REST_Framework中,提供了序列化器 对象Serialzier的定义,可以帮助我们简化序列化与反序列化的操作,还提供丰富的类视图,扩展类,视图集来简化视图的编写工作,REST_Framework还提供了认证,权限,限流,过滤,分页,接口文档等功能支持,REST_Framework提供了一个用于测试api接口的可视化web页面,可以游览器直接访问接口

restful就是一个接口开发的规范,不局限于django或者drf,即使不使用drf,也能实现符合restful规范的api接口

特点:

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

文档链接:

https://q1mi.github.io/Django-REST-framework-documentation/#django-rest-framework

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

drf框架执行流程:

8.drf框架 - 图3

环境安装依赖:

drf是以django扩展应用的方式提供的,所以可以直接利用已有的django环境无需重新创建,如果没有django环境就要先创建django

python (2.7,3.2以上)

Django (1.10,1.11,2.0以上)

  1. # mkvirtualenv drfdemo -p python3
  2. #创建虚拟环境
  3. #pip install django==2.2.0 -i https://pypi.douban.com/simple
  4. # 安装django
  5. pip install djangorestframework -i https://pypi.douban.com/simple
  6. #安装djangorestframework
  7. pip install pymysql -i https://pypi.douban.com/simple

添加rest_framework应用

在setting.py中的INSTALLED_APPS中注册”rest_framework”,把drf框架注册到Django项目中

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

  • 将请求的数据 如json格式,转换为模型类对象
  • 通过模型类对象进行数据库操作,完成客户端请求的增删改查
  • 将模型类对象转换为响应的数据 如json格式

体验drf完全简写代码过程

  • 在django下创建子应用
    python manage.py startapp students
  • 创建模型操作类
    子应用的models.py文件中创建模型对象
    执行数据迁移(注意准备步骤,注册app,设置操作数据库驱动pymysql,setting中配置数据库信息) ```python from django.db import models

创建一个模型类

class Student(models.Model):

  1. #表字段声明
  2. #字段名 = models.数据类型(字段约束)
  3. name = models.CharField(null=False,max_length=32,verbose_name="姓名")
  4. sex = models.BooleanField(default=True,verbose_name="性别")
  5. age = models.IntegerField(verbose_name="年龄")
  6. class_num = models.CharField(max_length=5,verbose_name="班级编号")
  7. description = models.TextField(max_length=1000,verbose_name="个性签名")
  8. #表信息
  9. class Meta:
  10. #设置表名
  11. db_table="tb_students"
  12. verbose_name="学生"
  13. verbose_name_plural = verbose_name
  14. #模型的操作方法
  15. def __str__(self):
  16. return self.name
  1. - 创建序列化器<br />在students应用目录中新建serializers.py用于保存该应用的序列化器<br />创建一个StudentModelSerializer用于序列化和反序列化
  2. ```python
  3. #创建序列化器,在视图中调用该类
  4. from rest_framework import serializers
  5. from .models import Student
  6. class StudentModelSerializer(serializers.ModelSerializer):
  7. #创建一个学生信息的序列化器 类
  8. #模型序列化器相关声明
  9. class Meta:
  10. model = Student
  11. fields ="all"
  12. # model 指明该序列化器处理的数据字段从模型类studnet生成
  13. # fields 指明该序列化器包含模型类中的哪些字段,all代表包含所有
  • 编写视图
    在students应用的views.py中创建视图 StudentsViewSet,这是一个视图集合
    ```python from rest_framework.viewsets import ModelViewSet from .models import Student from .serializers import StudentModelSerializer

class StudentViewSet(ModelViewSet): queryset = Student.object.all() serializer_class = StudentModelSerializer

queryset 指明该视图集在查询数据时使用的数据集

serializer_class 指明该视图在进行序列化或者反序列化时使用的序列化器

  1. - 定义路由<br />在students应用的urls.py中定义路由信息
  2. ```python
  3. from . import views
  4. from django.urls import path.re_path
  5. from rest_framework.routers import DefaultRouter
  6. #路由列表
  7. urlpatterns = []
  8. #可以处理视图的路由器
  9. router = DefaultRouter()
  10. #向路由器中注册视图集
  11. router.register('studnets',views.StudnetviewSet)
  12. #将路由器中的所有路由信息追加到django的路由列表中
  13. urlpatterns += router.urls
  • 网页访问应用

序列化器-Serializer

  • 序列化,序列化器会把模型对象转换成字典,将来提供给视图经过response以后变成json字符串
  • 反序列化,把客户端发送过来的数据,经过视图调用request以后变成python字典,序列化器可以把字典转换成模型
  • 反序列化,完成数据校验功能和操作数据库
  • serializer不是只能为数据库模型定义类,也可以为非数据库模型类的数据定义,serializer是独立于数据库之外的存在

序列化器使用阶段:

  1. 在客户端请求的时候,使用序列化器可以完成对数据的反序列化
  2. 在服务端响应时,使用序列化器可以完成对数据的序列化

序列化器支持的数据格式:

数据格式 字段构造方式
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)
RegeField 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_lenght 最小长度
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页面时,显示的字段帮助提示信息

定义序列化器

django REST framework 中的Serializer使用类来定义,必须继承rest_framework.serializers.Serializer

  1. 1.在应用中新建 serializers.py文件 用来存放序列化器类
  2. import rest_framework import serializers
  3. class StudentSerializer(serializers.Serializer):
  4. #需要进行转换的字段,都写在该类中,接收来自模型的数据进行转换,模型中的name字段转换成CharField格式
  5. name = serializers.CharField()
  6. 2.在视图中创建类
  7. from django.views import View
  8. from serializers import StudentSerializer #引入写的序列化器类
  9. from django.http.response import HttpResponse
  10. from students.models import Student #引入写的模型类,用于查询数据,传给序列化器
  11. from django.http.response import JsonResponse
  12. class StudentView(View):
  13. def get(self,request):
  14. #根据模型类获取所有的数据,也可以获取某条数据
  15. student_list = Student.objects.all()
  16. #实例化序列化器,创建序列化器对象
  17. serializer = StudentSerializerinstance=student_list,data=,context=,many=True
  18. #instance 模型对象或者模型列表
  19. #data 进行反序列化阶段使用的数据,数据来自于客户端的提交
  20. #context 当需要从视图中转发数据到序列化器时,可以使用
  21. #many 当instance参数为模型列表时,则many值必须为True,表示传递的参数是多个
  22. print(serializer.data)
  23. 转换后的数据放在序列化器对象.data
  24. #【0rderedDict([(name:XXX)]),0rderedDict([(name:ccc)])】
  25. #0rderedDict python内置的高级数据类型,有序字典
  26. # from collection import 0rderedDict
  27. print(student_list)
  28. #<QuerySet [<studnet:xxx>,<Studnet:ccc>]>
  29. return JsonResponse(serializer.data,safe=False)
  30. #JsonResponse不识别列表,所以加上safe=False

创建Serializer对象

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

Serializer的构造方法为:

  1. Serializer(instance=None, data=empty, **kwarg)

说明:

  • 用于序列化时,将模型类对象传入instance参数
  • 用于反序列化时,将要被反序列化的数据传入data参数
  • 除了instance和data参数外,在构造Serializer对象时,还可通过context参数额外添加数据,如
  1. serializer = AccountSerializer(account, context={'request': request})

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

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

序列化-基本使用

1) 先查询出一个学生对象

  1. from students.models import Student
  2. student = Student.objects.get(id=3)

2) 构造序列化器对象

  1. from .serializers import StudentSerializer
  2. serializer = StudentSerializer(instance=student)

3)获取序列化数据

通过data属性可以获取序列化后的数据

  1. serializer.data
  2. # {'id': 4, 'name': '小张', 'age': 18, 'sex': True, 'description': '猴赛雷'}

序列化器进行反序列化验证数据

数据验证

开发中,用户的数据是不可信的

使用序列化器进行反序列化时,需要对数据进行验证后,才能获取成功的数据或保存成模型类对象

在获取反序列化的客户端数据前,必须在视图中调用序列化对象的is_valid()方法,序列化器内部是在is_valid方法内部调用验证选项和验证方法进行验证,验证成功返回True,否在返回False

验证失败,可以通过序列化器对象的errors属性获取错误信息,返回字典,包含了字段和字段的错误提示,如果是非字段错误,可以通过修改REST Farmework配置中的NON_FIELD_ERRORS_KEY来控制错误字典中的键名

验证成功,可以通过序列化器对象的validated_data属性获取数据

在定义序列化器时,指明每个字段的序列化类型和选项参数,本身就是一种验证行为

反序列化验证数据案例

客户端传数据过来使用反序列化对数据进行验证

  • 创建新的子应用
  • 创建反序列化器
    ```python 在子应用的目录下新建:serializers.py文件

from rest_framework import serializers

字段验证函数 只能验证一个字段数据

def check_class_num(data): if data ==”404”: raise serializers.ValidationError(“没有404的班级”) return data

class StudentSerializer(serializers.Serializer): name = serializers.CharField(max_length=20,required=True)

  1. #定义的规则检测name是否是字符串类型,并且最大长度20,是必填项,字段内置验证
  2. age = serializers.IntegerField(max_value=100,)
  3. sex = serializers.BooleanField(allow_null=True,default=1)
  4. #validators=[check_class_num],是使用字段验证函数对该字段进行验证
  5. class_num = serializers.CharField(required=True,validators=[check_class_num])
  6. description = serializers.CharField(allow_null=True,allow_blank=True)
  7. #字段验证方法 :validate() 验证所有字段,validate_字段名()验证单个字段,字段名必须是上面定义的名字
  8. def validate_name(self,attrs):
  9. if attrs =="王"
  10. #抛出错误
  11. raise serializers.ValidationError("错误信息")
  12. #每次验证完成以后,必须要返回数据,返回的就是传过来的数据,当然可以修改后返回,不返回会数据丢失
  13. return attrs
  14. def validate(self,attrs):
  15. #attrs接收的是,视图中实例化序列化器对象的时候传入的数据,此案例中是data
  16. if attrs.get("age") >60 and attrs.get('sex')==1:
  17. raise serializers.ValidationError("错误信息")
  18. return attrs

单个字段的校验优先级比多个字段的优先级高

“”” 视图中的序列化器对象在传递数据的时候 ,必填字段是必须传递的也就是我们定义的规则中有required=True的必须传,否则会抛出验证异常,我们可以使用partial参数来允许部分字段的更新,

如: 在视图中实例化序列化器对象的时候添加该参数: serializer = StudentSerializer(studnet,data,partial=True) partial=True 是设置序列化器只针对客户端提交的字段进行验证,没有提交的字段即使有验证选项和方法也不进行验证,客户端没提交的那些就默认通过,当然数据库中的字段规则设置也要是允许该字段为空否则会报错

“””

在视图文件中编写类:

from django.Views import View from django.http.response import HttpResponse

class StudentView(View): def post(self,request): print(request.body) import json data = json.loads(request.body)

  1. #反序列化
  2. #1.实例化序列化器对象
  3. serialiser = StudentSerializer(data = data)
  4. #2.调用验证方法,验证客户端传来的数据和序列化器类中的定义规则是否符合,通过返回True,失败返回False,raise_exception=True是指如果验证失败,以后的代码就不执行了,直接抛出错误
  5. """
  6. is_valid实际上内部执行了三种不同的验证方式
  7. 1.先执行字段内置的验证选项
  8. 2.再执行字段验证函数
  9. 3.最后执行validate自定义验证方法,包括validate_字段,validate
  10. """
  11. ret = serializer.is_valid(raise_exception=True)
  12. #验证成功后,将通过验证的信息存放在validated_data中
  13. serializer.validated_data
  14. #验证失败的错误信息存在
  15. serializer.errors
  16. return HttpResponse("OK")
  1. <a name="9f7e9f84"></a>
  2. #### 使用序列化器进行反序列化阶段操作数据库
  3. 数据保存
  4. 通过序列化器完成数据的更新或者添加,把视图中对于模型中的操作代码移出视图,放入序列化器
  5. 前面的验证数据成功后,可以使用序列化器完成数据反序列化的过程,这个过程可以把数据转成模型类对象
  6. 可以通过create()和update()两个方法来实现,是定义在序列化器类中的,必须是create和update名
  7. ```python
  8. ''#序列化器文件中
  9. from .models import Student
  10. class StudentSerializer(serializers.Serializer):
  11. def create(self,validate_data):
  12. #添加数据
  13. #validate_data接收的是数据验证成功后传过来的数据,自动传的
  14. #models语法进行数据库的操作
  15. ret = Studnet.objects.create(
  16. **validated_data
  17. )
  18. return ret
  19. #把添加的结果返回
  20. #接下来就可以在视图中使用 serializer.save(),会自动调用序列化器内的create()方法或者update()方法
  21. def update(self,instance,validated_data):
  22. #更新数据
  23. #instances是更新的模型是哪个,也就是models类是哪个,validated_data是更新的数据]
  24. #validated_data传递过来几个参数就要更新几个参数
  25. #validated_data是验证成后的数据,都是自动传参的
  26. instance.name = validated_data.get("name")
  27. instance.age = validated_data.get("age")
  28. #这是模型的save和序列化中的save是不一样的
  29. instance.save()
  30. return ret
  31. #视图文件中
  32. from django.Views import View
  33. from django.http.response import HttpResponse
  34. class StudentView(View):
  35. def put(self,request):
  36. """修改数据"""
  37. import json
  38. data = json.loads(request.body)
  39. id = data.get('id')
  40. student = Student.objects.get(pk=id)
  41. #创建序列化器对象,此时数据是还没有更新的
  42. serializer = SudentSerializer(instance=student,data=data)
  43. serializer.is_valid(raise_exception=True)
  44. #会调用序列器的update方法,具体的更新在update方法中写
  45. #serializer.save()会根据我们是否传入instance来判断是调用create还是update,传入了instance则是updata,没传则是create
  46. serializer.save()
  47. """
  48. 在对序列化器进行save保存时,可以传递额外的数据,这些数据可以在create()和update()中的validated_data中获取到
  49. 如:
  50. request.user是django中记录当前登陆用户的模型对象
  51. serializer.save(owner=request.user)
  52. """

序列化器操作数据库附加参数说明

  • 对序列化器进行save()保存时,可以额外传递数据,这些数据可以在create()和update()中的validated_data中获取到
  1. 可以传递任意参数到数据保存方法中
  2. 如:request.user django中记录当前登录用户的模型对象
  3. serializer.save(owner=request.user)
  • 默认序列化器必须传递所有必填字段[required=True],否则会抛出异常验证,但是可以使用partial参数来允许部分字段更新
  1. #update BookInfo with partial data
  2. partial =True 设置序列化器只是针对客户端提交的字段进行验证,没有提交的字段,即使有验证选项或方法也不进行验证,设置此字段的时候要在模型类中定义的字段要允许字段为空,也就是定义的字段要有null=True
  3. serializer = BookInfoSerializer(book,data=data,partial=True)

模型类的序列化器

如果我们想要使用的序列化器对应的是Django的模型类,DRF为我们提供了ModelSerializer模型类序列化器来帮助我们快速创建一个Serializer类

ModelSerializer与常规的Serializer相同,但是提供了

  • 基于模型类自动生成一系列序列化器字段
  • 基于模型类自动为Serializer生成validators,如unique_together
  • 包含默认默认的create()和update()的实现

定义模型类序列化器

  1. class BookInfoSerializer(serializers.ModelSerializer):
  2. #图书数据序列化器
  3. #也可以定义字段声明
  4. token = serializers.CharField(read_only=True,default='abc')
  5. #模型声明
  6. class Meta:
  7. model=BookInfo
  8. #调用模型所有字段
  9. fields = '__all__'
  10. #fields = ["id","name","age"]
  11. #read_only_fields表示设置模型中那些字段属于只读类型,对于不在模型中的字段无效
  12. read_only_fields=["id",'name']
  13. #添加额外的属性,相当于定义的字段声明
  14. extra_kwargs={
  15. 'token':{'read_only':True},
  16. 'age':{"min_value":1."max_value":100}
  17. }
  18. """
  19. model 指明参考那个模型类
  20. fields 指明为模型类的那些字段生成
  21. """

指定字段

  • 使用fields来明确字段,__all__表名包含所有字段,也可以写明具体哪些字段,如
  1. class BookInfoSerializer(serializers.ModelSerializer):
  2. """图书数据序列化器"""
  3. class Meta:
  4. model = BookInfo
  5. fields = ('id', 'btitle', 'bpub_date')
  • 使用exclude可以明确排除掉哪些字段
  1. class BookInfoSerializer(serializers.ModelSerializer):
  2. """图书数据序列化器"""
  3. class Meta:
  4. model = BookInfo
  5. exclude = ('image',)
  • 显示指明字段,如:
  1. class HeroInfoSerializer(serializers.ModelSerializer):
  2. hbook = BookInfoSerializer()
  3. class Meta:
  4. model = HeroInfo
  5. fields = ('id', 'hname', 'hgender', 'hcomment', 'hbook')
  • 指明只读字段

可以通过read_only_fields指明只读字段,即仅用于序列化输出的字段

  1. class BookInfoSerializer(serializers.ModelSerializer):
  2. """图书数据序列化器"""
  3. class Meta:
  4. model = BookInfo
  5. fields = ('id', 'btitle', 'bpub_date' 'bread', 'bcomment')
  6. read_only_fields = ('id', 'bread', 'bcomment')

添加额外参数

我们可以使用extra_kwargs参数为ModelSerializer添加或修改原有的选项参数

  1. class BookInfoSerializer(serializers.ModelSerializer):
  2. """图书数据序列化器"""
  3. class Meta:
  4. model = BookInfo
  5. fields = ('id', 'btitle', 'bpub_date', 'bread', 'bcomment')
  6. extra_kwargs = {
  7. 'bread': {'min_value': 0, 'required': True},
  8. 'bcomment': {'min_value': 0, 'required': True},
  9. }
  10. # BookInfoSerializer():
  11. # id = IntegerField(label='ID', read_only=True)
  12. # btitle = CharField(label='名称', max_length=20)
  13. # bpub_date = DateField(allow_null=True, label='发布日期', required=False)
  14. # bread = IntegerField(label='阅读量', max_value=2147483647, min_value=0, required=True)
  15. # bcomment = IntegerField(label='评论量', max_value=2147483647, min_value=0, required=True)

http请求与响应

drf除了在数据序列化部分简写代码以外,还在试图中提供了简写操作,所以在django原有的django.views.View类基础上,drf封装了多个视图子类提供使用

Django REST Framework提供的试图的主要作用:

  • 控制序列化器的执行(检验,保存,转换数据)
  • 控制数据库查询的执行
  • 调用请求类和响应类,这两个类也是由drf帮我们再次扩展了一些功能类。

Request

  1. rest_framework.request.Request

REST Framework传入视图的request对象不再是Django默认的HTTP Request对象,而是在REST Framework提供的扩展了HTTP Request类的Request类的对象,在drf中原生的django的http请求对象,通过request._request调用

REST Framework提供了Parser解析器,在接受请求后会自动根据Content-Type指明的请求数据类型如json 表单等将请求数据进行parse解析,解析为Query Dict对象保存到Request对象中

Request对象的数据是自动根据前端发送数据的格式进行解析之后的结构

无论前端发生的是哪一种数据格式,我们都可以统一的方式读取数据

常用属性

  • .data

request.data返回解析之后的请求体数据,类似于django中标准的request.POST和request.FIELS属性,但是提供如下特性。

  1. 包含了解析之后的文件和非文件数据
  2. 包含了对POST PUT PATCH请求方式解析后的数据
  3. 利用了REST Framework的parse解析器,不仅支持表单类型数据,也支持json数据
  4. 相当于drf的request.data替代了 django的request.POST,request.FILES,request.body、
  • .query_params

request.query_params返回解析之后的查询字符串数据,是字典形式的 query dict,字典形式的我们可以使用.get()和.getlist()进行取值,如:一个键名重复出现多次的时候 get只能查出最后一个值 getlist可以获取所有的值是一个列表

request.query_params.get(“字典中的键”)

request.query_params.getlist(“字典中的键”)

request.query_params与Django原生的request.GET相同,只是更换了更正确的名称而已。

Response

  1. rest_framework.response.Response

REST framework 提供了一个响应类Response,使用该类构造响应对象时,响应的具体数据内容会被转换(renderer渲染器)成符合前端需求的类型

REST framework 提供了Renderer渲染器,用来根据请求头中的Accept(接受数据类型声明)来自动转换响应数据到对应格式,如果前端请求中未生名Accept,则会采用默认的方式处理响应数据,可以通过配置来修改默认响应格式[就是Renderer能通过请求中的Accept查询出客户端支持和希望的数据类型,把视图的结果以客户端能识别的格式返回]

可以在rest_framework.settings.py查找所有的drf默认配置项

  1. REST_FRAMEWORK = {
  2. 'DEFAULT_RENDERER_CLASSES': ( # 默认响应渲染类
  3. 'rest_framework.renderers.JSONRenderer', # json渲染器
  4. 'rest_framework.renderers.BrowsableAPIRenderer', # 浏览器API渲染器
  5. )
  6. }

构造方式

  1. Response(data, status=None, template_name=None, headers=None, content_type=None)
  2. """
  3. data数据不是要renderer处理后的数据,只传递python的内置类型数据就可以,REST Framework 会使用renderer渲染器处理data
  4. data不能是复杂的数据结构,如Django的模型类对象,对于这样的数据可以使用Serializer序列化器进行序列化后,再传递给data
  5. 参数说明
  6. data 为响应准备的序列化处理后的数据
  7. status 状态码默认是200
  8. template_name 模板名称 如果使用HTMLRenderer 时需指明
  9. headers 存放响应头信息的字典
  10. content_type 响应数据的Content-Type,通常此参数无需传递,REST framework会根据前端所需类型数据来设置该参数。
  11. """
  12. from rest_framework .Views import APIView
  13. from rest_framework .response import Response
  14. class StudentAPIView(APIView):
  15. def get(self,request):
  16. response = Response("ok")
  17. #设置cookie
  18. response.set_cookie("username","li")
  19. #设置响应头信息
  20. response['comm']='oldhy'
  21. return response
  22. #使用 rest_framework .response.Response的视图必须继承APIView,否则无法实现相应的效果

常用属性

  • .data

传给response对象的序列化后,但尚未render处理的数据

  • .status_code

状态码的数字

  • .content

经过renderer处理后的响应数据

状态码

方便设置状态码,REST framewrok在rest_framework.status模块中提供了常用状态码常量。

  • 信息告知 - 1xx
  1. HTTP_100_CONTINUE
  2. HTTP_101_SWITCHING_PROTOCOLS
  • 成功 - 2xx
  1. HTTP_200_OK
  2. HTTP_201_CREATED
  3. HTTP_202_ACCEPTED
  4. HTTP_203_NON_AUTHORITATIVE_INFORMATION
  5. HTTP_204_NO_CONTENT
  6. HTTP_205_RESET_CONTENT
  7. HTTP_206_PARTIAL_CONTENT
  8. HTTP_207_MULTI_STATUS
  • 重定向 - 3xx
  1. HTTP_300_MULTIPLE_CHOICES
  2. HTTP_301_MOVED_PERMANENTLY
  3. HTTP_302_FOUND
  4. HTTP_303_SEE_OTHER
  5. HTTP_304_NOT_MODIFIED
  6. HTTP_305_USE_PROXY
  7. HTTP_306_RESERVED
  8. HTTP_307_TEMPORARY_REDIRECT
  • 客户端错误 - 4xx
  1. HTTP_400_BAD_REQUEST
  2. HTTP_401_UNAUTHORIZED
  3. HTTP_402_PAYMENT_REQUIRED
  4. HTTP_403_FORBIDDEN
  5. HTTP_404_NOT_FOUND
  6. HTTP_405_METHOD_NOT_ALLOWED
  7. HTTP_406_NOT_ACCEPTABLE
  8. HTTP_407_PROXY_AUTHENTICATION_REQUIRED
  9. HTTP_408_REQUEST_TIMEOUT
  10. HTTP_409_CONFLICT
  11. HTTP_410_GONE
  12. HTTP_411_LENGTH_REQUIRED
  13. HTTP_412_PRECONDITION_FAILED
  14. HTTP_413_REQUEST_ENTITY_TOO_LARGE
  15. HTTP_414_REQUEST_URI_TOO_LONG
  16. HTTP_415_UNSUPPORTED_MEDIA_TYPE
  17. HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE
  18. HTTP_417_EXPECTATION_FAILED
  19. HTTP_422_UNPROCESSABLE_ENTITY
  20. HTTP_423_LOCKED
  21. HTTP_424_FAILED_DEPENDENCY
  22. HTTP_428_PRECONDITION_REQUIRED
  23. HTTP_429_TOO_MANY_REQUESTS
  24. HTTP_431_REQUEST_HEADER_FIELDS_TOO_LARGE
  25. HTTP_451_UNAVAILABLE_FOR_LEGAL_REASONS
  • 服务器错误 - 5xx
  1. HTTP_500_INTERNAL_SERVER_ERROR
  2. HTTP_501_NOT_IMPLEMENTED
  3. HTTP_502_BAD_GATEWAY
  4. HTTP_503_SERVICE_UNAVAILABLE
  5. HTTP_504_GATEWAY_TIMEOUT
  6. HTTP_505_HTTP_VERSION_NOT_SUPPORTED
  7. HTTP_507_INSUFFICIENT_STORAGE
  8. HTTP_511_NETWORK_AUTHENTICATION_REQUIRED

http请求响应状态码使用案例

  1. 1.新建Django项目创建app
  2. 2.注册路由 注册应用
  3. 3. 在试图文件中编写代码
  4. from rest_framework.views import APIView
  5. from rest_framework.response import Response
  6. from rest_framework import status
  7. class Student1APIView(APIView):
  8. def get(self,request):
  9. #使用Response进行返回数据
  10. response = Response("ok")
  11. #设置cookie
  12. response.set_cookie("username","li")
  13. #设置响应头信息
  14. response['comm']='oldhy'
  15. return response
  16. def get(self,request):
  17. #使用request提取数据
  18. data = request.data
  19. new_data = request.query_params.get("用户传过来的数据字典形式的键")
  20. #使用Response返回状态码
  21. return Response(status=status.HTTP_201_CREATED)

drf 视图

Django REST Framework 提供的视图的主要作用有:

  • 控制序列化器的执行 (检验 保存 转换数据)
  • 控制数据库查询的执行(数据库的删除 查询代码写在视图中 更新和添加写在序列化器中)

REST Framework 提供了众多的通用视图基类与扩展类,用来简化视图的编写

基类

APIView

  1. rest_framework.views.APIView

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

drf的APIView在继承django view的基础上新增了

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

支持定义的类属性

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

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

  1. 举例:
  2. # Create your views here.
  3. """APIView是drf里面提供的所有视图类的父类
  4. APIView提供的功能/属性/方法是最少的,所以使用APIView基本类似我们使用django的View
  5. """
  6. """
  7. GET /students/ 获取多个学生信息
  8. POST /students/ 添加一个学生信息
  9. GET /students/<pk>/ 获取一个学生信息
  10. PUT /students/<pk>/ 修改一个学生信息
  11. DELETE /students/<pk>/ 删除一个学生信息
  12. """
  13. from rest_framework.views import APIView
  14. from students.models import Student
  15. from .serializers import StudentModelSerializer
  16. from rest_framework.response import Response
  17. from rest_framework import status
  18. class Student1APIView(APIView):
  19. def get(self,request):
  20. """获取所有学生信息"""
  21. # 1. 获取学生信息的数据模型
  22. student_list = Student.objects.all()
  23. # 2. 调用序列化器
  24. serializer = StudentModelSerializer(instance=student_list, many=True)
  25. # 3. 返回数据
  26. return Response(serializer.data)
  27. def post(self,request):
  28. """添加一个学生信息"""
  29. # 1. 调用序列化器对用户提交的数据进行验证
  30. serializer = StudentModelSerializer(data=request.data)
  31. serializer.is_valid(raise_exception=True)
  32. # 2. 调用序列化器进行数据库操作
  33. instance = serializer.save() # save()方法返回的是添加成功以后的模型对象
  34. serializer = StudentModelSerializer(instance=instance)
  35. # 3. 返回新增数据
  36. return Response(serializer.data, status=status.HTTP_201_CREATED)
  37. class Student2APIView(APIView):
  38. def get(self,request,pk):
  39. """获取一个学生信息"""
  40. # 1. 根据pk获取模型对象
  41. student = Student.objects.get(pk=pk)
  42. # 2. 序列化器转换数据
  43. serializer = StudentModelSerializer(instance=student)
  44. # 3. 响应数据
  45. return Response(serializer.data)
  46. def put(self,request,pk):
  47. """修改一个学生信息"""
  48. # 1. 通过pk查询学生信息
  49. student = Student.objects.get(pk=pk)
  50. # 3. 调用序列化器对客户端发送过来的数据进行验证
  51. serializer = StudentModelSerializer(instance=student, data=request.data)
  52. serializer.is_valid(raise_exception=True)
  53. # 4. 保存数据
  54. instance = serializer.save() #?这里实际上调用的序列化器里面的update方法
  55. serializer = StudentModelSerializer(instance=instance)
  56. # 5. 返回结果
  57. return Response(serializer.data, status=status.HTTP_201_CREATED)
  58. def delete(self, request, pk):
  59. # 1. 通过pk查询学生信息
  60. Student.objects.get(pk=pk).delete()
  61. return Response({"message":"ok"}, status=status.HTTP_204_NO_CONTENT)
  62. #路由分发
  63. urlpatterns = [
  64. path('asview', 视图中的类名.as_view())
  65. ]
  66. as_view()可以根据客户端的请求方法自动去视图中的类去匹配相应的方法名,并执行该方法,如客户端使用的get方法进行请求,则匹配到的是视图类中的get方法

GenericAPIView

通过视图类主要作用就是把视图中独特的代码抽取出来,让视图方法中的代码更加通用,方便把通用代码进行简写

  1. rest_framework.generics.GenericAPIView

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

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

  • serializer_class 属性

指明视图使用的序列化器是哪一个

  • get_serializer_class(self)方法

当出现一个类视图中调用多个序列化器时候,可以通过条件判断在get_serializer_class方法中返回不同序列化器的类名,就可以让视图方法执行不同的序列化器对象了

返回序列化器类,默认返回的是serializer_class可以重写get_serializer_class(self)方法

如:

  1. def get_serializer_class(self):
  2. if self.request.method == 'get':
  3. return getSerializer
  4. return postSerializer
  • get_serializer(self,args,*kwargs)方法

返回值是序列化器对象,就是返回get_serializer_class中返回的那个序列化器对象,主要用来提供给Mixin扩展类使用,如果我们在视图中想要获取序列化器对象,可以直接调用该方法

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

requets: 当前视图的请求对象

view:当前请求的类视图对象

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

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

  • query_set属性

指明使用的数据查询集合

  • get_queryset(self)方法

返回视图使用的查询集,主要用来提供给Mixin扩展类使用,是列表视图与详情视图获取数据的基础,默认返回queryset属性,可以重写。

如:

  1. def get_queryset(self):
  2. user = self.request.user
  3. return user.accounts.all()
  • get_object(self)方法

返回单个视图模型类对象,主要是用来给Mixin扩展类使用

在视图中可以调用该方法获取单条详情信息的模型类对象

如详情信息的模型类对象不在会返回404

该方法会默认使用APIView提供的check_object_permissions方法检查当前对象是否有权限被访问

如:

  1. # url(r'^books/(?P<pk>\d+)/$', views.BookDetailView.as_view()),
  2. class BookDetailView(GenericAPIView):
  3. queryset = BookInfo.objects.all()
  4. serializer_class = BookInfoSerializer
  5. def get(self, request, pk):
  6. book = self.get_object() # get_object()方法根据pk参数查找queryset中的数据对象
  7. serializer = self.get_serializer(book)
  8. return Response(serializer.data)
  • pagination_class属性

指明分页控制类

  • fiter_backends属性

指明过滤控制后端

GenericAPIView属性方法案例

  1. 案例1
  2. from rest_framework.response import Response
  3. from rest_framework import status
  4. from rest_framework.generics import GenericAPIView
  5. from students.models import Student
  6. from students.serializers import StudentModelSerializer,Student2ModelSerializer
  7. class Student1APIView(GenericAPIView):
  8. # 用于指定当前视图类中使用的默认序列化器
  9. serializer_class = StudentModelSerializer
  10. # 用于指定当前视图类中使用的数据集
  11. queryset = Student.objects.all()
  12. # get_serializer_class 这个方法主要的作用就是提供给开发者需要在同一个视图类中调用多个序列化器时进行重写时使用的.
  13. def get_serializer_class(self):
  14. if self.request.method.lower() == "get":
  15. return Student2ModelSerializer
  16. else:
  17. return StudentModelSerializer
  18. def get(self,request):
  19. """获取多条"""
  20. # serializer = self.serializer_class(instance=self.queryset.all(),many=True)
  21. serializer = self.get_serializer(instance=self.get_queryset(),many=True)
  22. return Response(serializer.data)
  23. def post(self,request):
  24. """添加信息"""
  25. serialzier = self.get_serializer(data=request.data,context={})
  26. serialzier.is_valid(raise_exception=True)
  27. serialzier.save()
  28. return Response(serialzier.data)
  29. class Student2APIView(GenericAPIView):
  30. serializer_class = StudentModelSerializer
  31. # 面向对象中, 类属性的值不能出现变量赋值的情况,一定要具体的代码逻辑或者具体值
  32. queryset = Student.objects.all()
  33. def get(self,request,pk):
  34. """获取一条数据"""
  35. # serializer = self.serializer_class(instance=self.queryset.get(pk=pk))
  36. serializer = self.get_serializer(instance=self.get_object())
  37. return Response(serializer.data)
  38. def put(self,request,pk):
  39. serializer = self.get_serializer(instance=self.get_object(), data=request.data)
  40. serializer.is_valid(raise_exception=True)
  41. serializer.save()
  42. return Response(serializer.data)
  43. def delete(self,request,pk):
  44. self.get_object().delete()
  45. return Response(status=status.HTTP_204_NO_CONTENT)
  1. 案例2
  2. from rest_framework.generics import GenericAPIView
  3. from students.models import Student
  4. from .serializers import StudentModelSerializer, StudentModel2Serializer
  5. from rest_framework.response import Response
  6. class StudentsGenericAPIView(GenericAPIView):
  7. # 本次视图类中要操作的数据[必填],就是模型类查询出的数据
  8. queryset = Student.objects.all()
  9. # 本次视图类中要调用的默认序列化器[选填],当类继承GenericAPIView的时候必须声明serializer_class
  10. serializer_class = StudentModelSerializer
  11. def get(self, request):
  12. """获取所有学生信息"""
  13. serializer = self.get_serializer(instance=self.get_queryset(), many=True)
  14. return Response(serializer.data)
  15. def post(self,request):
  16. data = request.data
  17. serializer = self.get_serializer(data=data)
  18. serializer.is_valid(raise_exception=True)
  19. instance = serializer.save()
  20. serializer = self.get_serializer(instance=instance)
  21. return Response(serializer.data)
  22. class StudentGenericAPIView(GenericAPIView):
  23. queryset = Student.objects.all()
  24. serializer_class = StudentModelSerializer
  25. def get_serializer_class(self):
  26. """重写获取序列化器类的方法"""
  27. if self.request.method == "GET":
  28. return StudentModel2Serializer
  29. else:
  30. return StudentModelSerializer
  31. # 在使用GenericAPIView视图获取或操作单个数据时,视图方法中的代表主键的参数最好是pk
  32. def get(self,request,pk):
  33. """获取一条数据"""
  34. serializer = self.get_serializer(instance=self.get_object())
  35. return Response(serializer.data)
  36. def put(self,request,pk):
  37. data = request.data
  38. serializer = self.get_serializer(instance=self.get_object(),data=data)
  39. serializer.is_valid(raise_exception=True)
  40. serializer.save()
  41. serializer = self.get_serializer(instance=self.get_object())
  42. return Response(serializer.data)
  43. 序列化器类:
  44. from rest_framework import serializers
  45. from students.models import Student
  46. class StudentModelSerializer(serializers.ModelSerializer):
  47. class Meta:
  48. model= Student
  49. fields = "__all__"
  50. class StudentModel2Serializer(serializers.ModelSerializer):
  51. class Meta:
  52. model= Student
  53. fields = ("name","class_null")

扩展类

  • ListModeMixin

列表视图扩展类,提供了list(request,args,*kwargs)方法快速实现列表视图,返回200状态码

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

源代码:

  1. class ListModelMixin(object):
  2. """
  3. List a queryset.
  4. """
  5. def list(self, request, *args, **kwargs):
  6. # 过滤
  7. queryset = self.filter_queryset(self.get_queryset())
  8. # 分页
  9. page = self.paginate_queryset(queryset)
  10. if page is not None:
  11. serializer = self.get_serializer(page, many=True)
  12. return self.get_paginated_response(serializer.data)
  13. # 序列化
  14. serializer = self.get_serializer(queryset, many=True)
  15. return Response(serializer.data)

案例:

  1. from rest_framework.mixins import ListModelMixin
  2. class BookListView(ListModelMixin, GenericAPIView):
  3. queryset = BookInfo.objects.all()
  4. serializer_class = BookInfoSerializer
  5. def get(self, request):
  6. #提供的list方法
  7. return self.list(request)
  • CreateModelMixin

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

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

源码:

  1. class CreateModelMixin(object):
  2. """
  3. Create a model instance.
  4. """
  5. def create(self, request, *args, **kwargs):
  6. # 获取序列化器
  7. serializer = self.get_serializer(data=request.data)
  8. # 验证
  9. serializer.is_valid(raise_exception=True)
  10. # 保存
  11. self.perform_create(serializer)
  12. headers = self.get_success_headers(serializer.data)
  13. return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
  14. def perform_create(self, serializer):
  15. serializer.save()
  16. def get_success_headers(self, data):
  17. try:
  18. return {'Location': str(data[api_settings.URL_FIELD_NAME])}
  19. except (TypeError, KeyError):
  20. return {}

案例:

  1. class BookDetailView(RetrieveModelMixin, GenericAPIView):
  2. queryset = BookInfo.objects.all()
  3. serializer_class = BookInfoSerializer
  4. def post(self, request):
  5. return self.create(request)
  • RetrieveModelMixin

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

如果存在,返回200,否则返回404

源码:

  1. class RetrieveModelMixin(object):
  2. """
  3. Retrieve a model instance.
  4. """
  5. def retrieve(self, request, *args, **kwargs):
  6. # 获取对象,会检查对象的权限
  7. instance = self.get_object()
  8. # 序列化
  9. serializer = self.get_serializer(instance)
  10. return Response(serializer.data)

案例:

  1. class BookDetailView(RetrieveModelMixin, GenericAPIView):
  2. queryset = BookInfo.objects.all()
  3. serializer_class = BookInfoSerializer
  4. def get(self, request, pk):
  5. return self.retrieve(request)
  • UpdateModelMixin

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

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

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

源码:

  1. class UpdateModelMixin(object):
  2. """
  3. Update a model instance.
  4. """
  5. def update(self, request, *args, **kwargs):
  6. partial = kwargs.pop('partial', False)
  7. instance = self.get_object()
  8. serializer = self.get_serializer(instance, data=request.data, partial=partial)
  9. serializer.is_valid(raise_exception=True)
  10. self.perform_update(serializer)
  11. if getattr(instance, '_prefetched_objects_cache', None):
  12. # If 'prefetch_related' has been applied to a queryset, we need to
  13. # forcibly invalidate the prefetch cache on the instance.
  14. instance._prefetched_objects_cache = {}
  15. return Response(serializer.data)
  16. def perform_update(self, serializer):
  17. serializer.save()
  18. def partial_update(self, request, *args, **kwargs):
  19. kwargs['partial'] = True
  20. return self.update(request, *args, **kwargs)

案例:

  1. class Student4APIView(UpdateModelMixin,GenericAPIView):
  2. serializer_class = StudentModelSerializer
  3. queryset = Student.objects.all()
  4. def put(self,request,pk):
  5. return self.update(request,pk)
  • DestroyModelMixin

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

成功返回204 不存在返回404

源码:

  1. class DestroyModelMixin(object):
  2. """
  3. Destroy a model instance.
  4. """
  5. def destroy(self, request, *args, **kwargs):
  6. instance = self.get_object()
  7. self.perform_destroy(instance)
  8. return Response(status=status.HTTP_204_NO_CONTENT)
  9. def perform_destroy(self, instance):
  10. instance.delete()

案例:

  1. class Student4APIView(DestroyModelMixin,GenericAPIView):
  2. serializer_class = StudentModelSerializer
  3. queryset = Student.objects.all()
  4. def delete(self,request,pk):
  5. return self.destroy(request,pk)

扩展类综合案例:

  1. """GenericAPIView结合视图扩展类实现api接口"""
  2. from rest_framework.mixins import ListModelMixin,CreateModelMixin
  3. class Students2GenericAPIView(GenericAPIView,ListModelMixin,CreateModelMixin):
  4. # 本次视图类中要操作的数据[必填]
  5. queryset = Student.objects.all()
  6. # 本次视图类中要调用的默认序列化器[选填]
  7. serializer_class = StudentModelSerializer
  8. def get(self, request):
  9. """获取多个学生信息"""
  10. return self.list(request)
  11. def post(self,request):
  12. """添加学生信息"""
  13. return self.create(request)
  14. from rest_framework.mixins import RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin
  15. class Student2GenericAPIView(GenericAPIView,RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin):
  16. queryset = Student.objects.all()
  17. serializer_class = StudentModelSerializer
  18. # 在使用GenericAPIView视图获取或操作单个数据时,视图方法中的代表主键的参数最好是pk
  19. def get(self,request,pk):
  20. """获取一条数据"""
  21. return self.retrieve(request,pk)
  22. def put(self,request,pk):
  23. """更新一条数据"""
  24. return self.update(request,pk)
  25. def delete(self,request,pk):
  26. """删除一条数据"""
  27. return self.destroy(request,pk)

GenericAPIView的视图子类

  1. 由视图扩展类和通用视图类还可以进行组合,产生新的视图这些视图子类,可以让我们开发基本的API接口变得更加简单
  • CreateAPIView

提供post方法

继承自 GenericAPIView、CreateModelMixin

  • ListAPIView

提供 get 方法

继承自:GenericAPIView、ListModelMixin

  • RetrieveAPIView

提供 get 方法

继承自: GenericAPIView、RetrieveModelMixin

  • DestoryAPIView

提供 delete 方法

继承自:GenericAPIView、DestoryModelMixin

  • UpdateAPIView

提供 put 和 patch 方法

继承自:GenericAPIView、UpdateModelMixin

  • RetrieveUpdateAPIView

提供 get、put、patch方法

继承自: GenericAPIView、RetrieveModelMixin、UpdateModelMixin

  • RetrieveUpdateDestoryAPIView

提供 get、put、patch、delete方法

继承自:GenericAPIView、RetrieveModelMixin、UpdateModelMixin、DestoryModelMixin

案例 :

  1. 视图文件中:
  2. class Student6APIView(RetrieveUpdateDestroyAPIView):
  3. serializer_class = StudentModelSerializer
  4. queryset = Student.objects.all()
  5. #在想使用哪些方法的时候直接继承该类就可以了,该类的基类中帮我们提供了处理代码,我们是需要使用就可以了,但是要指明使用的序列化器和处理的数据集

视图集VIewSet

为了让视图代码变得更加简短,drf提供了视图集,视图集允许开发者自定义类视图的方法名,还允许为一个类分配多个不同的路由,从而让操作同一个模型的视图方法写在一个视图类中

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

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

ViewSet视图集类不再是get(),post()等方法,而是实现动作action 如:list(),create()等

视图集只在使用as_view()方法进行路由分发的时候,才会将action动作与具体请求方式对应上 ,就是将客户端的请求方法与视图类中的方法进行对应

如:

  1. class BookInfoViewSet(viewsets.ViewSet):
  2. def list(self, request):
  3. books = BookInfo.objects.all()
  4. serializer = BookInfoSerializer(books, many=True)
  5. return Response(serializer.data)
  6. def retrieve(self, request, pk=None):
  7. try:
  8. books = BookInfo.objects.get(id=pk)
  9. except BookInfo.DoesNotExist:
  10. return Response(status=status.HTTP_404_NOT_FOUND)
  11. serializer = BookInfoSerializer(books)
  12. return Response(serializer.data)

在设置路由时,可以进行如下操作:

  1. urlpatterns = [
  2. url(r'^books/$', BookInfoViewSet.as_view({'get':'list'}),#当客户端请求是get方法且路由可以匹配上,就去执行BookInfoViewSet视图类的list方法
  3. url(r'^books/(?P<pk>\d+)/$', BookInfoViewSet.as_view({'get': 'retrieve'})
  4. ]

常见的视图集父类

  • ViewSet

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

ViewSet主要通过继承ViewSetMixin来实现在调用as_view()时传入字典的映射来处理工作

在VIewSet中,没有提供任何动作 action方法,需要我们自己实现action方法,就是需要自己在视图类中写处理逻辑

  • GenericViewSet

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

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

如:

  1. from rest_framework.viewsets import GenericViewSet
  2. from rest_framework.mixins import ListModelMixin,CreateModelMixin,RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin
  3. class
  4. Student4ViewSet(GenericViewSet,ListModelMixin,CreateModelMixin,RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin):
  5. queryset = Student.objects.all()
  6. serializer_class = StudentModelSerializer

url配置

  1. urlpatterns = [
  2. path("students7/", views.Student4ViewSet.as_view({"get": "list", "post": "create"})),
  3. re_path("students7/(?P<pk>\d+)/", views.Student4ViewSet.as_view({"get": "retrieve","put":"update","delete":"destroy"})),
  4. ]
  • ModelViewSet

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

  • ReadOnlyModelViewSet

继承自GenericViewSet,同时包括了ListModelMixin、RetrieveModelMixin。

视图集中定义附加action动作

在视图集中,处理上述默认的方法动作外还可以添加自定义动作

如:

  1. from rest_framework.viewsets import ModelViewSet,ReadOnlyModelViewSet
  2. class StudentModelViewSet(ModelViewSet):
  3. queryset = Student.objects.all()
  4. serializer_class = StudentModelSerializer
  5. def login(self,request):
  6. """学生登录功能"""
  7. return Response({"message":"登录成功"})

url配置

  1. urlpatterns = [
  2. path("students8/", views.StudentModelViewSet.as_view({"get": "list", "post": "create"})),
  3. re_path("students8/(?P<pk>\d+)/",
  4. views.StudentModelViewSet.as_view({"get": "retrieve", "put": "update", "delete": "destroy"})),
  5. path("stu/login/",views.StudentModelViewSet.as_view({"get":"login"}))
  6. ]

action属性

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

如:

  1. from rest_framework.viewsets import ModelViewSet
  2. from students.models import Student
  3. from .serializers import StudentModelSerializer
  4. from rest_framework.response import Response
  5. class StudentModelViewSet(ModelViewSet):
  6. queryset = Student.objects.all()
  7. serializer_class = StudentModelSerializer
  8. def get_new_5(self,request):
  9. """获取最近添加的5个学生信息"""
  10. # 操作数据库
  11. print(self.action) # 获取本次请求的视图方法名
  12. 通过路由访问到当前方法中.可以看到本次的action就是请求的方法名

路由

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

REST Framework提供了两个router

  • SimpleRouter
  • DefaultRouter

使用方法

  • 创建router对象 并注册视图集
  1. URLS 文件中:
  2. from rest_framework import routers
  3. router = routers.DefaultRouter()
  4. router.register(r'router_stu', StudentModelViewSet, base_name='student')
  5. #
  6. 如上述代码会形成的路由如下
  7. ^router_stu/$ name: student-list
  8. ^router_stu/{pk}/$ name: student-detail

register(prefix, viewset, base_name)

prefix 该视图集的路由前缀

viewset 视图集

base_name 路由别名的前缀

  • 添加路由数据

就是添加到路由列表中‘

  1. urlpatterns = [
  2. ...
  3. ]
  4. urlpatterns += router.urls
  5. urlpatterns = [
  6. ...
  7. url(r'^', include(router.urls))
  8. ]
  9. 两种都可以

路由使用案例:

  1. 视图文件:
  2. from rest_framework.viewsets import ModelViewSet,ReadOnlyModelViewSet
  3. class StudentModelViewSet(ModelViewSet):
  4. queryset = Student.objects.all()
  5. serializer_class = StudentModelSerializer
  6. def login(self,request):
  7. """学生登录功能"""
  8. print(self.action)
  9. return Response({"message":"登录成功"})
  10. 路由文件:
  11. from django.urls import path, re_path
  12. from . import views
  13. urlpatterns = [
  14. ...
  15. ]
  16. """使用drf提供路由类router给视图集生成路由列表"""
  17. # 实例化路由类
  18. # drf提供一共提供了两个路由类给我们使用,他们用法一致,功能几乎一样
  19. from rest_framework.routers import DefaultRouter
  20. router = DefaultRouter()
  21. # 注册视图集
  22. # router.register("路由前缀",视图集类)
  23. router.register("router_stu",views.StudentModelViewSet)
  24. # 把生成的路由列表追加到urlpatterns
  25. print( router.urls )
  26. urlpatterns += router.urls

上面的代码就成功生成了路由地址[增/删/改/查一条/查多条的功能],但是不会自动我们在视图集自定义方法的路由。

所以我们如果也要给自定义方法生成路由,则需要进行action动作的声明

视图集中附加action的声明

在视图集中,如果想要让Router自动帮助我们为自定义的动作生成路由信息,需要使用 rest_framework.decorators.action装饰器

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

action装饰器可以接收两个参数

  • methods 声明该action对应的请求方式,列表传递
  • detail
  1. 声明该action的路径是否与单一资源对应,就是是否可以携带pk
  2. xxx/<pk>/action方法名/
  3. True 表示路径格式是xxx/<pk>/action方法名/
  4. False 表示路径格式是xxx/action方法名/

如:

  1. from rest_framework.viewsets import ModelViewSet
  2. from rest_framework.decorators import action
  3. class StudentModelViewSet(ModelViewSet):
  4. queryset = Student.objects.all()
  5. serializer_class = StudentModelSerializer
  6. # methods 设置当前方法允许哪些http请求访问当前视图方法
  7. # detail 设置当前视图方法是否是操作一个数据
  8. # detail为True,表示路径名格式应该为 router_stu/{pk}/login/
  9. @action(methods=['get'], detail=True)
  10. def login(self, request,pk):
  11. """登录"""
  12. ...
  13. # detail为False 表示路径名格式应该为 router_stu/get_new_5/
  14. @action(methods=['put'], detail=False)
  15. def get_new_5(self, request):
  16. """获取最新添加的5个学生信息"""
  17. #路由生成的信息如下:
  18. ^router_stu/get_new_5/$ name: router_stu-get_new_5
  19. ^router_stu/{pk}/login/$ name: router_stu-login

路由router形成url的方式

SimpleRouter

8.drf框架 - 图4

DefaultRouter

8.drf框架 - 图5

DefaultRouter与SimpleRouter的区别是,DefaultRouter会多附带一个默认的API根视图,返回一个包含所有列表视图的超链接响应数据。

DRF框架常用的组件

认证Authentication

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

site-packages/rest_framework/settings.py

  1. # 可以在项目的主应用的settings.py配置文件中加入以下配置覆盖全局默认的配置方案。
  2. REST_FRAMEWORK = {
  3. 'DEFAULT_AUTHENTICATION_CLASSES': (
  4. 'rest_framework.authentication.SessionAuthentication', # session认证
  5. 'rest_framework.authentication.BasicAuthentication', # 基本认证
  6. )
  7. }

也可以在每个视图中通过设置authentication_classess类属性来设置

  1. from rest_framework.authentication import SessionAuthentication, BasicAuthentication
  2. from rest_framework.views import APIView
  3. class ExampleView(APIView):
  4. # 类属性
  5. authentication_classes = [SessionAuthentication, BasicAuthentication]
  6. def get(self,request):
  7. pass

认证失败会有两种可能的返回值从,这个需要我们配合权限组件来使用

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

权限 Permissions

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

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

提供的权限

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

可以在配置文件settings.py中全局设置默认的权限管理类:如:

  1. # drf的配置信息,需要卸载django的配置文件,而且必须写在REST_FRAMEWORK的字典中,才能被drf识别
  2. REST_FRAMEWORK = {
  3. ....
  4. # 权限[全局配置,所有的视图都会被影响到]
  5. 'DEFAULT_PERMISSION_CLASSES': (
  6. 'rest_framework.permissions.IsAuthenticated', # 已经登录认证的用户才能访问
  7. )
  8. }

如果没有设置权限组件,默认使用的配置如下:

  1. 'DEFAULT_PERMISSION_CLASSES': (
  2. 'rest_framework.permissions.AllowAny',
  3. )

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

  1. from rest_framework.permissions import IsAuthenticated
  2. from rest_framework.views import APIView
  3. class ExampleView(APIView):
  4. permission_classes = (IsAuthenticated,)

认证和权限使用案例:

  1. from rest_framework.authentication import SessionAuthentication
  2. from rest_framework.permissions import IsAuthenticated
  3. from rest_framework.generics import RetrieveAPIView
  4. class StudentAPIView(RetrieveAPIView):
  5. queryset = Student.objects.all()
  6. serializer_class = StudentSerializer
  7. authentication_classes = [SessionAuthentication]
  8. permission_classes = [IsAuthenticated]

自定义权限

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

  • .has_permission(self,request,view)

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

  • .has_object_permission(self,request,view,obj)

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

如:

  1. 在当前子应用下,创建一个权限文件permissions.py中声明自定义权限类:
  2. from rest_framework.permissions import BasePermission
  3. class IsXiaoMingPermission(BasePermission):
  4. def has_permission(self, request, view):
  5. if request.user and request.user.username == "xiaoming":
  6. return True
  7. 视图文件:
  8. from .permissions import IsXiaoMingPermission
  9. class StudentViewSet(ModelViewSet):
  10. queryset = Student.objects.all()
  11. serializer_class = StudentSerializer
  12. permission_classes = [IsXiaoMingPermission]

可选限流类

  • AnonRateThrottle

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

使用 DEFAULT_THROTTLE_RATES[‘anon’]来设置频次

  • UserRateThrottle

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

使用 DEFAULT_THROTTLE_RATES[‘user’]来设置频次

  • ScopedRateThrottle

限制用户对于每个视图的访问频次,使用ip或user id。

案例:

  1. class ContactListView(APIView):
  2. throttle_scope = 'contacts'
  3. ...
  4. class ContactDetailView(APIView):
  5. throttle_scope = 'contacts'
  6. ...
  7. class UploadView(APIView):
  8. throttle_scope = 'uploads'
  9. ...
  10. REST_FRAMEWORK = {
  11. 'DEFAULT_THROTTLE_CLASSES': (
  12. 'rest_framework.throttling.ScopedRateThrottle',
  13. ),
  14. 'DEFAULT_THROTTLE_RATES': {
  15. 'contacts': '1000/day',
  16. 'uploads': '20/day'
  17. }
  18. }

使用:

可以在配置文件中,使用DEFAULT_THROTTLE_CLASSESDEFAULT_THROTTLE_RATES进行全局配置,

  1. REST_FRAMEWORK = {
  2. 'DEFAULT_THROTTLE_CLASSES': ( # 启用的限制类
  3. 'rest_framework.throttling.AnonRateThrottle',
  4. 'rest_framework.throttling.UserRateThrottle'
  5. ),
  6. 'DEFAULT_THROTTLE_RATES': { # 限制频率
  7. 'anon': '100/day',
  8. 'user': '1000/day'
  9. }
  10. }

DEFAULT_THROTTLE_RATES 可以使用 second, minute, hourday来指明周期。

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

  1. from rest_framework.throttling import UserRateThrottle
  2. from rest_framework.views import APIView
  3. class ExampleView(APIView):
  4. throttle_classes = (UserRateThrottle,)

综合案例:

  1. 全局配置中设置访问频率,settings.py代码:
  2. REST_FRAMEWORK = {
  3. # 权限[全局配置,会被局部配置覆盖]
  4. # 'DEFAULT_PERMISSION_CLASSES': (
  5. # 'rest_framework.permissions.IsAuthenticated',
  6. # ),
  7. # 限流
  8. # 'DEFAULT_THROTTLE_CLASSES': ( # 全局启用的限制类
  9. # 'rest_framework.throttling.AnonRateThrottle', # 匿名用户,游客
  10. # 'rest_framework.throttling.UserRateThrottle' # 登录用户
  11. # ),
  12. 'DEFAULT_THROTTLE_RATES': { # 限制频率
  13. 'anon': '3/minute',
  14. 'user': '10/minute',
  15. 'access': '5/minute', # 这个是自定义限流的频率配置
  16. }
  17. }
  18. 视图代码:
  19. from students.models import Student
  20. from students.serializers import StudentModelSerializer
  21. from rest_framework.viewsets import ModelViewSet
  22. from rest_framework.permissions import AllowAny,IsAuthenticated,IsAuthenticatedOrReadOnly,IsAdminUser
  23. from .permission import ISMingGe
  24. from rest_framework.throttling import UserRateThrottle,AnonRateThrottle,ScopedRateThrottle
  25. class Students8APIView(ModelViewSet):
  26. serializer_class = StudentModelSerializer
  27. queryset = Student.objects.all()
  28. # 权限配置
  29. permission_classes = [AllowAny]
  30. # 限流配置
  31. # throttle_classes = [AnonRateThrottle,UserRateThrottle]
  32. # 自定义限流配置
  33. throttle_classes = [ScopedRateThrottle]
  34. throttle_scope = 'access'

过滤 Filtering

对于泪飙数据可能需要根据字段进行过滤,我们可以通过添加django-fitlter扩展开增强支持

  1. pip3 install django-filter

在配置文件setting.py中增加过滤组件的设置:

  1. INSTALLED_APPS = [
  2. ...
  3. 'django_filters', # 需要注册应用,
  4. ]
  5. REST_FRAMEWORK = {
  6. ...
  7. # 全局配置,也可以使用局部配置
  8. 'DEFAULT_FILTER_BACKENDS': ('django_filters.rest_framework.DjangoFilterBackend',)
  9. }

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

  1. class StudentListView(ListAPIView):
  2. queryset = Student.objects.all()
  3. serializer_class = StudentSerializer
  4. filter_fields = ('age', 'sex')
  5. # 127.0.0.1:8000/opt/students/?sex=true #单个过滤条件
  6. # http://127.0.0.1:8000/opt/students/?sex=false&age=27 # 多个并列的过滤条件

排序Ordering Filter

对于列表数据,REST Framework 提供了Ordering Filter过滤器来帮助我们快速指明数据按照字段进行排序

使用方法

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

全段可以传递的ordering参数的可选字段值需要在ordering_fields中指明、

案例:

  1. class StudentListView(ListAPIView):
  2. queryset = Student.objects.all()
  3. serializer_class = StudentModelSerializer
  4. filter_backends = [OrderingFilter]
  5. ordering_fields = ('id', 'age')
  6. # 127.0.0.1:8000/books/?ordering=-age
  7. # -id 表示针对id字段进行倒序排序
  8. # id 表示针对id字段进行升序排序

如果需要在过滤以后再次进行排序,则需要两者进行同步,要么都写在全局配置中,要么都写在视图类中

  1. from rest_framework.generics import ListAPIView
  2. from students.models import Student
  3. from .serializers import StudentModelSerializer
  4. from django_filters.rest_framework import DjangoFilterBackend
  5. class Student3ListView(ListAPIView):
  6. queryset = Student.objects.all()
  7. serializer_class = StudentModelSerializer
  8. filter_fields = ('age', 'sex')
  9. # 因为排序配置和过滤配置使用同一个类属性,所以当视图中需要使用排序和过滤时,
  10. # 要么大家一起在视图类中局部配置,要么大家一起在全局中配置,否则会出现过滤组件使用无效的情况
  11. # filter_backends = [DjangoFilterBackend,OrderingFilter]
  12. ordering_fields = ('id', 'age')
  13. #配置文件
  14. # 过滤组件[全局引入]
  15. # 'DEFAULT_FILTER_BACKENDS': ('django_filters.rest_framework.DjangoFilterBackend','rest_framework.filters.OrderingFilter')

分页 Pagination

REST Framework 提供了分页支持

可以在配置文件中设置全局的分页方式。如:

  1. REST_FRAMEWORK = {
  2. 'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',
  3. 'PAGE_SIZE': 100 # 每页数目
  4. }
  5. 如果在配置settings.py文件中, 设置了全局分页,那么在drf中凡是调用了ListModelMixinlist(),都会自动分页。如果项目中出现大量需要分页的数据,只有少数部分的分页,则可以在少部分的视图类中关闭分页功能。
  6. class 视图类(ListAPIView):
  7. pagination_class = None

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

  1. class LargeResultsSetPagination(PageNumberPagination):
  2. page_size = 1000
  3. page_size_query_param = 'page_size'
  4. max_page_size = 10000
  5. class BookDetailView(RetrieveAPIView):
  6. queryset = BookInfo.objects.all()
  7. serializer_class = BookInfoSerializer
  8. pagination_class = LargeResultsSetPagination

可选分页器

  • PageNumberPagination

前端访问网址形式

  1. get http://127.0.0.1:8000/students/?page=4

可以在子类中定义的属性有:

page_size 每页的数目

page_query_param 前端发送的页数关键字名,默认是page

page_size_query_param 前端发送的每页数目关键字名 默认是None

max_page_size 前端最多能设置的每页数量

  1. # 声明分页的配置类
  2. from rest_framework.pagination import PageNumberPagination
  3. class StandardPageNumberPagination(PageNumberPagination):
  4. # 默认每一页显示的数据量
  5. page_size = 2
  6. # 允许客户端通过get参数来控制每一页的数据量
  7. page_size_query_param = "size"
  8. max_page_size = 10
  9. # 自定义页码的参数名
  10. page_query_param = "p"
  11. class StudentAPIView(ListAPIView):
  12. queryset = Student.objects.all()
  13. serializer_class = StudentModelSerializer
  14. pagination_class = StandardPageNumberPagination
  15. # 127.0.0.1/four/students/?p=1&size=5
  • LimitOffsetPagination

前端访问网址形式

  1. GET http://127.0.0.1/four/students/?limit=100&offset=100

可以在子类中定义的属性

default_limit 默认限制 ,默认值与page_size设置一致

limit_query_param limit参数名 默认是limit

offset_query_param offset参数名 默认是offset

max_limit 最大limit限制 默认None

  1. from rest_framework.pagination import LimitOffsetPagination
  2. class StandardLimitOffsetPagination(LimitOffsetPagination):
  3. # 默认每一页查询的数据量,类似上面的page_size
  4. default_limit = 2
  5. limit_query_param = "size"
  6. offset_query_param = "start"
  7. class StudentAPIView(ListAPIView):
  8. queryset = Student.objects.all()
  9. serializer_class = StudentModelSerializer
  10. # 调用页码分页类
  11. # pagination_class = StandardPageNumberPagination
  12. # 调用查询偏移分页类
  13. pagination_class = StandardLimitOffsetPagination

异常处理 Exceptions

REST Framework 提供了自定义异常处理,我们可以自定义的当时来编写异常处理函数,如 我们想要创建一个自定义异常函数

这个函数,我们保存到当前主应用中 ,在实际工作中,我们可以设置一个单独的独立的公共目录来保存这种公共的函数/工具/类库

  1. from rest_framework.views import exception_handler as drf_exception_handler
  2. from django.db import DatabaseError
  3. from rest_framework.response import Response
  4. from rest_framework import status
  5. def custom_exception_handler(exc, context):
  6. """
  7. 自定义异常处理函数
  8. :param exc: 异常对象,本次发生的异常对象
  9. :param context: 字典,异常出现时的执行上下文环境
  10. :return:
  11. """
  12. # 先让drf进行异常判断
  13. response = drf_exception_handler(exc, context)
  14. # 判断response对象是否为None
  15. if response is None:
  16. """出现drf不能处理的异常"""
  17. if isinstance(exc, DatabaseError):
  18. view = context.get("view")
  19. print('数据库报错,[%s]: %s' % (view, exc))
  20. return Response({"detail":"服务器内部错误!"}, status=status.HTTP_507_INSUFFICIENT_STORAGE)
  21. if isinstance(exc, ZeroDivisionError):
  22. view = context.get("view")
  23. print("0不能作为除数! [%s]: %s" % (view, exc) )
  24. return Response({"detail":"服务器内部错误!"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
  25. return response

在主应用的配置文件settings.py中声明自定义的异常处理

  1. REST_FRAMEWORK = {
  2. # 异常处理
  3. 'EXCEPTION_HANDLER': 'drfdemo.exceptions.custom_exception_handler',
  4. }

如果未声明,会采用默认的方式,如下

rest_frame/settings.py

  1. REST_FRAMEWORK = {
  2. 'EXCEPTION_HANDLER': 'rest_framework.views.exception_handler'
  3. }

REST framework定义的异常

APIException使用drf中所有异常的父类,他的子类有以下:

  • ParseError 解析错误
  • AuthenticationFailed 认证失败
  • NotAuthenticated 尚未认证
  • PermissionDenied 权限受限
  • NotFound 未找到
  • MethodNotAllowed 请求方式不支持
  • NotAcceptable 要获取的数据格式不支持
  • Throttled 超过限流次数
  • ValidationError 校验失败

也就是说,很多的没有在上面列出来的异常,就需要我们在自定义异常中自己处理了。

自动生成接口文档

官方文档:http://core-api.github.io/python-client/

REST Framework 可以帮助我们自动生成接口文档

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

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

安装依赖

  1. pip install coreapi
  2. REST framewrok生成接口文档需要coreapi库的支持。

设置接口文档访问路径

  1. settings.py中配置接口文档。
  2. REST_FRAMEWORK = {
  3. # 。。。 其他选项
  4. # 接口文档
  5. 'DEFAULT_SCHEMA_CLASS': 'rest_framework.schemas.AutoSchema',
  6. }

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

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

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

  1. from rest_framework.documentation import include_docs_urls
  2. urlpatterns = [
  3. ...
  4. path('docs/', include_docs_urls(title='站点页面标题'))
  5. ]

文档描述说明的定义位置

  • 单一方法的视图,可直接使用类视图的文档字符串,如
  1. class BookListView(generics.ListAPIView):
  2. """
  3. 返回所有图书信息.
  4. """
  • 包含多个方法的视图,在类视图的文档字符串中,分开方法定义,如
  1. class BookListCreateView(generics.ListCreateAPIView):
  2. """
  3. get:
  4. 返回所有图书信息.
  5. post:
  6. 新建图书.
  7. """
  • 对于视图集ViewSet,仍在类视图的文档字符串中分开定义,但是应使用action名称区分,如
  1. class BookInfoViewSet(mixins.ListModelMixin, mixins.RetrieveModelMixin, GenericViewSet):
  2. """
  3. list:
  4. 返回图书列表数据
  5. retrieve:
  6. 返回图书详情数据
  7. latest:
  8. 返回最新的图书数据
  9. read:
  10. 修改图书的阅读量
  11. """

访问接口文档

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

两点说明

1) 视图集ViewSet中的retrieve名称,在接口文档网站中叫做read

2)参数的Description需要在模型类或序列化器类的字段中以help_text选项定义,如:

  1. class Student(models.Model):
  2. ...
  3. age = models.IntegerField(default=0, verbose_name='年龄', help_text='年龄')
  4. class StudentSerializer(serializers.ModelSerializer):
  5. class Meta:
  6. model = Student
  7. fields = "__all__"
  8. extra_kwargs = {
  9. 'age': {
  10. 'required': True,
  11. 'help_text': '年龄'
  12. }
  13. }

django Admin和XAdmin介绍

Admin

django 内置了一个强大的组件 叫Admin 提供给网站管理员快速开发运营后台的管理站点。

站点文档: https://docs.djangoproject.com/zh-hans/2.2/ref/contrib/admin/

辅助文档:https://www.runoob.com/django/django-admin-manage-tool.html

要使用Admin,必须先创建超级管理员. python manage.py createsuperuser

访问地址:http://127.0.0.1:8000/admin

admin站点默认并没有提供其他的操作给我们,所以一切功能都需要我们进行配置,在项目中,我们每次创建子应用的时候都会存在一个admin.py文件,这个文件就是用于配置admin站点功能的文件。

admin.py里面允许我们编写的代码一共可以分成2部分:

列表页配置

主要针对与项目中各个子应用里面的models.py里面的模型,根据这些模型自动生成后台运营站点的管理功能

  1. from django.contrib import admin
  2. from .models import Student
  3. class StudentModelAdmin(admin.ModelAdmin):
  4. """学生模型管理类"""
  5. pass
  6. # admin.site.register(模型类, 模型管理类)
  7. admin.site.register(Student, StudentModelAdmin)

关于列表页的配置 如下:

  1. from django.contrib import admin
  2. from .models import Student
  3. class StudentModelAdmin(admin.ModelAdmin):
  4. """学生模型管理类"""
  5. date_hierarchy = 'born' # 按指定时间字段的不同值来进行选项排列
  6. list_display = ['id', "name", "sex", "age", "class_num","born","my_born"] # 设置列表页的展示字段
  7. ordering = ['-id'] # 设置默认排序字段,字段前面加上-号表示倒叙排列
  8. actions_on_bottom = True # 下方控制栏是否显示,默认False表示隐藏
  9. actions_on_top = True # 上方控制栏是否显示,默认False表示隐藏
  10. list_filter = ["class_num"] # 过滤器,按指定字段的不同值来进行展示
  11. search_fields = ["name"] # 搜索内容
  12. def my_born(self,obj):
  13. return str(obj.born).split(" ")[0]
  14. my_born.short_description = "出生日期" # 自定义字段的描述信息
  15. my_born.admin_order_field = "born" # 自定义字段点击时使用哪个字段作为排序条件
  16. # admin.site.register(模型类, 模型管理类)
  17. admin.site.register(Student, StudentModelAdmin)

详情页的配置

  1. from django.contrib import admin
  2. from .models import Student
  3. class StudentModelAdmin(admin.ModelAdmin):
  4. """学生模型管理类"""
  5. date_hierarchy = 'born' # 按指定时间字段的不同值来进行选项排列
  6. list_display = ['id', "name", "sex", "age", "class_null","born","my_born"] # 设置列表页的展示字段
  7. ordering = ['-id'] # 设置默认排序字段,字段前面加上-号表示倒叙排列
  8. actions_on_bottom = True # 下方控制栏是否显示,默认False表示隐藏
  9. actions_on_top = True # 上方控制栏是否显示,默认False表示隐藏
  10. list_filter = ["class_null"] # 过滤器,按指定字段的不同值来进行展示
  11. search_fields = ["name"] # 搜索内容
  12. def my_born(self,obj):#相当于在模型类中新加了一个字段
  13. return str(obj.born).split(" ")[0]
  14. my_born.short_description = "出生日期" # 自定义字段的描述信息
  15. my_born.admin_order_field = "born" # 自定义字段点击时使用哪个字段作为排序条件
  16. def delete_model(self, request, obj):
  17. """当站点删除当前模型时执行的钩子方法"""
  18. print("有人删除了模型信息[添加/修改]")
  19. # raise Exception("无法删除") # 可以阻止删除
  20. return super().delete_model(request, obj) # 继续删除
  21. def save_model(self, request, obj, form, change):
  22. self,客户的请求对象,模型对象,客户提交的表单,修改后的数据)
  23. """
  24. 当站点保存当前模型时
  25. """
  26. print("有人修改了模型信息[添加/修改]")
  27. # 区分添加和修改? obj是否有id
  28. print(obj.id)
  29. return super().save_model(request, obj, form, change)
  30. #配置添加页的编辑页 显示的表单字段
  31. # fields = ('name', 'age', 'class_null', "description") # exclude 作用与fields相反
  32. # readonly_fields = ["name"] # 设置只读字段
  33. # 字段集,fieldsets和fields只能使用其中之一,字段分组显示
  34. fieldsets = (
  35. ("必填项", {
  36. 'fields': ('name', 'age', 'sex')
  37. }),
  38. ('可选项', {
  39. 'classes': ('collapse',), # 折叠样式
  40. 'fields': ('class_null', 'description'),
  41. }),
  42. )
  43. # admin.site.register(模型类, 模型管理类)
  44. admin.site.register(Student, StudentModelAdmin)

XAdmin

xadmin是Django的第三方扩展,是一个比Django的admin站点使用更方便的后台站点。构建于admin站点之上。

文档:http://sshwsfc.github.io/xadmin/

  1. [https://xadmin.readthedocs.io/en/latest/index.html](https://xadmin.readthedocs.io/en/latest/index.html)

安装

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

在配置文件中 setting.py中注册应用

  1. INSTALLED_APPS = [
  2. ...
  3. 'xadmin',
  4. 'crispy_forms',
  5. 'reversion',
  6. ...
  7. ]
  8. # 修改使用中文界面
  9. LANGUAGE_CODE = 'zh-Hans'
  10. # 修改时区
  11. TIME_ZONE = 'Asia/Shanghai'

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

  1. python manage.py makemigrations
  2. python manage.py migrate

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

  1. import xadmin
  2. xadmin.autodiscover()
  3. # version模块自动注册需要版本控制的 Model
  4. from xadmin.plugins import xversion
  5. xversion.register_models()
  6. urlpatterns = [
  7. path('xadmin/', xadmin.site.urls),
  8. ]

创建超级用户

python manage.py createsuperuser

使用

  • xadmin不再使用Django的admin.py进行功能配置了,而是需要编写代码在adminx.py文件中。
    xadmin的配置文件需要我们在每个子应用中使用时先创建adminx.py
  • xadmin的站点管理类不用继承admin.ModelAdmin,而是直接继承object即可。

例如:在子应用students中创建adminx.py文件。

站点的全局配置

  1. import xadmin
  2. from xadmin import views
  3. class BaseSetting(object):
  4. """xadmin的基本配置"""
  5. enable_themes = True # 开启主题切换功能
  6. use_bootswatch = True
  7. xadmin.site.register(views.BaseAdminView, BaseSetting)
  8. class GlobalSettings(object):
  9. """xadmin的全局配置"""
  10. site_title = "路飞学城" # 设置站点标题
  11. site_footer = "路飞学城有限公司" # 设置站点的页脚
  12. menu_style = "accordion" # 设置菜单折叠
  13. xadmin.site.register(views.CommAdminView, GlobalSettings)

站点Model管理

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

  • list_display 控制列表展示的字段

    1. list_display = ['id', 'name', 'sex', 'age']
  • search_fields 控制可以通过搜索框搜索的字段名称,xadmin使用的是模糊查询

    1. search_fields = ['id','name']
  • list_filter 可以进行过滤操作的列,对于分类、性别、状态

    1. list_filter = ['is_delete']
  • ordering 默认排序的字段

  • readonly_fields 在编辑页面的只读字段
  • exclude 在编辑页面隐藏的字段
  • list_editable 在列表页可以快速直接编辑的字段
  • show_detail_fields 在列表页提供快速显示详情信息
  • refresh_times 指定列表页的定时刷新

    1. refresh_times = [5, 10,30,60] # 设置允许后端管理人员按多长时间(秒)刷新页面
  • list_export 控制列表页导出数据的可选格式

    1. list_export = ('xls', 'xml', 'json') list_export设置为None来禁用数据导出功能
    2. list_export_fields = ('id', 'title', 'pub_date') # 允许导出的字段
  • show_bookmarks 控制是否显示书签功能

    1. show_bookmarks = True
  • data_charts 控制显示图表的样式

    1. data_charts = {
    2. "order_amount": {
    3. 'title': '图书发布日期表',
    4. "x-field": "pub_date",
    5. "y-field": ('title',),
    6. "order": ('id',)
    7. },
    8. # 支持生成多个不同的图表
    9. # "order_amount": {
    10. # 'title': '图书发布日期表',
    11. # "x-field": "pub_date",
    12. # "y-field": ('title',),
    13. # "order": ('id',)
    14. # },
    15. }
    • title 控制图标名称
    • x-field 控制x轴字段
    • y-field 控制y轴字段,可以是多个值
    • order 控制默认排序
  • model_icon 控制菜单的图标
    这里使用的图标是来自bootstrap3的图标。https://v3.bootcss.com/components/
    ``` class BookInfoAdmin(object): model_icon = ‘fa fa-gift’

xadmin.site.register(models.BookInfo, BookInfodmin)

  1. 修改admin或者xadmin站点下的子应用成中文内容。
  2. ```python
  3. # 在子应用的apps.py下面的配置中,新增一个属性verbose_name
  4. from django.apps import AppConfig
  5. class StudentsConfig(AppConfig):
  6. name = 'students'
  7. verbose_name = "学生管理"
  8. # 然后在当前子应用的__init__.py里面新增一下代码:
  9. default_app_config = "students.apps.StudentsConfig"