ModelSerializer

序列化准备:

配置 settings.py

# 注册rest_framework框架 INSTALLED_APPS = [ ... 'rest_framework' ] # 配置mysql数据库 DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME': 'db10', 'USER': 'root', 'PASSWORD':'root', } } ​ """ 任何__init__.py文件中 import pymysql pymysql.install_as_MySQLdb() """ ​ # 国际化 LANGUAGE_CODE = 'zh-hans' TIME_ZONE = 'Asia/Shanghai' USE_I18N = True USE_L10N = True USE_TZ = False ​ # 配置静态文件 MEDIA_URL = '/media/' MEDIA_ROOT = os.path.join(BASE_DIR, 'media')

 

路由

# 主路由: from django.conf.urls import url, include from django.contrib import admin from django.views.static import serve from django.conf import settings urlpatterns = [ url(r'^admin/', admin.site.urls), # 路由分发 url(r'^api/', include('app01.urls')), # 暴露media文件夹 url(r'^media/(?P<path>.*)', serve, {'document_root': settings.MEDIA_ROOT}) ] # 子路由: from django.conf.urls import url from . import views ​ urlpatterns = [ ... ]

 

模型层: models.py

# 多表设计 Book表：name、price、img、authors、publish、is_delete、create_time ​ Publish表：name、address、is_delete、create_time Author表：name、age、is_delete、create_time ​ AuthorDetail表：mobile, author、is_delete、create_time

 

知识补充:

基表

# 上述的表中都含有 is_delete、create_time 字段,我们可以创建一个基表类含有这两个字段,其他的表来继承这个基表类即可(类似抽象类) ​ class BaseModel(models.Model): is_delete = models.BooleanField(default=False) # 该字段默认是 0 create_time = models.DateTimeField(auto_now_add=True) ​ # 作为基表的model类不能在数据库中形成对应的表,所以一定需要设置 abstract = True class Meta: abstract = True ​

断关联多表关系(***)

1、外键位置： 一对多 - 外键放多的一方 一对一 - 从逻辑正反向考虑，如作者表与作者详情表，作者删除级联删除详情，详情删除作者依旧存在，所以建议外键在详情表中 多对多 - 外键在关系表中 2、ORM正向方向连表查找： 正向：通过外键字段 eg: author_detial_obj.author 反向：通过related_name的值 eg：author_obj.detail 注：依赖代码见下方 3、连表操作关系： 1）作者删除，作者详情级联 - on_delete=models.CASCADE # 被关联表中的数据删除,主关联表中的对应数据也删除 2）作者删除，作者详情置空 - null=True, on_delete=models.SET_NULL # 被关联表中的数据删除,主关联表中的对应的字段为空(null) 3）作者删除，作者详情重置 - default=0, on_delete=models.SET_DEFAULT # 被关联表中的数据删除,主关联表中的对应数据字段可以通过事先定义好的default=0改为0 4）作者删除，作者详情不动 - on_delete=models.DO_NOTHING # 被关联表中的数据删除,主关联表中的数据不做任何处理 注：拿作者与作者详情表举例 4、外键关联字段的参数 - 如何实现 断关联、目前表间操作关系、方向查询字段 - 图书表中: # 关联出版社外键字段 publish = models.ForeignKey( to='Publish', db_constraint=False, # book表与publish表在库中段关联,但在逻辑上还是有关系 related_name='books', # 反向跨表时按related_name定义的名字即可 on_delete=models.DO_NOTHING, # 断级联,当出版社删除时,对应的图书不做任何处理 ) # 关联作者外键字段 authors = models.ManyToManyField( to='Author', db_constraint=False, related_name='books', ) - 作者详情表中 author = models.OneToOneField( to='Author', db_constraint=False, related_name='detail', on_delete=models.CASCADE, # 级联 ) 注意: 1.ManyToManyField不能设置on_delete，OneToOneField、ForeignKey必须设置on_delete（django1.x系统默认级联，但是django2.x必须手动明确） 2.OneToOneField 本质是继承了 ForeignKey

 

