二次封装 Response方法
自定义APIResponse方法继承Response，重新 __ init _ _方法
# 自定义APIResponse方法，便于以后每次使用Response
from rest_framework.response import Response
# 1.自定义一个类，继承 drf的 Response方法，重写该方法的 __init__方法
class APIResponse(Response):
# 格式化 data
def __init__(self, status=0, msg='ok', results=None, http_status=None, headers=None, exception=False, **kwargs):
data = {
# json的response基础有数据状态码和数据状态信息
'status': status,
'msg': msg
}
if results is not None: # 如果后台有响应数据返回
data['results'] = results
# 如后台有响应的其它信息（一切自定义数据），直接放到响应数据data中
data.update(**kwargs)
super().__init__(data=data, status=http_status, headers=headers, exception=exception)
基表设置 （注意设置abstract = True）
from django.db import models
# 知识点（一）基表
"""
如果数据库中有多张表都存在相同的字段，这时可以设置一个基表, 继承基表
在 Model 类的内部配置 Meta 类并设置 abstract=True ,这就表示作为基表
"""
class BaseModel(models.Model):
create_time = models.DateTimeField(auto_now_add=True)
is_delete = models.BooleanField(default=False)
class Meta:
# 基表必须设置 abstract,基表是给普通的 Model类继承使用的，设置abstract就不会完成数据库迁移完成建表
abstract = True
class Book(BaseModel):
name = models.CharField(max_length=32)
price = models.DecimalField(max_digits=5, decimal_places=2)
class Publish(BaseModel):
name = models.CharField(max_length=32)
address = models.CharField(max_length=64)
...
ORM多表关联操作
外键所放位置
一对多：外键放在多的一方
多对多：外键放在常用的一方
一对一：外键放在不常用的一方（从逻辑正方向考虑，如作者和作者详情表（一对一关系），如果外键放在作者表中（常用表；此时被关联关系），一旦删除了详情表，作者也会被级联删除，但是详情删除应当对作者保留（因为存在有的作者没有设置详情），所以外键不应该放在作者表中；外键放在详情表中（不常用，此时是被关联关系），删除作者，会级联删除详情，因为作者删除后详情存在就无意义，和之前的一对一关系外键放置不一样，之前都是把外键放在查询频率高的表）
模型层：models.py
class BaseModel(models.Model):
create_time = models.DateTimeField(auto_now_add=True)
is_delete = models.BooleanField(default=False)
class Meta:
# 基表必须设置 abstract,基表是给普通的 Model类继承使用的，设置abstract就不会完成数据库迁移完成建表
abstract = True
# 知识点（二）表断关联
class Book(BaseModel):
name = models.CharField(max_length=32)
price = models.DecimalField(max_digits=5, decimal_places=2)
publish = models.ForeignKey(to='Publish', related_name='books', db_constraint=False, on_delete=models.DO_NOTHING)
# 重点：多对多外键实际在关系表中，ORM默认关系表中两个外键字段都是级联
# ManyToManyField字段不提供设置on_delete, 如果想设置关系表级联，只能手动定义关系表
authors = models.ManyToManyField(to='Author', related_name='books', db_constraint=False)
# 自定义序列化字段
@property
def publish_name(self):
return self.publish.name
@property
def authors_list(self):
temp_author_list = []
for author in self.authors.all():
temp_author_list.append({
'name': author.name,
'sex': author.get_sex_display(),
'phone': author.detail.phone
})
return temp_author_list
class Publish(BaseModel):
name = models.CharField(max_length=32)
address = models.CharField(max_length=64)
class Author(BaseModel):
name = models.CharField(max_length=16)
sex = models.IntegerField(choices=((0, '男'), (1, '女')), default=0)
class AuthorDetail(BaseModel):
phone = models.CharField(max_length=11, default=None)
# 有作者可以没有详情，删除作者，详情一定会被级联删除
# 外键字段为正向查询字段，related_name是反向查询字段
author = models.OneToOneField(to='Author', related_name='detail', db_constraint=False, on_delete=models.CASCADE)
"""
表断关联：
1.表之间没有外键关联，但是有外键逻辑关联
2.断关联后不会影响数据库查询效率，但是会极大提高数据库增删改效率（不影响增删改查操作）
3.断关联一定要通过逻辑保证表之间数据的安全
4.断关联：db_constraint=False,设置了这个参数就表示断关联
5.级联关系：
作者没了，详情也没： on_delete=models.CASCADE
出版社没了，但书还是那个出版社出版的： on_delete=models.DO_NOTHING
部门没了，员工没有部门（空部门）： null=True, on_delete=models.SET_NULL
部门没了，员工进入默认部门（默认值）：default=0, on_delete=models.SET_DEFAULT
6.重点：多对多外键实际在关系表中，ORM默认关系表中两个外键字段都是级联
ManyToManyField字段不提供设置 on_delete, 如果想设置关系表级联，只能手动定义关系表
7.外键字段为正向查询字段，related_name是反向查询字段
"""
多表查询之单查、群查
序列化层：api/serializer.py
from rest_framework.serializers import ModelSerializer
from . import models
class BookModelSerializer(ModelSerializer):
class Meta:
model = models.Book
fields = ['name', 'price', 'publish_name', 'authors_list']
路由层：api/urls.py
from django.conf.urls import url, include
from . import models
from . import views
urlpatterns = [
url(r'^books/$', views.BookAPIView.as_view()),
url(r'^books/(?P<pk>d+)$', views.BookAPIView.as_view())
]
视图层：views.py
from rest_framework.views import APIView
from . import models
from .response import APIResponse
from .serializer import BookModelSerializer
class BookAPIView(APIView):
def get(self, request, *args, **kwargs):
pk = kwargs.get('pk')
if pk:
book_obj = models.Book.objects.filter(pk=pk).first()
if not book_obj:
return APIResponse(1, '单查 error',http_status=400)
book_data = BookModelSerializer(book_obj).data
return APIResponse(results=book_data)
# 群查
book_ser = models.Book.objects.filter(is_delete=False).all()
book_list_data = BookModelSerializer(book_ser, many=True).data
return APIResponse(results=book_list_data)
def post(self,request,*args,**kwargs):
#单增:传的数据是与model对应的一个字典
# 群增：设计传递的是多个model对应的字典列表
request_data = request.data
if isinstance(request_data,dict):
many = False
elif isinstance(request_data,list): #在postman中设计一个列表存入每条数据
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_result = book_ser.save() #book_result是对象<class 'app01.models.Book'>，如果增加多个就是列表套一个个对象
return Response({
'status':0,
'msg':'ok',
'results':serializers.V2BookModelSerializer(book_result,many=many).data
})
#单删: 有pk #在postman中通过路径传参
#群删：有pks {"pks": [1, 2, 3]} #通过json传参
def delete(self,request,*args,**kwargs):
pk = kwargs.get('pk')
if pk:
pks = [pk]
else:
pks = request.data.get('pks')
if models.Book.objects.filter(pk__in=pks,is_delete=False).update(is_delete=True):
return Response({
'status':0,
'msg':'删除成功'
})
return Response({
'status':1,
'msg':'删除失败'
})
视图层注意点：(**)
1.序列化数据最后必须要.data （因为要传给前端）
2.反序列化通过data传参，序列化通过instance传参（当你只传一个参数时，默认是instanca的参数）
3.反序列化与序列化都能使用many=True，序列化和反序列化数据只要被[]嵌套都要写many=True
instance/data/many/partial四个关键参数的用法总结
instance/data/many/partial 影响序列化对象行为的四个关键参数。
1.如果没有data参数，只有instance，那么就不存在反序列化校验一说，只有序列化对象instance。
2.如果有data，没有instance，那么需要进行校验data，然后将data进行反序列化，得到validated_data,此时再通过序列化对象获取data，这个data和初始化提供的data可不一样，这个序列化validated_data后的data，比起初始化data，可能减少了无效的字段（序列化没有定义的字段）。
3.如果又提供了instance 又提供了data, 那么只要有data或者部分data，那么data都要进行验证才能进行下面的save等操作，如果不经过is_valid过程，那么后面的获取序列化数据或者反序列化数据都会无效。
4.many参数将直接影响序列化类的类型，如果是many=False，那么直接使用当前序列化类。如果many=True,将实例化一个ListSerializer类来序列化或者反序列化类。（这也是看源码是漏掉的地方，一直奇怪普通Serialiszer类怎么没看到对多对象序列化的特殊处理。查看BaseSerializer.__new__方法）或者class Meta:中定义了list_serializer_class指定的多对象序列化类。
5.终于弄懂了，partial用于部分更新，为啥子要伴随instance,因为要指明给save用，在save操作时给那个instance部分更新。逻辑这回走到下面源码中的get_initial()获取要进行更新instance的字段数据。
单整体改
单指的是单独一条数据，整体指这条数据的所有字段都必须传值修改
基于上述文章的代码修改，序列化层不用变，只修改views.py
1) 单整体改，说明前台要提供修改的数据，那么数据就需要校验，校验的数据应该在实例化“序列化类对象”时，赋值给data
2）修改，就必须明确被修改的模型类对象，并在实例化“序列化类对象”时，赋值给instance，必须赋值给instance
3）整体修改，所有校验规则有required=True的字段，都必须提供，因为在实例化“序列化类对象”时，参数partial默认为False
注：如果partial值设置为True，就是可以局部改
1）单整体修改，一般用put请求：
V2BookModelSerializer(
instance=要被更新的对象,
data=用来更新的数据,
partial=默认False，必须的字段全部参与校验
)
2）单局部修改，一般用patch请求：
V2BookModelSerializer(
instance=要被更新的对象,
data=用来更新的数据,
partial=设置True，必须的字段都变为选填字段
)
注：partial设置True的本质就是使字段 required=True 校验规则失效
请求方法：put 整体修改
请求参数：pk从路由传参，修改的数据通过数据包json传递
请求接口： http://127.0.0.1:8080/app01/books/pk/
#单整体改 对/books/pk/ 传的参数是与model对应的字典 {name|price|publish|authors}在json中传递
def put(self,request,*args,**kwargs):
request_data = request.data
pk = kwargs.get('pk')
#先获取要修改的对象
try:
old_book_obj = models.Book.objects.get(pk=pk,is_delete=False)
except:
#当输入不存在的pk
return Response({
'status':1,
'msg':'参数错误'
})
book_ser = serializers.V2BookModelSerializer(instance=old_book_obj,data=request_data,partial=False)
book_ser.is_valid(raise_exception=True)
book_obj = book_ser.save()
return Response({
'status':0,
'msg':'ok',
'results':serializers.V2BookModelSerializer(book_obj).data
})
单整体修改注意点（******）
1.需要修改的数据通过data传递
2.需要修改的模型类对象必须传递给instance
3.参数partial设置为False (默认是False,这里不设置也行)
单局部修改
单整体修改和单局部修改只有一点不相同：
设置参数partial=True，就变成单局部修改，修改的参数就不必全部传，想修改什么数据就传什么数据
单局部修改和群局部修改整合
序列化层 serializer.py
群改（重点）需要设置ListSerializer，创建BookListSerializer继承ListSerializer,重写update方法
# 重点：ListSerializer与ModelSerializer建立关联的是：
# ModelSerializer的Meta类的 - list_serializer_class
class BookListSerializer(ListSerializer):
def update(self, instance, validated_data): #需要重写update方法
# print(instance) # 要更新的对象们
# print(validated_data) # 更新的对象对应的数据们
# print(self.child) # 服务的模型序列化类 - V2BookModelSerializer
for index, obj in enumerate(instance):
self.child.update(obj, validated_data[index])
return instance
# 原模型序列化类变化
class BookModelSerializer(ModelSerializer):
class Meta:
# ...
# 群改，需要设置 自定义ListSerializer，重写群改的 update 方法
list_serializer_class = V2BookListSerializer
请求方式：patch
请求参数：pk从路由获取，修改参数从数据包通过json格式传递 单局部修改： /books/pk/ pk通过路由传参，修改数据通过json传参 群局部修改： /books/ 修改的数据都是从json传递 eg:[{'pk':1,'name':'花果山'}，{'pk':2,'price':3.33}]
请求接口：http://127.0.0.1:8080/app01/books/pk/
视图层:views.py
#单局部改和群局部改整合
#单局部改：对 /books/pk/ pk通过路由传参，修改数据选择传参，通过数据包json传递
#群局部修改：/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): #群改
pks = []
# 遍历前台数据[{pk:1, name:123}, {pk:3, price:7}, {pk:7, publish:2}]，拿一个个字典
for dic in request_data:
pk=dic.pop('pk',None) #返回pk值
if pk:
pks.append(pk)
#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合理的对象数据保存下来
book_obj = models.Book.objects.get(pk=pk)
objs.append(book_obj)
#对应索引的数据也保存下来
new_request_data.append(request_data[index])
except:
# 重点：反面教程 - pk对应的数据有误，将对应索引的data中request_data中移除
#在for循环中不要使用删除
# index = pks.index(pk)
# request_data.pop(index)
continue
#生成一个serializer对象
book_ser = serializers.BookModelSerializer(instance=objs,data=new_request_data,partial=True,many=True)
book_ser.is_valid(raise_exception=True)
book_objs = book_ser.save()
return Response({
'status':0,
'msg':'ok',
'results':serializers.BookModelSerializer(book_objs,many=True).data
})
思路：
1.先将单改，群改的数据都格式化成 pks=[要需要的对象主键标识] | request_data=[每个要修改的对象对应的修改数据]
2.pks与request_data数据筛选，
将pks中的没有对应数据的pk与数据已删除的pk移除，request_data对应索引位上的数据也移除
将合理的pks转换为 objs
注意点：
1.本篇文章讲了局部修改patch,和整体修改put,都需要设置参数instance传入的是要修改的对象，data传入的是修改的数据2.群修改的话需要使用ListSerializer,重写update方法
(#####)
# 单整体改、群整体改
def put(self, request, *args, **kwargs):
"""
单整体改：前台提交字典，接口 /books/(pk)/
群整体改：前台提交列表套字典，接口 /books/，注每一个字典都可以通过pk
"""
pk = kwargs.get('pk')
request_data = request.data
if pk: # 单改
try:
book_obj = models.Book.objects.get(pk=pk)
except:
return APIResponse(1, 'pk error')
# 修改和新增，都需要通过数据，数据依旧给data，修改与新增不同点，instance要被赋值为被修改对象
book_ser = serializers.BookModelSerializer(instance=book_obj, data=request_data)
book_ser.is_valid(raise_exception=True)
book_obj = book_ser.save()
return APIResponse(results=serializers.BookModelSerializer(book_obj).data)
else: # 群改
if not isinstance(request_data, list) or len(request_data) == 0:
return APIResponse(1, 'data error', http_status=400)
# [{pk:1,...}, {pk:3,...}, {pk:100,...}] => [obj1, obj3, obj100] + [{...}, {...}, {...}]
# 要考虑pk对应的对象是否被删，以及pk没有对应的对象
# 假设pk3被删，pk100没有 => [obj1] + [{...}]
# 注：一定不要在循环体中对循环对象进行增删(影响对象长度)的操作
obj_list = []
data_list = []
for dic in request_data:
# request_data可能是list，单内部不一定是dict
try:
pk = dic.pop('pk')
try:
obj = models.Book.objects.get(pk=pk, is_delete=False)
obj_list.append(obj)
data_list.append(dic)
except:
pass
except:
return APIResponse(1, 'data error', http_status=400)
book_ser = serializers.BookModelSerializer(instance=obj_list, data=data_list, many=True)
book_ser.is_valid(raise_exception=True)
book_obj_list = book_ser.save()
return APIResponse(results=serializers.BookModelSerializer(book_obj_list, many=True).data)