文章首页 Web开发 Windows开发 编程语言 数据库技术 移动平台 系统服务 微信 设计 布布扣 其他

python | DRF 框架知识总览

时间：2020-12-05 15:18:10   收藏：0   阅读：37

DRF 框架

DRF 框架知识总览

接口(api)

什么是接口

前台与后台进行信息交互的媒介 -- url链接

接口组成

接口文档

为什么要写接口文档
编写文档方式
书写过程

接口规范

为什么要制定接口规范
通用的接口规范: Restful 接口规范

FBV 与 CBV : Function|Class Base View

DRF 框架的基础视图类

APIView

请求模块
DRF 框架APIView 的请求生命周期 概览

技术分享图片

重写as_view方法

技术分享图片

解析模块

技术分享图片

技术分享图片

技术分享图片

技术分享图片

渲染模块
响应模块
响应类: Response
异常模块

DRF 核心组件

序列组件

技术分享图片

序列化基类 BaseSerializer
单表序列化
单表反序列化
序列化类其他配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
class AuthorModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.Author
        # 不常用，将全部字段提供给外界
        fields = ‘__all__‘ 
        
# ------------------------------------------------------------------

class AuthorModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.Author
        # 不常用，排除指定字段的其他所有字段，不能自动包含 外键反向 字段
        exclude = [‘is_delete‘, ‘updated_time‘]  
        
# ------------------------------------------------------------------

class AuthorModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.Author
        # ‘detail‘, ‘books‘ 是 外键(正向|反向) 字段
        fields = [‘name‘, ‘detail‘, ‘books‘]
        # 不常用，自动深度，自动深度会显示外键关联表的所有字段
        depth = 2  
# 正向外键字段：就是外键的属性名
# 反向外键字段：就是外键属性设置的related_name
子序列化
1
2
3
4
5
 
"""
1）子序列化的字段，必须是 外键(正向|反向) 字段
2）子序列化对应的数据是单个many=False，数据对应是多个many=True
3）子序列化其实就是自定义序列化字段，覆盖了原有 外键(正向|反向)字段 的规则，所以不能进行反序列化
"""
多表序列化与反序列化
1
2
3
4
 
"""
1）外键字段要参与反序列化，所以外键字段设置为write_only
2）外键关系需要连表序列化结果给前台，可以用@property来自定义连表序列化
"""
序列化类外键字段的覆盖
1
2
3
4
5
6
7
8
9
10
11
 
"""
1）在序列化类中自定义字段，名字与model类中属性名一致，就称之为覆盖操作
	（覆盖的是属性的所有规则：extra_kwargs中指定的简易规则、model字段提供的默认规则、数据库唯一约束等哪些规则）

2）外键覆盖字段用PrimaryKeyRelatedField来实现，可以做到只读、只写、可读可写三种形式
	只读：read_only=True
	只写：queryset=关联表的queryset, write_only=True
	可读可写：queryset=关联表的queryset
	
3）当外界关联的数据是多个时，需标识many=True条件
"""
十大接口 序列化总结
1
2
3
4
5
6
7
 
"""
1）初始化序列化类，设置partial=True可以将所有反序列化字段的 required 设置为 False（提供就校验，不提供不校验），可以运用在局部修改接口

2）初始化序列化类，设置context={...}，在序列化类操作self.context，实现视图类和序列化类数据互通

3）只有要完成资源的群改这种特殊需求时，才需要自定义ListSerializer绑定给自定义的ModelSerializer，重写update方法，来完成需求
"""
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
"""
def __init__(self, instance=None, data=empty, **kwargs):
    pass

instance：是要被赋值对象的 - 对象类型数据赋值给instance
data：是要被赋值数据的 - 请求来的数据赋值给data
kwargs：内部有三个属性：many、partial、context
    many：操作的对象或数据，是单个的还是多个的
    partial：在修改需求时使用，可以将所有校验字段required校验规则设置为False
    context：用于视图类和序列化类直接传参使用
"""