from django.db import models ​ # 基表 class BaseModel(models.Model): is_delete = models.BooleanField(default=False) # 该字段默认是 0 create_time = models.DateTimeField(auto_now_add=True) ​ # 作为基表的model类不能在数据库中形参对应的表,所以需要设置 abstract = True class Meta: abstract = True ​ # 图书表 class Book(BaseModel): # 继承基表,就会继承基表中的字段 name = models.CharField(max_length=64) price = models.DecimalField(max_digits=5, decimal_places=2) img = models.ImageField(upload_to='img', default='img/default.jpg') # 关联出版社外键字段 publish = models.ForeignKey( to='Publish', db_constraint=False, # book表与publish表在库中段关联,但在逻辑上还是有关系 related_name='books', # 反向跨表时按related_name定义的名字即可 on_delete=models.DO_NOTHING, # 断级联,当出版社删除时,对应的图书不错任何处理 ) # 关联作者外键字段 authors = models.ManyToManyField( to='Author', db_constraint=False, related_name='books', ) # ModelSerializer序列化 自定义的字段属性 @property def publish_name(self): return self.publish.name # 利用跨表查询返回publish的name @property def author_list(self): return self.authors.values('name', 'detail__mobile') ​ class Meta: db_table = 'book' verbose_name = '书籍' verbose_name_plural = verbose_name ​ def __str__(self): return self.name ​ class Publish(BaseModel): name = models.CharField(max_length=64) address = models.CharField(max_length=64) ​ class Meta: db_table = 'publish' verbose_name = '出版社' verbose_name_plural = verbose_name ​ def __str__(self): return self.name ​ class Author(BaseModel): name = models.CharField(max_length=64) age = models.IntegerField() ​ class Meta: db_table = 'author' verbose_name = '作者' verbose_name_plural = verbose_name ​ def __str__(self): return self.name ​ class AuthorDetail(BaseModel): mobile = models.CharField(max_length=11) author = models.OneToOneField( to='Author', db_constraint=False, related_name='detail', on_delete=models.CASCADE, # 级联 ) ​ class Meta: db_table = 'author_detail' verbose_name = '作者详情' verbose_name_plural = verbose_name ​ def __str__(self): return '%s的详情' %self.author.name

 

ModelSerializer 序列化 使用:

应用下创建 serializers.py

from rest_framework.serializers import ModelSerializer, SerializerMethodField from . import models from rest_framework.exceptions import ValidationError ​ # 创建Book模类的序列化类 class BookModelSerializer(ModelSerializer): class Meta: # 了解: 该方式设置的序列化字段，必须在fields中声明 # publish_address = SerializerMethodField() # def get_publish_addr(self, obj): # return obj.publish.address ​ # 1.序列化关联的model类 model = models.Book # 2.参与序列化的字段(插拔式),可选择字段展示(model类中有的字段都可以展示,也可以在model类中自定义字段来展示) fields = ('name', 'price','publish_name') # 这里直接写外键字段,到前端展示的是对应model类一条记录的外键pk值 ​ # 了解 # fields = '__all__' # 展示所有model类字段,除model中自定义的方法字段 # exclude = ('id', 'is_delete', 'create_time') # 不展示的字段 # depth = 1 # 自动连表深度

 

视图层

from rest_framework.views import APIView from rest_framework.response import Response ​ from . import models, serializers ​ class Book(APIView): def get(self, request, *args, **kwargs): pk = kwargs.get('pk') if pk: try: # 根据pk查询对应的书籍,注意要指定is_delete=False,因为被删除的数据不能给用户查看 book_obj = models.Book.objects.get(pk=pk, is_delete=False) # model对象不能直接返回给前端,需要序列化,拿到serializers对象字典 book_data = serializers.BookModelSerializer(book_obj).data except: return Response({ 'status': 1, 'msg': '书籍不存在' }) else: # 查所有 book_query = models.Book.objects.filter(is_delete=False).all() # 序列化 注意: book_query是列表,序列化是要指定many=True book_data = serializers.BookModelSerializer(book_query, many=True).data return Response({ 'status': 0, 'msg': 'ok', 'results': book_data })

 

路由层

urlpatterns = [ url(r'^books/$', views.Book.as_view()), url(r'^books/(?P<pk>.*)/$', views.Book.as_view()), ]

 

 

ModelSerializer 反序列化 使用:

serializers.py文件中:

