天天看点
返回

带你读《Python Django Web典型模块 开发实战》之二：用Django REST framework实现第2章 用Django REST framework实现

点击查看第一章 点击查看第三章

第2章 用Django REST framework实现

豆瓣API应用

　　活跃在互联网上的年轻人中，不论是文艺青年还是非文艺青年，可能都会去逛豆瓣网（以后简称为豆瓣），因此大家对豆瓣并不陌生。豆瓣上多年以来囤积的海量数据，对于无数与文艺相关的项目是非常重要的内容。比如想要开发一个面向喜欢重金属音乐的用户群体的音乐推荐软件，就需要获取豆瓣中重金属类目下的音乐数据信息，以此了解哪些音乐评分较高。

　　几年前，豆瓣这些数据的API，都是免费提供给广大开发者的，但是随着近些年数据资产的价值越来越被重视，豆瓣向外提供数据查询的API开始收费，包括电影、图书、音乐等所有类目。

　　开发者想要获得豆瓣上的数据，需要向豆瓣付费，才可以有权限调用相关的API，而本章就是开发一个这样的业务模型。

2.1 豆瓣API功能介绍

　　豆瓣图书的API功能原理是用户通过输入图书的ISBN号（书号）、书名、作者、出版社等部分信息，就可获取到该图书在豆瓣上的所有信息。当然，API中除了要包含检索信息之外，还要包含开发者的apikey，用来记录开发者访问API的次数，以此向开发者收费。目前豆瓣图书的API是0.3元/100次。

2.2 Django REST framework序列化

　　序列化（Serialization）是指将对象的状态信息转换为可以存储或传输形式的过程。在客户端与服务端传输的数据形式主要分为两种：XML和JSON。在Django中的序列化就是指将对象状态的信息转换为JSON数据，以达到将数据信息传送给前端的目的。

　　序列化是开发API不可缺少的一个环节，Django本身也有一套做序列化的方案，这个方案可以说已经做得很好了，但是若跟Django REST framework相比，还是不够极致，速度不够快。

2.2.1 Postman的使用

　　Postman是一款非常流行的API调试工具，其使用简单、方便，而且功能强大。

　　通过Postman可以便捷地向API发送GET、POST、PUT和DELETE请求，几乎是资深或者伪资深开发人员调试API的首选。当然，这并不是Postman在开发领域如此受欢迎的唯一理由。Postman最早是以Chrome浏览器插件的形式存在，可以从Chrome应用商店搜索、下载并安装，后来因为一些原因，Chrome应用商店在国内无法访问， 2018年Postman停止了对Chrome浏览器的支持，提供了独立安装包，不再依赖Chrome，同时支持Linux、Windows和Mac OS系统。

　　测试人员做接口测试会有更多选择，例如Jmeter和soapUI等，因为测试人员就是完成产品的测试，而开发人员不需要有更多的选择，毕竟开发人员是创新者、创造者。Postman的下载地址是

https://www.getpostman.com/apps

。

2.2.2 用serializers.Serializer方式序列化

　　还记得我们在第1章中新建的Django项目book吗？下面我们来一起在这个项目中一步一步地通过Serializer序列化组件，完成豆瓣API核心功能的开发。

　　（1）打开项目book。

　　（2）安装Django REST framework及其依赖包markdown和django-filter。命令如下：

　　

　　pip install djangorestframework markdown django-filter

　　（3）在settings中注册，代码如下：

INSTALLED_APPS = [
　　    'django.contrib.admin',
　　    'django.contrib.auth',
　　    'django.contrib.contentTypes',
　　    'django.contrib.sessions',
　　    'django.contrib.messages',
　　    'django.contrib.staticfiles',
　　    'users.apps.UsersConfig',
　　    'rest_framework'
　　]

　　（4）设计users的models.py，重构用户表UserProfile，增加字段APIkey和money。当然，为了演示核心功能，可以建立一张最简单的表，大家可以根据个人喜好增加一些业务字段来丰富项目功能。

from django.db import models
　　from django.contrib.auth.models import AbstractUser
　　# Create your models here.
　　class UserProfile(AbstractUser):
　　    """
　　    用户
　　    """
　　    APIkey=models.CharField(max_length=30,verbose_name='APIkey',default='abcdefghigklmn')
　　    money=models.IntegerField(default=10,verbose_name='余额')
　　    class Meta:
　　        verbose_name='用户'
　　        verbose_name_plural = verbose_name
　　    def __str__(self):
　　        return self.username