# 常见使用
# 单查接口
UserModelSerializer(instance=user_obj)

# 群查接口
UserModelSerializer(instance=user_query, many=True)

# 单增接口，request.data是字典
UserModelSerializer(data=request.data) 

# 群增接口，request.data是列表
UserModelSerializer(data=request.data, many=True)

# 单整体改接口，request.data是字典
UserModelSerializer(instance=user_obj, data=request.data)

# 群整体改接口，request.data是列表，且可以分离出pks，转换成user_queryset
UserModelSerializer(instance=user_queryset, data=request.data, many=True)

# 单局部改接口，request.data是字典
UserModelSerializer(instance=user_obj, data=request.data, partial=True)

# 群局部改接口，request.data是列表，且可以分离出pks，转换成user_queryset
UserModelSerializer(instance=user_queryset, data=request.data, partial=True, many=True)

# 删接口，用不到序列化类
开发流程
1
2
3
4
 
1）在model类中自定义 读字段，在serializer类中自定义 写字段
2）将model自带字段和所以自定义字段书写在fields中，用write_only和read_only区别model自带字段
3）可以写基础校验规则，也可以省略
4）制定局部及全局钩子
Response
二次封装Response
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
# 新建response.py文件
from rest_framework.response import Response

class APIResponse(Response):
    def __init__(self, status=0, msg=‘ok‘, http_status=None, headers=None, exception=False, **kwargs):
        # 将外界传入的数据状态码、状态信息以及其他所有额外存储在kwargs中的信息，都格式化成data数据
        data = {
            ‘status‘: status,
            ‘msg‘: msg
        }
        # 在外界数据可以用result和results来存储
        if kwargs:
            data.update(kwargs)

        super().__init__(data=data, status=http_status, headers=headers, exception=exception)


# 使用：
# APIResponse() 代表就返回 {"status": 0, "msg": "ok"}

# APIResponse(result="结果") 代表返回 {"status": 0, "msg": "ok", "result": "结果"}

# APIResponse(status=1, msg=‘error‘, http_status=400, exception=True) 异常返回 {"status": 1, "msg": "error"}
视图家族
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
"""
视图基类：APIView、GenericAPIView
视图工具类：mixins包下的五个类（六个方法）
工具视图类：generics包下的所有GenericAPIView的子类
视图集：viewsets包下的类
"""

""" GenericAPIView基类（基本不会单独使用，了解即可，但是是高级视图类的依赖基础）
1）GenericAPIView继承APIV iew，所有APIView子类写法在继承GenericAPIView时可以保持一致
2）GenericAPIView给我们提供了三个属性 queryset、serializer_class、lookup_field
3）GenericAPIView给我们提供了三个方法 get_queryset、get_serializer、get_obj
"""


""" mixins包存放了视图工具类（不能单独使用，必须配合GenericAPIView使用）
CreateModelMixin：单增工具类
	create方法
	
ListModelMixin：群查工具类
	list方法

RetrieveModelMixin：单查工具类
	retrieve方法

UpdateModelMixin：单整体局部改工具类
	update方法

DestroyModelMixin：单删工具类
	destory方法
"""

""" generics包下的所有GenericAPIView的子类（就是继承GenericAPIView和不同mixins下的工具类的组合）
1）定义的视图类，继承generics包下已有的特点的GenericAPIView子类，可以在只初始化queryset和serializer_class两个类属性后，就获得特定的功能

2）定义的视图类，自己手动继承GenericAPIView基类，再任意组合mixins包下的一个或多个工具类，可以实现自定义的工具视图类，获得特定的功能或功能们

注：
i）在这些模式下，不能实现单查群查共存（可以加逻辑区分，也可以用视图集知识）
ii）DestroyModelMixin工具类提供的destory方法默认是从数据库中删除数据，所以一般删除数据的需求需要自定义逻辑
"""
views.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# ----------------------------- 过渡写法：了解 -----------------------------

