Django --- API接口规范 Rest Framework DRF序列化与反序列化

API接口规范

web应用模式

在开发Web应用中，有两种应用模式：

前后端不分离

前后端分离

API接口

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

rpc：翻译成中文:远程过程调用[远程服务调用]，但是接口多了,对应函数名和参数就多了,前端在请求api接口时,就会比较难找.容易出现重复的接口

restful：翻译成中文: 资源状态转换，把后端所有的数据/文件都看成资源.那么接口请求数据,本质上来说就是对资源的操作了.
例如：
POST 请求：http://www.lufei.com/api/students/ 添加学生数据
GET请求： http://www.lufei.com/api/students/ 获取所有学生
DELETE请求： http://www.lufei.com/api/students/ 删除1个学生

Restful API规范

简介

REST全称是Representational State Transfer，中文意思是表述（编者注：通常译为表征）性状态转移=改变数据状态。 它首次出现在2000年Roy Fielding的博士论文中。

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

这种风格的理念认为后端开发任务就是提供数据的，对外提供的是数据资源的访问接口，所以在定义接口时，客户端访问的URL路径就表示这种要操作的数据资源。而对于数据资源分别使用POST、DELETE、GET、UPDATE等请求动作来表达对数据的增删查改。

可以使用任何一个框架都可以实现符合restful规范的API接口
参考文档：http://www.runoob.com/w3cnote/restful-architecture.html

restful API规范详情

域名

应该尽量将API部署在专用域名之下。

https://www.jd.com
https://api.example.com
1
2

如果确定API很简单，不会有进一步扩展，可以考虑放在主域名下。

https://example.org/api/+
1

版本（Versioning）

应该将API的版本号放入URL。

http://www.example.com/app/1.0/foo
​
http://www.example.com/app/1.1/foo
​
http://www.example.com/app/2.0/foo
1
2
3
4
5

另一种做法是，将版本号放在HTTP头信息中，但不如放入URL方便和直观。Github就采用了这种做法。

因为不同的版本，可以理解成同一种资源的不同表现形式，所以应该采用同一个URL。版本号可以在HTTP请求头信息的Accept字段中进行区分（参见Versioning REST Services）

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
1
2
3
4
5

路径（Endpoint）

路径又称"终点"（endpoint），表示API的具体网址，每个网址代表一种资源（resource）

资源作为网址，只能有名词，不能有动词，而且所用的名词往往与数据库的表名对应。
举例来说，以下是不好的例子:

/getProducts
/listOrders
/retreiveClientByOrder?orderId=1
1
2
3

对于一个简洁结构，你应该始终用名词。 此外，利用的HTTP方法可以分离网址中的资源名称的操作

GET /products ：将返回所有产品清单
POST /products ：将产品新建到集合
GET /products/4 ：将获取产品 4
PATCH（或）PUT /products/4 ：将更新产品 4
1
2
3
4

对于一个简洁结构，你应该始终用名词。 此外，利用的HTTP方法可以分离网址中的资源名称的操作。

GET /products ：将返回所有产品清单
POST /products ：将产品新建到集合
GET /products/4 ：将获取产品 4
PATCH（或）PUT /products/4 ：将更新产品 4
1
2
3
4

API中的名词应该使用复数。无论子资源或者所有资源。
举例来说，获取产品的API可以这样定义

获取单个产品：http://127.0.0.1:8080/AppName/rest/products/1
获取所有产品: http://127.0.0.1:8080/AppName/rest/products
1
2

HTTP动词

对于资源的具体操作类型，由HTTP动词表示。
常用的HTTP动词有下面四个（括号里是对应的SQL命令）

GET（SELECT）：从服务器取出资源（一项或多项）。# 查询

POST（CREATE）：在服务器新建一个资源。# 添加

PUT（UPDATE）：在服务器更新资源（客户端提供改变后的完整资源）。# 更新

DELETE（DELETE）：从服务器删除资源。# 删除

还有三个不常用的HTTP动词。

PATCH（UPDATE）：在服务器更新(更新)资源（客户端提供改变的属性）。

HEAD：获取资源的元数据。

OPTIONS：获取信息，关于资源的哪些属性是客户端可以改变的。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

下面是一些例子。

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
2
3
4
5
6
7
8

过滤信息

如果记录数量很多，服务器不可能都将它们返回给用户。API应该提供参数，过滤返回结果。
下面是一些常见的参数。query_string 查询字符串,地址栏后面问号后面的数据,格式: name=xx&sss=xxx

?limit=10：# 指定返回记录的数量
?offset=10：# 指定返回记录的开始位置。
?page=2&per_page=100：# 指定第几页，以及每页的记录数。
?sortby=name&order=asc：# 指定返回结果按照哪个属性排序，以及排序顺序。
?animal_type_id=1：# 指定筛选条件
1
2
3
4
5