　　（5）在settings中配置用户表的继承代码：

AUTH_USER_MODEL='users.UserProfile'

　　（6）在users的models.py文件中新建书籍信息表book，为了演示方便，我们姑且将作者字段并入书籍信息表，读者在实际项目中可根据业务模式灵活设计数据表model：

from datetime import datetime
　　from django.db import models
　　class Book(models.Model):
　　    """
　　    书籍信息
　　    """
　　    title=models.CharField(max_length=30,verbose_name='书名',default='')
　　    isbn=models.CharField(max_length=30,verbose_name='isbn',default='')
　　    author=models.CharField(max_length=20,verbose_name='作者',default='')
　　    publish=models.CharField(max_length=30,verbose_name='出版社',default='')
　　    rate=models.FloatField(default=0,verbose_name='豆瓣评分')
　　    add_time = models.DateTimeField(default=datetime.now, verbose_name='添加时间')
　　    class Meta:
　　        verbose_name='书籍信息'
　　        verbose_name_plural = verbose_name
　　    def __str__(self):
　　        return self.title

　　（7）执行数据更新命令：

python manage.py makemigrations
　　python manage.py migrate

　　（8）建立一个超级用户，用户名为admin，邮箱为[email protected]，密码为admin1234。

python manage.py createsuperuser
　　Username: admin
　　邮箱: [email protected]
　　Password:
　　Password (again):

　　（9）通过PyCharm的Databases操作面板，直接在book表内增加一条记录，title为一个书名，isbn为777777，author为一个作者，publish为一个出版社，rate为6.6，add_time为154087130331。

　　（10）准备工作已经完成，接下来是我们的“正片”开始啦。在users目录下新建py文件serializers，将序列化的类代码写入其中：

from rest_framework import serializers
　　from .models import UserProfile,Book
　　class BookSerializer(serializers.Serializer):
　　    title=serializers.CharField(required=True,max_length=100)
　　    isbn=serializers.CharField(required=True,max_length=100)
　　    author=serializers.CharField(required=True,max_length=100)
　　    publish=serializers.CharField(required=True,max_length=100)
　　    rate=serializers.FloatField(default=0)

　　（11）在users/views中编写视图代码：

from .serializers import BookSerializer
　　from rest_framework.views import APIView
　　from rest_framework.response import Response
　　from .models import UserProfile,Book
　　class BookAPIView1(APIView):
　　    """
　　    使用Serializer
　　    """
　　    def get(self, request, format=None):
　　        APIKey=self.request.query_params.get("apikey", 0)
　　        developer=UserProfile.objects.filter(APIkey=APIKey).first()
　　        if developer:
　　            balance=developer.money
　　            if balance>0:
　　                isbn = self.request.query_params.get("isbn", 0)
　　                books = Book.objects.filter(isbn=int(isbn))
　　                books_serializer = BookSerializer(books, many=True)
　　                developer.money-=1
　　                developer.save()
　　                return Response(books_serializer.data)
　　            else:
　　                return Response("兄弟，又到了需要充钱的时候！好开心啊！")
　　        else:
　　            return Response("查无此人啊")

　　（12）在urls中配置路由如下：

from django.contrib import admin
　　from django.urls import path
　　from users.views import BookAPIView1
　　urlpatterns = [
　　    path('admin/', admin.site.urls),
　　    path('apibook1/',BookAPIView1.as_view(),name='book1'),
　　]

　　至此，我们可以运行book项目，使用Postman访问API来测试一下啦。我们用Postman的GET方式访问API：

http://127.0.0.1:8000/apibook1/?apikey=abcdefghigklmn&isbn=777777

　　我们获得了想要的JSON数据：

[
　　    {
　　        "title": "一个书名",
　　        "isbn": "777777",
　　        "author": "一个作者",
　　        "publish": "一个出版社",
　　        "rate": 6.6
　　    }
　　]

　　然后到数据库中查看一下，发现用户admin的money被减去了1，变成了9。当我们用Postman故意填错apikey时，访问：

http://127.0.0.1:8000/apibook1/?apikey=abcdefghigklmn33&isbn=777777

　　API返回的数据为：

　　"查无此人啊"

　　当我们连续访问10次：

http://127.0.0.1:8000/apibook1/?apikey=abcdefghigklmn&isbn=777777