from rest_framework.generics import GenericAPIView
class BookV1APIView(GenericAPIView):
    # 将数据和序列化提示为类属性，所有的请求方法都可以复用
    queryset = models.Book.objects.filter(is_delete=False).all()
    serializer_class = serializers.BookModelSerializer
    lookup_field = ‘pk‘  # 可以省略，默认是pk，与url有名分组对应的

    # 群查
    def get(self, request, *args, **kwargs):
        # queryset = models.Book.objects.filter(is_delete=False).all()  # => 方法+属性两行代码
        queryset = self.get_queryset()
        # serializer = serializers.BookModelSerializer(instance=queryset, many=True)  # => 方法+属性两行代码
        serializer = self.get_serializer(instance=queryset, many=True)
        return APIResponse(results=serializer.data)

    # 单查
    # def get(self, request, *args, **kwargs):
    #     obj = self.get_object()
    #     serializer = self.get_serializer(obj)
    #     return APIResponse(results=serializer.data)

    # 单增
    def post(self, request, *args, **kwargs):
        # serializer = serializers.BookModelSerializer(data=request.data)
        serializer = self.get_serializer(data=request.data)  # 同样的步骤多了，好处就来了
        serializer.is_valid(raise_exception=True)
        obj = serializer.save()
        return APIResponse(result=self.get_serializer(obj).data, http_status=201)
    
# ----------------------------- 过渡写法：了解 -----------------------------

from rest_framework.generics import GenericAPIView
from rest_framework import mixins
class BookV2APIView(GenericAPIView, mixins.RetrieveModelMixin, mixins.CreateModelMixin):
    queryset = models.Book.objects.filter(is_delete=False).all()
    serializer_class = serializers.BookModelSerializer

    # 单查
    def get(self, request, *args, **kwargs):
        # obj = self.get_object()
        # serializer = self.get_serializer(obj)
        # return APIResponse(results=serializer.data)

        # return self.retrieve(request, *args, **kwargs)

        response = self.retrieve(request, *args, **kwargs)
        return APIResponse(result=response.data)

    # 单增
    def post(self, request, *args, **kwargs):
        return self.create(request, *args, **kwargs)


# ----------------------------- 开发写法：常用 -----------------------------

from rest_framework.generics import RetrieveAPIView
class BookV3APIView(RetrieveAPIView):
    queryset = models.Book.objects.filter(is_delete=False).all()
    serializer_class = serializers.BookModelSerializer

    # 单查
    pass
urls.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
from django.conf.urls import url
from . import views

urlpatterns = [
    # ...
    
    url(r‘^v1/books/$‘, views.BookV1APIView.as_view()),
    url(r‘^v1/books/(?P<pk>\d+)/$‘, views.BookV1APIView.as_view()),

    url(r‘^v2/books/$‘, views.BookV2APIView.as_view()),
    url(r‘^v2/books/(?P<pk>\d+)/$‘, views.BookV2APIView.as_view()),

    url(r‘^v3/books/$‘, views.BookV3APIView.as_view()),
    url(r‘^v3/books/(?P<pk>\d+)/$‘, views.BookV3APIView.as_view()),
]
基于generics包下工具视图类的六大基础接口
视图集
路由组件 : 必须配合视图集使用

urls.py

1
2
3
4
5
6
7
8
9
10
11
12
13
 
from django.conf.urls import url, include
from . import views
# 路由组件，必须配合视图集使用
from rest_framework.routers import SimpleRouter
router = SimpleRouter()

# 以后就写视图集的注册即可：BookV3APIView和BookV4APIView都是视图集
router.register(‘v3/books‘, views.BookV3APIView, ‘book‘)
router.register(‘v4/books‘, views.BookV4APIView, ‘book‘)

urlpatterns = [
    url(‘‘, include(router.urls))
]

views.py

1
2
3
4
 
from rest_framework.viewsets import ReadOnlyModelViewSet
class BookV4APIView(ReadOnlyModelViewSet):
    queryset = models.Book.objects.filter(is_delete=False).all()
    serializer_class = serializers.BookModelSerializer
