系统权限类使用
图书接口：游客只读，用户可增删改查权限使用
from rest_framework.permissions import IsAuthenticatedOrReadOnly
class BookViewSet(ModelViewSet):
# 游客只读，用户可增删改查
permission_classes = [IsAuthenticatedOrReadOnly]
queryset = models.Book.objects.all()
serializer_class = serializers.BookSerializer
特殊路由映射的请求
实现用户中心信息自查，不带主键的get请求，走单查逻辑
urls.py
# 用路由组件配置，形成的映射关系是 /user/center/ => list | user/center/(pk)/ => retrieve
# router.register('user/center', views.UserCenterViewSet, 'center')
urlpatterns = [
# ...
# /user/center/ => 单查，不能走路由组件，只能自定义配置映射关系
url('^user/center/$', views.UserCenterViewSet.as_view({'get': 'user_center'})),
]
views.py
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response
class UserCenterViewSet(GenericViewSet):
permission_classes = [IsAuthenticated, ]
queryset = models.User.objects.filter(is_active=True).all()
serializer_class = serializers.UserCenterSerializer
def user_center(self, request, *args, **kwargs):
# request.user就是前台带token，在经过认证组件解析出来的，
# 再经过权限组件IsAuthenticated的校验，所以request.user一定有值，就是当前登录用户,并且是对象
serializer = self.get_serializer(request.user)
return Response(serializer.data)
token刷新机制（了解）
drf-jwt直接提供刷新功能
"""
1）运用在像12306这样极少数安全性要求高的网站
2）第一个token由登录签发
3）之后的所有正常逻辑，都需要发送两次请求，第一次是刷新token的请求，第二次是正常逻辑的请求
"""
settings.py
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
from rest_framework_jwt.views import ObtainJSONWebToken, RefreshJSONWebToken
urlpatterns = [
url('^login/$', ObtainJSONWebToken.as_view()), # 登录签发token接口 类名仅作参考
url('^refresh/$', RefreshJSONWebToken.as_view()), # 刷新toekn接口 类名仅作参考
]
Postman
# 接口：/api/refresh/
# 方法：post
# 数据：{"token": "登录签发的token"}
认证组件项目使用：多方式登录
urls.py
# 自定义登录（重点）：post请求 => 查操作(签发token返回给前台) - 自定义路由映射
url('^user/login/$', views.LoginViewSet.as_view({'post': 'login'})),
views.py
# 重点：自定义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) # 会根据post方法默认完成create入库检验，校验唯一约束字段
token = serializer.context.get('token')
return Response({"token": token})
serializers.py
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）User表创建两条数据
2）Group表创建一条数据，name叫vip
3）操作User和Group的关系表，让1号用户属于1号vip组
"""
permissions.py
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: # 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
from .permissions import IsVipUser
class CarViewSet(ModelViewSet):
permission_classes = [IsVipUser]
queryset = models.Car.objects.all()
serializer_class = serializers.CarSerializer
serializers.py
class CarSerializer(serializers.ModelSerializer):
class Meta:
model = models.Car
fields = ('name', )
urls.py
router.register('cars', views.CarViewSet, 'car')
频率组件
重点
"""
1）如何自定义频率类
2）频率校验的规则
3）自定义频率类是最常见的：短信接口一分钟只能发生一条短信
"""
自定义频率类
"""
1）自定义类继承SimpleRateThrottle (或者设定全局变量，views中直接调用，下面给案列)
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）UserRateThrottle: 限制所有用户访问频率
#2）AnonRateThrottle：只限制匿名用户访问频率
频率组件项目使用：请求方式频率限制
throttles.py
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} # 设定频率
# ident 唯一标识
settings.py
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
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
或者在全局变量中设定user，anon频率参数，views中直接调用全局频率设定
# setting.py
REST_FRAMEWORK = {
# 频率规则配置
'DEFAULT_THROTTLE_RATES': {
# 只能设置 s，m，h，d，且只需要第一个字母匹配就ok，m = min = maaa 就代表分钟
'user': '3/min', # 配合drf提供的 UserRateThrottle 使用，限制所有用户访问频率
'anon': '3/min', # 配合drf提供的 AnonRateThrottle 使用，只限制匿名用户访问频率
},
}
# views.py
from rest_framework.throttling import AnonRateThrottle,UserRateThrottle
class BookViewSet(ModelViewSet):
queryset = models.Book.objects.all()
serializer_class = serializers.BookSerializer
permission_classes = [IsAuthenticatedOrReadOnly] # 配置权限校验,所有用户
# throttle_classes = [AnonRateThrottle] # 针对匿名用户
throttle_classes = [UserRateThrottle]
异常组件项目使用：记录异常信息到日志文件
exception.py
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
REST_FRAMEWORK = {
# ...
# 异常模块
# 'EXCEPTION_HANDLER': 'rest_framework.views.exception_handler', # 原来的，只处理客户端异常
'EXCEPTION_HANDLER': 'api.exception.exception_handler',
}
课程小结
"""
1）认证模块：多方式登录
2）权限组件：vip权限认证
3）频率组件：请求方式的频率限制
4）异常组件：目的是记录异常日志
drf整体总结：
1）APIView生命周期：请求解析、响应渲染、异常响应(日志)
2）序列化组件
3）视图家族
4）三大认证
5）群查：搜索、排序、分页、分类、区间
"""