参数的设计允许存在冗余，即允许API路径和URL参数偶尔有重复。比如，GET /zoos/ID/animals 与 GET /animals?zoo_id=ID 的含义是相同的。

/zoos/2/animals

/animals?zoo_id=2
1
2
3

状态码（Status Codes）

服务器向用户返回的状态码和提示信息，常见的有以下一些（方括号中是该状态码对应的HTTP动词）。

200 OK - [GET]：服务器成功返回用户请求的数据

201 CREATED - [POST/PUT/PATCH]：用户新建或修改数据成功。

202 Accepted - [*]：表示一个请求已经进入后台排队（异步任务）

204 NO CONTENT - [DELETE]：用户删除数据成功。

400 INVALID REQUEST - [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 - [*]：服务器发生错误，用户将无法判断发出的请求是否成功。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

状态码的完全列表参见https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html或https://zh.wikipedia.org/wiki/HTTP%E7%8A%B6%E6%80%81%E7%A0%81。

错误处理（Error handling）

如果状态码是4xx，服务器就应该向用户返回出错信息。一般来说，返回的信息中将error作为键名，出错信息作为键值即可。

{
    error: "Invalid API key"
}
1
2
3

返回结果

针对不同操作，服务器向用户返回的结果应该符合以下规范。

GET /collections：返回资源对象的列表（数组）

GET /collection/ID：返回单个资源对象(json)

POST /collection：返回新生成的资源对象(json)

PUT /collection/ID：返回完整的资源对象(json)

DELETE /collection/ID：返回一个空文档(空字符串)
1
2
3
4
5
6
7
8
9

其他

服务器返回的数据格式，应该尽量使用JSON，避免使用XML。

DRF序列化与反序列化(基础序列化器)

DRF介绍

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

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

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

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

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

Django Rest Framework

Rest Framework介绍

核心思想: 缩减编写api接口的代码量 – DRF

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

特点

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

安装DRF

DRF需要以下包和环境依赖：

• Python (2.7, 3.2, 3.3, 3.4, 3.5, 3.6)
• Django (1.10, 1.11, 2.0，2.2)
• windows10、Linux

安装

pip3 install django==2.2 # 安装django2 不要安装django1
pip3 install djangorestframework # 安装drf
1
2

创建一个django项目

django-admin startproject django_drf---->django_drf为项目名称
1

添加rest_framework应用

在settings.py的IINSTALLED_APPS中添加’rest_framework’,。

INSTALLED_APPS = [
    ...
    'rest_framework',
]
1
2
3
4

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

• 将请求的数据（如JSON格式）转换为模型类对象
• 操作数据库
• 将模型类对象转换为响应的数据（如JSON格式）

drf的使用

准备工作

创建一个app，名字为students，并在INSTALLED_APPS注册

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'app01.apps.App01Config',
    'rest_framework',
    'student',
}
1
2
3
4
5
6
7
8
9
10
11

在上面创建的student应用里找到models.py文件（student/models.py），创建模型操作类:

from django.db import models


# Create your models here.
class Student(models.Model):
    # 模型字段
    name = models.CharField(max_length=8, 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" # 将表名改为tb_student
        verbose_name = "学生"# 将原英文表名改为学生
        verbose_name_plural = verbose_name
	# __str__魔术方法可以使模型类对象转成中文字符显示
    def __str__(self):
        return self.name
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

安装pymysql,执行数据库连接

pip install pymysql
1

在项目的主目录下的__init__.py中使用pymysql作为数据库驱动

import pymysql

pymysql.install_as_MySQLdb()
1
2
3

settings.py配置文件中设置数据库的相关配置

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'students',
        'HOST': '127.0.0.1',
        'PORT': 3306,
        'USER': 'root',
        'PASSWORD': '',
    }
}
1
2
3
4
5
6
7
8
9
10

在终端下执行数据库迁移指令

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

在执行 python manage.py makemigrations会报出如下错误

解决方法:
注释掉 python/site-packages/django/backends/mysql/base.py中的35和36行代码。

在执行 python manage.py migrate会报如下错误

解决方法:
backends/mysql/operations.py146行里面新增一个行代码：

创建总路由使用了路由分发
django_drf/settings.py

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

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

1
2
3
4
5
6
7
8

创建序列化器

在student应用目录中新建serializers.py（student/serializers.py）用于保存该应用的序列化器。
创建一个StudentSerializer用于序列化与反序列化。

from rest_framework.serializers import ModelSerializer
from student import models
# 创建序列化器类，回头会在视图中被调用
class StudentSerializer(ModelSerializer): # 需要继承ModelSerializer被继承的父类处理model数据
    class Meta:
        model = models.Student # model 指明该序列化器处理的数据字段从模型类Student参考生成
        fields = '__all__' # fields 指明该序列化器包含模型类中的哪些字段，'all'指明包含所有字段
1
2
3
4
5
6
7

