人人都能看懂的Django REST framework

╰+哭是因爲堅強的太久メ 2022-10-05 00:49 254阅读 0赞

### 文章目录 ###

*   *   *  一、前后端分离
         *   *  1. 开发模式
             *  2. 前后端分离的优势
             *  3. 为什么要有前后端分离
             *  4. 前后端分离的缺点
         *  二、RESTful API
         *   *  1. RESTful API设计规范
         *  三、快速入手
         *  四、序列化
         *   *  1. 普通序列化
             *   *  1.1 模型类
                 *  1.2 序列化
                 *  1.3 参数约束
                 *  1.4 利用反序列化生成模型对象
                 *  1.5 利用序列化生成JSON数据
             *  2. 模型序列化ModelSerializer
             *   *  2.1 序列化
                 *  2.2 编写视图
                 *  2.3 编写子路由
                 *  2.4 编写根路由
                 *  2.5 注意
             *  3. 模型序列化（高级）
             *   *  3.1 模型类
                 *  3.2 序列化
                 *  3.3 视图
                 *  3.4 路由
                 *  3.5 StringRelatedField
                 *   *  3.5.1 序列化
                 *  3.6 PrimaryKeyRelatedField
                 *   *  3.6.1 序列化
                 *  3.7 HyperlinkedRelatedField
                 *   *  3.7.1 报错
                     *  3.7.2 添加根路由、子路由别名
                 *  3.8 SlugRelatedField
                 *   *  3.8.1 序列化
                 *  3.9 HyperlinkedIdentityField
                 *   *  3.9.1 序列化
                 *  3.10 HyperlinkedModelSerializer
                 *   *  3.10.1 序列化
                 *  3.11 序列化嵌套
                 *   *  3.11.1 序列化
                     *  3.11.2 执行结果
                 *  3.12 depth
                 *   *  3.12.1 序列化
                     *  3.12.2 执行结果
                 *  3.13 SerializerMethodField
                 *   *  3.13.1 序列化
                     *  3.13.2 执行结果
                 *  3.14 source
                 *   *  3.14.1 序列化
                     *  3.14.2 执行结果
                     *  3.14.3 将返回的对象转为具体内容
                     *  3.14.4 利用source实现可读可写
                 *  3.15 to\_representation方法
                 *   *  3.15.1 模型类
                     *  3.15.2 序列化
                     *  3.15.3 路由
             *  4. 序列化验证
             *   *  4.1 模型类
                 *  4.2 视图
                 *  4.3 路由
                 *  4.4 序列化
                 *  4.5 Validators（了解）
         *  五、请求和响应
         *   *  1. 请求
             *  2. 响应
             *  3. 状态码
             *  4. API视图
             *   *  4.1 基于函数视图的@api\_view装饰器
                 *  4.2 基于类视图的APIView类
             *  5. 路由
         *  六、类视图
         *   *  1. mixins
             *  2. 路由
             *  3. 使用通用的基于类的视图
         *  七、认证和权限
         *   *  1. 创建用户
             *  2. 快速体验
             *   *  2.1 模型类
                 *  2.2 视图
                 *  2.3 序列化类
                 *  2.4 路由
                 *  2.5 测试
                 *  2.6 总结
             *  3. 权限
             *   *  3.1 添加权限
                 *  3.2 测试
             *  4. 认证
             *   *  4.1 BasicAuthentication
                 *   *  4.1.1 路由
                     *  4.1.2 视图
                     *  4.1.3 小结
                 *  4.2 TokenAuthentication
                 *   *  4.2.1 配置
                     *  4.2.2 路由
                     *  4.2.3 视图
                     *  4.2.4 测试
                 *  4.3 SessionAuthentication
                 *   *  4.3.1 视图
                     *  4.3.2 测试
                 *  4.4 自定义认证
                 *   *  4.4.1 模型类
                     *  4.4.2 视图
                     *  4.4.3 自定义权限
                     *  4.4.4 路由
                     *  4.4.5 测试
                 *  4.5 JWT验证
                 *   *  4.5.1 安装
                     *  4.5.2 注册
                     *  4.5.3 配置
                     *  4.5.4 路由
                     *  4.5.5 视图
                     *  4.5.6 测试
                     *  4.5.7 JWT权限验证
                 *  4.6 JWT优缺点
         *  八、频率
         *   *  1. 内置频率类
             *  2. 配置
             *  3. 视图
         *  九、版本控制
         *   *  1. 五种控制方案
             *  2. 视图
             *  3. 路由
             *  4. 配置
             *  5. 通用的基于类的视图中的用法
             *   *  5.1 模型
                 *  5.2 序列化
                 *  5.3 视图
                 *  5.4 路由
                 *  5.5 测试
         *  十、分页
         *   *  1. 分页方式
             *  2. 普通分页
             *  3. 切割分页
             *  4. 加密分页
             *  5. 配置
             *

### 一、前后端分离 ###

#### 1. 开发模式 ####

在Web开发模式中，有两种开发模式

*  前后端不分离
 *  前后端分离

#### 2. 前后端分离的优势 ####

在前后端不分离模式中，前端页面看到的效果都是由后端控制，由后端渲染页面或重定向，也就是后端需要控制前端的展示，前端与后端的耦合度很高。

这种应用模式比较适合纯网页应用，但是当后端对接App时，App可能并不需要后端返回一个HTML网页，而仅仅是数据本身，所以后端原本返回网页的接口不再适用于前端App应用，为了对接App后端还需再开发一套接口。

在前后端分离的应用模式中，后端仅返回前端所需的数据，不再渲染HTML页面，不再控制前端的效果。至于前端用户看到什么效果，从后端请求的数据如何加载到前端中，都由前端自己决定，网页有网页的处理方式，App有App的处理方式，但无论哪种前端，所需的数据基本相同，后端仅需开发一套逻辑对外提供数据即可。

在前后端分离的应用模式中，前端与后端的耦合度相对较低。

在前后端分离的应用模式中，我们通常将后端开发的每个视图都称为一个接口，或者API，前端通过访问接口来对数据进行增删改查。

#### 3. 为什么要有前后端分离 ####

*  多端适应
 *  前后端开发职责不清
    
     *  模板到低是前端写还是后端写？如果前端写，前端就要懂后端模板语言
     *  如果后端写，那么后端就要懂前段html, css, js甚至更多更多
 *  开发效率问题，前后端相互等待
    
     *  前端在写的时候，就希望后端全部写好自己再写
     *  后端在写的时候，就希望前端全部写好自己再写
 *  前端一直配合着后端，能力受限（搞来搞去写静态页面，天天给后台写模板）
 *  后台开发语言和模板高度耦合，导致开发语言依赖（一旦用python开发，以后要换成java或者其他语言）

#### 4. 前后端分离的缺点 ####