自定义路由组件
上传文件接口
urls.py
1
2
3
4
5
6
7
8
9
10
11
12
 
from django.conf.urls import url, include
from . import views
# 路由组件，必须配合视图集使用
from rest_framework.routers import SimpleRouter
router = SimpleRouter()

# /books/image/(pk) 提交 form-data：用image携带图片
router.register(‘books/image‘, views.BookUpdateImageAPIView, ‘book‘)

urlpatterns = [
    url(‘‘, include(router.urls))
]
serializers.py
1
2
3
4
 
class BookUpdateImageModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.Book
        fields = [‘image‘]
views.py
1
2
3
4
5
6
 
# 上次文件 - 修改头像 - 修改海报
from rest_framework.viewsets import GenericViewSet
from rest_framework import mixins
class BookUpdateImageAPIView(GenericViewSet, mixins.UpdateModelMixin):
    queryset = models.Book.objects.filter(is_delete=False).all()
    serializer_class = serializers.BookUpdateImageModelSerializer

三大认证组件

权限

Django权限六表: 扩展User表
models.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
from django.db import models

# RBAC - Role-Based Access Control
# Django的 Auth组件 采用的认证规则就是RBAC

from django.contrib.auth.models import AbstractUser
class User(AbstractUser):
    mobile = models.CharField(max_length=11, unique=True)

    def __str__(self):
        return self.username


class Book(models.Model):
    name = models.CharField(max_length=64)

    def __str__(self):
        return self.name


class Car(models.Model):
    name = models.CharField(max_length=64)

    def __str__(self):
        return self.name
settings.py
1
2
 
# 自定义User表，要配置
AUTH_USER_MODEL = ‘api.User‘
admin.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
from django.contrib import admin
from . import models

from django.contrib.auth.admin import UserAdmin as DjangoUserAdmin

# 自定义User表后，admin界面管理User类
class UserAdmin(DjangoUserAdmin):
    # 添加用户课操作字段
    add_fieldsets = (
        (None, {
            ‘classes‘: (‘wide‘,),
            ‘fields‘: (‘username‘, ‘password1‘, ‘password2‘, ‘is_staff‘, ‘mobile‘, ‘groups‘, ‘user_permissions‘),
        }),
    )
    # 展示用户呈现的字段
    list_display = (‘username‘, ‘mobile‘, ‘is_staff‘, ‘is_active‘, ‘is_superuser‘)


admin.site.register(models.User, UserAdmin)
admin.site.register(models.Book)
admin.site.register(models.Car)
导入
1
2
3
 
# 1）像专门做人员权限管理的系统（CRM系统）都是公司内部使用，所以数据量都在10w一下，一般效率要求也不是很高
# 2）用户量极大的常规项目，会分两种用户：前台用户(三大认证) 和 后台用户(RBAC来管理)
# 结论：没有特殊要求的Django项目可以直接采用Auth组件的权限六表，不需要自定义六个表，也不需要断开表关系，但可能需要自定义User表
做项目是否要分表管理前后台用户
1
2
3
4
5
6
7
8
9
10
11
12
13
 
"""
1）是否需要分表
答案：不需要
理由：前后台用户共存的项目，后台用户量都是很少；做人员管理的项目，基本上都是后台用户；前后台用户量都大的会分两个项目处理

2）用户权限六表是否需要断关联
答案：不需要
理由：前台用户占主导的项目，几乎需求只会和User一个表有关；后台用户占主导的项目，用户量不会太大

3）Django项目有没有必须自定义RBAC六表
答案：不需要
理由：auth组件功能十分强大且健全（验证密码，创建用户等各种功能）；admin、xadmin、jwt、drf-jwt组件都是依赖auth组件的（自定义RBAC六表，插件都需要自定义，成本极高）
"""

权限六表：RBAC - Role-Based Access Control

三表

技术分享图片

六表

技术分享图片

三大认证规则

技术分享图片