编写视函数（取出数据并传给drf处理的功能）

在students应用的views.py中创建视图StudentView（students/views.py），这是一个视图集合。

'''方式一'''
from django.shortcuts import render
from django.views import View
# Create your views here.
from app01 import models
from django.http import JsonResponse
from student.serializer import StudentSerializer

class StudentView(View): # 继承View
    def get(self,request):  # [{},]
        students = models.Student.objects.all()# 查到queryset类型数据
         # 引入先前创建的序列化student/serializers.py中创建的序列化器并把取到的模型类对象处理成列表套字典的数据类型
        serializer_obj = StudentSerializer(instance=students,many=True)
        print(serializer_obj.data,type(serializer_obj.data))   #[{},]
        # JsonResponse回复Json数据，可以直接erializer_obj.data，safe=False非字典数据类型时False，json_dumps_params={'ensure_ascii':False}字节流转换成ascii，涉及到原码
        return JsonResponse(serializer_obj.data,safe=False,json_dumps_params={'ensure_ascii':False})

'''方式二'''
from rest_framework.viewsets import ModelViewSet
# 两句话查五个接口
class StudentView(ModelViewSet):# 继承一个ModelViewSet

    queryset = models.Student.objects.all()
    serializer_class = StudentSerializer
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

定义路由

在students/urls.py中定义路由信息

from django.contrib import admin
from django.urls import path, include
from student import views
from rest_framework.routers import DefaultRouter
'''使用上面view中方式一时 urls如下'''
urlpatterns = [
    path('student/', views.StudentView.as_view()),
]

'''使用上面view中方式二时 urls如下，drf提供自动分发路由的功能'''
url_obj = DefaultRouter()# 可以处理视图的路由器，自动通过视图来生成增删改查的url路径
url_obj.register('students', views.StudentView)#students是生成的url前缀，名称随便写，向路由器中注册视图集
urlpatterns += url_obj.urls# 将路由器中的所以路由信息追到到django的路由列表中
1
2
3
4
5
6
7
8
9
10
11
12
13

最后把students子应用中的路由文件加载到总路由文件中.（上面写过）

# django_drf/urls.py
from django.contrib import admin
from django.urls import path,include

urlpatterns = [
    path('admin/', admin.site.urls),
    path("stu/",include("students.urls")),
]
1
2
3
4
5
6
7
8

运行测试

点击链接127.0.0.1:8000/stu/students 可以访问获取所有数据的接口
我们可以通过这个页面来进行对数据的增删改查

序列化器的使用

序列化功能

先创建一个app：ser 终端操作

python manage.py startapp ser
1

在django_drf/settings.py的INSTALLED_APPS中注册ser

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'app01.apps.App01Config',
    'rest_framework',
    'student',
    'ser'
]
1
2
3
4
5
6
7
8
9
10
11
12

我们已有了一个数据库模型类student/Student，使用这个数据模型类即可。如果我们想为这个模型类提供一个序列化器，可以定义如下：
在ser应用中创建一个py文件,比如叫做serializer.py

from rest_framework import serializers
# 字段需要和表中的字段类型一样用serializers.字段类型表示，（）中可以写约束条件，这个后面再说
class StudentSerializer(serializers.Serializer):
    # id = serializers.IntegerField()
    name = serializers.CharField()
    sex = serializers.BooleanField()
    age = serializers.IntegerField()
    class_null = serializers.CharField()
    description = serializers.CharField()
1
2
3
4
5
6
7
8
9

在视图sers/views.py中使用序列化功能

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

class StudentView(View):
    def get(self,request):
        # 序列化多条数据
        # 查询所有数据
        students = models.Student.objects.all()
        # 多条记录序列化必须加many=True参数
'''
1）用于序列化时，将模型类对象传入**instance**参数

2）用于反序列化时，将要被反序列化的数据传入**data**参数

3）除了instance和data参数外，在构造Serializer对象时，还可通过**context**参数额外添加数据，如
serializer = AccountSerializer(account, context={'request': request})
        '''
        serializer_obj = StudentSerializer(instance=students,many=True)
        # serializer.data是列表里有多个小字典的形式
        print(serializer_obj.data,type(serializer_obj.data))
        return JsonResponse(serializer_obj.data,safe=False,json_dumps_params={'ensure_ascii':False})
        
		# 序列化单条数据
		# 查询一条数据
	    students = models.Student.objects.get(id=1)
	    # 单条记录序列化
        serializer_obj = StudentSerializer(instance=students)
        '''serializer.data是一个字典'''
        print(serializer_obj.data, type(serializer_obj.data))
        return JsonResponse(serializer_obj.data, safe=False, json_dumps_params={'ensure_ascii': False})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

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

反序列化功能

反序列化主要用于校验数据 如下
和序列化功能相同还是使用ser应用，在serializer.py中定义一个校验数据的函数

