写接口前的准备为演示方便，增删查改接口仅限于单张book表，其他表方法一样，数据库使用的是自带的 sqlite3。
创建模型表
# models.py
from django.db import models
class BaseModel(models.Model):
"""
将图书表、出版社表、作者表都有的三个字段写在一个 BaseModel 类中，直接继承即可
但是本 BaseModel 类也会生成一张表，如果不想要这张表，可以在内部的 Meta 类中定义 abstract=True
"""
is_delete = models.BooleanField(default=False) # 默认是 False，不删除
# 创建时间
create_time = models.DateTimeField(auto_now_add=True)
# auto_now_add=True 只要记录创建，不需要手动插入时间，自动将当前时间插入
# 另一种写法：
# import datetime
# create_time = models.DateTimeField(default=datetime.datetime.now) # now 不能加括号，不然记录的是每次程序启动的时间
# 最后更新时间
last_update_time = models.DateTimeField(auto_now=True)
# auto_now=True 只要更新，就把当前时间插入
class Meta:
# 单个字段，有索引，可唯一
# 多个字段，有联合索引，可联合唯一
abstract = True # 抽象表，不在数据库中建立出表
class Book(BaseModel):
id = models.AutoField(primary_key=True) # id 字段可以不写，不写默认也有。但所有的表最好统一，写就都写
name = models.CharField(max_length=32, help_text='这里填书名')
price = models.DecimalField(max_digits=5, decimal_places=2)
""" 外键 """
publish = models.ForeignKey(to='Publish', on_delete=models.DO_NOTHING, db_constraint=False)
# to_field 参数默认不用写，作用是关联到 Publish 主键
# db_constraint=False 表示这个外键只是逻辑上的关联，实质上没有外键联系。但不会影响增删改和 orm 查询
"""
表断关联：
1、表之间没有外键关联，但是有外键逻辑关联（有充当外键的字段）
2、断关联后不会影响数据库查询效率，但是会极大的提高数据库增删改的效率（不影响增删改查操作）
3、断关联一定要通过逻辑保证表之间数据的安全，不要出现脏数据（一般由程序员在代码层面限制）
4、断关联后的级联关系：
作者删掉，作者详情也跟着删掉：on_delete=models.CASCADE
出版社删掉，图书还在：on_delete=models.DO_NOTHING
部门删掉，员工还在，员工的部门可以为空：null=True，on_delete=models.SET_NULL
部门删掉，员工进入默认部门（默认值）：default=0, on_delete=models.SET_DEFAULT
"""
# 多对多的第三张表，只有关联字段时，用自动就够了，有扩展字段，用半自动
# 因为第三张表一共有三张表互相关联，所以不能写 on_delete
authors = models.ManyToManyField(to='Author', db_constraint=False)
def __str__(self):
return self.name
class Meta:
verbose_name_plural = '图书表' # admin 中显示中文表名
@property
def publish_name(self):
return self.publish.name
def author_list(self):
author_list = self.authors.all()
lis = []
for author in author_list:
lis.append({'name': author.name, 'sex': author.get_sex_display()})
return lis
# 也可以用列表推导式一行完成
# return [{'name': author.name, 'sex': author.get_sex_display()} for author in author_list]
class Publish(BaseModel):
id = models.AutoField(primary_key=True)
name = models.CharField(max_length=32)
addr = models.CharField(max_length=32)
def __str__(self):
return self.name
class Meta:
verbose_name_plural = '出版社表'
class Author(BaseModel):
name = models.CharField(max_length=32)
sex = models.IntegerField(choices=((1, '男'), (2, '女')))
""" 外键 """
# OneToOneField 本质就是 ForeignKey + unique
authordetail = models.OneToOneField(to='AuthorDetail', db_constraint=False, on_delete=models.CASCADE)
def __str__(self):
return self.name
class Meta:
verbose_name_plural = '作者表'
class AuthorDetail(BaseModel):
mobile = models.CharField(max_length=11)
def __str__(self):
return self.name
class Meta:
verbose_name_plural = '作者详情表'
写一个序列化类
# ser.py
from rest_framework import serializers
from api import models
# 写一个类，继承 ListSerializer，重写 update
class BookListSerializer(serializers.ListSerializer):
# 重写 create 方法，加了一个打印 validated_data 功能
# def create(self, validated_data):
# print(validated_data)
# return super().create(validated_data)
def update(self, instance, validated_data):
# instance ==> [book对象1, book对象2 ...]
# validated_data ==> [{name: xx, price: xx}, {name: xx, price: xx} ...]
# self.child 是 BookModelSerializer 对象，
# 想保存数据，可以使用 BookModelSerializer 的 update 方法，
return [
# self.child.update(对象，字典) for attrs in validated_data
self.child.update(instance[i], attrs) for i, attrs in enumerate(validated_data)
# 通过 enumerate 枚举出 validated_data 这个列表的 index（i） 和 字典（attrs）
]
class BookModelSerializer(serializers.ModelSerializer):
# 如何让前端收到的数据显示的是名称而不是id号：
# 方法一：
# publish = serializers.CharField(source='publish.name') # 只序列化可以，反序列化就有问题了
# 方法二，在 models.py 中对应的表里写一个方法 publish_name 就可以直接放在 fields 中
"""
@property
def publish_name(self):
return self.publish.name
"""
class Meta:
list_serializer_class = BookListSerializer
model = models.Book
# fields = '__all__'
# depth = 1 # 展示数据的深度，数字表示展示几层，很少用
fields = ('name', 'price', 'authors', 'publish', 'publish_name', 'author_list')
# 但前端会收到两个 publish，一个是 id 号，一个是名字。解决方法是定义一个为只写，一个为只读
extra_kwargs = {
'authors': {'write_only': True},
'author_list': {'read_only': True},
'publish': {'write_only': True},
'publish_name': {'read_only': True},
}
自定义异常处理和自定义Response
最好在项目文件夹下新建一个 utils 文件夹。
将自定义的异常处理写在 exceptions.py 中，放在 utils 文件夹内。
将自定义的Response写在 response.py 中，放在 utils 文件夹内。
但本次在视图类中没有使用自定义Response，只使用了自定义异常处理。
自定义异常处理
# exceptions.py
from rest_framework.views import exception_handler
from rest_framework import status
from rest_framework.response import Response
def my_exception_handler(exc, context):
response = exception_handler(exc, context)
if not response: # 如果返回的是 None
# if isinstance(exc, ZeroDivisionError): # 如果视图类中有特定错误就可以做出相应的返回
# return Response(data={'status': 777, 'msg': '除以0的错误' + str(exc)}, status=status.HTTP_400_BAD_REQUEST)
return Response(data={'status': 999, 'msg': str(exc)}, status=status.HTTP_400_BAD_REQUEST)
else: # 如果返回的是 response 对象
return Response(data={'status': 888, 'msg': response.data.get('detail')}, status=status.HTTP_400_BAD_REQUEST)
自定义Response
# response.py
from rest_framework.response import Response
class APIResponse(Response):
def __init__(self, code=100, msg='成功', data=None, status=None, headers=None, **kwargs):
dic = {'code': code, 'msg': msg}
if data:
dic = {'code': code, 'msg': msg, 'data': data}
dic.update(kwargs)
super().__init__(data=dic, status=status, headers=headers)
全局配置自定义的异常处理
# settings.py
REST_FRAMEWORK = {'EXCEPTION_HANDLER': 'utils.exceptions.my_exception_handler'}
配置URL
URL的配置使用了路由分发
# 项目下的 urls.py
from django.conf.urls import url, include
from django.contrib import admin
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^api/', include('api.urls'))
]
# 应用下的 urls.py
from django.conf.urls import url
from api import views
urlpatterns = [
url(r'^books/$', views.BookAPIView.as_view()),
url(r'^books/(?P<pk>\d+)', views.BookAPIView.as_view()),
url(r'^books2/$', views.Book2APIView.as_view()),
url(r'^books2/(?P<pk>\d+)', views.Book2APIView.as_view()),
]
基于 APIView 的视图类接口
from api import models
from rest_framework.views import APIView
from rest_framework.response import Response
from api.ser import BookModelSerializer
class BookAPIView(APIView):
def get(self, request, *args, **kwargs):
"""查询单条数据和查询所有数据合在一个方法中"""
# 查询单条数据
if kwargs.get('pk', None):
book = models.Book.objects.filter(pk=kwargs.get('pk')).first()
book_ser = BookModelSerializer(instance=book)
return Response(book_ser.data)
# 查询所有数据
book_list = models.Book.objects.all().filter(is_delete=False) # 查询所有没有被删的书
book_list_ser = BookModelSerializer(book_list, many=True)
return Response(data=book_list_ser.data)
def post(self, request, *args, **kwargs):
"""同时具备增单条和增多条的功能"""
# 如果是字典，就是单条数据新增
if isinstance(request.data, dict):
book_ser = BookModelSerializer(data=request.data)
book_ser.is_valid(raise_exception=True)
book_ser.save()
return Response(data=book_ser.data)
# 如果是列表，就是多条数据新增，列表内部是多个字典（单条数据）
elif isinstance(request.data, list):
book_ser = BookModelSerializer(data=request.data, many=True) # 增多条
# 有了 many=True 这个参数，book_ser 就是 ListSerializer 的对象了
# print(type(book_ser)) # 输出：<class 'rest_framework.serializers.ListSerializer'>
book_ser.is_valid(raise_exception=True)
book_ser.save() # ListSerializer 的 create 方法
"""
create 方法内部就是一个for循环，self.child 就是 BookModelSerializer 对象
也就是说，增多条的 ListSerializer 内部其实就是for循环了一个个增单条的 BookModelSerializer
def create(self, validated_data):
return [
self.child.create(attrs) for attrs in validated_data
]
"""
return Response(data=book_ser.data)
def put(self, request, *args, **kwargs):
"""同时具备单条修改和多条修改功能"""
# 单条数据修改
if kwargs.get('pk', None):
book = models.Book.objects.filter(pk=kwargs.get('pk')).first()
book_ser = BookModelSerializer(instance=book, data=request.data, partial=True)
# partial=True：允许局部修改，如只修改书名和价格
# 如果不写这个字段想达到同样的效果，要在 ser.py 的 extra_kwargs 中给每个字段都加上 require=False
book_ser.is_valid(raise_exception=True)
book_ser.save()
return Response(data=book_ser.data)
# 多条数据修改
else:
"""
前端传来的数据格式必须是：[{id: 1, name: xx, price: xx}, {id: 2, name: xx, price: xx}]
要先将数据处理成：对象列表[book对象1, book对象2] 和 要修改的数据列表[{name: xx, price: xx}, {name: xx, price: xx}]
"""
book_list = []
modify_data = []
for item in request.data:
# 前端传来的 request.data 可能不是列表套字典的格式，直接处理可能会报错，所以最好有全局的异常处理进行捕获
pk = item.pop('id')
book = models.Book.objects.get(pk=pk)
book_list.append(book)
modify_data.append(item)
"""
处理好后再修改数据，有两种方案：
第一种方案：
直接在视图里写，简单
for循环 book_ser = BookModelSerializer(instance=对象列表, data=修改的数据列表) 一个一个修改。
"""
# for i, is_data in enumerate(modify_data):
# book_ser = BookModelSerializer(instance=book_list[i], data=is_data)
# book_ser.is_valid(raise_exception=True)
# book_ser.save()
# return Response('成功')
"""
第二种方案：
在序列化类中写，不常用
book_ser = BookModelSerializer(instance=对象列表, data=修改的数据列表, many=True)
但要重写 ListSerializer 的 update 方法，
因为此时 book_ser 是 ListSerializer 的对象，而源码中没写 update 方法，
需要自己写一个类继承 ListSerializer，里面重写 update 方法。
问题在于如何让 BookModelSerializer 和自己写的类建立联系？
查看源码可知，ListSerializer 的父类 BaseSerializer 的 __new__() 中调用了 many_init()
many_init() 内部的如下代码通过反射，在meta中找不到 list_serializer_class 时才会走 ListSerializer
list_serializer_class = getattr(meta, 'list_serializer_class', ListSerializer)
因此可以在 ser.py 中自己写的 BookModelSerializer 的 Meta 类中定一个变量叫 list_serializer_class，
把自己写的 BookListSerializer 这个类赋给这个变量，在 BookListSerializer 内重写 update 方法
这样只要修改数据时 BookModelSerializer 传了 many=True，就走的是 BookListSerializer 的 update 方法
同样，如果重写了 create 方法，新增数据时只要传了 many=True，就走的是 BookListSerializer 的 create 方法
"""
book_ser = BookModelSerializer(instance=book_list, data=modify_data, many=True)
book_ser.is_valid(raise_exception=True)
book_ser.save()
return Response(book_ser.data)
def delete(self, request, *args, **kwargs):
"""单个删除和批量删除"""
pk = kwargs.get('pk') # 如果是单条删除，pk=要删除数据的id值，多条删除，pk=None
pks = []
if pk: # 如果有值，说明是单条删除
pks.append(pk) # 即使是单条数据也放在一个列表中，和多条删除用同一个方法处理
else: # 如果没有值，是多条删除
# 如果是多条删除，前端发来的数据格式必须是：{'pks': [要删除的多条数据的id值]}，这是下面一行代码规定的
# 获取到要删除的多条id值组成的列表
pks = request.data.get('pks')
# 最后，不论是单条还是多条删除，pks都是一个列表，里面是要删除数据的id值
ret = models.Book.objects.filter(pk__in=pks, is_delete=False).update(is_delete=True)
"""
pk__in：后面必须等于一个列表，是依次拿出列表里的每一项
is_delete=False：确保之前没有被删除过的数据被过滤出来
.update(is_delete=True)：用 update 方法加上 is_delete=True 来标识要被删除的数据
ret：返回值是受影响的行数（如果是0，表示要删的数据之前都已被标识为已删除了）
"""
if ret:
return Response(data={'msg': '删除成功！删除了%s条数据' % ret})
return Response(data={'msg': '没有要删除的数据...'})
基于 GenericAPIView 的视图类接口
from api import models
from rest_framework.generics import GenericAPIView
from rest_framework.response import Response
from api.ser import BookModelSerializer
class Book2APIView(GenericAPIView):
queryset = models.Book.objects.all()
serializer_class = BookModelSerializer
def get(self, request, *args, **kwargs):
"""单查和群查"""
if kwargs.get('pk'):
book = self.get_object()
book_ser = self.get_serializer(book)
return Response(book_ser.data)
# 查询所有数据
book_list = self.get_queryset().filter(is_delete=False) # 查询所有没有被删的书
book_list_ser = self.get_serializer(book_list, many=True)
return Response(data=book_list_ser.data)
def post(self, request, *args, **kwargs):
"""单增和群增"""
if isinstance(request.data, dict):
book_ser = self.get_serializer(data=request.data)
book_ser.is_valid(raise_exception=True)
book_ser.save()
return Response(data=book_ser.data)
elif isinstance(request.data, list):
book_ser = self.get_serializer(data=request.data, many=True)
book_ser.is_valid(raise_exception=True)
book_ser.save()
return Response(data=book_ser.data)
def put(self, request, *args, **kwargs):
"""单修和群修"""
if kwargs.get('pk'):
book = self.get_object()
book_ser = self.get_serializer(instance=book, data=request.data, partial=True)
book_ser.is_valid(raise_exception=True)
book_ser.save()
return Response(data=book_ser.data)
else:
book_list = []
modify_data = []
for item in request.data:
pk = item.pop('pk')
book = self.get_queryset().get(pk=pk)
# book = self.get_queryset().filter(pk=pk).first() # 这样写也可以
book_list.append(book)
modify_data.append(item)
book_ser = self.get_serializer(instance=book_list, data=modify_data, many=True, partial=True)
book_ser.is_valid(raise_exception=True)
book_ser.save()
return Response(book_ser.data)
def delete(self, request, *args, **kwargs):
"""单删和多删"""
pk = kwargs.get('pk')
pks = []
if pk:
pks.append(pk)
else:
pks = request.data.get('pks')
ret = self.get_queryset().filter(pk__in=pks, is_delete=False).update(is_delete=True)
if ret:
return Response(data={'msg': '删除成功！删除了%s条数据' % ret})
return Response(data={'msg': '没有可删除的数据...'})
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