　　"兄弟，又到了需要充钱的时候！好开心啊！"

　　至此，一个简单的模仿豆瓣图书API的功能就实现了。在实际的项目中，这样的实现方式虽然原理很清晰，但是存在着很明显的短板，比如被查询的表的字段不可能只有几个，我们在真正调用豆瓣图书API的时候就会发现，即使只查询一本书的信息，由于有很多的字段和外键字段，返回的数据量也会非常大。如果使用Serializer进行序列化，那么工作量实在太大，严重影响了开发效率。

　　所以，这里使用Serializer进行序列化，目的是让大家通过这种序列化方式更加轻松地理解Django REST framework的序列化原理。在实际生产环境中，更加被广泛应用的序列化方式是采用了Django REST framework的ModelSerializer。

2.2.3 用serializers.ModelSerializer方式序列化

　　在上一节中，我们通过使用Django REST framework的Serializer序列化，实现了一个模仿豆瓣图书API的功能，在这一节，我们将要使用Django REST framework的ModelSerializer来实现这个功能。因为都是在book项目中，所以上一节中介绍的很多步骤我们没有必要重复。我们现在要做的，首先是到数据库中的UserProfile表中，将用户admin的money从0修改回10，不然API只能返回提醒充值的数据。

　　在users/Serializer.py中，写book的ModelSerializer序列化类：

from rest_framework import serializers
　　from .models import UserProfile,Book
　　class BookModelSerializer(serializers.ModelSerializer):
　　    class Meta:
　　        model = Book
　　        fields="__all__"                #将整个表的所有字段都序列化

　　在users/views.py中，编写基于BookModelSerializer的图书API视图类：

from .serializers import BookModelSerializer
　　from rest_framework.views import APIView
　　from rest_framework.response import Response
　　from .models import UserProfile,Book
　　class BookAPIView2(APIView):
　　    """
　　    使用ModelSerializer
　　    """
　　    def get(self, request, format=None):
　　        APIKey=self.request.query_params.get("apikey", 0)
　　        developer=UserProfile.objects.filter(APIkey=APIKey).first()
　　        if developer:
　　            balance=developer.money
　　            if balance>0:
　　                isbn = self.request.query_params.get("isbn", 0)
　　                books = Book.objects.filter(isbn=int(isbn))
　　                books_serializer = BookModelSerializer(books, many=True)
　　                developer.money-=1
　　                developer.save()
　　                return Response(books_serializer.data)
　　            else:
　　                return Response("兄弟，又到了需要充钱的时候！好开心啊！")
　　        else:
　　            return Response("查无此人啊")

注意：使用ModelSerializer序列化对应的视图类与使用Serializer进行序列化对应的视图类，除了序列化的方式不同，其他的代码都是相同的。

　　在urls中配置路由代码：

from django.contrib import admin
　　from django.urls import path
　　from users.views import BookAPIView1,BookAPIView2
　　urlpatterns = [
　　    path('admin/', admin.site.urls),
　　    path('apibook1/',BookAPIView1.as_view(),name='book1'),
　　    path('apibook2/',BookAPIView2.as_view(),name='book2'),
　　]

　　使用Postman对API进行测试，用GET的方式访问：

http://127.0.0.1:8000/apibook2/?apikey=abcdefghigklmn&isbn=777777

　　返回书籍所有的字段数据：

[
　　    {
　　        "id": 1,
　　        "title": "一个书名",
　　        "isbn": "777777",
　　        "author": "一个作者",
　　        "publish": "一个出版社",
　　        "rate": 6.6,
　　        "add_time": null
　　    }
　　]

注意：这里的add_time字段为null，是因为这个项目使用了Django默认的db.sqlite3数据库。由于db.sqlite3在存储时间字段的时候，是以时间戳的格式保存的，所以直接使用Django REST framework的Serializer进行序列化失败。在实际项目中，我们会选择MySQL等主流数据库，就不会出现这种情况了。

　　可以看出，对于一条有很多字段的数据记录来说，使用ModelSerializer的序列化方式，可以一句话将所有字段序列化，非常方便。当然，ModelSerializer也可以像Serializer一样对某几个特定字段进行序列化，写法也很简单，只需要对原本的BookModelSerializer修改一行代码：