# 校验数据
class StudentSerializer2(serializers.Serializer):
    # id = serializers.IntegerField()
    name = serializers.CharField(max_length=8,required=True)
    sex = serializers.BooleanField()# 默认约束条件required=True，意思是这个数据必须有
    age = serializers.IntegerField()
    class_null = serializers.CharField()
    description = serializers.CharField()
1
2
3
4
5
6
7
8

然后再ser/view.py中构建一个post函数

from django.http import JsonResponse, request
from django.shortcuts import render
from django.views import View
from ser import models
from ser.serializer import StudentSerializer,StudentSerializer2
from rest_framework import serializers
from rest_framework.views import APIView
# Create your views here.

class StudentView(APIView): 
# 前端request.POST请求回来的数据Django解析不了,但drf中的APIView封装解析功能，所以继承一下APIView，直接可以request.data拿到数据
    def post(self,request):
        # print('<<<<<<<<<<',request.POST)
        # request.data{'name': 'chaochaochao', 'age': 18}字典类型数据
        print('>>>>>>>>>>',request.data)
        serializers_obj = StudentSerializer2(data=request.data)
        if serializers_obj.is_valid(): # 所有字段校验都没错返回True，但凡有一个 字段校验错误返回False is_valid()触发校验
        	# serializers_obj.validated_data拿到校验成功后的数据
            print('校验成功后的数据',serializers_obj.validated_data)
            # 然后这里可以写保存数据的逻辑...因为拿到的是字典类型的数据可以用**打散的方式操作数据
            return JsonResponse(serializers_obj.validated_data)
        else:
            print(serializers_obj.errors)
            return JsonResponse({'error':'校验失败'},status=400)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

序列化功能和反序列化经常用到一些字段和参数

常用字段:

选项参数

通用参数

read_only和write_only的用法
ser/serializer.py文件

from rest_framework import serializers

class StudentSerializer3(serializers.Serializer):
    '''序列化对应字段数据时，需要在序列化器类中声明和模型类中对应字段相同名称的属性字段'''
    id = serializers.IntegerField(read_only=True)  #序列化阶段需要，反序列化阶段不需要校验
    name = serializers.CharField(max_length=8,error_messages={'max_length':'太长了，受不了','required':'也不能没有啊'})
    sex = serializers.BooleanField()
    age = serializers.IntegerField(max_value=18)
    class_null = serializers.CharField(required=False)
    description = serializers.CharField(write_only=True) # 该字段数据序列化阶段不会被提取出来，反序列化时，必须要传过来进行校验
    # 共同点 write_only=True  required=True（要求提交的数据必须包含该字段数据）
    # 不同点： write_only=True 该字段数据序列化阶段不会被提取出来，反序列化时，必须要传过来进行校验，required=True该字段数据序列化阶段也会被提取出来
1
2
3
4
5
6
7
8
9
10
11
12

自定义校验数据

还是在ser/serializer.py文件中自定义

import re # 引入正则模块校验post请求数据
def check_name(val):
    if not re.match('a',val):  #val: xxllaa 以a开头的数据
    	'''serializers.ValidationError是serializers提供的一个错误类型，
    	当校验不通过时ValidationError会捕获到错误返回 raise主动抛出异常 '''
        raise serializers.ValidationError('不是以a开头的，不行')
    return val

class StudentSerializer3(serializers.Serializer):
    '''序列化对应字段数据时，需要在序列化器类中声明和模型类中对应字段相同名称的属性字段'''
    id = serializers.IntegerField(read_only=True)  #序列化阶段需要，反序列化阶段不需要校验
    # validatior代表检查name时，会通过一遍check_name函数
    name = serializers.CharField(max_length=8,validators=[check_name,])
    sex = serializers.BooleanField()
    age = serializers.IntegerField(max_value=18)
    class_null = serializers.CharField(required=False)
    description = serializers.CharField(write_only=True) # 该字段数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

局部钩子和全局钩子

局部钩子
局部钩子示例：
还是用ser/serializer.py文件

from ser import models
from rest_framework import serializers
class StudentSerializer3(serializers.Serializer):
    name = serializers.CharField(validators=[check_name,])
    sex = serializers.BooleanField()
    age = serializers.IntegerField(max_value=18)
    class_null = serializers.CharField()
    description = serializers.CharField(write_only=True) 
    # 定义局部钩子
'''局部钩子(is_valid参数检验完成之后，只要定义了局部钩子，那么局部钩子自动调用执行)
def validate_属性名(self,data),data参数就是该属性对应数据'''
    def validate_name(self,data):
        if '666' in data:
        	# serializers.ValidationError如666不在data中抛出异常
            raise serializers.ValidationError('光喊6不行的')
        return data  #校验成功之后，一定要返回该字段数据，不然validated_data属性是没有该值的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

全局钩子
全局钩子示例
还是用ser/serializer.py文件