认证组件

重点
1
2
3
4
5
 
"""
1）认证规则
2）如何自定义认证类
3）我们一般不需要自定义认证类，在settings中全局配置第三方 jwt 认证组件提供的认证类即可
"""
自定义认证类
1
2
3
4
5
6
7
 
"""
1）自定义认证类，继承 BaseAuthentication 类
2）必须重写 authenticate(self, request) 方法
	没有认证信息，返回None：匿名用户(游客) => 匿名用户request.user也有值，就是"匿名对象(Anonymous)"
	有认证信息，且通过，返回(user, token)：合法用户 => user对象会存到request.user中
	有认证信息，不通过，抛异常：非法用户
"""

权限组件

重点
1
2
3
4
5
 
"""
1）权限规则
2）如何自定义权限类
3）我们一般在视图类中局部配置drf提供的权限类，但是也会自定义权限类完成局部配置
"""
自定义权限类
1
2
3
4
5
6
7
8
9
10
11
12
 
"""
1）自定义权限类，继承 BasePermission 类
2）必须重写 has_permission(self, request, view): 方法
	设置权限条件，条件通过，返回True：有权限
	设置权限条件，条件失败，返回False：有权限
	
3）drf提供的权限类：
AllowAny：匿名与合法用户都可以
IsAuthenticated：必须登录，只有合法用户可以
IsAdminUser：必须是admin后台用户
IsAuthenticatedOrReadOnly：匿名只读，合法用户无限制
"""

jwt 认证示意图

1
2
3
4
5
 
""" jwt优势
1）没有数据库写操作，高效
2）服务器不存token，低耗
3）签发校验都是算法，集群
"""

技术分享图片

技术分享图片

技术分享图片

技术分享图片

jwt 认证算法: 签发与校验

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
"""
1）jwt分三段式：头.体.签名 （head.payload.sgin）
2）头和体是可逆加密，让服务器可以反解出user对象；签名是不可逆加密，保证整个token的安全性的
3）头体签名三部分，都是采用json格式的字符串，进行加密，可逆加密一般采用base64算法，不可逆加密一般采用hash(md5)算法
4）头中的内容是基本信息：公司信息、项目组信息、token采用的加密方式信息
{
	"company": "公司信息",
	...
}
5）体中的内容是关键信息：用户主键、用户名、签发时客户端信息(设备号、地址)、过期时间
{
	"user_id": 1,
	...
}
6）签名中的内容时安全信息：头的加密结果 + 体的加密结果 + 服务器不对外公开的安全码 进行md5加密
{
	"head": "头的加密字符串",
	"payload": "体的加密字符串",
	"secret_key": "安全码"
}
"""
签发：根据登录请求提交来的 账号 + 密码 + 设备信息 签发 token
1
2
3
4
5
6
7
 
"""
1）用基本信息存储json字典，采用base64算法加密得到 头字符串
2）用关键信息存储json字典，采用base64算法加密得到 体字符串
3）用头、体加密字符串再加安全码信息存储json字典，采用hash md5算法加密得到 签名字符串

账号密码就能根据User表得到user对象，形成的三段字符串用 . 拼接成token返回给前台
"""
校验：根据客户端带token的请求 反解出 user 对象
1
2
3
4
5
 
"""
1）将token按 . 拆分为三段字符串，第一段 头加密字符串 一般不需要做任何处理
2）第二段 体加密字符串，要反解出用户主键，通过主键从User表中就能得到登录用户，过期时间和设备信息都是安全信息，确保token没过期，且时同一设备来的
3）再用 第一段 + 第二段 + 服务器安全码 不可逆md5加密，与第三段 签名字符串 进行碰撞校验，通过后才能代表第二段校验得到的user对象就是合法的登录用户
"""

drf项目的jwt认证开发流程（重点）

1
2
3
4
5
6
7
 