class BookModelSerializer(serializers.ModelSerializer):
　　    class Meta:
　　        model = Book
　　        # fields="__all__"                        #将整个表的所有字段都序列化
　　        fields = ('title', 'isbn', 'author')     #指定序列化某些字段           
http://127.0.0.1:8000/apibook2/?apikey=abcdefghigklmn&isbn=777777

　　返回的数据就成了：

[
　　    {
　　        "title": "一个书名",
　　        "isbn": "777777",
　　        "author": "一个作者"
　　    }
　　]

　　至此，我们对Django REST framework的两种序列化方式做一个总结：Serializer和ModelSerializer两种序列化方式中，前者比较容易理解，适用于新手；后者则在商业项目中被使用的更多，在实际开发中建议大家多使用后者。

　　记得笔者初学Django REST framework时，一直很困惑于用哪种序列化方式更好。因为许多教材中都将Django REST framework的Serializer和ModelSerializer，与Django的Form和ModelForm做对比，虽然二者相似，在优劣选择上却是不同的。Form虽然没有ModelForm效率高，但是ModelForm的使用增加了项目的耦合度，不符合项目解耦原则，所以Form比ModelForm更优（除了字段量过大的情况）；而ModelSerializer有Serializer所有的优点，同时并没有比Serializer明显的不足之外，所以ModelSerializer比Serializer更优。

2.3 Django REST framework视图三层封装

　　其实，Django REST framework中最令人困惑的并不是Serializer与ModelSerializer的选择，而是三层封装的视图使用哪种好？到底应该怎样选择？视图层层封装，层层嵌套，令人混乱不堪，再加上版本更替，许多教程与实际项目中的演示对不上号，学习起来更是晦涩难懂。

　　最无奈的是，就算硬着头皮将文档教程“啃”下来，但依然困惑于实现一个功能，到底应该封装几层，使用哪种视图方式，根本不敢贸然选择，犹豫不决之间又浪费了许多时间。因此业内有十个抛弃Django REST framework的人里九个是因为视图封装之说。我们将会在下一节聊一聊视图的三层封装，如果你也是一个对Django REST framework视图的三层封装如鲠在喉的程序员，可要打起精神来。

2.3.1 用mixins.ListModelMixin+GenericAPIView的方式实现视图封装

　　在users/views.py中，使用mixins.ListModelMixin+GenericAPIView编写基于Book ModelSerializer的图书API视图类。代码如下：

from .serializers import BookModelSerializer
　　from rest_framework.response import Response
　　from .models import UserProfile,Book
　　from rest_framework import mixins
　　from rest_framework import generics
　　ookMixinView1(mixins.ListModelMixin,generics.GenericAPIView):
　　    queryset=Book.objects.all()
　　    serializer_class = BookModelSerializer
　　    def get(self,request,*args,**kwargs):    #如果这里不加get函数，代表默认不
　　                                                支持get访问这个api，所以必须加上
　　        APIKey = self.request.query_params.get("apikey", 0)
　　        developer = UserProfile.objects.filter(APIkey=APIKey).first()
　　        if developer:
　　            balance=developer.money
　　            if balance>0:
　　                isbn = self.request.query_params.get("isbn", 0)
　　                developer.money -= 1
　　                developer.save()
　　                self.queryset = Book.objects.filter(isbn=int(isbn))
　　                return self.list(request, *args, **kwargs)
　　            else:
　　                return Response("兄弟，又到了需要充钱的时候！好开心啊！")
　　        else:
　　            return Response("查无此人啊")

　　在urls中配置路由代码如下：

from django.contrib import admin
　　from django.urls import path
　　from users.views import BookAPIView1,BookAPIView2
　　from users.views import BookMixinView1
　　urlpatterns = [
　　    path('admin/', admin.site.urls),
　　    path('apibook1/',BookAPIView1.as_view(),name='book1'),
　　    path('apibook2/',BookAPIView2.as_view(),name='book2'),
　　    path('apibook3/',BookMixinView1.as_view(),name='book3'),
　　]

　　这时，我们再使用Postman对API进行测试，用GET的方式访问：

http://127.0.0.1:8000/apibook3/?apikey=abcdefghigklmn&isbn=777777

　　我们获得了跟使用APIView编写的API视图同样的效果，也获得了以下数据：

[
　　    {
　　        "title": "一个书名",
　　        "isbn": "777777",
　　        "author": "一个作者"
　　    }
　　]

2.3.2 用generics.ListAPIView的方式实现视图封装

　　在users/views.py中，使用generics.ListAPIView编写基于BookModelSerializer的图书API视图类，代码如下：