from ser import models
from rest_framework import serializers
class StudentSerializer3(serializers.Serializer):
    name = serializers.CharField(validators=[check_name,])
    sex = serializers.BooleanField()
    age = serializers.IntegerField(max_value=18)
    class_null = serializers.CharField()
    description = serializers.CharField(write_only=True) 
    # 全局钩子
     # def validate(self, data): validate后面不用跟属性名 data是有序字典，并且是经过所有校验之后的结果数据
     def validate(self, data):
        print('data',data)
        p1 = data.get('p1')
        p2 = data.get('p2')
        if p1 != p2:
            raise serializers.ValidationError('两次密码不一致')
        return data  #校验成功之后，一定要返回该字段数据，不然validated_data属性是没有该值的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

反序列化时校验顺序： 字段1的参数校验，字段1的局部钩子，字段2的参数校验，字段2的局部钩子…最后执行全局钩子

is_valid中raise_exception参数

ser/viewsr.py文件

class StudentsView(APIView):
    def post(self,request):
        # print('>>>>>>', request.POST)  #由于用户提交的数据可能是json数据，django解析不了，所有我们借助drf来解析，就需要继承drf的APIView类
        print('?????', request.data)  #{'name': 'chaochaochao', 'age': 18}字典类型数据
        serializer_obj = StudentSerializer3(data=request.data, context={'request':request})
        # 加上raise_exception=True如果校验不通过直接中断程序并返回错误信息,status=400
        s = serializer_obj.is_valid(raise_exception=True)  #return JsonResponse(错误信息,status=400)
        print('xxxxxxxxxxxxxxxxxx')
        if s:  #所有字段校验都没问题，返回True，但凡是有一个字段校验失败，返回False
            print('校验成功之后的数据',serializer_obj.validated_data)
        else:
            print(serializer_obj.errors)
            return JsonResponse({'error':'校验失败'},status=400)
1
2
3
4
5
6
7
8
9
10
11
12
13

context参数

通过context参数附加的数据，可以通过Serializer对象的context属性获取
视图部分ser/viewsr.py文件

class StudentsView(APIView):
    def post(self,request):
        print('?????', request.data) 
       # 加上context可以传递参数，context实际上是APIView对request的扩展重写，之前的request的方法还可以继续使用
        serializer_obj = StudentSerializer3(data=request.data, context={'request':request})
        s = serializer_obj.is_valid()
        print('xxxxxxxxxxxxxxxxxx')
        if s:  #所有字段校验都没问题，返回True，但凡是有一个字段校验失败，返回False
            print('校验成功之后的数据',serializer_obj.validated_data)
        else:
            print(serializer_obj.errors)
            return JsonResponse({'error':'校验失败'},status=400)
1
2
3
4
5
6
7
8
9
10
11
12

序列化器部分ser/serializer.py文件

class StudentSerializer3(serializers.Serializer):
    def validate_age(self, data):
        return data
    # # 全局钩子
    	# self.context.get('request').path使用request的path方法获得请求路径
        print('额外参数》》》》',self.context.get('request').path)
        print('data',data)
        p1 = data.get('p1')
        p2 = data.get('p2')
        if p1 != p2:
            raise serializers.ValidationError('两次密码不一致，你恐怕是傻子吧')
        return data
1
2
3
4
5
6
7
8
9
10
11
12

反序列化的数据保存功能

方式一：直接保存

ser/viewsr.py文件,直接在视图文件里保存

class StudentView(APIView):
    def post(self, request):
        serializers_obj = StudentSerializer2(data=request.data)
        if serializers_obj.is_valid():  # 所有字段校验都没错返回True，但凡有一个 字段校验错误返回False
            print('校验成功后的数据', serializers_obj.validated_data)  # validated_data拿到校验成功后的数据
            # 模型类调用create方法用**打散字典的方法保存数据
            new_obj = models.Student.objects.create(**serializers_obj.validated_data)
            print(new_obj,type(new_obj))
            # new_obj拿到的是个模型类对象需要序列化一下返回给前端
            obj = StudentSerializer2(instance=new_obj)
            return JsonResponse(obj.data)
        else:
            print(serializers_obj.errors)
            return JsonResponse({'error': '校验失败'}, status=400)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

方式二：通过save方法来保存数据（save+create）

ser/viewsr.py文件

class StudentView(APIView):
    def post(self, request):
        serializers_obj = StudentSerializer2(data=request.data)
        if serializers_obj.is_valid():  # 所有字段校验都没错返回True，但凡有一个 字段校验错误返回False
            print('校验成功后的数据', serializers_obj.validated_data)  # validated_data拿到校验成功后的数据
            # save触发序列化器serializer.py文件中对应的create方法
            new_obj = serializer_obj.save()  
            print(new_obj,type(new_obj))
            # new_obj拿到的是个模型类对象需要序列化一下返回给前端
            obj = StudentSerializer2(instance=new_obj)
            return JsonResponse(obj.data)
        else:
            print(serializers_obj.errors)
            return JsonResponse({'error': '校验失败'}, status=400)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