# 创建Book模型类的反序列化类 class BookModelDeserializer(ModelSerializer): class Meta: # 序列化关联的model类 model = models.Book # 1.fields内的变量名(字段)要对应关联的model类, # 2.fields内的字段是前端发来的,字段有默认值的可以不参与反序列化 fields = ('name', 'price', 'publish', 'authors') # extra_kwargs 用来完成反序列化字段的 系统校验规则 extra_kwargs = { 'name': { 'required': True, 'min_length':1, 'error_messages': {'required':'必填项', 'min_length': '太短',} } } # 局部钩子 def validate_name(self, value): # 书名不能包含 K 字符 if 'k' in value.lower(): raise ValidationError('函非法字符') return value # 全局钩子 def validate(self, attrs): # attrs 是个字典 print(attrs) # OrderedDict([('name', '三国'), ('price', Decimal('2.33')), ('publish', <Publish: 首都出版社>), ('authors', [<Author: hanmm>])]) publish = attrs.get('publish') print(publish, type(publish)) # 首都出版社 <class 'app01.models.Publish'> name = attrs.get('name') print(name, type(name)) # 三国 <class 'str'> # 同一出版社的书不能重复创建 if models.Book.objects.filter(name=name, publish=publish): raise ValidationError({'book': '该书已存在'}) return attrs ​ # ModelSerializer类已经帮我们实现了 create 与 update 方法

 

视图层

class Book(APIView): def post(self, request, *args, **kwargs): # 拿到数据包中的数据字典 request_data = request.data # 将数据包字典反序列化并校验,拿到序列化后的对象 book_ser = serializers.BookModelDeserializer(data=request_data) # 当校验失败，马上终止当前视图方法，抛异常返回给前台 book_ser.is_valid(raise_exception=True) # 指定参数raise_exception=True, 当 book_ser.is_valid为False时自动向前端抛出错误 book_obj = book_ser.save() return Response({ 'status': 0, 'msg': 'ok', 'results': serializers.BookModelSerializer(book_obj).data })

 注意:

ser_obj = CarModelSerializer(数据) # 产生序列化类对象(可能参与序列化，也可能参与反序列化) ser_obj.data # 序列化的数据 ser_obj.is_valid() # 启动序列化校验规则（系统内容=>局部钩子=>全局钩子）源码中run_validation调用一系列的校验规则ser_obj.save() # 序列化校验后的数据操作(保存,修改)

 

路由层

urlpatterns = [ url(r'^books/$', views.Book.as_view()), url(r'^books/(?P<pk>.*)/$', views.Book.as_view()), ]

 

ModelSerializer 序列化反序列化整合(*****)

1) fields中设置所有序列化与反序列化字段(插拔式) 2) extra_kwargs划分只序列化或只反序列化字段 write_only：只反序列化 (要写入数据库的字段) read_only：只序列化 (要展示给前端的字段) 自定义字段默认只序列化(read_only) 3) 设置反序列化所需的 系统、局部钩子、全局钩子 等校验规则

 

serializers.py文件中:

class V2BookModelSerializer(ModelSerializer): class Meta: model = models.Book # 设置所有字段 fields = ('name', 'price', 'img', 'author_list', 'publish_name', 'publish', 'authors') # extra_kwargs划分只序列化或只反序列化字段 extra_kwargs = { 'name': { 'required': True, 'min_length': 1, 'error_messages': {'required': '必填项', 'min_length': '太短', }, }, 'publish': { 'write_only': True }, # 外键字段序列化到前端就是一个数字,所有没不要参与序列化,但有必要参与反序列化 'authors': {'write_only': True }, 'img': {'read_only': True}, 'author_list': {'read_only': True}, 'publish_name': { 'read_only': True} } ​ # 局部钩子 def validate_name(self, value): # 书名不能包含 K 字符 if 'k' in value.lower(): raise ValidationError('函非法字符') return value ​ # 全局钩子 def validate(self, attrs): # attrs 是个字典 print(attrs) # OrderedDict([('name', '三国'), ('price', Decimal('2.33')), ('publish', <Publish: 首都出版社>), ('authors', [<Author: hanmm>])]) publish = attrs.get('publish') print(publish, type(publish)) # 首都出版社 <class 'app01.models.Publish'> name = attrs.get('name') print(name, type(name)) # 三国 <class 'str'> if models.Book.objects.filter(name=name, publish=publish): raise ValidationError({'book': '该书已存在'}) return attrs

 

视图层

查 - 单查 | 群查

增 - 单增 | 群增

删 - 单删 | 群删