"""
1）用账号密码访问登录接口，登录接口逻辑中调用 签发token 算法，得到token，返回给客户端，客户端自己存到cookies中

2）校验token的算法应该写在认证类中(在认证类中调用)，全局配置给认证组件，所有视图类请求，都会进行认证校验，所以请求带了token，就会反解出user对象，在视图类中用request.user就能访问登录的用户

注：登录接口需要做 认证 + 权限 两个局部禁用
"""

drf-jwt框架基本使用

安装
1
 
>: pip install djangorestframework-jwt
签发token(登录接口)：视图类已经写好了，配置一下路由就行（urls.py）
1
2
3
4
5
6
7
 
# api/urls.py
urlpatterns = [
    # ...
    url(‘^login/$‘, ObtainJSONWebToken.as_view()),
]

# Postman请求：/api/login/，提供username和password即可
校验token(认证组件)：认证类已经写好了，全局配置一下认证组件就行了（settings.py）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
# drf-jwt的配置
import datetime
JWT_AUTH = {
    # 配置过期时间
    ‘JWT_EXPIRATION_DELTA‘: datetime.timedelta(days=7),
}


# drf配置（把配置放在最下方）
REST_FRAMEWORK = {
    # 自定义三大认证配置类们
    ‘DEFAULT_AUTHENTICATION_CLASSES‘: [‘rest_framework_jwt.authentication.JSONWebTokenAuthentication‘],
    # ‘DEFAULT_PERMISSION_CLASSES‘: [],
    # ‘DEFAULT_THROTTLE_CLASSES‘: [],
}
设置 需要登录才能访问的接口测试
1
2
3
4
5
6
7
 
from rest_framework.permissions import IsAuthenticated
class UserCenterViewSet(GenericViewSet, mixins.RetrieveModelMixin):
    # 设置必须登录才能访问的权限类
    permission_classes = [IsAuthenticated, ]

    queryset = models.User.objects.filter(is_active=True).all()
    serializer_class = serializers.UserCenterSerializer
测试封路认证接口
1
2
3
4
5
 
"""
1）用 {"username": "你的用户", "password": "你的密码"} 访问 /api/login/ 接口等到 token 字符串

2）在请求头用 Authorization 携带 "jwt 登录得到的token" 访问 /api/user/center/1/ 接口访问个人中心
"""
token 的刷新机制
drf-jwt 直接提供了刷新功能
1
2
3
4
5
 
"""
1）运用在像12306这样极少数安全性要求高的网站
2）第一个token由登录签发
3）之后的所有正常逻辑，都需要发送两次请求，第一次是刷新token的请求，第二次是正常逻辑的请求
"""
settings.py
1
2
3
4
5
6
7
8
9
10
11
 
import datetime

JWT_AUTH = {
    # 配置过期时间
    ‘JWT_EXPIRATION_DELTA‘: datetime.timedelta(minutes=5),

    # 是否可刷新
    ‘JWT_ALLOW_REFRESH‘: True,
    # 刷新过期时间
    ‘JWT_REFRESH_EXPIRATION_DELTA‘: datetime.timedelta(days=7),
}
urls.py
1
2
3
4
5
 
from rest_framework_jwt.views import ObtainJSONWebToken, RefreshJSONWebToken
urlpatterns = [
    url(‘^login/$‘, ObtainJSONWebToken.as_view()),  # 登录签发token接口
    url(‘^refresh/$‘, RefreshJSONWebToken.as_view()),  # 刷新toekn接口
]
Postman
1
2
3
 
# 接口：/api/refresh/
# 方法：post
# 数据：{"token": "登录签发的token"}
认证组件的使用, 多方式登录
urls.py
1
2
 
# 自定义登录（重点）：post请求 => 查操作(签发token返回给前台) - 自定义路由映射
url(‘^user/login/$‘, views.LoginViewSet.as_view({‘post‘: ‘login‘})),
views.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 