ser/serializer.py文件

from rest_framework import serializers
from ser import models
class StudentSerializer2(serializers.Serializer):
    def create(self,validated_data):
        # validated_data 校验成功之后的数据
        print('create执行了>>>>>>',validated_data)
        '''views文件中的save方法触发了这个函数，执行
        模型类调用create方法用**打散字典的方法保存数据'''
        new_obj = models.Student.objects.create(**validated_data)
        return new_obj
1
2
3
4
5
6
7
8
9
10

反序列化的数据更新功能

方式一 先查询在更新

ser/viewsr.py文件

class StudentView(APIView):
    def put(self,request):
        ''' partial=True进行部分字段校验，也就是说，传递过来那个字段数据，
        就校验哪个字段数据，没有传递过来的不校验
        {'name':'xxx',"age":18} 只校验name和age的数据，
        其他数据不校验（即便是序列化类中要求必填的数据，也是直接忽略的）'''
        serializer_obj = StudentSerializer2(data=request.data,partial=True)
        if serializer_obj.is_valid():
            '''validated_data只能拿到校验通过的值，没通过返回None'''
            # id = serializer_obj.validated_data.get('id') # 错误
            '''由于id值不需要校验，所以在validated_data里面没有id数据，
            所以我们通过request.data来获取'''
            id = request.data.get('id')
            print('id', id)
            # 查询到模型类对象可以直接使用update方法更新，拿到的是字典类型数据**解包传入
            objs = models.Student.objects.filter(id=id)
            objs.update(**serializer_obj.validated_data)
            # 序列化返回前端
            new_obj = objs.first()
            obj = StudentSerializer2(instance=new_obj)
            return JsonResponse(obj.data)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

方式二：save方法触发update方法来数据的更新

ser/viewsr.py文件

class StudentView(APIView):
    def put(self , request):
        # 先查询到记录对象
        objs = models.Student.objects.filter(id=request.data.get("id"))
        # 取出查询到的对象给下面的serializer_obj传进行序列化（instance=obj）
        obj = objs.first()
        '''
        实例化序列化器类的对象时，如果传递了instance=模型类对象，
        那么将来通过serializer_obj.save() 会触发执行类中的update方法
        
        实例化序列化器类的对象时，如果没有传递instance=模型类对象参数，
        那么将来通过serializer_obj.save() 会触发执行类中的create方法
        '''
        serializer_obj = StudentSerializer2(data=request.data, partial=True, instance=obj)
        if serializer_obj.is_valid():
            # save方法触发update方法更新
            new_obj = serializer_obj.save()
            obj = StudentSerializer2(instance=new_obj)
            return JsonResponse(obj.data)
        else:
            return JsonResponse({'error': '校验失败'}, status=400)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

ser/serializer.py文件

class StudentSerializer2(serializers.Serializer):
    id = serializers.IntegerField(read_only=True)
    name = serializers.CharField(max_length=8, required=True)
    # 默认约束条件required=True，意思是这个数据必须有
    sex = serializers.BooleanField(required=False)  
    age = serializers.IntegerField(required=False)
    class_null = serializers.CharField(required=False)
    description = serializers.CharField(required=False)
    
    def update(self, instance, validated_data):
        # instance老的模型类对象
        '''打印结果：
         update Student object (1)
        {'name': 'axxoo2'}
        '''
        print('update执行了', instance)
        print(validated_data)
        instance.id = validated_data.get("id")
        instance.name = validated_data.get("name")
        instance.sex = validated_data.get("sex")
        instance.age = validated_data.get("age")
        instance.class_null = validated_data.get("class_null")
        instance.description = validated_data.get("description")
        instance.save()
        return instance
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

Modelserializer序列化器的使用(进阶)

Modelserializer的简单介绍

如果我们想要使用序列化器对应的是Django的模型类，DRF为我们提供了ModelSerializer模型类序列化器来帮助我们快速创建一个Serializer类。ModelSerializer与常规的Serializer相同，但提供了：

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

简单使用

先创建一个mser的APP应用

python manage.py startapp msers
1

在主项目文件下settings.py文件中注册应用

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'app01.apps.App01Config',
    'rest_framework',
    'student',
    'ser',
    'mser',
]
1
2
3
4
5
6
7
8
9
10
11
12
13

在主项目文件写路由urls.py文件

from django.contrib import admin
from django.urls import path, include
urlpatterns = [
    path('admin/', admin.site.urls),
    path('stu/', include('student.urls')),
    path('ser/', include('ser.urls')),
    path('mser/', include('mser.urls')),
]
1
2
3
4
5
6
7
8

配置应用的路由 mser/urls.py

from mser import views
urlpatterns = [
    path('students/', views.StudentView.as_view()),
]
1
2
3
4