class V2Book(APIView): # 单查 有pk(有指定的查) # 群查 无pk def get(self, request, *args, **kwargs): pk = kwargs.get('pk') if pk: try: book_obj = models.Book.objects.get(pk=pk, is_delete=False) book_data = serializers.V2BookModelSerializer(book_obj).data except: return Response({ 'status': 1, 'msg': '书籍不存在' }) else: book_query = models.Book.objects.filter(is_delete=False).all() book_data = serializers.V2BookModelSerializer(book_query, many=True).data return Response({ 'status': 0, 'msg': 'ok', 'results': book_data }) ​ # 单增 : 传输的数据包是一个与model类对应的字典, 需要逻辑判断 # 群层 : 传输的数据包是一个装了多个与model类对应的列表, 需要逻辑判断 def post(self, request, *args, **kwargs): request_data = request.data # 单增与群增的代码一样,区别在与反序列化时是否指定many=True if isinstance(request_data, dict): # 判断request_data是否是dict的对象 # 是单增 many=False many = False elif isinstance(request_data, list): # 判断request_data是否是dict的对象 # 是群增 many=True many = True else: # 都没通过数据有误 return Response({ 'status': 1, 'msg': '数据有误', }) # 反序列化 book_ser = serializers.V2BookModelSerializer(data=request_data, many=many) # 校验字段是否都符合 book_ser.is_valid(raise_exception=True) book_obj_list = book_ser.save() print(book_obj_list, type(book_obj_list)) # [<Book: 东游>, <Book: 水浒>] <class 'list'> return Response({ 'status': 0, 'msg': 'ok', 'results':serializers.V2BookModelSerializer(book_obj_list, many=many).data }) ​ # 单删 有pk 指定一个pk # 群删 有pks 指定多个pk {"pks": [1, 2, 3]} def delete(self, request, *args, **kwargs): pk = kwargs.get('pk') if pk: pks = [pk] else: pks =request.data.get('pks') # 返回修改几条记录的数量 num = models.Book.objects.filter(pk__in=pks, is_delete=False).update(is_delete=True) if num: return Response({ 'status': 0, 'msg': '删除成功', }) return Response({ 'status': 1, 'msg': '删除失败', })

 

路由层

from django.conf.urls import url from . import views ​ urlpatterns = [ url('^v2/books/$', views.V2Book.as_view()), url('^v2/books/(?P<pk>.*)/$', views.V2Book.as_view()), ]

 

改的操作:

单改 - 单整体改 | 单局部改

群改 - 群整体改 | 群局部改

1) 单整体改，说明前台要提供修改的数据，那么数据就需要校验，校验的数据应该在实例化“序列化类对象”时，赋值给data 2）修改，就必须明确被修改的模型类对象，并在实例化“序列化类对象”时，赋值给instance 3）整体修改，所有校验规则有required=True的字段，都必须提供，因为在实例化“序列化类对象”时，参数partial默认为False

 

1.单整体修改，一般用put请求：# 如果partial值设置为True，就是可以局部改 book_ser = serializers.V2BookModelSerializer( instance=book_obj, # instance是要被修改的对象,有这个参数就是修改,没有就是增加 data=request_data, # 参与反序列化校验的数据信息 partial=False, # partial默认就是False,意思是每个必须字段都要有,也就是整体改,反之是局部改 ) 2.单局部修改，一般用patch请求： V2BookModelSerializer( instance=要被更新的对象, data=用来更新的数据, partial=设置True，必须的字段都变为选填字段 ) 注：partial设置True的本质就是使字段 required=True 校验规则失效

 

1.单整体改:

# 单整体修改:对 v2/books/(pk)/ 传的数据是与model对应的字典{name|price|publish|authors} def put(self, request, *args, **kwargs): # 数据 request_data = request.data # 被修改model类对象的pk pk = kwargs.get('pk') # 先拿到被修改的model类对象,再利用反序列化校验request_data数据 book_obj = models.Book.objects.filter(pk=pk).first() if book_obj is None: return Response({ 'status': 1, 'msg': '参数错误', }) # 目的：将众多数据的校验交给序列化类来处理 - 让序列化类扮演反序列化角色，校验成功后，序列化类来帮你入库 book_ser = serializers.V2BookModelSerializer( instance=book_obj, # instance是要被修改的对象,有这个参数就是修改,没有就是增加 data=request_data, # 参与反序列化校验的数据信息 partial=False, # partial默认就是False,意思是每个必须字段都要有,也就是整体改,反之是局部改 ) # 校验 book_ser.is_valid(raise_exception=True) # 校验通过后利用save()方法,调用ModelSerializer中的update方法自动完成单个整体修改 book_ser.save() return Response({ 'status': 0, 'msg': 'ok', 'results': serializers.V2BookModelSerializer(instance=book_obj).data # instance=book_obj 也可以只写book_obj,默认就是传给instance })

 

