1 原生django实现接口
创建app
django-admin startapp stuapi # 原生django写接口
django-admin startapp students # drf实现接口
1.1 stuapi models设计
models.py
from django.db import models
# Create your models here.
class Student(models.Model):
# 表字段声明
# 字段名=models.数据类型(字段约束)
name = models.CharField(null=False, max_length=32, verbose_name="姓名")
sex = models.BooleanField(default=True, verbose_name="性别")
age = models.IntegerField(verbose_name="年龄")
class_num = models.CharField(max_length=5, verbose_name="班级编号")
description = models.TextField(max_length=1000, verbose_name="个性签名")
# 表信息
class Meta:
# 设置表名
db_table="tb_students"
verbose_name="学生"
verbose_name_plural=verbose_name
# 模型的操作方法
def __str__(self):
return self.name
settings.py
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'stuapi',
]
......
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'students',
'USER': 'root',
'PASSWORD': '79cab2a76cc22c80',
'HOST': '127.0.0.1',
'PORT': '3306',
}
}
执行数据迁移
# 第一步
python manage.py makemigrations
# 第二步
python manage.py migrate
1.2 stuapi views设计
from django.shortcuts import render
from django.views import View
from django.http import JsonResponse
from .models import Student
# Create your views here.
'''
post /student/ 添加一个学生信息
get /student/ 获取所有学生信息
get /student/<pk>/ 获取一个学生信息
put /student/<pk>/ 更新一个学生信息
delete /student/<pk>/ 删除一个学生信息
一个路由对应一个视图类，所以上面5个接口需要分成两个类来完成
'''
class StudentView(View):
def post(self, request):
'''
1接收提交的数据
2校验数据
3操作数据库保存数据
4返回结果
:param request:
:return:
'''
name = request.POST.get("name")
sex =request.POST.get("sex")
age = request.POST.get("age")
class_num = request.POST.get("class_num")
description = request.POST.get("description")
instance = Student.objects.create(
name=name,
sex=sex,
age=age,
class_num=class_num,
description =description
)
return JsonResponse(
data={
'id' : instance.pk,
'name': instance.name,
'sex': instance.sex,
'age': instance.age,
'class_num': instance.class_num,
'description': instance.description
}, status=201
)
def get(self,request):
'''
1读取数据库
2返回数据
:param request:
:return:
'''
students_list = list(Student.objects.values())
return JsonResponse(data=students_list, status=200, safe=False)
class StudentInfoView(View):
def get(self, request, pk):
'''
获取一条数据
:param request:
:param pk:
:return:
'''
try:
instance = Student.objects.get(pk=pk)
return JsonResponse(data={
'id': instance.pk,
'name': instance.name,
'sex': instance.sex,
'age': instance.age,
'class_num': instance.class_num,
'description': instance.description
}, status=200)
except Student.DoesNotExist:
return JsonResponse(data={}, status=404)
1.3 stuapi urls设计
stuapi路径下新建urls.py
# stuapi-->urls.py
from django.urls import path
from . import views
urlpatterns = [
path('students', views.StudentView.as_view()),
path('students/<pk>', views.StudentInfoView.as_view()),
]
urls.py
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('api/', include('stuapi.urls')),
]
暂时关闭CSRF
settings.py
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
# 'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
- 以上就是原生django编写接口，接口url如下：
http://127.0.0.1:8000/api/students/1
http://127.0.0.1:8000/api/students
2 drf快速生成接口
2.1 models设计
直接使用上面stuapi的models，无需重新写
2.2 创建序列化器
安装drf
pip install djangorestframework
pip list
......
djangorestframework 3.13.1
......
配置settings
INSTALLED_APPS = [
...
'rest_framework',
]
- students目录下新建serializers.py
from rest_framework import serializers
from stuapi.models import Student
class StudentModelSerializer(serializers.ModelSerializer):
class Meta():
model = Student
# fields = '__all__' # 将数据库中所有字段进行转换
fields = ['id', 'name'] # 指定需要转换的字段
2.3 编写视图
# from django.shortcuts import render
from rest_framework.viewsets import ModelViewSet
from stuapi.models import Student
from .serializers import StudentModelSerializer
# Create your views here.
class StudentModelViewSet(ModelViewSet):
queryset = Student.objects.all()
serializer_class = StudentModelSerializer
2.4 定义路由
students目录下新建urls.py
from rest_framework.routers import DefaultRouter
# from django.urls import path
from . import views
router = DefaultRouter()
router.register('stu', views.StudentModelViewSet, basename='stu') #每个序列化类注册一次,自动包含四个方法
urlpatterns = [
] + router.urls
主urls.py
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('api/', include('stuapi.urls')),
path('api/', include('students.urls')),
]
3 序列化器 序列化数个模型对象
作用：
- 序列化,序列化器会把模型对象转换成字典,经过response以后变成json字符串
- 反序列化,把客户端发送过来的数据,经过request以后变成字典,序列化器可以把字典转成模型
- 反序列化,完成数据校验功能
django-admin startapp sers # 新建app，用于实现序列化
3.1 模型
models使用之前的student
3.2 序列化器
serializers是drf提供给开发者调用的序列化器模块，里面声明了所有可用的序列化器的基类。
rest_framework.serializers.Serializer 序列化器基类，drf中所有的序列化器类都必须继承于Serializer。
rest_framework.serializers.ModelSerializer 模型序列化器类，是序列化器基类的子类，在工作中除了Serializer以外，最常用的就是ModelSerializer
客户端：字典--> 反序列化 --> 服务端：模型对象
客户端：字典<-- 序列化 <-- 服务端：模型对象
# serializers.py
from rest_framework import serializers
# 学生信息序列化器
class StudentSerializer(serializers.Serializer):
'''
1. 转换的字段声明 详见第四章内容
字段 = serializers.字段类型（选项=选项值，）
'''
id = serializers.IntegerField()
name = serializers.CharField()
sex = serializers.BooleanField()
age = serializers.IntegerField()
description = serializers.CharField()
'''
2. 如果当前序列化器继承的是ModelSerializer，则需要声明调用的模型类型
class Meta：
model = 模型
fields = ['字段1','字段2',......]
'''
'''
3. 验证代码的对象方法
def validate(self, attrs): # 方法名是固定的
pass
return attrs
另一种使用方法
def validate_<字段名>(self, data): # 方法名格式是固定的，必须要按此方法名，否则序列化器不识别
pass
return data
'''
'''
4. 模型操作的方法，只有下面两种
def create(self, validated_data): # 添加数据操作，添加数据以后，自动实现了从字典变成模型对象的过程
pass
def update(self, instance, calidated_data): # 更新数据操作，更新数据以后，自动实现了从字典变成模型对象的过程
pass
'''
3.3 视图
Serializer的构造方法为：
Serializer(instance=None, data=empty, **kwarg)
序列化器对象初始化有３个参数:
- instance，模型对象或者模型对象组成的列表，用于对数据进行序列化，把模型转换成字典
- data，字典，用于对数据进行反序列化，把数据进行验证和保存到数据库
- context，字典，用于把路由或者视图的自定义参数传递到序列化器里面使用 context将来作为序列化器对象的子属性
- many，当序列化器进行序列化时，如果模型有多个，则many必须为True
from django.shortcuts import render
from django.http.response import JsonResponse
from django.views import View
from .serializers import StudentSerializer
from stuapi.models import Student
# Create your views here.
# 使用django本身设计view
class StudentView(View):
# 如果要被序列化的是包含多条数据的查询集QuerySet，可以通过添加many=True参数补充说明
def get(self, request):
'''序列化器--序列化阶段的调用'''
# 0.获取数据集 序列化器不产生数据，需先获取数据
student_list = Student.objects.all()
# 1.实例化序列化器，得到序列化对象
serializer = StudentSerializer(instance=student_list, many=True) # many:是否多个模型
# 2.调用序列化对象的data属性方法获取转换后的数据
data = serializer.data
# 3.响应数据
return JsonResponse(data=data, status=200, safe=False)
def get2(self, request): # 单个模型数据
'''序列化器--序列化阶段的调用'''
# 0.获取数据集 序列化器不产生数据，需先获取数据
student = Student.objects.first()
# 1.实例化序列化器，得到序列化对象
serializer = StudentSerializer(student)
# 2.调用序列化对象的data属性方法获取转换后的数据
data = serializer.data
# 3.响应数据
return JsonResponse(data=data, status=200)
3.4 路由
sers.urls
from django.urls import path
from . import views
urlpatterns = [
path('students/', views.StudentView.as_view()),
]
drfdemo.urls
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('api/', include('stuapi.urls')),
path('api/', include('students.urls')),
path('sers/', include('sers.urls'))
]
4 serializer常用字段
| 字段 | 字段构造方式 |
|---|---|
| BooleanField | BooleanField() |
| NullBooleanField | NullBooleanField() |
| CharField | CharField(max_length=None, min_length=None, allow_blank=False, trim_whitespace=True) |
| EmailField | EmailField(max_length=None, min_length=None, allow_blank=False) |
| RegexField | RegexField(regex, max_length=None, min_length=None, allow_blank=False) |
| SlugField | SlugField(maxlength=50, min_length=None, allow_blank=False) 正则字段，验证正则模式 [a-zA-Z0-9-]+ |
| URLField | URLField(max_length=200, min_length=None, allow_blank=False) |
| UUIDField | UUIDField(format=’hex_verbose’) format: 1) 'hex_verbose' 如"5ce0e9a5-5ffa-654b-cee0-1238041fb31a" 2） 'hex' 如 "5ce0e9a55ffa654bcee01238041fb31a" 3）'int' – 如: "123456789012312313134124512351145145114" 4）'urn' 如: "urn:uuid:5ce0e9a5-5ffa-654b-cee0-1238041fb31a" |
| IPAddressField | IPAddressField(protocol=’both’, unpack_ipv4=False, **options) |
| IntegerField | IntegerField(max_value=None, min_value=None) |
| FloatField | FloatField(max_value=None, min_value=None) |
| DecimalField | DecimalField(max_digits, decimal_places, coerce_to_string=None, max_value=None, min_value=None) max_digits: 最多位数 decimal_palces: 小数点位置 |
| DateTimeField | DateTimeField(format=api_settings.DATETIME_FORMAT, input_formats=None) |
| DateField | DateField(format=api_settings.DATE_FORMAT, input_formats=None) |
| TimeField | TimeField(format=api_settings.TIME_FORMAT, input_formats=None) |
| DurationField | DurationField() |
| ChoiceField | ChoiceField(choices) choices与Django的用法相同 |
| MultipleChoiceField | MultipleChoiceField(choices) |
| FileField | FileField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL) |
| ImageField | ImageField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL) |
| ListField | ListField(child=, min_length=None, max_length=None) |
| DictField | DictField(child=) |
选项参数
| 参数名称 | 作用 |
|---|---|
| max_length | 最大长度[适用于字符串，列表，文件] |
| min_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页面时，显示的字段帮助提示信息 |
5 反序列化 字段选项 、validate_<字段名>、validate、validators
客户端：字典–> 反序列化 –> 服务端：模型对象
5.1 字段声明与数据验证
serializers.py
from rest_framework import serializers
# 学生信息序列化器
class StudentSerializer(serializers.Serializer):
'''
客户端：字典--> 反序列化 --> 服务端：模型对象
客户端：字典<-- 序列化 <-- 服务端：模型对象
'''
'''
1. 转换的字段声明
字段 = serializers.字段类型（选项=选项值，）
'''
id = serializers.IntegerField(read_only=True) # read_only=True只在序列化阶段使用，反序列化阶段不使用
name = serializers.CharField(required=True) # required=True反序列化阶段必填
sex = serializers.BooleanField(default=True) # 反序列化阶段客户端未传值时的默认值
age = serializers.IntegerField(max_value=100, min_value=0) # 反序列化阶段限制客户端传值范围
description = serializers.CharField(allow_null=True, allow_blank=True) # 反序列化阶段允许客户端穿null或空格
'''
2. 如果当前序列化器继承的是ModelSerializer，则需要声明调用的模型类型
class Meta：
model = 模型
fields = ['字段1','字段2',......]
'''
'''
3. 验证代码的对象方法
def validate(self, attrs): # 方法名是固定的
pass
return attrs
另一种使用方法
def validate_<字段名>(self, data): # 方法名格式是固定的，必须要按此方法名，否则序列化器不识别
pass
return data
'''
'''
4. 模型操作的方法，只有下面两种
def create(self, validated_data): # 添加数据操作，添加数据以后，自动实现了从字典变成模型对象的过程
pass
def update(self, instance, calidated_data): # 更新数据操作，更新数据以后，自动实现了从字典变成模型对象的过程
pass
'''
views.py
import json
from django.shortcuts import render
from django.http.response import JsonResponse
from django.views import View
from .serializers import StudentSerializer
from stuapi.models import Student
# Create your views here.
# 使用django本身设计view
class StudentView(View):
# 反序列化例
def get(self, request):
'''反序列化 采用字段选项来验证数据'''
# 1 接收客户端提交的数据
# data = json.dumps(request.body)
# 模拟客户端数据
data = {
'name': '小红',
'age': '9000',
'sex': True,
'class_num': '301',
'description': '假装是个人描述！'
}
# 1.1 实例化序列化器，获取序列化对象
serializer = StudentSerializer(data=data)
# 1.2 调用序列化器进行数据验证
ret = serializer.is_valid() # 不抛出异常
ret = serializer.is_valid(raise_exception=True) # 抛出异常
# 1.3 获取验证以后的结果
print('ret:', ret)
if ret:
print(serializer.validated_data)
else:
print(serializer.errors)
# 2 操作数据库
# 3 返回结果
return JsonResponse({})
# 运行结果：
# ret: False
# {'age': [ErrorDetail(string='Ensure this value is less than or equal to 100.', code='max_value')]}
# 将age改为30，运行结果：
# ret: True
# OrderedDict([('name', '小红'), ('sex', True), ('age', 30), ('description', '假装是个人描述！')])
- 自定义错误信息
age = serializers.IntegerField(max_value=100, min_value=0, error_messages={'max_value':'最大值不能超过100', 'min_value':'最小值不能小于0'}) # 反序列化阶段限制客户端传值范围
5.2 验证单个字段validate_<字段名>
serializers.py 验证单个字段def validate_<字段名>(self, data)
class StudentSerializer(serializers.Serializer):
客户端：字典--> 反序列化 --> 服务端：模型对象
1. 转换的字段声明
id = serializers.IntegerField(read_only=True) # read_only=True只在序列化阶段使用，反序列化阶段不使用
name = serializers.CharField(required=True) # required=True反序列化阶段必填
sex = serializers.BooleanField(default=True) # 反序列化阶段客户端未传值时的默认值
age = serializers.IntegerField(max_value=100, min_value=0, error_messages={'max_value':'最大值不能超过100', 'min_value':'最小值不能小于0'}) # 反序列化阶段限制客户端传值范围
description = serializers.CharField(allow_null=True, allow_blank=True) # 反序列化阶段允许客户端穿null或空格
2. 如果当前序列化器继承的是ModelSerializer，则需要声明调用的模型类型
3. 验证代码的对象方法 def validate_<字段名>(self, data): # 方法名格式是固定的，必须要按此方法名，否则序列化器不识别
def validate_name(self,data):
print('name=', data) # data就是name字段的值
if data in ['Python', 'Django']:
# 在序列化器中，验证失败可以通过抛出异常的方式来告知is_valid
raise serializers.ValidationError(detail='姓名不符合规范',code='valid_name')
# 验证成功，则返回数据
return data
4. 模型操作的方法:添加数据和更新数据
5.3 验证多个字段validate()
serializers.py 验证多个字段def validate(self, attrs)
3. 验证代码的对象方法
# 方法名是固定的
def validate(self, attrs):
# 验证来自客户端的所有数据，类似注册时的密码和确认密码就只能在validate()中校验
print('attrs=', attrs) # attrs= OrderedDict([('name', '范德'), ('sex', True), ('age', 3), ('class_num', '307'), ('description', '假装是个人描述！')])
if attrs['class_num']=='307' and attrs['sex']:
raise serializers.ValidationError(detail='307班只能进小姐姐', code='validate')
return attrs
5.4 外部验证方法
serializers.py
from rest_framework import serializers
# 一般共用的校验可使用外部校验函数
def check_classnum(data):
if data == '301':
raise serializers.ValidationError(detail='不能是301班', code='check_classnum')
# 验证完成，务必返回结果
return data
# 学生信息序列化器
class StudentSerializer(serializers.Serializer):
id = serializers.IntegerField(read_only=True) # read_only=True只在序列化阶段使用，反序列化阶段不使用
name = serializers.CharField(required=True) # required=True反序列化阶段必填
sex = serializers.BooleanField(default=True) # 反序列化阶段客户端未传值时的默认值
age = serializers.IntegerField(max_value=100, min_value=0, error_messages={'max_value':'最大值不能超过100', 'min_value':'最小值不能小于0'}) # 反序列化阶段限制客户端传值范围
class_num = serializers.CharField(required=True, validators=[check_classnum]) # 外部校验函数
description = serializers.CharField(allow_null=True, allow_blank=True) # 反序列化阶段允许客户端穿null或空格
6 反序列化 添加和更新数据
6.1 views实现添加数据
缺点：需要反序列化一次，然后再序列化一次
from django.http.response import JsonResponse
from django.views import View
from .serializers import StudentSerializer
from stuapi.models import Student
class StudentView(View):
# 反序列化例
def get(self, request):
'''反序列化 采用字段选项来验证数据'''
# 1 接收客户端提交的数据
# data = json.dumps(request.body)
# 模拟客户端数据
data = {
'name': '范德',
'age': '3',
'sex': True,
'class_num': '301',
'description': '假装是个人描述！'
}
# 1.1 实例化序列化器，获取序列化对象
serializer = StudentSerializer(data=data) # 反序列化用data
# 1.2 调用序列化器进行数据验证
ret = serializer.is_valid(raise_exception=True) # 抛出异常，代码不会往下执行
# 1.3 获取验证以后的结果
data = serializer.validated_data
# 2 操作数据库
student = Student.objects.create(**data)
serializer = StudentSerializer(instance=data) #再序列化一次，序列化用instance
# 3 返回结果
return JsonResponse(serializer.data, status=201)
6.2 序列化器中实现
serializer.py
from rest_framework import serializers
from stuapi.models import Student
# 一般共用的校验可使用外部校验函数
def check_classnum(data):
if data == '301':
raise serializers.ValidationError(detail='不能是301班', code='check_classnum')
# 验证完成，务必返回结果
return data
# 学生信息序列化器
class StudentSerializer(serializers.Serializer):
'''
客户端：字典--> 反序列化 --> 服务端：模型对象
客户端：字典<-- 序列化 <-- 服务端：模型对象
'''
'''
1. 转换的字段声明
字段 = serializers.字段类型（选项=选项值，）
'''
id = serializers.IntegerField(read_only=True) # read_only=True只在序列化阶段使用，反序列化阶段不使用
name = serializers.CharField(required=True) # required=True反序列化阶段必填
sex = serializers.BooleanField(default=True) # 反序列化阶段客户端未传值时的默认值
age = serializers.IntegerField(max_value=100, min_value=0, error_messages={'max_value':'最大值不能超过100', 'min_value':'最小值不能小于0'}) # 反序列化阶段限制客户端传值范围
class_num = serializers.CharField(required=True, validators=[check_classnum]) # 外部校验函数
description = serializers.CharField(allow_null=True, allow_blank=True) # 反序列化阶段允许客户端穿null或空格
'''
2. 如果当前序列化器继承的是ModelSerializer，则需要声明调用的模型类型
class Meta：
model = 模型
fields = ['字段1','字段2',......]
'''
'''
3. 验证代码的对象方法
def validate(self, attrs): # 方法名是固定的
pass
return attrs
def validate(self, attrs):
# 验证来自客户端的所有数据，类似注册时的密码和确认密码就只能在validate()中校验
print('attrs=', attrs) # attrs= OrderedDict([('name', '范德'), ('sex', True), ('age', 3), ('class_num', '307'), ('description', '假装是个人描述！')])
if attrs['class_num']=='307' and attrs['sex']:
raise serializers.ValidationError(detail='307班只能进小姐姐', code='validate')
return attrs
另一种使用方法
def validate_<字段名>(self, data): # 方法名格式是固定的，必须要按此方法名，否则序列化器不识别
def validate_name(self,data):
print('name=', data) # data就是name字段的值
if data in ['Python', 'Django']:
# 在序列化器中，验证失败可以通过抛出异常的方式来告知is_valid
raise serializers.ValidationError(detail='姓名不符合规范',code='valid_name')
# 验证成功，则返回数据
return data
'''
def validate_name(self, data):
print('name=', data) # data就是name字段的值
if data in ['Python', 'Django']:
# 在序列化器中，验证失败可以通过抛出异常的方式来告知is_valid
raise serializers.ValidationError(detail='姓名不符合规范', code='valid_name')
# 验证成功，则返回数据
return data
'''
4. 模型操作的方法，只有下面两种
def create(self, validated_data): # 添加数据操作，添加数据以后，自动实现了从字典变成模型对象的过程
pass
def update(self, instance, calidated_data): # 更新数据操作，更新数据以后，自动实现了从字典变成模型对象的过程
pass
'''
def create(self, validated_data):
'''
添加数据，方法名固定为create
:param validated_data: 固定参数，就是验证成功以后的结果
:return:
'''
student = Student.objects.create(**validated_data)
return student
def update(self, instance, validated_data):
'''
更新数据操作，方法名固定为update
:param instance: 固定参数，实例化序列化器对象时，必须传入的模型对象
:param validated_data:固定参数，就是验证成功以后的结果
:return:
'''
instance.name = validated_data['name']
instance.sex = validated_data['sex']
instance.age = validated_data['age']
instance.description = validated_data['description']
instance.class_num = validated_data['class_num']
instance.save() # 这个是模型对象的方法
return instance
update()方法优化
def update(self, instance, validated_data):
'''
更新数据操作，方法名固定为update
:param instance: 固定参数，实例化序列化器对象时，必须传入的模型对象
:param validated_data:固定参数，就是验证成功以后的结果
:return:
'''
for key, value in validated_data.items():
setattr(instance, key, value)
instance.save() # 这个是模型对象的方法
return instance
views.py添加数据
import json
from django.shortcuts import render
from django.http.response import JsonResponse
from django.views import View
from .serializers import StudentSerializer
from stuapi.models import Student
class StudentView(View):
# 反序列化添加数据
def get(self, request):
'''反序列化 采用字段选项来验证数据'''
# 1 接收客户端提交的数据
# data = json.dumps(request.body)
# 模拟客户端数据
data = {
'name': '大范德',
'age': '31',
'sex': True,
'class_num': '302',
'description': '假装是个人描述！'
}
# 1.1 实例化序列化器，获取序列化对象
serializer = StudentSerializer(data=data)
# 1.2 调用序列化器进行数据验证
ret = serializer.is_valid(raise_exception=True) # 抛出异常，代码不会往下执行
# 2 操作数据库
serializer.save() #会根据实例化序列化器时，是否传入instance参数，来调用create或update方法
# 注意：反序列化时，传的是data参数，则调用create方法；序列化时，传的是instance参数，则调用update方法
# 3 返回结果
return JsonResponse(serializer.data, status=201)
views.py更新数据
import json
from django.shortcuts import render
from django.http.response import JsonResponse
from django.views import View
from .serializers import StudentSerializer
from stuapi.models import Student
class StudentView(View):
def get(self, request):
# 1 根据客户端访问的url获取PK值
# /sers/students/2
pk = 3
try:
student = Student.objects.get(pk=pk)
except Student.DoesNotExist:
return JsonResponse({'errors':'当前数据不存在'}, status=400)
# 2 模拟客户端数据
data = {
'name': '大范德',
'age': '23',
'sex': True,
'class_num': '302',
'description': '这是在更新数据'
}
# 3 修改操作中的实例化器对象
serializer = StudentSerializer(instance=student, data=data)
# 4 验证数据
serializer.is_valid(raise_exception=True)
# 5 入库
serializer.save()
# 6 返回数据
return JsonResponse(serializer.data, status=201)
说明
1.在对序列化器进行save()保存时，可以额外传递数据，这些数据可以在create()和update()中的validated_data参数获取到
serializer.save(owner=request.user)
# 可以在save中传递一些不需要验证的数据到模型里面
2.默认序列化器必须要传递所有required字段，否则会抛验证异常。但我们可以使用partial参数来允许部分字段更新
serializer=StudentSerializer(student,data={'name':'xiaomi'},partial=True)
原文地址：http://www.cnblogs.com/momolei/p/16818315.html
1. 本站所有资源来源于用户上传和网络，如有侵权请邮件联系站长！
2. 分享目的仅供大家学习和交流，请务用于商业用途!
3. 如果你也有好源码或者教程，可以到用户中心发布，分享有积分奖励和额外收入！
4. 本站提供的源码、模板、插件等等其他资源，都不包含技术服务请大家谅解！
5. 如有链接无法下载、失效或广告，请联系管理员处理！
6. 本站资源售价只是赞助，收取费用仅维持本站的日常运营所需！
7. 如遇到加密压缩包，默认解压密码为"gltf",如遇到无法解压的请联系管理员！
8. 因为资源和程序源码均为可复制品，所以不支持任何理由的退款兑现，请斟酌后支付下载
声明：如果标题没有注明"已测试"或者"测试可用"等字样的资源源码均未经过站长测试.特别注意没有标注的源码不保证任何可用性