创建序列化器
mser/serializer.py文件

from rest_framework import serializers
from ser import models
class StudentModelSerializer(serializers.ModelSerializer):
    # 定义一个序列化器
    class Meta:
    	'''
    	- model 指明参照哪个模型类
		- fields 指明为模型类的哪些字段生成
		- exclude 排除字段
		- extra_kwargs 自定义属性参数
		'''
        model = models.Student
        # 校验表中所以字段
        fields = '__all__'
        # 需要校验的字段
        fields = ['name', 'age', 'password','class_null','sex', 'description']
        #排除某些字段，注意不能和fields属性同时使用
        exclude = ['name', 'age']  
        extra_kwargs = {
            'id':{'read_only':True},
            'name':{
                'max_length':5,
                # 定制错误信息
                'error_messages': {
                    'max_length':'龙哥太长了',
                },
                # 自定义校验函数
                # 'validators':[]
            },
        }
    # 可以使用局部钩子和全局钩子
    # 局部钩子
    def validate_name(self,data):
        if '66' in data:
            raise serializers.ValidationError('不能光喊6')
        return data
    # 全局钩子
    def validate(self,data):
        return data
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

视图部分： 数据的序列化
mser/views.py文件

from django.http import JsonResponse
from ser import models
from mser.serializers import StudentModelSerializer
from rest_framework.views import APIView
class StudentView(APIView):
    # get请求，序列化处理数据
    def get(self, requset):
        # QuerySet模型类对象
        all_student = models.Student.objects.all()
        print(all_student, type(all_student))
        # 序列化
        serializer_obj = StudentModelSerializer(instance=all_student, many=True)
        return JsonResponse(serializer_obj.data, safe=False)
    # post请求
    def post(self,request):
    	# 获取到请求数据
        serializer_obj = StudentModelSerializer(data=request.data)
		# 判断校验数据
        if serializer_obj.is_valid():
        	'''打印结果
        	>>>>>>> OrderedDict([('name', '龙哥622'), ('age', 18), 
        	('password', '66666'), ('class_null', '32'), ('sex', True),
        	 ('description', '硬气')])
        	'''
            print('>>>>>>>',serializer_obj.validated_data)
            # 上面使用的ModelSerializer，所以不需要我们自己写create方法
            obj = serializer_obj.save() 
            # 饭序列化给前端
            new_obj = StudentModelSerializer(instance=obj)
            return JsonResponse(new_obj.data)
        else:
            print(serializer_obj.errors)
            return JsonResponse({'error':'校验失败'})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

drf视图

APIView中的request

REST framework 传入视图的request对象不再是Django默认的HttpRequest对象，而是REST framework提供的扩展了HttpRequest类的Request类的对象。

REST framework 提供了Parser解析器，在接收到请求后会自动根据Content-Type指明的请求数据类型（如JSON、表单等）将请求数据进行parse解析，解析为类字典[QueryDict]对象保存到Request对象中。这里我们可以自行写一个接口测试一下 django原来的模式是解析不了json数据的，drf可以解析。但是需要注意的是： 客户端如果传递过来的是json数据，那么request.data获取到的字典类型数据，不是querydict类型，也就没有了getlist方法，多选的数据，通过get就能取出来。

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

from django.shortcuts import render
from django.views import View
from rest_framework.views import APIView
class StudentsView(APIView):
    # 获取所有数据
    def get(self,request):
        # http://127.0.0.1:8000/req/students/?a=1&b=2&b=3  b可能为多选数据
        print(request.query_params.getlist('b'))
        # request.GET和request.query_params是等价的
        print(request.query_params) # 
        print(request.GET)
        students = models.Student.objects.all()
        serializer_obj = StudentModelSerializer(instance=students,many=True)
        return Response(serializer_obj.data,status=400) # 自定义状态码
        return Response(serializer_obj.data)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

response介绍