2.单与群 的 整体/局部修改 ListSerializer

serializers.py文件中

from rest_framework.serializers import ListSerializer # 重点：ListSerializer与ModelSerializer建立关联的是：ModelSerializer的Meta类的 - list_serializer_class class V2BookListSerializer(ListSerializer): def update(self, instance, validated_data): print(instance) # 要更新的model类对象们,如Book表的一条条记录 print(validated_data) # 更新的model对象对应的数据们(前端传来的) print(self.child) # 服务的模型序列化类 (这里是:V2BookModelSerializer) for index, obj in enumerate(instance): # drf框架没有群改实现体,调用的是ModelSerializer的update self.child.update(obj, validated_data[index]) return instance # 原模型序列化类变化 class V2BookModelSerializer(ModelSerializer): class Meta: # 群改，需要设置 自定义ListSerializer，重写群改的 update 方法 list_serializer_class = V2BookListSerializer ...

 

视图层

# 单局部改：对 v2/books/(pk)/ 传的数据，数据字段key都是选填 # 群局部改：对 v2/books/ # 请求数据 - [{pk:1, name:123}, {pk:3, price:7}, {pk:7, publish:2}] def patch(self, request, *args, **kwargs): request_data = request.data pk = kwargs.get('pk') ​ # 将单改，群改的数据都格式化成 pks=[需要的对象主键标识] | request_data=[每个要修改的对象对应的修改数据] if pk and isinstance(request_data, dict): # 单局部改 pks = [pk,] request_data = [request_data,] elif not pk and isinstance(request_data, list): #群局部改 # 拿到pk pks = [] for dic in request_data: # 遍历前台数据[{pk:1, name:123}, {pk:3, price:7}, {pk:7, publish:2}]，拿一个个字典 pk = dic.pop('pk', None) # 若前台没有传pk,要指定None if pk: pks.append(pk) else: return Response({ 'status': 1, 'msg': '数据有误', }) else: return Response({ 'status': 1, 'msg': '数据有误', }) ​ # pks与request_data数据筛选， # 1）将pks中的没有对应数据的pk与数据已删除的pk移除，request_data对应索引位上的数据也移除 # 2）将合理的pks转换为 objs objs = [] new_request_data = [] for index, pk in enumerate(pks): try: # 拿到pk对应的合理model对象,并存储 obj = models.Book.objects.get('pk') objs.append(obj) # 对应索引的数据就需要保存下来 new_request_data.append(request_data[index]) except: continue book_ser = serializers.V2BookModelSerializer( instance=objs, data=new_request_data, partial=True, # 字段任意 群局部改和群整体改都可以 many=True, ) book_ser.is_valid(raise_exception=True) book_objs = book_ser.save() # update与create 都会返回对应的model对象 return Response({ 'status': 0, 'msg': 'ok', 'results': serializers.V2BookModelSerializer(book_objs, many=True).data })

 

 总结:

1、整体修改与局部修改 # 序列化 ser_obj = ModelSerializer(model_obj) # 反序列化，save() => create() ser_obj = ModelSerializer(data=model_data) # save() => update() ser_obj = ModelSerializer(instance=model_obj,data=model_data) # partial=True => 匹配字段required=True校验条件 ser_obj = ModelSerializer(instance=model_obj,data=model_data,partial=True) 2、群改ListSerializer ser_obj = ModelSerializer(instance=model_obj,data=model_data,partial=True,many=True) # 一旦设置了many=True，反序列化情况下的create、update就不再调用ModelSerializer的 # 而是调用 ModelSerializer.Meta.list_serializer_class 指向的 ListSerializer 类的create、update # ListSerializer默认只实现了群增的create，要实现群改，必须重写update class MyListSerializer(ListSerializer): def update(self, instance, validated_data): # print(instance) # 要更新的对象们: [obj1, obj2, ...] # print(validated_data) # 更新的对象对应的数据们: [{}, {}, ...] # print(self.child) # 服务的模型序列化类 - V2BookModelSerializer for index, obj in enumerate(instance): self.child.update(obj, validated_data[index]) return instance class MyModelSerializer(ModelSerializer): class Meta: # ... list_serializer_class = MyListSerializer 将两者类建立关联，在MyListSerializer中就可以用self.child拿到MyModelSerializer，进而使用MyModelSerializer中封装好的方法 cls.Meta.list_serializer_class.child = cls