*  前后端学习门槛增加（比如后台很多模板语法控制前端展示，但是分离以后，需要前端自己去实现,增加前端成本，对后台来说，后端要满足规范）
 *  数据依赖导致文档重要性增加
    
     *  文档是否详细
     *  是否及时更新
     *  修改要及时通知其他端
 *  前端工作量加大
 *  SEO（搜索引擎优化）的难度增加(都是Ajax，像一些初级爬虫全部挡在外面，比如一些搜索引擎，这样你的排名就不靠前了）

### 二、RESTful API ###

#### 1. RESTful API设计规范 ####

*  域名

应该尽量将API部署在专用域名之下

https://api.example.com

如果确定API很简单，不会有进一步扩展，可以考虑放在主域名下。

https://example.com/api/

*  协议

推荐使用HTTPS

*  版本

应该将API的版本号放入URL

http://www.example.com/app/v1.0/apples
     
    http://www.example.com/app/v1.1/apples
     
    http://www.example.com/app/v2.0/apples

比如，v1.0版本返回

{
    	"name": "lucy"
    }

v2.0版本返回

{
    	"name": "lucy",
    	"age": 18
    }

*  路径

对于一个简洁结构，你应该始终用名词。 此外，利用的HTTP方法可以分离网址中的资源名称的操作。

推荐用名词+复数

https://xxx.com/api/v2.0/students/

GET 	/products 		将返回所有产品清单
    POST 	/products 		将产品新建到集合
    GET 	/products/4 	将获取产品4
    PATCH 	/products/4 	将更新产品4（部分属性更新）
    PUT  	/products/4		将更新产品4（全部属性更新）

*  HTTP动词

对数据的操作CRUD

create, read, update, delete

GET--->获取资源
    	https://xxx.com/api/v2.0/students/
    POST--->新增资源
    	https://xxx.com/api/v2.0/students/
    PUT--->更新资源
    	https://xxx.com/api/v2.0/students/1/
    PATCH--->部分更新
    	https://xxx.com/api/v2.0/students/1/
    DELETE--->删除资源
    	https://xxx.com/api/v2.0/students/1/

比如，只更新name属性，使用PUT
    { 
    	"id": 1,
    	"name": "lucy",
    	"age": 20
    }
    使用PATCH时
    { 
    	"id": 1,
    	"age": 20
    }

<table> 
 <thead> 
  <tr> 
   <th>请求方法</th> 
   <th>请求地址</th> 
   <th>后端操作</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>GET</td> 
   <td>/students</td> 
   <td>获取所有学生</td> 
  </tr> 
  <tr> 
   <td>POST</td> 
   <td>/students</td> 
   <td>增加学生</td> 
  </tr> 
  <tr> 
   <td>GET</td> 
   <td>/students/1</td> 
   <td>获取编号为1的学生</td> 
  </tr> 
  <tr> 
   <td>PUT</td> 
   <td>/students/1</td> 
   <td>更新编号为1的学生（全部属性）</td> 
  </tr> 
  <tr> 
   <td>DELETE</td> 
   <td>/students/1</td> 
   <td>删除编号为1的学生</td> 
  </tr> 
  <tr> 
   <td>PATCH</td> 
   <td>/students/1</td> 
   <td>更新编号为1的学生（部分属性）</td> 
  </tr> 
 </tbody> 
</table>

*  过滤信息

https://xxx.com/api/v2.0/students/?page=2

?limit=10	指定返回记录的数量
    ?offset=10	指定返回记录的开始位置
    ?page=2&per_page=100	指定第几页，以及每页的记录数
    ?sortby=name&order=asc	指定返回结果按照哪个属性排序，以及排序顺序
    ?animal_type_id=1		指定筛选条件

*  状态码

移动端要求这样的格式
    {
    	"code": 1,
    	"msg": "xxx",
    	"data": {}
    }

200 OK - [GET]:服务器成功返回用户请求的数据。
    201 CREATED - [POST/PUT/PATCH]:用户新建或修改数据成功。
    202 Accepted - []:表示一个请求已经进入后台排队（异步任务）。
    204 NO CONTENT - [DELETE]:用户删除数据成功。
    400 INVALID REQUEST - [POST/PUT/PATCH]:用户发出的请求有错误，服务器没有进行新建或修改数据的操作。
    401 Unauthorized - []:表示用户没有权限（令牌、用户名、密码错误）。
    403 Forbidden - []:表示用户得到授权（与401错误相对），但是访问是被禁止的。
    404 NOT FOUND - []:用户发出的请求针对的是不存在的记录，服务器没有进行操作，该操作是幂等的。
    406 Not Acceptable - [GET]:用户请求的格式不可得（比如用户请求JSON格式，但是只有XML格式）。
    410 Gone -[GET]:用户请求的资源被永久删除，且不会再得到的。
    422 Unprocesable entity - [POST/PUT/PATCH]:当创建一个对象时，发生一个验证错误。
    500 INTERNAL SERVER ERROR - [*]:服务器发生错误，用户将无法判断发出的请求是否成功。

*  错误处理

移动端要求这样的格式
    {
    	"code": 1,
    	"msg": "xxx",
    	"data": {}
    }

{ 
    	error:"Invalid API key"
    }

*  返回结果

返回的数据都是json

GET		/collection				返回资源对象的列表（数组）
    GET 	/collection/resource	返回单个资源对象
    POST 	/collection				返回新生成的资源对象
    PUT 	/collection/resource	返回完整的资源对象
    PATCH 	/collection/resource	返回完整的资源对象
    DELETE 	/collection/resource	返回一个空文档

### 三、快速入手 ###

### 四、序列化 ###

#### 1. 普通序列化 ####

##### 1.1 模型类 #####

from django.db import models
    
    
    # Create your models here.
    class Article(models.Model):
        title = models.CharField(verbose_name='标题', max_length=100)
        vnum = models.IntegerField(verbose_name='浏览量')
        content = models.TextField(verbose_name='内容')

##### 1.2 序列化 #####

最普通的序列化，需要自己手写需要序列化的字段。

from rest_framework import serializers
    from .models import Article
    
    
    # 普通的序列化
    class ArticleSerializer(serializers.Serializer):
        id = serializers.IntegerField(read_only=True)
        vnum = serializers.IntegerField()
        content = serializers.CharField(max_length=1000)
        title = serializers.CharField(required=True, max_length=100)
    
        def create(self, validated_data):
            return Article.objects.create(**validated_data)
    
        def update(self, instance, validated_data):
            instance.title = validated_data.get('title', instance.title)  # 没取到用原来的
            instance.vnum = validated_data.get('vnum', instance.vnum)
            instance.content = validated_data.get('content', instance.content)
            instance.save()
            return instance

##### 1.3 参数约束 #####

read_only: True表示不允许用户自己上传，只能用于api的输出。

write_only: 与read_only对应

required: 顾名思义，就是这个字段是否必填。

allow_null/allow_blank: 是否允许为NULL/空。

error_messages: 出错时，信息提示。
    name = serializers.CharField(required=True, min_length=6,
                    error_messages={
                        'min_length': '名字不能小于6个字符',
                        'required': '请填写名字'})

label: 字段显示设置，如 label=’验证码’

help_text: 在指定字段增加一些提示文字，这两个字段作用于api页面比较有用。

style: 说明字段的类型，这样看可能比较抽象，看下面例子：
    # 在api页面，输入密码就会以*显示
    password = serializers.CharField(
        style={'input_type': 'password'})
    # 会显示选项框
    color_channel = serializers.ChoiceField(
        choices=['red', 'green', 'blue'],
        style={'base_template': 'radio.html'})

validators: 自定义验证逻辑。

##### 1.4 利用反序列化生成模型对象 #####

当我们反序列化的时候，要用data关键字

当我们反序列化的时候，会帮我们校验数据是否合法

在Terminal中打开执行命令python manage.py shell，打开shell

>>> from app03.serializers import ArticleSerializer
    >>> from rest_framework.renderers import JSONRenderer
    
    >>> d = { "title":"这是一个测试标签","vnum":11,"content":"哈哈哈哈"}
    >>> ser = ArticleSerializer(data=d)
    >>> ser.is_valid()  # 验证数据是否正确，比如少写属性
    True
    >>> ser.save()  # 保存数据
    <Article: Article object (1)>

##### 1.5 利用序列化生成JSON数据 #####

当我们序列化的时候，要用instance关键字

当序列化的时候，如果是多个数据，需要加many=True，单个对象不需要

>>> from app03.models import *
    >>> from rest_framework.renderers import JSONRenderer
    >>> from app03.serializers import ArticleSerializer
    
    # 单个对象序列化
    >>> art = Article.objects.get(id=1)
    >>> ser = ArticleSerializer(art)
    >>> ser.data
    { 'id': 1, 'title': '这是一个测试标签', 'vnum': 11, 'content': '哈哈哈哈'}
    >>> JSONRenderer().render(ser.data).decode('utf-8')
    '{"id":1,"title":"这是一个测试标签","vnum":11,"content":"哈哈哈哈"}'
    
    
    # 多个对象序列化
    >>> arts = Article.objects.all()
    >>> ser = ArticleSerializer(instance=arts,many=True)
    >>> ser.data
    [OrderedDict([('id', 1), ('title', '这是一个测试标签'), ('vnum', 11), ('content'
    , '哈哈哈哈')]), OrderedDict([('id', 2), ('title', '111'), ('vnum', 100), ('cont
    ent', 'hahahahaha')])]
    >>> JSONRenderer().render(ser.data).decode('utf-8')
    '[{ "id":1,"title":"这是一个测试标签","vnum":11,"content":"哈哈哈哈"},{ "id":2,"ti
    tle":"111","vnum":100,"content":"hahahahaha"}]'

#### 2. 模型序列化ModelSerializer ####

ModelSerializer默认帮我们实现了创建和更新方法，简化了我们的操作，当然如果你想自己写，可以重写它。其余使用方法跟普通的序列化一样。

##### 2.1 序列化 #####

class ArticleSerializer(serializers.ModelSerializer):
        class Meta:
            model = Article
            fields = ('id', 'title', 'vnum', 'content')  # 三者取一
            # exclude = () # 表示不返回字段 三者取一
            # fields = '__all__' # 表示所有字段 三者取一
    
            # read_only_fields = () # 设置只读字段 不接受用户修改

##### 2.2 编写视图 #####

##### 2.3 编写子路由 #####

from django.urls import path
    
    from app03 import views
    
    urlpatterns = [
        path('articles/', views.article_list, name='article_list'),  # 获取或创建
        path('articles/<int:pk>/', views.article_detail, name='article_detail'),  # 查找、更新、删除
    
    ]

##### 2.4 编写根路由 #####

urlpatterns = [
        path('admin/', admin.site.urls),
        path('api/app03/', include('app03.urls')),
    ]

##### 2.5 注意 #####

当请求方法为PATCH，序列化需要加 partial=True，让支持增量更新。

路由里面的参数跟视图里面的参数一定要一样，因为是关键字传参。上述体现在pk的使用。

#### 3. 模型序列化（高级） ####

##### 3.1 模型类 #####

from django.db import models
    
    
    # Create your models here.
    
    class Category(models.Model):
        name = models.CharField(verbose_name='分类', max_length=10)
    
        def __str__(self):
            return self.name
    
    
    class Article(models.Model):
        title = models.CharField(verbose_name='标题', max_length=100)
        vnum = models.IntegerField(verbose_name='浏览量')
        content = models.TextField(verbose_name='内容')
        category = models.ForeignKey(to=Category, on_delete=models.CASCADE, related_name='articles')  # related_name 反向查找
    
        def __str__(self):
            return self.title

##### 3.2 序列化 #####

class ArticleSerializer(serializers.ModelSerializer):
        class Meta:
            model = Article
            fields = ('id', 'title', 'vnum', 'content', 'category')
    
    
    class CategorySerializer(serializers.ModelSerializer):
        class Meta:
            model = Category
            fields = '__all__'

##### 3.3 视图 #####

@csrf_exempt
    def category_list(request):
        if request.method == 'GET':
            cats = Category.objects.all()
            ser = CategorySerializer(instance=cats, many=True)
            return JsonResponse({ 'status': 200, 'data': ser.data})
        elif request.method == 'POST':
            data = JSONParser().parse(request)  # 把前端传过来的json数据转为python里面的数据类型
            ser = CategorySerializer(data=data)
            if ser.is_valid():
                ser.save()
                return JsonResponse({ 'status': 201, 'data': ser.data})
            return JsonResponse({ 'status': 400, 'data': ser.errors})
    
    
    @csrf_exempt
    def category_detail(request, pk):
        try:
            art = Category.objects.get(pk=pk)
        except Category.DoesNotExist as e:
            return JsonResponse({ 'msg': "未获取到pk值", 'status': 404})
        if request.method == 'GET':
            ser = CategorySerializer(instance=art)
            return JsonResponse({ 'status': 200, 'data': ser.data})
        elif request.method == 'PUT':
            data = JSONParser().parse(request)
            ser = CategorySerializer(instance=art, data=data)
            if ser.is_valid():
                ser.save()
                return JsonResponse({ 'status': 201, 'data': ser.data})
            return JsonResponse({ 'status': 400, 'data': ser.errors})
        elif request.method == 'PATCH':
            data = JSONParser().parse(request)
            ser = CategorySerializer(instance=art, data=data, partial=True)
            if ser.is_valid():
                ser.save()
                return JsonResponse({ 'status': 201, 'data': ser.data})
            return JsonResponse({ 'status': 400, 'data': ser.errors})
        elif request.method == 'DELETE':
            art.delete()
            return JsonResponse({ 'msg': '删除成功', 'status': 204})

##### 3.4 路由 #####

from django.urls import path
    
    from app03 import views
    
    urlpatterns = [
        path('articles/', views.article_list, name='article_list'),
        path('articles/<int:pk>/', views.article_detail, name='article_detail'),
        path('categorys/', views.category_list, name='category_list'),
        path('categorys/<int:pk>/', views.category_detail, name='category_detail'),
    
    ]

##### 3.5 StringRelatedField #####

StringRelatedField 将返回一个对应关系 model 的 `__str__()` 方法的返回值。

###### 3.5.1 序列化 ######

class ArticleSerializer(serializers.ModelSerializer):
        category = serializers.StringRelatedField()
    
        class Meta:
            model = Article
            fields = '__all__'
    
    
    class CategorySerializer(serializers.ModelSerializer):
        articles = serializers.StringRelatedField(many=True)  # 不写，默认返回id，写了返回__str__指定的字段
    
        class Meta:
            model = Category
            fields = ('id', 'name', 'articles')  # articles是反向引用，隐形属性

##### 3.6 PrimaryKeyRelatedField #####

使用 PrimaryKeyRelatedField 将返回一个对应关系 model 的主键。

参数：

*  queryset 用于在验证字段输入时模型实例查找。关系必须明确设置 queryset，或设置 read\_only = True
 *  many 如果是对应多个的关系，就设置为 True
 *  allow\_null 如果设置为 True，则该字段将接受 None 的值或为空的关系的空字符串。默认为 False
 *  pk\_field 设置为一个字段以控制主键值的序列化/反序列化。例如，pk\_field = UUIDField（format =‘hex’） 将UUID主键序列化为紧凑的十六进制表示。

###### 3.6.1 序列化 ######

class ArticleSerializer(serializers.ModelSerializer):
        category = serializers.PrimaryKeyRelatedField(read_only=True)
    
        class Meta:
            model = Article
            fields = '__all__'
    
    
    class CategorySerializer(serializers.ModelSerializer):
        articles = serializers.PrimaryKeyRelatedField(read_only=True, many=True)
    
        class Meta:
            model = Category
            fields = ('id', 'name', 'articles')  # articles是反向引用，隐形属性

##### 3.7 HyperlinkedRelatedField #####

使用 HyperlinkedRelatedField 将返回一个超链接，该链接指向对应关系 model 的详细数据，view-name 是必选参数，也就是路由中 name 的值，为对应的视图生成超链接。

参数：

*  view\_name 用作关系目标的视图名称。如果使用的是标准路由器类，那么它的格式为 `<modelname>-detail` 的字符串
 *  queryset 验证字段输入时用于模型实例查询的查询器。关系必须明确设置 queryset，或设置 read\_only = True
 *  many 如果应用于多对多关系，则应将此参数设置为 True
 *  allow\_null 如果设置为 True，则该字段将接受 None 的值或为空的关系的空字符串。默认为 False
 *  lookup\_field 应该用于查找的目标上的字段。应该对应于引用视图上的 URL 关键字参数。默认值为 pk
 *  lookup\_url\_kwarg 与查找字段对应的 URL conf 中定义的关键字参数的名称。默认使用与 lookup\_field 相同的值
 *  format 如果使用 format 后缀，超链接字段将对目标使用相同的 format 后缀，除非使用 format 参数进行覆盖。

from django.http import JsonResponse
    from django.shortcuts import render
    
    # Create your views here.
    from django.views.decorators.csrf import csrf_exempt
    from rest_framework.parsers import JSONParser
    
    from app03.serializers import ArticleSerializer, CategorySerializer
    from app03.models import *
    
    
    @csrf_exempt
    def article_list(request):
        if request.method == 'GET':
            arts = Article.objects.all()
            ser = ArticleSerializer(instance=arts, many=True, context={ 'request': request})
            return JsonResponse({ 'status': 200, 'data': ser.data})
        elif request.method == 'POST':
            data = JSONParser().parse(request)  # 把前端传过来的json数据转为python里面的数据类型
            ser = ArticleSerializer(data=data, context={ 'request': request})
            if ser.is_valid():
                ser.save()
                return JsonResponse({ 'status': 201, 'data': ser.data})
            return JsonResponse({ 'status': 400, 'data': ser.errors})
    
    
    @csrf_exempt
    def article_detail(request, pk):
        try:
            art = Article.objects.get(pk=pk)
        except Article.DoesNotExist as e:
            return JsonResponse({ 'msg': "未获取到pk值", 'status': 404})
        if request.method == 'GET':
            ser = ArticleSerializer(instance=art, context={ 'request': request})
            return JsonResponse({ 'status': 200, 'data': ser.data})
        elif request.method == 'PUT':
            data = JSONParser().parse(request)
            ser = ArticleSerializer(instance=art, data=data, context={ 'request': request})
            if ser.is_valid():
                ser.save()
                return JsonResponse({ 'status': 201, 'data': ser.data})
            return JsonResponse({ 'status': 400, 'data': ser.errors})
        elif request.method == 'PATCH':
            data = JSONParser().parse(request)
            ser = ArticleSerializer(instance=art, data=data, partial=True, context={ 'request': request})
            if ser.is_valid():
                ser.save()
                return JsonResponse({ 'status': 201, 'data': ser.data})
            return JsonResponse({ 'status': 400, 'data': ser.errors})
        elif request.method == 'DELETE':
            art.delete()
            return JsonResponse({ 'msg': '删除成功', 'status': 204})
    
    
    @csrf_exempt
    def category_list(request):
        if request.method == 'GET':
            cats = Category.objects.all()
            ser = CategorySerializer(instance=cats, many=True, context={ 'request': request})
            return JsonResponse({ 'status': 200, 'data': ser.data})
        elif request.method == 'POST':
            data = JSONParser().parse(request)  # 把前端传过来的json数据转为python里面的数据类型
            ser = CategorySerializer(data=data, context={ 'request': request})
            if ser.is_valid():
                ser.save()
                return JsonResponse({ 'status': 201, 'data': ser.data})
            return JsonResponse({ 'status': 400, 'data': ser.errors})
    
    
    @csrf_exempt
    def category_detail(request, pk):
        try:
            art = Category.objects.get(pk=pk)
        except Category.DoesNotExist as e:
            return JsonResponse({ 'msg': "未获取到pk值", 'status': 404})
        if request.method == 'GET':
            ser = CategorySerializer(instance=art, context={ 'request': request})
            return JsonResponse({ 'status': 200, 'data': ser.data})
        elif request.method == 'PUT':
            data = JSONParser().parse(request)
            ser = CategorySerializer(instance=art, data=data, context={ 'request': request})
            if ser.is_valid():
                ser.save()
                return JsonResponse({ 'status': 201, 'data': ser.data})
            return JsonResponse({ 'status': 400, 'data': ser.errors})
        elif request.method == 'PATCH':
            data = JSONParser().parse(request)
            ser = CategorySerializer(instance=art, data=data, partial=True, context={ 'request': request})
            if ser.is_valid():
                ser.save()
                return JsonResponse({ 'status': 201, 'data': ser.data})
            return JsonResponse({ 'status': 400, 'data': ser.errors})
        elif request.method == 'DELETE':
            art.delete()
            return JsonResponse({ 'msg': '删除成功', 'status': 204})

###### 3.7.1 报错 ######

AssertionError: `HyperlinkedRelatedField` requires the request in the serializer context. Add `context={'request': request}` when instantiating the
     serializer.

在所有的XXXSerializer中添加上下文 context=\{‘request’: request\}，比如：

ArticleSerializer(instance=arts, many=True, context={ 'request': request})

###### 3.7.2 添加根路由、子路由别名 ######

根路由

urlpatterns = [
        path('admin/', admin.site.urls),
        path('api/app03/', include(('app03.urls', 'app03'), namespace='app03')),
    
    ]

子路由

urlpatterns = [
        path('articles/', views.article_list, name='article-list'),
        path('articles/<int:pk>/', views.article_detail, name='article-detail'),
        path('categorys/', views.category_list, name='category-list'),
        path('categorys/<int:pk>/', views.category_detail, name='category-detail'),
    
    ]

模型序列化类中，使用 view\_name=‘根别名:子别名’

class ArticleSerializer(serializers.ModelSerializer):
        category = serializers.HyperlinkedRelatedField(
            view_name='app03:category-detail',
            read_only=True,
        )
    
        class Meta:
            model = Article
            fields = '__all__'
    
    
    class CategorySerializer(serializers.ModelSerializer):
        articles = serializers.HyperlinkedRelatedField(
            view_name='app03:article-detail',
            read_only=True,
            many=True
        )
    
        class Meta:
            model = Category
            fields = ('id', 'name', 'articles')  # articles是反向引用，隐形属性

##### 3.8 SlugRelatedField #####

使用 SlugRelatedField 将返回一个指定对应关系 model 中的字段，需要参数 slug\_field 中指定字段名称。

参数：

*  slug\_field 应该用于表示目标的字段。这应该是唯一标识任何给定实例的字段。例如 username 。这是必选参数
 *  queryset 验证字段输入时用于模型实例查询的查询器。 关系必须明确设置 queryset，或设置 read\_only = True
 *  many 如果应用于多对多关系，则应将此参数设置为 True
 *  allow\_null 如果设置为 True，则该字段将接受 None 的值或为空的关系的空字符串。默认为 False

###### 3.8.1 序列化 ######

class ArticleSerializer(serializers.ModelSerializer):
        category = serializers.SlugRelatedField(
            read_only=True,
            slug_field='name',
        )
    
        class Meta:
            model = Article
            fields = '__all__'
    
    
    class CategorySerializer(serializers.ModelSerializer):
        articles = serializers.SlugRelatedField(
            read_only=True,
            slug_field='vnum',
            many=True
        )
    
        class Meta:
            model = Category
            fields = ('id', 'name', 'articles')  # articles是反向引用，隐形属性

##### 3.9 HyperlinkedIdentityField #####

使用 HyperlinkedIdentityField 将返回指定 view-name 的超链接的字段。

参数：

*  view\_name 应该用作关系目标的视图名称。如果您使用的是标准路由器类，则它将是格式为 `<model_name>-detail` 的字符串。必选参数
 *  lookup\_field 应该用于查找的目标上的字段。应该对应于引用视图上的 URL 关键字参数。默认值为 pk
 *  lookup\_url\_kwarg 与查找字段对应的 URL conf 中定义的关键字参数的名称。默认使用与 lookup\_field 相同的值
 *  format 如果使用 format 后缀，超链接字段将对目标使用相同的 format 后缀，除非使用 format 参数进行覆盖

###### 3.9.1 序列化 ######

class ArticleSerializer(serializers.ModelSerializer):
        category = serializers.HyperlinkedIdentityField(
            view_name='app03:category-detail',
        )
    
        class Meta:
            model = Article
            fields = '__all__'
    
    
    class CategorySerializer(serializers.ModelSerializer):
        articles = serializers.HyperlinkedIdentityField(
            view_name='app03:article-detail',
            many=True
        )
    
        class Meta:
            model = Category
            fields = ('id', 'name', 'articles')  # articles是反向引用，隐形属性

##### 3.10 HyperlinkedModelSerializer #####

`HyperlinkedModelSerializer` 类与 `ModelSerializer` 类相似，只不过它使用超链接来表示关系而不是主键。

默认情况下，序列化器将包含一个 `url` 字段而不是主键字段。  
`url` 字段将使用 `HyperlinkedIdentityField` 序列化器字段来表示，并且模型上的任何关系都将使用 `HyperlinkedRelatedField` 序列化器字段来表示。

###### 3.10.1 序列化 ######

class ArticleSerializer(serializers.HyperlinkedModelSerializer):
        class Meta:
            model = Article
            fields = '__all__'
            extra_kwargs = { 
                'url': { 'view_name': 'app03:article-detail', 'lookup_field': 'pk'},
                'category': { 'view_name': 'app03:category-detail', 'lookup_field': 'pk'}
            }
    
    
    class CategorySerializer(serializers.HyperlinkedModelSerializer):
        class Meta:
            model = Category
            fields = ('id', 'name', 'articles', 'url')  # articles是反向引用，隐形属性
            extra_kwargs = { 
                'url': { 'view_name': 'app03:category-detail', 'lookup_field': 'pk'},
                'articles': { 'view_name': 'app03:article-detail', 'lookup_field': 'pk'}
            }

##### 3.11 序列化嵌套 #####

顾名思义就是序列化里面有另一个序列化类

###### 3.11.1 序列化 ######

class ArticleSerializer(serializers.ModelSerializer):
        class Meta:
            model = Article
            fields = '__all__'
    
    
    class CategorySerializer(serializers.ModelSerializer):
        articles = ArticleSerializer(many=True)
    
        class Meta:
            model = Category
            fields = ('id', 'name', 'articles')  # 这里的articles与前面的articles对应

###### 3.11.2 执行结果 ######

http://127.0.0.1:8000/api/app03/categorys/

{ 
        "status": 200,
        "data": [
            { 
                "id": 1,
                "name": "分类一",
                "articles": [
                    { 
                        "id": 1,
                        "title": "这是一个测试标签",
                        "vnum": 11,
                        "content": "哈哈哈哈",
                        "category": 1
                    },
                    { 
                        "id": 2,
                        "title": "标题000",
                        "vnum": 100,
                        "content": "hehehehehe",
                        "category": 1
                    }
                ]
            },
            { 
                "id": 2,
                "name": "分类二",
                "articles": [
                    { 
                        "id": 3,
                        "title": "标题111",
                        "vnum": 100,
                        "content": "hahahahaha",
                        "category": 2
                    }
                ]
            }
        ]
    }

##### 3.12 depth #####

这个字段可以用来深度遍历

###### 3.12.1 序列化 ######

class ArticleSerializer(serializers.ModelSerializer):
        class Meta:
            model = Article
            fields = '__all__'
            depth = 2
    
    
    class CategorySerializer(serializers.ModelSerializer):
        class Meta:
            model = Category
            fields = ('id', 'name', 'articles')

###### 3.12.2 执行结果 ######

http://127.0.0.1:8000/api/app03/articles/

{ 
        "status": 200,
        "data": [
            { 
                "id": 1,
                "title": "这是一个测试标签",
                "vnum": 11,
                "content": "哈哈哈哈",
                "category": { 
                    "id": 1,
                    "name": "分类一"
                }
            },
            { 
                "id": 2,
                "title": "标题000",
                "vnum": 100,
                "content": "hehehehehe",
                "category": { 
                    "id": 1,
                    "name": "分类一"
                }
            },
            { 
                "id": 3,
                "title": "标题111",
                "vnum": 100,
                "content": "hahahahaha",
                "category": { 
                    "id": 2,
                    "name": "分类二"
                }
            }
        ]
    }

##### 3.13 SerializerMethodField #####

通过这个属性我们可以自定义一些属性。

自定义属性必须实现 get\_自定义属性名 的方法，obj 代表当前 被序列化的模型的 对象。

比如有这样的需求，统计每个分类下有多少篇文章

###### 3.13.1 序列化 ######

class ArticleSerializer(serializers.ModelSerializer):
        class Meta:
            model = Article
            fields = '__all__'
    
    
    class CategorySerializer(serializers.ModelSerializer):
        count = serializers.SerializerMethodField()
    
        class Meta:
            model = Category
            fields = ('id', 'name', 'articles', 'count')
    
        # 自定义属性必须实现 get_自定义属性名 的方法
        # obj代表当前 被序列化的模型的对象
        def get_count(self, obj):
            return obj.articles.count()

###### 3.13.2 执行结果 ######

http://127.0.0.1:8000/api/app03/categorys/

{ 
        "status": 200,
        "data": [
            { 
                "id": 1,
                "name": "分类一",
                "articles": [
                    1,
                    2
                ],
                "count": 2
            },
            { 
                "id": 2,
                "name": "分类二",
                "articles": [
                    3
                ],
                "count": 1
            }
        ]
    }

##### 3.14 source #####

序列化的时候指定数据源

###### 3.14.1 序列化 ######

class ArticleSerializer(serializers.ModelSerializer):
        category = serializers.CharField(source='category.name')
    
        class Meta:
            model = Article
            fields = '__all__'
    
    
    class CategorySerializer(serializers.ModelSerializer):
        arts = serializers.CharField(source='articles.all')
    
        # arts = serializers.CharField(source='article_set.all') # 如果没有related_name
    
        class Meta:
            model = Category
            fields = ('id', 'name', 'articles', 'arts')

###### 3.14.2 执行结果 ######

http://127.0.0.1:8000/api/app03/categorys/

{ 
        "status": 200,
        "data": [
            { 
                "id": 1,
                "name": "分类一",
                "articles": [
                    1,
                    2
                ],
                "arts": "<QuerySet [<Article: 这是一个测试标签>, <Article: 标题000>]>"
            },
            { 
                "id": 2,
                "name": "分类二",
                "articles": [
                    3
                ],
                "arts": "<QuerySet [<Article: 标题111>]>"
            }
        ]
    }

###### 3.14.3 将返回的对象转为具体内容 ######

class MyCharField(serializers.CharField):
        def to_representation(self, value):
            data_list = []
            for val in value:
                data_list.append({ 'title': val.title, 'content': val.content})
            return data_list
    
    
    class ArticleSerializer(serializers.ModelSerializer):
        category = serializers.CharField(source='category.name')
    
        class Meta:
            model = Article
            fields = '__all__'
    
    
    class CategorySerializer(serializers.ModelSerializer):
        # arts = serializers.CharField(source='articles.all')
        arts = MyCharField(source='articles.all')
    
        class Meta:
            model = Category
            fields = ('id', 'name', 'articles', 'arts')

http://127.0.0.1:8000/api/app03/categorys/

{ 
        "status": 200,
        "data": [
            { 
                "id": 1,
                "name": "分类一",
                "articles": [
                    1,
                    2
                ],
                "arts": [
                    { 
                        "title": "这是一个测试标签",
                        "content": "哈哈哈哈"
                    },
                    { 
                        "title": "标题000",
                        "content": "hehehehehe"
                    }
                ]
            },
            { 
                "id": 2,
                "name": "分类二",
                "articles": [
                    3
                ],
                "arts": [
                    { 
                        "title": "标题111",
                        "content": "hahahahaha"
                    }
                ]
            }
        ]
    }

###### 3.14.4 利用source实现可读可写 ######

from collections import OrderedDict
    
    
    class ChoiceDisplayField(serializers.Field):
        """Custom ChoiceField serializer field."""
    
        def __init__(self, choices, **kwargs):
            """init."""
            self._choices = OrderedDict(choices)
            super(ChoiceDisplayField, self).__init__(**kwargs)
    
        # 返回可读性良好的字符串而不是 1，-1 这样的数字
        def to_representation(self, obj):
            """Used while retrieving value for the field."""
            return self._choices[obj]
    
        def to_internal_value(self, data):
            """Used while storing value for the field."""
            for i in self._choices:
                # 这样无论用户POST上来但是CHOICES的 Key 还是Value 都能被接受
                if i == data or self._choices[i] == data:
                    return i
            raise serializers.ValidationError("Acceptable values are {0}.".format(list(self._choices.values())))

##### 3.15 to\_representation方法 #####

序列化器的每个字段实际都是由该字段类型的to\_representation方法决定格式的，可以通过重写该方法来决定格式。解决序列化和反序列化之间的关系。

###### 3.15.1 模型类 ######

from django.db import models
    
    
    # Create your models here.
    
    class Category(models.Model):
        name = models.CharField(verbose_name='分类', max_length=10)
    
        def __str__(self):
            return self.name
    
    
    class Tag(models.Model):
        name = models.CharField(verbose_name='标签名字', max_length=10)
        created_time = models.DateTimeField()
    
        def __str__(self):
            return self.name
    
    
    class Article(models.Model):
        title = models.CharField(verbose_name='标题', max_length=100)
        vnum = models.IntegerField(verbose_name='浏览量')
        content = models.TextField(verbose_name='内容')
        category = models.ForeignKey(to=Category, on_delete=models.CASCADE, related_name='articles')
        tags = models.ManyToManyField(to=Tag, related_name='articles')
    
        def __str__(self):
            return self.title

###### 3.15.2 序列化 ######

class ArticleSerializer(serializers.ModelSerializer):
        class Meta:
            model = Article
            fields = '__all__'
    
        def to_representation(self, instance):
            representation = super(ArticleSerializer, self).to_representation(instance)
            representation['category'] = CategorySerializer(instance.category).data
            representation['tags'] = TagSerializer(instance.tags, many=True).data
            return representation
    
    
    class CategorySerializer(serializers.ModelSerializer):
        class Meta:
            model = Category
            fields = ('id', 'name', 'articles')
    
    
    class TagSerializer(serializers.ModelSerializer):
        created_time = serializers.DateTimeField(format='%Y-%m-%d %H:%M:%S')
    
        class Meta:
            model = Tag
            fields = '__all__'

###### 3.15.3 路由 ######

from django.urls import path
    
    from app03 import views
    
    urlpatterns = [
        path('articles/', views.article_list, name='article-list'),
        path('articles/<int:pk>/', views.article_detail, name='article-detail'),
        path('categorys/', views.category_list, name='category-list'),
        path('categorys/<int:pk>/', views.category_detail, name='category-detail'),
        path('tags/', views.tag_list, name='tag-list'),
        path('tags/<int:pk>/', views.tag_detail, name='tag-detail'),
    
    ]

#### 4. 序列化验证 ####

一般前后端分离的时候，我们都会校验前端的参数时候合法。如果我们ModelSerializer话，因为它本身已经帮我们写好create方法，所以我们基本不需要再写验证。但是一些特殊的我们就需要重写或者自己写验证方法。

##### 4.1 模型类 #####

from django.db import models
    
    
    # Create your models here.
    class User(models.Model):
        GENDERS = (
            (1, '男'), (2, "女")
        )
        name = models.CharField(max_length=10, verbose_name='名字')
        phone = models.CharField(max_length=11, verbose_name='手机号')
        gender = models.IntegerField(choices=GENDERS, verbose_name='性别')
        pwd = models.CharField(verbose_name='密码', max_length=64)

##### 4.2 视图 #####

from django.http import JsonResponse
    
    # Create your views here.
    from django.views.decorators.csrf import csrf_exempt
    from rest_framework.parsers import JSONParser
    
    from app04.serializers import UserSerializer
    from app04.models import *
    
    
    @csrf_exempt
    def user_list(request):
        if request.method == 'GET':
            user = User.objects.all()
            ser = UserSerializer(instance=user, many=True, context={ 'request': request})
            return JsonResponse({ 'status': 200, 'data': ser.data})
        elif request.method == 'POST':
            data = JSONParser().parse(request)  # 把前端传过来的json数据转为python里面的数据类型
            ser = UserSerializer(data=data, context={ 'request': request})
            if ser.is_valid():
                ser.save()
                return JsonResponse({ 'status': 201, 'data': ser.data})
            return JsonResponse({ 'status': 400, 'data': ser.errors})
    
    
    @csrf_exempt
    def user_detail(request, pk):
        try:
            user = User.objects.get(pk=pk)
        except User.DoesNotExist as e:
            return JsonResponse({ 'msg': "未获取到pk值", 'status': 404})
        if request.method == 'GET':
            ser = UserSerializer(instance=user, context={ 'request': request})
            return JsonResponse({ 'status': 200, 'data': ser.data})
        elif request.method == 'PUT':
            data = JSONParser().parse(request)
            ser = UserSerializer(instance=user, data=data, context={ 'request': request})
            if ser.is_valid():
                ser.save()
                return JsonResponse({ 'status': 201, 'data': ser.data})
            return JsonResponse({ 'status': 400, 'data': ser.errors})
        elif request.method == 'PATCH':
            data = JSONParser().parse(request)
            ser = UserSerializer(instance=user, data=data, partial=True, context={ 'request': request})
            if ser.is_valid():
                ser.save()
                return JsonResponse({ 'status': 201, 'data': ser.data})
            return JsonResponse({ 'status': 400, 'data': ser.errors})
        elif request.method == 'DELETE':
            user.delete()
            return JsonResponse({ 'msg': '删除成功', 'status': 204})

##### 4.3 路由 #####

from django.urls import path
    
    from app04 import views
    
    urlpatterns = [
        path('users/', views.user_list, name='user-list'),
        path('users/<int:pk>/', views.user_detail, name='user-detail'),
    ]

##### 4.4 序列化 #####

from collections import OrderedDict
    
    from rest_framework import serializers
    from .models import User
    import re
    
    
    class ChoiceDisplayField(serializers.Field):
        """Custom ChoiceField serializer field."""
    
        def __init__(self, choices, **kwargs):
            """init."""
            self._choices = OrderedDict(choices)
            super(ChoiceDisplayField, self).__init__(**kwargs)
    
        # 返回可读性良好的字符串而不是 1，-1 这样的数字
        def to_representation(self, obj):
            """Used while retrieving value for the field."""
            return self._choices[obj]
    
        def to_internal_value(self, data):
            """Used while storing value for the field."""
            for i in self._choices:
                # 这样无论用户POST上来但是CHOICES的 Key 还是Value 都能被接受
                if i == data or self._choices[i] == data:
                    return i
            raise serializers.ValidationError("Acceptable values are {0}.".format(list(self._choices.values())))
    
    
    class UserSerializer(serializers.ModelSerializer):
        phone = serializers.CharField(max_length=11, min_length=11, required=True)
        # 可以单独序列化一个模型中不存在的字段，只是不保存数据库而已
        # 必须要有write_only 不然报错
        pwd1 = serializers.CharField(max_length=64, write_only=True)
    
        # 这样写，支持序列化，不支持反序列化，get_gender_display是一种格式
        # gender = serializers.CharField(source='get_gender_display')
    
        # 方法一
        # 既支持序列化，又支持反序列化
        # def to_representation(self, instance):
        # representation = super(UserSerializer, self).to_representation(instance)
        # representation['gender'] = instance.get_gender_display()
        # return representation
        # 方法二
        # 支持可读可写
        GENDERS = (
            (1, '男'), (2, "女")
        )
        gender = ChoiceDisplayField(choices=GENDERS)
    
        class Meta:
            model = User
            fields = '__all__'
            extra_kwargs = { 
                # 写的时候必传，读的时候不需要传
                'pwd': { 'write_only': True}
            }
    
        # 单独验证
        # 自定义验证函数 validate_属性名 序列化的时候会自动执行这个函数
        def validate_phone(self, phone):
            # 验证手机号是否合法
            if not re.match(r'1[3456789]\d{9}', phone):
                raise serializers.ValidationError('手机号不合法')
            # 验证手机号是否被注册过
            if User.objects.filter(phone=phone).all():
                raise serializers.ValidationError('手机号已被注册')
            # 验证通过，一定要有返回值
            return phone
    
        # 组合验证
        # 验证两次密码是否一致
        def validate(self, attrs):
            if attrs.get('pwd1') != attrs.get('pwd'):
                raise serializers.ValidationError('两次密码输入不正确')
            # 验证后在pop掉pwd1, 因为数据库中没有pwd1字段
            if 'pwd1' in attrs:
                attrs.pop('pwd1')
            return attrs

##### 4.5 Validators（了解） #####

*  UniqueValidator：对象是唯一

username = serializers.CharField(required=True, allow_blank=False, label="用户名", max_length=16, min_length=6,validators=[UniqueValidator(queryset=User.objects.all(), message="用户已经存在")],error_messages={ 
                                             "blank": "用户名不允许为空",
                                             "required": "请输入用户名",
                                             "max_length": "用户名长度最长为16位",
                                             "min_length": "用户名长度至少为6位"
                                         })

*  UniqueTogetherValidator：联合唯一

class UserFav(models.Model):
        user = models.ForeignKey(User,verbose_name="用户",on_delete=False)
        goods = models.ForeignKey(Goods,verbose_name="商品",on_delete=False)
        add_time = models.DateTimeField(default=datetime.now,verbose_name="用户收藏")
    
        class Meta:
            verbose_name = "用户收藏"
            verbose_name_plural=verbose_name
            unique_together = (('user','goods'),)
            
    class UserFavSerializer(serializers.ModelSerializer):
        user = serializers.HiddenField(default=serializers.CurrentUserDefault())
    
        class Meta:
            model = UserFav
            fields = ('id','user', 'goods')
            validators = [UniqueTogetherValidator(queryset=UserFav.objects.all(),fields=('user','goods'),message='您已收藏')]

### 五、请求和响应 ###

目前，我们使用的是Django中的request、response、状态码

DRF里面的request是基于Django里面的request进行封装的，DRF中也有response、状态码。

from rest_framework.decorators import api_view
    from rest_framework.response import Response
    from rest_framework import status

#### 1. 请求 ####

REST里面有个HttpRequest特别相似的对象叫request，主要获取前端传递过来的数据，获取数据的方法就是**request.data**

#### 2. 响应 ####

REST里面有个HttpResponse特别相似的对象叫Response,主要用来给前端传递数据，传递数据的方法就是**Response(data)**

#### 3. 状态码 ####

REST里面的状态码比较人性化。每个状态都用意思去表示。比如

HTTP_200_OK = 200  # OK
    HTTP_201_CREATED = 201  # 创建成功
    HTTP_403_FORBIDDEN = 403  # 权限拒绝
    ......

#### 4. API视图 ####

API视图主要为了咱们RESTFUL风格的API。主要用来包装request、response、现在api请求方法。

*  基于函数视图的`@api_view`装饰器
 *  基于类视图的`APIView`类

##### 4.1 基于函数视图的@api\_view装饰器 #####

from app04.serializers import UserSerializer
    from app04.models import *
    from rest_framework.decorators import api_view
    from rest_framework.response import Response
    from rest_framework import status
    
    @api_view(['GET', 'POST'])
    def user_list(request):
        if request.method == 'GET':
            user = User.objects.all()
            ser = UserSerializer(instance=user, many=True, context={ 'request': request})
            return Response(ser.data, status=status.HTTP_200_OK)
        elif request.method == 'POST':
    
            ser = UserSerializer(data=request.data, context={ 'request': request})
            if ser.is_valid():
                ser.save()
                return Response(ser.data, status=status.HTTP_201_CREATED)
            return Response(ser.errors, status=status.HTTP_400_BAD_REQUEST)

##### 4.2 基于类视图的APIView类 #####

from app04.serializers import UserSerializer
    from app04.models import *
    from rest_framework.decorators import api_view
    from rest_framework.response import Response
    from rest_framework import status
    from rest_framework.views import APIView
    from django.http import Http404
    
    class UserDetail(APIView):
        def get_object(self, pk):
            try:
                user = User.objects.get(pk=pk)
                return user
            except Exception as e:
                raise Http404()
    
        def get(self, request, *args, **kwargs):
            user = self.get_object(kwargs.get('pk'))
            ser = UserSerializer(instance=user, context={ 'request': request})
            return Response(ser.data, status=status.HTTP_200_OK)
    
        def put(self, request, *args, **kwargs):
            user = self.get_object(kwargs.get('pk'))
            ser = UserSerializer(instance=user, data=request.data, context={ 'request': request})
            if ser.is_valid():
                ser.save()
                return Response(ser.data, status=status.HTTP_201_CREATED)
            return Response(ser.errors, status=status.HTTP_400_BAD_REQUEST)
    
        def patch(self, request, *args, **kwargs):
            user = self.get_object(kwargs.get('pk'))
            ser = UserSerializer(instance=user, data=request.data, context={ 'request': request}, partial=True)
            if ser.is_valid():
                ser.save()
                return Response(ser.data, status=status.HTTP_201_CREATED)
            return Response(ser.errors, status=status.HTTP_400_BAD_REQUEST)
    
        def delete(self, request, *args, **kwargs):
            user = self.get_object(kwargs.get('pk'))
            user.delete()
            return Response(status=status.HTTP_204_NO_CONTENT)

#### 5. 路由 ####

from django.urls import path
    
    from app04 import views
    
    urlpatterns = [
        path('users/', views.user_list, name='user-list'),
        # path('users/<int:pk>/', views.user_detail, name='user-detail'),
        path('users/<int:pk>/', views.UserDetail.as_view(), name='user-detail'),
    ]

### 六、类视图 ###

使用类视图最大的好处就是可以创建复用的行为。

#### 1. mixins ####

我们常用的操作比如创建、更新、删除、查找。REST框架已经帮我们写好了，写的代码就在mixins这个类里面。

所以只有我们自己的视图直接继承这个类，就完全可以拥有上面的所有功能。

from rest_framework import mixins
    from rest_framework import generics
    
    
    class UserList(mixins.ListModelMixin, mixins.CreateModelMixin, generics.GenericAPIView):
        queryset = User.objects.all()
        serializer_class = UserSerializer
    
        def get(self, request, *args, **kwargs):
            return self.list(request, *args, **kwargs)
    
        def post(self, request, *args, **kwargs):
            return self.create(request, *args, **kwargs)

# RetrieveModelMixin获取一个模型实例
    class UserDetail(mixins.RetrieveModelMixin, mixins.UpdateModelMixin, mixins.DestroyModelMixin, generics.GenericAPIView):
        queryset = User.objects.all()
        serializer_class = UserSerializer
    
        def get(self, request, *args, **kwargs):
            return self.retrieve(request, *args, **kwargs)
    
        def put(self, request, *args, **kwargs):
            return self.update(request, *args, **kwargs)
    
        def patch(self, request, *args, **kwargs):
            kwargs['partial'] = True
            return self.partial_update(request, *args, **kwargs)
    
        def delete(self, request, *args, **kwargs):
            return self.destroy(request, *args, **kwargs)

> 注意：路由关键字的参数要是pk

#### 2. 路由 ####

from django.urls import path
    
    from app04 import views
    
    urlpatterns = [
        # path('users/', views.user_list, name='user-list'),
        path('users/', views.UserList.as_view(), name='user-list'),
        # path('users/<int:pk>/', views.user_detail, name='user-detail'),
        path('users/<int:pk>/', views.UserDetail.as_view(), name='user-detail'),
    ]

#### 3. 使用通用的基于类的视图 ####

我们可以可以看到我的代码量已经减少了很多，但是我们还可以继续优化。REST把我们常见的操作继续封装了起来，封装 起来的代码就在`ListCreateAPIView`和`RetrieveUpdateDestroyAPIView`

class UserList(generics.ListCreateAPIView):
        queryset = User.objects.all()
        serializer_class = UserSerializer
    
    
    class UserDetail(generics.RetrieveUpdateDestroyAPIView):
        queryset = User.objects.all()
        serializer_class = UserSerializer

### 七、认证和权限 ###

现在我们写的接口，会发现一个问题，就是任何人都可以创建数据，都可以修改数据。这样肯定是不行的，我们希望只有数据的创建者才能有权限修改数据。如果不是，只能有读取权限。

#### 1. 创建用户 ####

在终端中执行命令：python manage.py createsuperuser

#### 2. 快速体验 ####

##### 2.1 模型类 #####

from django.db import models
    
    
    # Create your models here.
    class Game(models.Model):
        name = models.CharField(verbose_name='游戏名字', max_length=10)
        desc = models.CharField(verbose_name='描述', max_length=20)
        user = models.ForeignKey('auth.User', on_delete=models.CASCADE)

##### 2.2 视图 #####

from django.shortcuts import render
    from rest_framework import generics
    from .models import Game
    from .serializers import GameSerializer
    from rest_framework.authentication import SessionAuthentication, BasicAuthentication
    
    
    # Create your views here.
    
    class GameList(generics.ListCreateAPIView):
        queryset = Game.objects.all()
        serializer_class = GameSerializer
    
        # 重写perform_create 创建的时候提供当前登录的用户
        def perform_create(self, serializer):
            serializer.save(user=self.request.user)
            # 到底谁给request.user赋值的 DRF中的认证类
    
    
    class GameDetail(generics.RetrieveUpdateDestroyAPIView):
        queryset = Game.objects.all()
        serializer_class = GameSerializer

##### 2.3 序列化类 #####

from rest_framework import serializers
    from .models import Game
    
    
    class GameSerializer(serializers.ModelSerializer):
        class Meta:
            model = Game
            fields = '__all__'
            extra_kwargs = { 
                "user": { "read_only": True}
            }

##### 2.4 路由 #####

from django.urls import path
    
    from app05 import views
    
    urlpatterns = [
        path('games/', views.GameList.as_view(), name='game-list'),
        path('games/<int:pk>/', views.GameDetail.as_view(), name='game-detail'),
    ]

##### 2.5 测试 #####

http://127.0.0.1:8000/api/app05/games/

首先在Body–>raw中，传入json数据，如下：

{ 
        "name": "和平精英",
        "desc": "射击"
    }

其次在Authorization中，Type选择Basic Auth，输入上面创建的用户即可。

##### 2.6 总结 #####

DRF默认认证是SessionAuthentication、BasicAuthentication

目前采用BasicAuthentication，通过浏览器传递账号密码，base64加密 ，认证成功后，返回一个元组  
元组的第一个元素（用户对象），赋值给 request

我们重写 perform\_create 就可以从 request 拿到 user

#### 3. 权限 ####

刚才我们创建两个用户，现在我通过 nice1 去更新我们 nice 创建的数据，发现是可以更新的，但是这个并不是我们想要的。

现在我们有两种情况，第一，不认证也能修改成功；第二，其他人认证后也能修改成功。

##### 3.1 添加权限 #####

创建一个permissions.py，写如下代码：

from rest_framework.permissions import BasePermission, SAFE_METHODS
    
    
    class IsOwnOrReadOnly(BasePermission):
        # 重写has_object_permission
        def has_object_permission(self, request, view, obj):
            if request.method in SAFE_METHODS:
                return True
            # obj指模型对象
            return obj.user == request.user

上面代码的意思代表判断当前的数据创建用户是否跟当前登录用户是否一个人。并在更新视图上加上该权限

from django.shortcuts import render
    from rest_framework import generics
    from .models import Game
    from .serializers import GameSerializer
    from rest_framework.authentication import SessionAuthentication, BasicAuthentication
    from rest_framework import permissions
    from .permissions import IsOwnOrReadOnly
    
    
    # Create your views here.
    
    class GameList(generics.ListCreateAPIView):
        queryset = Game.objects.all()
        serializer_class = GameSerializer
    
        # 重写perform_create 创建的时候提供当前登录的用户
        def perform_create(self, serializer):
            serializer.save(user=self.request.user)
            # 到底谁给request.user赋值的 DRF中的认证类
    
    
    class GameDetail(generics.RetrieveUpdateDestroyAPIView):
        queryset = Game.objects.all()
        serializer_class = GameSerializer
        # 第一个权限解决不认证也能修改成功的情况
        # 第二个自定义认证权限解决其他人认证也能修改成功的情况
        permission_classes = [permissions.IsAuthenticatedOrReadOnly, IsOwnOrReadOnly]

##### 3.2 测试 #####

测试方法和上面一样，没有权限如下：

{ 
        "detail": "You do not have permission to perform this action."
    }

#### 4. 认证 ####

*  BasicAuthentication：此身份验证方案使用 HTTP基本身份验证，根据用户的用户名和密码进行签名。基本身份验证通常仅适用于测试。
 *  TokenAuthentication：此身份验证方案使用基于令牌的简单HTTP身份验证方案。令牌认证适用于客户端 - 服务器设置，例如本机桌面和移动客户端。
 *  SessionAuthentication：此身份验证方案使用 Django 的默认会话后端进行身份验证。会话身份验证适用于与您的网站在同一会话上下文中运行的AJAX客户端。
 *  RemoteUserAuthentication：此身份验证方案允许您将身份验证委派给Web服务器，该服务器设置`REMOTE_USER` 环境变量。

##### 4.1 BasicAuthentication #####

Http Basic 是一种比较简单的身份认证方式。 在 Http header 中添加键值对 Authorization: Basic xxx （xxx 是 username:passowrd base64 值）。而Base64 的解码是非常方便的，如果不使用 Https ，相当于是帐号密码直接暴露在请求中。

GET /auth/basic/ HTTP/1.1
    Host: xxxxx
    Authorization: Basic em1rOjEyMzQ1Ng==

###### 4.1.1 路由 ######

from django.urls import path
    
    from app06 import views
    
    urlpatterns = [
        path('carts/', views.CartView.as_view(), name='cart-list'),
    ]

###### 4.1.2 视图 ######

from django.shortcuts import render
    from rest_framework.views import APIView
    from django.http import JsonResponse
    from rest_framework.authentication import BasicAuthentication
    from rest_framework.permissions import IsAuthenticated
    
    
    # Create your views here.
    
    class CartView(APIView):
        # 基于什么登录认证的
        # 登录有很多方式，这里基于浏览器账号密码登录的
        authentication_classes = [BasicAuthentication]
        # 只有登录才能访问
        permission_classes = [IsAuthenticated]
    
        def get(self, request, *args, **kwargs):
            ctx = { 
                "code": 1,
                "msg": "ok",
                "data": { 
                    "goods": [
                        { 
                            "name": "苹果",
                            "price": 12
                        },
                        { 
                            "name": "橘子",
                            "price": 10
                        }
                    ]
                }
            }
            return JsonResponse(data=ctx, json_dumps_params={ 'ensure_ascii': False})

###### 4.1.3 小结 ######

DRF默认认证是SessionAuthentication、BasicAuthentication

支持多个认证，取认证成功的那个认证方法

##### 4.2 TokenAuthentication #####

###### 4.2.1 配置 ######

# settings.py
    INSTALLED_APPS = (
        ...
        'rest_framework.authtoken'
    )
    # 配置完上面，需要迁移，python manage.py migrate
    
    # 全局配置
    REST_FRAMEWORK = { 
        'DEFAULT_AUTHENTICATION_CLASSES': (
            'rest_framework.authentication.BasicAuthentication',
            'rest_framework.authentication.SessionAuthentication',
            'rest_framework.authentication.TokenAuthentication'，
        ),
    }
    # 如果有些视图不需要验证，可以将该类中认证设置为空
    # authentication_classes = []
    
    # 局部配置
    from rest_framework.authentication import BasicAuthentication, TokenAuthentication, SessionAuthentication
    class XXX(APIView):
        authentication_classes = [BasicAuthentication, TokenAuthentication, SessionAuthentication]

###### 4.2.2 路由 ######

放在根路由和子路由都可以，我写在了根路由。

from rest_framework.authtoken.views import obtain_auth_token
    urlpatterns = [
        # api-token-auth是随便起的
        path('api-token-auth/', obtain_auth_token),
    ]

这个路由的作用是生成 token

*  测试生成 token 接口

post 请求，http://10.36.172.81:8000/api-token-auth/

在 body 的 x-www-form-urlencoded 中设置 username 和 password，测试结果如下：

{ 
        "token": "596b0ffd0d02df6e745b4e1a6d08bec999bd95ed"
    }

###### 4.2.3 视图 ######

from django.shortcuts import render
    from rest_framework.views import APIView
    from django.http import JsonResponse
    from rest_framework.authentication import BasicAuthentication, TokenAuthentication
    from rest_framework.permissions import IsAuthenticated
    
    
    # Create your views here.
    
    class CartView(APIView):
        # 基于什么登录认证的
        # 登录有很多方式，这里基于浏览器账号密码登录的
        authentication_classes = [BasicAuthentication, TokenAuthentication]
        # 只有登录才能访问
        permission_classes = [IsAuthenticated]
    
        def get(self, request, *args, **kwargs):
            ctx = { 
                "code": 1,
                "msg": "ok",
                "data": { 
                    "goods": [
                        { 
                            "name": "苹果",
                            "price": 12
                        },
                        { 
                            "name": "橘子",
                            "price": 10
                        }
                    ]
                }
            }
            return JsonResponse(data=ctx, json_dumps_params={ 'ensure_ascii': False})

###### 4.2.4 测试 ######

封装到请求头中，在 Headers 中书写 key 和 value ，其中 token 是 4.2.2 中生成的。

Authorization: Token 596b0ffd0d02df6e745b4e1a6d08bec999bd95ed

认证成功后，返回数据，失败返回如下：

{ 
        "detail": "Invalid token."
    }

token值在分布式系统中会有问题产生，并且没有过期时间，一旦被窃取，任何人都可以使用。

##### 4.3 SessionAuthentication #####

###### 4.3.1 视图 ######

from django.shortcuts import render
    from rest_framework.views import APIView
    from django.http import JsonResponse
    from rest_framework.authentication import BasicAuthentication, TokenAuthentication, SessionAuthentication
    from rest_framework.permissions import IsAuthenticated
    
    
    # Create your views here.
    
    class CartView(APIView):
        # 基于什么登录认证的
        # 登录有很多方式，这里基于浏览器账号密码登录的
        authentication_classes = [BasicAuthentication, TokenAuthentication, SessionAuthentication]
        # 只有登录才能访问
        permission_classes = [IsAuthenticated]
    
        def get(self, request, *args, **kwargs):
            ctx = { 
                "code": 1,
                "msg": "ok",
                "data": { 
                    "goods": [
                        { 
                            "name": "苹果",
                            "price": 12
                        },
                        { 
                            "name": "橘子",
                            "price": 10
                        }
                    ]
                }
            }
            return JsonResponse(data=ctx, json_dumps_params={ 'ensure_ascii': False})

###### 4.3.2 测试 ######

get请求，在 Headers 中书写 key 和 value ，格式如下：

Cookie: csrftoken=SEmCnnmHVE0XZSFhBLPQD8HjLf43eCZdLU0aVvEjtlaf0hRjLvZmDmIwM9sl62lq; sessionid=h4jp85en5zspsthqffx66x1noc2y9k6r

##### 4.4 自定义认证 #####

###### 4.4.1 模型类 ######

from django.db import models
    
    
    # Create your models here.
    class User(models.Model):
        username = models.CharField(max_length=32, unique=True)
        password = models.CharField(max_length=64)
    
    
    class UserToken(models.Model):
        user = models.OneToOneField('User', models.CASCADE)
        token = models.CharField(max_length=64)

###### 4.4.2 视图 ######

import hashlib
    import time
    
    from rest_framework.views import APIView
    from django.http import JsonResponse
    from rest_framework.authentication import BasicAuthentication
    from rest_framework import exceptions
    from .permissions import MyPermission
    
    # Create your views here.
    from app06.models import User, UserToken
    
    
    def get_md5(user):
        ctime = str(time.time())
        m = hashlib.md5(bytes(user, encoding='utf-8'))
        m.update(bytes(ctime, encoding='utf-8'))
        return m.hexdigest()
    
    
    class LoginView(APIView):
        def post(self, request, *args, **kwargs):
            ret = { 'code': 1, 'msg': None, 'data': { }}
            # user = request._request.POST.get('username')
            # pwd = request._request.POST.get('password')
            # 等价于下面
            user = request.POST.get('username')
            pwd = request.POST.get('password')
            obj = User.objects.filter(username=user, password=pwd).first()
            if not obj:
                ret['code'] = -1
                ret['msg'] = '用户名或密码错误'
            token = get_md5(user)
            UserToken.objects.update_or_create(user=obj, defaults={ 'token': token})
            ret['token'] = token
            return JsonResponse(ret)
    
    
    class MyAuthentication(BasicAuthentication):
        # 必须重写这个方法
        def authenticate(self, request):
            # header key必须大写，前缀必须是"HTTP"，后面如果连接符是横线"-"，要改成下划线"_"
            # 例如你的header的key为api_auth，那在Django中应该使用request.META.get("HTTP_API_AUTH")来获取请求头的数据
            token = request.META.get('HTTP_TOKEN')
            obj = UserToken.objects.filter(token=token).first()
            if not obj:
                raise exceptions.AuthenticationFailed('认证失败')
            else:
                # 必须返回一个元组
                return (obj.user, obj)
    
    
    class CartView(APIView):
        # 自定义认证
        authentication_classes = [MyAuthentication]
        # 自定义权限
        permission_classes = [MyPermission]
    
        def get(self, request, *args, **kwargs):
            ctx = { 
                "code": 1,
                "msg": "ok",
                "data": { 
                    "goods": [
                        { 
                            "name": "苹果",
                            "price": 12
                        },
                        { 
                            "name": "橘子",
                            "price": 10
                        }
                    ]
                }
            }
            return JsonResponse(data=ctx, json_dumps_params={ 'ensure_ascii': False})

###### 4.4.3 自定义权限 ######

创建一个 permissions.py 文件

from rest_framework.permissions import BasePermission
    
    
    class MyPermission(BasePermission):
        def has_permission(self, request, view):
            if not request.user:
                return False
            return True

###### 4.4.4 路由 ######

from django.urls import path
    
    from app06 import views
    
    urlpatterns = [
        path('carts/', views.CartView.as_view(), name='cart-list'),
        path('login/', views.LoginView.as_view(), name='login'),
    ]

###### 4.4.5 测试 ######

首先，生成 token 。post 请求，http://127.0.0.1:8000/api/app06/login

在 Body 的 x-www-form-urlencoded 输入 username 和 password（必须在我们自己创建的模型库中存在）

登录认证成功后，产生 token ，携带 token 访问 http://127.0.0.1:8000/api/app06/carts/ ，get 请求，并在 Headers 中输入 token 和 上面生成的 token 值。

##### 4.5 JWT验证 #####

使用 django-rest-framework 开发 api 并使用 json web token 进行身份验证，使用 django-rest-framework-jwt 这个库来帮助我们简单的使用 jwt 进行身份验证。token 不会保存在服务器，保存在了客户端。

###### 4.5.1 安装 ######

pip install djangorestframework-jwt

###### 4.5.2 注册 ######

INSTALLED_APPS = [
        ......
        'rest_framework',
        'rest_framework.authtoken',
    ]

###### 4.5.3 配置 ######

# 全局配置
    REST_FRAMEWORK = { 
        'DEFAULT_AUTHENTICATION_CLASSES': (
            'rest_framework.authentication.BasicAuthentication',
            'rest_framework.authentication.SessionAuthentication',
            'rest_framework.authentication.TokenAuthentication',
            # 配置验证方式为Token验证
            'rest_framework_jwt.authentication.JSONWebTokenAuthentication'
        ),
        'DEFAULT_PERMISSION_CLASSES': (
            'rest_framework.permissions.IsAuthenticated',
        )
    }
    
    import datetime
    JWT_AUTH = { 
        'JWT_EXPIRATION_DELTA': datetime.timedelta(days=7),  # Token 过期时间为一周
        'JWT_AUTH_HEADER_PREFIX': 'JWT',  # Token的头为: JWT adashkjdhaskjhd21312312
        'JWT_ALLOW_REFRESH': False,
        'JWT_RESPONSE_PAYLOAD_HANDLER': 'app06.utils.jwt_response_payload_handler'
    }

###### 4.5.4 路由 ######

from rest_framework_jwt.views import obtain_jwt_token
    urlpatterns = [
        # path('admin/', admin.site.urls),
        # path('api/', include(router.urls)),
        # path('api/app02/', include('app02.urls')),
        # path('api/app03/', include(('app03.urls', 'app03'), namespace='app03')),
        # path('api/app04/', include(('app04.urls', 'app04'), namespace='app04')),
        # path('api/app05/', include(('app05.urls', 'app05'), namespace='app05')),
        # path('api/app06/', include(('app06.urls', 'app06'), namespace='app06')),
        # path('api-token-auth/', obtain_auth_token),
        path('api-token-auth/', obtain_jwt_token),
    
    ]

post 请求，http://127.0.0.1:8000/api-token-auth/

在 Body 的x-www-form-urlencoded 或 form-data 中输入 username 和 password，结果如下：

{ 
        "token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VyX2lkIjoxLCJ1c2VybmFtZSI6Im5pY2UiLCJleHAiOjE1OTgyODI1MDcsImVtYWlsIjoibmljZUBxcS5jb20ifQ.zFVFf0maDoIT76fKkgAum8cpqTUN7JQmrlrKkdQmX5Y"
    }

默认的返回值仅有 token，通过修改该视图的返回值可以完成我们的需求。在应用中新建一个 utils.py 文件，内容如下：

def jwt_response_payload_handler(token, user=None, request=None):
        # 除了返回token外，还返回 id 和 username
        return { 
            'token': token,
            'id': user.id,
            'username': user.username,
        }

然后在 settings.py 中配置

import datetime
    JWT_AUTH = { 
        'JWT_EXPIRATION_DELTA': datetime.timedelta(days=7),  # Token 过期时间为一周
        'JWT_AUTH_HEADER_PREFIX': 'JWT',  # Token的头为: JWT adashkjdhaskjhd21312312
        'JWT_ALLOW_REFRESH': False,
        'JWT_RESPONSE_PAYLOAD_HANDLER': 'app06.utils.jwt_response_payload_handler'
    }

测试结果为：

{ 
        "token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VyX2lkIjoxLCJ1c2VybmFtZSI6Im5pY2UiLCJleHAiOjE1OTgyODI1MzQsImVtYWlsIjoibmljZUBxcS5jb20ifQ.HjEJAASvnIxjOAhKC-pE72pY1YKswtbPGX93djKPtzs",
        "id": 1,
        "username": "nice"
    }

我们可以将 JWT 保存在 cookie 中，也可以保存在浏览器的本地存储里，我们保存在浏览器本地存储中，下次使用的时候带上即可。

###### 4.5.5 视图 ######

from rest_framework_jwt.authentication import JSONWebTokenAuthentication
    class CartView(APIView):
        # 基于jwt认证
        authentication_classes = [JSONWebTokenAuthentication]
        # 权限 只有登录才能访问
        permission_classes = [IsAuthenticated]
    
        def get(self, request, *args, **kwargs):
            ctx = { 
                "code": 1,
                "msg": "ok",
                "data": { 
                    "goods": [
                        { 
                            "name": "苹果",
                            "price": 12
                        },
                        { 
                            "name": "橘子",
                            "price": 10
                        }
                    ]
                }
            }
            return JsonResponse(data=ctx, json_dumps_params={ 'ensure_ascii': False})

###### 4.5.6 测试 ######

get 请求，http://127.0.0.1:8000/api/app06/carts/

在 Headers 中，输入 key 和 value，其中 key 是 Authorization，value 是 JWT + 两个空格 + 生成的 token 值。

###### 4.5.7 JWT权限验证 ######

和 3.1 中实现效果一样

from rest_framework_jwt.authentication import jwt_decode_handler
    
    
    # 判断当前数据的创建者是否与当前登录的用户一样
    class IsOwnOrReadOnly(BasePermission):
    
        def has_object_permission(self, request, view, obj):
            # if request.method in SAFE_METHODS:
            # return True
            # token = request.META.get('HTTP_AUTHORIZATION')[5:]
            token = request.META.get('HTTP_AUTHORIZATION').split()[-1]  # token解析出来
            token_user = jwt_decode_handler(token)
            if token_user:
                # obj.user.id数据创建者的id
                return obj.user.id == token_user.get('user_id')  # 证明 当前jwt验证的用户就是数据的创建者
            return False

##### 4.6 JWT优缺点 #####

优点

*  无状态（保存在客户端）
 *  避免csrf
 *  适合移动端

缺点

*  注销登录后Token时效问题（可以把token放到redis中，当我们删除用户时，删除token）

### 八、频率 ###

开放平台的API接口调用需要限制其频率，以节约服务器资源和避免恶意的频繁调用。

3/min
    
    {"127.0.0.1":["12.29.50","12.29.40","12.29.20"]}
    
    12.30.10   访问记录大于3 访问不了
    
    12.30.21   能访问
    "127.0.0.1":["12.30.21","12.29.50","12.29.40"]}

from rest_framework.throttling import SimpleRateThrottle
    
    allow_request 必须实现的方法
    
    AnonRateThrottle类:匿名用户 
    
    UserRateThrottle类:已认证用户
    
    ScopedRateThrottle类:每个用户对视图的访问次数

#### 1. 内置频率类 ####

在应用下新建一个throttlings.py 文件。如下代码：

from rest_framework.throttling import SimpleRateThrottle
    
    
    # {"127.0.0.1":["12.29.50","12.29.40","12.29.20"]}
    # key会缓存到django的缓存中，key相当于上面的127.0.0.1
    class VisitThrottling(SimpleRateThrottle):
        scope = '未认证用户'
    
        def get_cache_key(self, request, view):
            return self.get_ident(request)  # 使用ip当作key
    
    
    class UserThrottling(SimpleRateThrottle):
        scope = '已认证用户'
    
        def get_cache_key(self, request, view):
            return request.user  # 当前登录的用户当做key

#### 2. 配置 ####

# 全局配置
    REST_FRAMEWORK = { 
        'DEFAULT_AUTHENTICATION_CLASSES': (
            'rest_framework.authentication.BasicAuthentication',
            'rest_framework.authentication.SessionAuthentication',
            'rest_framework.authentication.TokenAuthentication',
            # 配置验证方式为Token验证
            'rest_framework_jwt.authentication.JSONWebTokenAuthentication'
        ),
        'DEFAULT_PERMISSION_CLASSES': (
            'rest_framework.permissions.IsAuthenticated',
        ),
        # 节流配置下面这两项
        'DEFAULT_THROTTLE_CLASSES': ['app06.throttlings.UserThrottling', ],
        'DEFAULT_THROTTLE_RATES': { 
            '未认证用户': '3/m',
            '已认证用户': '10/m',
        },
    }

#### 3. 视图 ####

视图中配置局部节流

class CartView(APIView):
        # 基于jwt认证
        authentication_classes = [JSONWebTokenAuthentication]
        # 权限 只有登录才能访问
        permission_classes = [IsAuthenticated]
        # 节流 局部
        throttle_classes = [VisitThrottling]
    
        def get(self, request, *args, **kwargs):
            ctx = { 
                "code": 1,
                "msg": "ok",
                "data": { 
                    "goods": [
                        { 
                            "name": "苹果",
                            "price": 12
                        },
                        { 
                            "name": "橘子",
                            "price": 10
                        }
                    ]
                }
            }
            return JsonResponse(data=ctx, json_dumps_params={ 'ensure_ascii': False})

### 九、版本控制 ###

API 版本控制允许我们在不同的客户端之间更改行为（同一个接口的不同版本会返回不同的数据）。 DRF提供了许多不同的版本控制方案。

可能会有一些客户端因为某些原因不再维护了，但是我们后端的接口还要不断的更新迭代，这个时候通过版本控制返回不同的内容就是一种不错的解决方案。

#### 1. 五种控制方案 ####

from rest_framework.versioning import BaseVersioning
    
    # 在请求头中
    class AcceptHeaderVersioning(BaseVersioning):
        """ GET /something/ HTTP/1.1 Host: example.com Accept: application/json; version=1.0 """
        pass
    
    # 在URL中
    class URLPathVersioning(BaseVersioning):
        """ urlpatterns = [ url(r'^(?P<version>[v1|v2]+)/users/$', users_list, name='users-list'), url(r'^(?P<version>[v1|v2]+)/users/(?P<pk>[0-9]+)/$', users_detail, name='users-detail') ] GET /1.0/something/ HTTP/1.1 Host: example.com Accept: application/json """
        pass
    
    # 使用别名namespace
    class NamespaceVersioning(BaseVersioning):
        """ # users/urls.py urlpatterns = [ url(r'^/users/$', users_list, name='users-list'), url(r'^/users/(?P<pk>[0-9]+)/$', users_detail, name='users-detail') ] # urls.py urlpatterns = [ url(r'^v1/', include('users.urls', namespace='v1')), url(r'^v2/', include('users.urls', namespace='v2')) ] GET /1.0/something/ HTTP/1.1 Host: example.com Accept: application/json """
        pass
    
    # 通过主机域
    class HostNameVersioning(BaseVersioning):
        """ GET /something/ HTTP/1.1 Host: v1.example.com Accept: application/json """
        pass
    
    # 通过URL查询参数
    class QueryParameterVersioning(BaseVersioning):
        """ GET /something/?version=0.1 HTTP/1.1 Host: example.com Accept: application/json """
        pass

#### 2. 视图 ####

class VersionView(APIView):
        def get(self, request, *args, **kwargs):
            # print(request.version) # v1
            if request.version == 'v1':
                ctx = { 'code': 1, 'msg': 'ok', 'data': { }}
                return JsonResponse(ctx)
            else:
                ctx = { 'code': 2, 'msg': 'ok', 'data': { }}
                return JsonResponse(ctx)

#### 3. 路由 ####

子路由

urlpatterns = [
        path('carts/', views.CartView.as_view(), name='cart-list'),
        path('login/', views.LoginView.as_view(), name='login'),
        path('<str:version>/version', views.VersionView.as_view(), name='version'),
    ]

根路由

urlpatterns = [
        path('api/app06/', include(('app06.urls', 'app06'), namespace='app06'))
    ]

#### 4. 配置 ####

# 全局配置
    REST_FRAMEWORK = { 
        # 认证
        'DEFAULT_AUTHENTICATION_CLASSES': (
            'rest_framework.authentication.BasicAuthentication',
            'rest_framework.authentication.SessionAuthentication',
            'rest_framework.authentication.TokenAuthentication',
            # 配置验证方式为Token验证
            'rest_framework_jwt.authentication.JSONWebTokenAuthentication'
        ),
        # 权限
        'DEFAULT_PERMISSION_CLASSES': (
            'rest_framework.permissions.IsAuthenticated',
        ),
        # 节流
        'DEFAULT_THROTTLE_CLASSES': ['app06.throttlings.UserThrottling', ],
        'DEFAULT_THROTTLE_RATES': { 
            '未认证用户': '3/m',
            '已认证用户': '10/m',
        },
        # 版本
        'DEFAULT_VERSIONING_CLASS': 'rest_framework.versioning.URLPathVersioning',
        'DEFAULT_VERSION': 'v1',  # 默认的版本
        'ALLOWED_VERSIONS': ['v1', 'v2'],  # 有效的版本
        'VERSION_PARAM': 'version',  # 版本的参数名与路由中一致
    }

#局部配置
    versioning_class = "注意不是列表"

#### 5. 通用的基于类的视图中的用法 ####

##### 5.1 模型 #####

from django.db import models
    
    
    # Create your models here.
    class Game(models.Model):
        name = models.CharField(max_length=10)
        status = models.IntegerField()

##### 5.2 序列化 #####

from rest_framework import serializers
    from .models import Game
    
    
    class GameSerializer(serializers.ModelSerializer):
        class Meta:
            model = Game
            fields = '__all__'

##### 5.3 视图 #####

from django.shortcuts import render
    from rest_framework import generics
    from .models import Game
    from .serializers import GameSerializer
    
    
    # Create your views here.
    class GameList(generics.ListCreateAPIView):
        serializer_class = GameSerializer
    
        def get_queryset(self):
            if self.request.version == 'v1':
                queryset = Game.objects.filter(status=1).all()
            else:
                queryset = Game.objects.filter(status=0).all()
            return queryset
    
        # def get_serializer_class(self):
        # # 序列化也支持重写，返回不同的序列化类
        # pass
    
    
    class GameDetail(generics.RetrieveUpdateDestroyAPIView):
        queryset = Game.objects.all()
        serializer_class = GameSerializer

##### 5.4 路由 #####

子路由

from django.urls import path
    
    from app07 import views
    
    urlpatterns = [
        path('games/', views.GameList.as_view(), name='game-list'),
        path('games/<int:pk>', views.GameDetail.as_view(), name='game-detail'),
    ]

根路由

urlpatterns = [
        path('api/app07/<str:version>/', include(('app07.urls', 'app07'), namespace='app07'))
    ]

##### 5.5 测试 #####

get 请求

http://127.0.0.1:8000/api/app07/v1/games/

http://127.0.0.1:8000/api/app07/v2/games/

### 十、分页 ###

当对于数据量大的时候，我们就需要采用分页操作。

#### 1. 分页方式 ####

*  普通分页，看第n页，每页显示m条数据；
 *  切割分页，在n个位置，向后查看m条数据；
 *  加密分页，这与普通分页方式相似，不过对url中的请求页码进行加密。

#### 2. 普通分页 ####

新建一个 pagenumberpagination.py 文件

from rest_framework.pagination import PageNumberPagination
    
    
    class MyPageNumberPagination(PageNumberPagination):
        page_size = 2
        max_page_size = 5
        page_size_query_param = 'size'
        page_query_param = 'page'

page\_query\_param：表示url中的页码参数  
page\_size\_query\_param：表示url中每页数量参数  
page\_size：表示每页的默认显示数量  
max\_page\_size：表示每页最大显示数量，做限制使用，避免突然大量的查询数据，数据库崩溃

#### 3. 切割分页 ####

from rest_framework.pagination import PageNumberPagination, LimitOffsetPagination
    
    class MyPageNumberPagination(LimitOffsetPagination):
        default_limit = 2
        limit_query_param = 'limit'
        offset_query_param = 'offset'
        max_limit = 5

default\_limit：表示默认每页显示几条数据  
limit\_query\_param：表示url中本页需要显示数量参数  
offset\_query\_param：表示从数据库中的第几条数据开始显示参数  
max\_limit：表示每页最大显示数量，做限制使用，避免突然大量的查询数据，数据库崩溃

#### 4. 加密分页 ####

from rest_framework.pagination import PageNumberPagination, LimitOffsetPagination, CursorPagination
    
    
    class MyPageNumberPagination(CursorPagination):
        cursor_query_param = 'cursor'
        page_size = 1
        ordering = 'id'
        page_size_query_param = 'size'
        max_page_size = 1

cursor\_query\_param：表示url中页码的参数  
page\_size\_query\_param：表示每页显示数据量的参数  
max\_page\_size：表示每页最大显示数量，做限制使用，避免突然大量的查询数据，数据库崩溃  
ordering：表示返回数据的排序方式

#### 5. 配置 ####

####  ####