REST framework提供了一个响应类Response，使用该类构造响应对象时，响应的具体数据内容会被转换（render渲染）成符合前端需求的类型。 我们后端如果通过Response来想用数据时，通过postman发送get请求获取数据，你会发现得到的是纯json数据，但是通过浏览器访问时会的到一个页面。
drf的APIView在响应内容的时候会自动通过请求头中的浏览器信息来进行数据的回复(Response)， 如果是浏览器，那么返回的就是个页面(当然我们也可以不让他返回页面，可设置的，后面说）如果不是浏览器，给你返回的就是纯json数据。这是由drf中配置的两个不同的响应类产生的效果，看下面的配置。

REST framework提供了Renderer 渲染器，用来根据请求头中的Accept（客户端希望接收的数据类型声明）来自动转换响应数据到对应格式。如果前端请求中未进行Accept声明，则会采用默认方式处理响应数据，我们可以通过配置来修改默认响应格式。

在项目主目录下的settings.py文件中配置渲染器

from rest_framework import settings
# 用户配置替换drf内部配置的写法
REST_FRAMEWORK = {
    'DEFAULT_RENDERER_CLASSES': (  # 默认响应渲染类
        'rest_framework.renderers.JSONRenderer',  # json渲染器
        'rest_framework.renderers.BrowsableAPIRenderer',  # 浏览器API渲染器
    )
}
1
2
3
4
5
6
7
8

response参数解释

参数说明：

• data: 为响应准备的序列化处理后的数据；
• status: 设置状态码，默认200；
• template_name: 模板名称，如果使用HTMLRenderer 时需指明； 如果觉得Response返回的那个页面丑，那么就可以通过这个模板自行定制。
• headers: 用于存放响应头信息的字典；比如放一些cookie啊或者一些自定制的响应头啊都可以，例如：return Response({‘msg’: ‘ok’},status=204,headers={‘xx’:‘oo’})
• content_type: 响应数据的Content-Type通常此参数无需传递，REST framework会根据前端所需类型数据(accept请求头)来设置该参数。

# 引入Response
from rest_framework.response import Response
    # response里面的相关参数
    return Response({},status=201，template_name=None,headers=None,content_type=None)
    '''
	status:状态码
	template:用于自定义浏览器的响应页面
	headers:自定义响应头键值对
	content_type:....
	'''
1
2
3
4
5
6
7
8
9
10

状态码大全

# 查看所有状态码
from rest_framework import status

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

增删改查的简单接口

创建一个新的req应用，配置就不在写了
总路由：

from django.contrib import admin
from django.urls import path,re_path,include #  re_path --- django1.11 url
urlpatterns = [
    path('admin/', admin.site.urls),
    path('stu/', include('student.urls')),
    path('ser/', include('ser.urls')),
    path('mser/', include('mser.urls')),
    path('req/', include('req.urls')),
]
1
2
3
4
5
6
7
8
9

req/urls.py

from django.contrib import admin
from django.urls import path,re_path,include #  re_path --- django1.11 url
from req import views
urlpatterns = [
    path('students/', views.StudentsView.as_view()),
    re_path('students/(?P\d+)/', views.StudentView.as_view()),
    # pk=3
    path('students2/', views.Students2View.as_view()),
    re_path('students2/(?P\d+)/', views.Student2View.as_view()),
]
1
2
3
4
5
6
7
8
9
10

req/serializers.py

from rest_framework import serializers
from ser import models
class StudentModelSerializer(serializers.ModelSerializer):
    # 定义序列化器
    class Meta:
        model = models.Student
        # fields = ['name', 'sex', 'age', 'class_null']
        fields = '__all__'
        extra_kwargs = {
            'id':{'read_only':True},
        }
class StudentModelSerializer2(serializers.ModelSerializer):
    class Meta:
        model = models.Student
        fields = ['name', 'age']
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

req/views.py

from django.shortcuts import render
from django.views import View
from rest_framework.views import APIView
# Create your views here.
from ser import models
from req.serializers import StudentModelSerializer, StudentModelSerializer2
from rest_framework.response import Response
from rest_framework import status

class StudentsView(APIView):
    # 获取所有数据
    def get(self,request):
        # http://127.0.0.1:8000/req/students/?a=1&b=2&b=3  b可能为多选数据
        print(request.query_params)  # -- request.GET  
        # print(request.GET)
        # print(request.query_params.getlist('b'))
        students = models.Student.objects.all()
        serializer_obj = StudentModelSerializer(instance=students,many=True)
        # return Response(serializer_obj.data,status=400)
        return Response(serializer_obj.data)

    # 添加单条记录
    def post(self,request):
        serializer_obj = StudentModelSerializer(data=request.data)
        if serializer_obj.is_valid():
            new_obj = models.Student.objects.create(**serializer_obj.validated_data)
            obj = StudentModelSerializer(instance=new_obj)
            return Response(obj.data, status=status.HTTP_201_CREATED)
class StudentView(APIView):
    # 获取单条数据
    def get(self, request, pk):
        student = models.Student.objects.get(pk=pk)
        serializer_obj = StudentModelSerializer(instance=student)
        return Response(serializer_obj.data)
    # 更新单条记录
    def put(self,request,pk):
        student = models.Student.objects.get(pk=pk)
        data = request.data
        serializer_obj = StudentModelSerializer(instance=student,data=data,partial=True)
        if serializer_obj.is_valid():
            instance = serializer_obj.save()
            new_serializer_obj = StudentModelSerializer(instance=instance)
            return Response(new_serializer_obj.data,status=status.HTTP_202_ACCEPTED)
        else:
            return Response({'error':"检验失败"})
    # 删除单条记录
    def delete(self, request, pk):
        models.Student.objects.get(pk=pk).delete()
        # return Response(None,)
        return Response('', status=status.HTTP_204_NO_CONTENT)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50