# 重点：自定义login，完成多方式登录
from rest_framework.viewsets import ViewSet
from rest_framework.response import Response
class LoginViewSet(ViewSet):
    # 登录接口，要取消所有的认证与权限规则，也就是要做局部禁用操作（空配置）
    authentication_classes = []
    permission_classes = []

    # 需要和mixins结合使用，继承GenericViewSet，不需要则继承ViewSet
    # 为什么继承视图集，不去继承工具视图或视图基类，因为视图集可以自定义路由映射：
    #       可以做到get映射get，get映射list，还可以做到自定义（灵活）
    def login(self, request, *args, **kwargs):
        serializer = serializers.LoginSerializer(data=request.data, context={‘request‘: request})
        serializer.is_valid(raise_exception=True)
        token = serializer.context.get(‘token‘)
        return Response({"token": token})
serializers.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
from rest_framework_jwt.serializers import jwt_payload_handler, jwt_encode_handler

# 重点：自定义login，完成多方式登录
class LoginSerializer(serializers.ModelSerializer):
    # 登录请求，走的是post方法，默认post方法完成的是create入库校验，所以唯一约束的字段，会进行数据库唯一校验，导致逻辑相悖
    # 需要覆盖系统字段，自定义校验规则，就可以避免完成多余的不必要校验，如唯一字段校验
    username = serializers.CharField()
    class Meta:
        model = models.User
        # 结合前台登录布局：采用账号密码登录，或手机密码登录，布局一致，所以不管账号还是手机号，都用username字段提交的
        fields = (‘username‘, ‘password‘)

    def validate(self, attrs):
        # 在全局钩子中，才能提供提供的所需数据，整体校验得到user
        # 再就可以调用签发token算法(drf-jwt框架提供的)，将user信息转换为token
        # 将token存放到context属性中，传给外键视图类使用
        user = self._get_user(attrs)
        payload = jwt_payload_handler(user)
        token = jwt_encode_handler(payload)
        self.context[‘token‘] = token
        return attrs

    # 多方式登录
    def _get_user(self, attrs):
        username = attrs.get(‘username‘)
        password = attrs.get(‘password‘)
        import re
        if re.match(r‘^1[3-9][0-9]{9}$‘, username):
            # 手机登录
            user = models.User.objects.filter(mobile=username, is_active=True).first()
        elif re.match(r‘^.+@.+$‘, username):
            # 邮箱登录
            user = models.User.objects.filter(email=username, is_active=True).first()
        else:
            # 账号登录
            user = models.User.objects.filter(username=username, is_active=True).first()
        if user and user.check_password(password):
            return user

        raise ValidationError({‘user‘: ‘user error‘})
权限组件的使用: VIP 用户权限
数据准备
1
2
3
4
5
 
"""
1）User表创建两条数据
2）Group表创建一条数据，name叫vip
3）操作User和Group的关系表，让1号用户属于1号vip组
"""
permissions.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 

from rest_framework.permissions import BasePermission

from django.contrib.auth.models import Group
class IsVipUser(BasePermission):
    def has_permission(self, request, view):
        if request.user and request.user.is_authenticated:  # 必须是合法用户
            try:
                vip_group = Group.objects.get(name=‘vip‘)
                if vip_group in request.user.groups.all():  # 用户可能不属于任何分组
                    return True  # 必须是vip分组用户
            except:
                pass

        return False
views.py
1
2
3
4
5
6
7
 

from .permissions import IsVipUser
class CarViewSet(ModelViewSet):
    permission_classes = [IsVipUser]

    queryset = models.Car.objects.all()
    serializer_class = serializers.CarSerializer
serializers.py
1
2
3
4
 
class CarSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.Car
        fields = (‘name‘, )
urls.py
1
 
router.register(‘cars‘, views.CarViewSet, ‘car‘)

频率组件

重点
1
2
3
4
5
 
"""
1）如何自定义频率类
2）频率校验的规则
3）自定义频率类是最常见的：短信接口一分钟只能发生一条短信
"""
自定义频率组件
1
2
3
4
5
6
7
8
9
 