from .serializers import BookModelSerializer

　　from rest_framework.response import Response

　　from .models import UserProfile,Book
　　from rest_framework import mixins
　　from rest_framework import generics
　　class BookMixinView2(generics.ListAPIView):
　　    queryset = Book.objects.all()
　　    serializer_class = BookModelSerializer
　　    def get(self,request,*args,**kwargs):
　　        APIKey = self.request.query_params.get("apikey", 0)
　　        developer = UserProfile.objects.filter(APIkey=APIKey).first()           
if developer:
　　            balance=developer.money
　　            if balance>0:
　　                isbn = self.request.query_params.get("isbn", 0)
　　                developer.money -= 1
　　                developer.save()
　　                self.queryset = Book.objects.filter(isbn=int(isbn))
　　                return self.list(request, *args, **kwargs)
　　            else:
　　                return Response("兄弟，又到了需要充钱的时候！好开心啊！")
　　        else:
　　            return Response("查无此人啊")           
from django.contrib import admin
　　from django.urls import path
　　from users.views import BookAPIView1,BookAPIView2
　　from users.views import BookMixinView1,BookMixinView2
　　urlpatterns = [
　　    path('admin/', admin.site.urls),
　　    path('apibook1/',BookAPIView1.as_view(),name='book1'),
　　    path('apibook2/',BookAPIView2.as_view(),name='book2'),
　　    path('apibook3/',BookMixinView1.as_view(),name='book3'),
　　    path('apibook4/',BookMixinView2.as_view(),name='book4'),
　　]           
http://127.0.0.1:8000/apibook4/?apikey=abcdefghigklmn&isbn=777777           
[
　　    {
　　        "title": "一个书名",
　　        "isbn": "777777",
　　        "author": "一个作者"
　　    }
　　]

注意：使用mixins.ListModelMixin+generics.GenericAPIView对APIView进行一次封装，至少需要加一个get函数：

def get(self,request,*args,**kwargs): 
　　    return self.list(request,*args,**kwargs)

而使用generics.ListAPIView则可以不用加这个函数，因为generics.ListAPIView相对于mixins.ListModelMixin+generics.GenericAPIView而言，所谓的封装，就是封装了一个get函数罢了。

2.3.3 用viewsets+Router的方式实现视图封装

　　在users/views.py中，使用viewsets.ModelViewSet编写基于BookModelSerializer的图书API视图类，代码如下：

from .serializers import BookModelSerializer
　　from rest_framework.response import Response
　　from .models import UserProfile,Book
　　from rest_framework import viewsets
　　from rest_framework.permissions import BasePermission
　　class IsDeveloper(BasePermission):
　　    message='查无此人啊'
　　    def has_permission(self,request,view):
　　        APIKey = request.query_params.get("apikey", 0)
　　        developer = UserProfile.objects.filter(APIkey=APIKey).first()
　　        if developer:
　　            return True
　　        else:
　　            print(self.message)
　　            return False
　　class EnoughMoney(BasePermission):
　　    message = "兄弟，又到了需要充钱的时候！好开心啊！"
　　    def has_permission(self,request,view):
　　        APIKey = request.query_params.get("apikey", 0)
　　        developer = UserProfile.objects.filter(APIkey=APIKey).first()
　　        balance = developer.money
　　        if balance > 0:
　　            developer.money -= 1
　　            developer.save()
　　            return True
　　        else:
　　            return False
　　class BookModelViewSet(viewsets.ModelViewSet):
　　    authentication_classes = []
　　    permission_classes = [IsDeveloper, EnoughMoney]
　　    queryset = Book.objects.all()
　　    serializer_class = BookModelSerializer
　　    def get_queryset(self):
　　        isbn = self.request.query_params.get("isbn", 0)
　　        books = Book.objects.filter(isbn=int(isbn))
　　        queryset=books
　　        return queryset           
from django.contrib import admin
　　from django.urls import path
　　from users.views import BookAPIView2
　　from users.views import BookMixinView1,BookMixinView2
　　from users.views import BookModelViewSet
　　from rest_framework.routers import DefaultRouter
　　from django.conf.urls import include
　　router=DefaultRouter()
　　router.register(r'apibook5',BookModelViewSet)
　　urlpatterns = [
　　    path('admin/', admin.site.urls),
　　    path('apibook2/',BookAPIView2.as_view(),name='book2'),
　　    path('apibook3/',BookMixinView1.as_view(),name='book3'),
　　    path('apibook4/',BookMixinView2.as_view(),name='book4'),
　　    path('',include(router.urls))
　　]           
http://127.0.0.1:8000/apibook5/?apikey=abcdefghigklmn&isbn=777777