"""
1）自定义类继承SimpleRateThrottle
2）设置类实现scope，值就是一个字符串，与settings中的DEFAULT_THROTTLE_RATES进行对应
	DEFAULT_THROTTLE_RATES就是设置scope绑定的类的频率规则：1/min 就代表一分钟只能访问一次
3）重写 get_cache_key(self, request, view) 方法，指定限制条件
	不满足限制条件，返回None：代表对这类请求不进行频率限制
	满足限制条件，返回一个字符串(是动态的)：代表对这类请求进行频率限制
		短信频率限制类，返回 "throttling_%(mobile)s" % {"mobile": 实际请求来的电话}
"""
系统频率类
1
2
 
#1）UserRateThrottle: 限制所有用户访问频率
#2）AnonRateThrottle：只限制匿名用户访问频率
频率组件项目使用：请求方式频率限制
throteles.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
from rest_framework.throttling import SimpleRateThrottle
# 只限制查接口的频率，不限制增删改的频率
class MethodRateThrottle(SimpleRateThrottle):
    scope = ‘method‘
    def get_cache_key(self, request, view):
        # 只有对get请求进行频率限制
        if request.method.lower() not in (‘get‘, ‘head‘, ‘option‘):
            return None

        # 区别不同的访问用户，之间的限制是不冲突的
        if request.user.is_authenticated:
            ident = request.user.pk
        else:
            # get_ident是BaseThrottle提供的方法，会根据请求头，区别匿名用户，
            # 保证不同客户端的请求都是代表一个独立的匿名用户
            ident = self.get_ident(request)
        return self.cache_format % {‘scope‘: self.scope, ‘ident‘: ident}
settings.py
1
2
3
4
5
6
7
8
9
10
 
REST_FRAMEWORK = {
    #  ...
    # 频率规则配置
    ‘DEFAULT_THROTTLE_RATES‘: {
        # 只能设置 s，m，h，d，且只需要第一个字母匹配就ok，m = min = maaa 就代表分钟
        ‘user‘: ‘3/min‘,  # 配合drf提供的 UserRateThrottle 使用，限制所有用户访问频率
        ‘anon‘: ‘3/min‘,  # 配合drf提供的 AnonRateThrottle 使用，只限制匿名用户访问频率
        ‘method‘: ‘3/min‘,
    },
}
views.py
1
2
3
4
5
6
7
8
 
from .permissions import IsVipUser
from .throttles import MethodRateThrottle
class CarViewSet(ModelViewSet):
    permission_classes = [IsVipUser]
    throttle_classes = [MethodRateThrottle]

    queryset = models.Car.objects.all()
    serializer_class = serializers.CarSerializer

异常组件项目使用:记录异常信息到日志文件

exception.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
from rest_framework.views import exception_handler as drf_exception_handler
from rest_framework.response import Response
def exception_handler(exc, context):
    # 只处理客户端异常，不处理服务器异常，
    # 如果是客户端异常，response就是可以直接返回给前台的Response对象
    response = drf_exception_handler(exc, context)

    if response is None:
        # 没有处理的服务器异常，处理一下
        # 其实给前台返回 服务器异常 几个字就行了
        # 那我们处理异常模块的目的是 不管任何错误，都有必要进行日志记录（线上项目只能通过记录的日志查看出现过的错误）
        response = Response({‘detail‘: ‘%s‘ % exc})

    # 需要结合日志模块进行日志记录的：项目中讲
    return response

settings.py

1
2
3
4
5
6
 
REST_FRAMEWORK = {
    # ...
    # 异常模块
    # ‘EXCEPTION_HANDLER‘: ‘rest_framework.views.exception_handler‘,  # 原来的，只处理客户端异常
    ‘EXCEPTION_HANDLER‘: ‘api.exception.exception_handler‘,
}

群查接口相关组件

目的:

原文：https://www.cnblogs.com/huangjiangyong/p/14088982.html

评论（0）
© 2014 bubuko.com 版权所有 - 联系我们:wmxa8@hotmail.com
打开技术之扣，分享程序人生！