　　获得了以下数据：

　[
　　    {
　　        "title": "一个书名",
　　        "isbn": "777777",
　　        "author": "一个作者"
　　    }
　　]

　　当我们连续10次用get访问API后，得到以下提示信息：

{
　　    "detail": "兄弟，又到了需要充钱的时候！好开心啊！"
　　}

注意：Django REST framework的权限组件有一个原则，即没有认证就没有权限！所以我们可以看见，在视图类BookModelViewSet中不但加入了permission_classes = [IsDeveloper, EnoughMoney]，还加入了authentication_classes = []这样一个空列表。这一行代码是必须加的，如果不加，虽然权限组件依然起作用，但是在权限通不过的时候，detail将不会显示我们自定义的message的内容，而永远只是提示认证未通过。

2.3.4 小结

　　在这一章中，我们使用Django REST framework三层封装（APIView、mixins和viewsets）分别实现了一遍豆瓣图书API的功能。对比这3种视图封装方式，大家觉得哪一种更优一些呢？

　　相信有很多Django REST framework的学习者，在学到视图封装的时候，都会认为APIView这一层封装的知识点还是比较好领会的，一切的麻烦都是从mixins开始，mixins虽然只是在APIView的基础上又做了一层封装，但是根据不同的method，又分成了mixins. ListModelMixin、generics.GenericAPIView和generics.ListAPIView，这样非常容易让人认为所谓Django REST framework的三层视图封装，指的是APIView、mixins和Generics.ListAPIView，然后当发现文档后面的viewsets时，概念瞬间就凌乱了，甚至学完viewsets，脑中依然一片混乱。

　　当读者发现有这么多方式可以实现同一个功能时，非常容易在选择时犹豫不决，再加上Django REST framework的许多教程中，经常会出现一些诸如“像魔法一样”“非常强大”、“很简单”这类故弄玄虚的词，令人更加困扰。

　　那么，到底该怎样选择视图封装呢？我们马上就将得到一个相对确切的答案。

　　首先，我们来剖析视图的封装层数。要知道，我们经常说到的Django REST framework的“三层视图封装”，并不是仅仅封装了三层，下面解剖一个viewsets.ModelViewSet看一下：

class ModelViewSet(mixins.CreateModelMixin,
　　                   mixins.RetrieveModelMixin,
　　                   mixins.UpdateModelMixin,
　　                   mixins.DestroyModelMixin,
　　                   mixins.ListModelMixin,
　　                   GenericViewSet):
　　class GenericViewSet(ViewSetMixin, generics.GenericAPIView):
　　class GenericAPIView(views.APIView):

　　可以看出，从APIView到views.ModelViewSet，mixins只是个过程，mixins存在的价值，更多的是为了帮助Django REST framework学习者，更加容易地理解视图封装的原理。但事实上似乎并没有起到帮助作用。可以说，我们在今后的项目中，只需要优先在APIView和viewsets中选择即可。至于mixins就好像是斐波那契数列一样，几乎永远不会缺席于应聘Django REST framework技术岗位的笔试题中，但在实际项目中却很少能用得上。

　　APIView和viewsets应该怎样选择呢？Django REST framework的官方文档中也有介绍过二者的取舍问题，但帮助不大。以我们在本章中实现的豆瓣图书API这个功能来看，viewsets虽然对APIView做了封装，但结果反而是代码更多了，逻辑更麻烦了，显然，像这类情况，我们应该选择APIView。总结一下，当视图要实现的功能中，存在数据运算、拼接的业务逻辑时，比如本章例子中，API成功访问一次，用户表中的money记录减少1，可以一律选择APIView的方式来写视图类，除此以外，优先使用viewsets的方式来写视图类，毕竟使用viewsets+Router在常规功能上效率极高。

Python api 网络架构 Web App开发 开发者 django python web开发 python django web项目 web python开发 udp python soket协议 django其他python
上一篇: 带你读《Python机器学习》之一：机器学习基础第1章
下一篇: 带你读《Unity游戏开发（原书第3版）》之二：游戏对象第2章

继续阅读