## 源码分析
1）APIView的dispath(self, request, *args, **kwargs)
2）dispath方法内 self.initial(request, *args, **kwargs) 进入三大认证
# 认证组件：校验用户 - 游客、合法用户、非法用户
# 游客：代表校验通过，直接进入下一步校验（权限校验）
# 合法用户：代表校验通过，将用户存储在request.user中，再进入下一步校验（权限校验）
# 非法用户：代表校验失败，抛出异常，返回403权限异常结果
self.perform_authentication(request)
# 权限组件：校验用户权限 - 必须登录、所有用户、登录读写游客只读、自定义用户角色
# 认证通过：可以进入下一步校验（频率认证）
# 认证失败：抛出异常，返回403权限异常结果
self.check_permissions(request)
# 频率组件：限制视图接口被访问的频率次数 - 限制的条件(IP、id、唯一键)、频率周期时间(s、m、h)、频率的次数（3/s）
# 没有达到限次：正常访问接口
# 达到限次：限制时间内不能访问，限制时间达到后，可以重新访问
self.check_throttles(request)
认证组件
Request类的 方法属性 user 的get方法 => self._authenticate() 完成认证
认证的细则：
# 做认证
def _authenticate(self):
# 遍历拿到一个个认证器，进行认证
# self.authenticators配置的一堆认证类产生的认证类对象组成的 list
for authenticator in self.authenticators:
try:
# 认证器(对象)调用认证方法authenticate(认证类对象self, request请求对象)
# 返回值：登陆的用户与认证的信息组成的 tuple
# 该方法被try包裹，代表该方法会抛异常，抛异常就代表认证失败
user_auth_tuple = authenticator.authenticate(self)
except exceptions.APIException:
self._not_authenticated()
raise
# 返回值的处理
if user_auth_tuple is not None:
self._authenticator = authenticator
# 如何有返回值，就将 登陆用户 与 登陆认证 分别保存到 request.user、request.auth
self.user, self.auth = user_auth_tuple
return
# 如果返回值user_auth_tuple为空，代表认证通过，但是没有 登陆用户 与 登陆认证信息，代表游客
self._not_authenticated()
权限组件
self.check_permissions(request)
认证细则：
def check_permissions(self, request):
# 遍历权限对象列表得到一个个权限对象(权限器)，进行权限认证
for permission in self.get_permissions():
# 权限类一定有一个has_permission权限方法，用来做权限认证的
# 参数：权限对象self、请求对象request、视图类对象
# 返回值：有权限返回True，无权限返回False
if not permission.has_permission(request, self):
self.permission_denied(
request, message=getattr(permission, 'message', None)
)
"""
##### utils/authentications.py
# 自定义认证类：
# 1）继承BaseAuthentication类
# 2）重新authenticate(self, request)方法，自定义认证规则
# 3）认证规则基于的条件：
# 没有认证信息返回None(游客)
# 有认证信息认证失败抛异常(非法用户)
# 有认证信息认证成功返回用户与认证信息元组(合法用户)
# 4）完全视图类的全局(settings文件中)或局部(确切的视图类)配置
from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed
from . import models
class MyAuthentication(BaseAuthentication):
"""
同前台请求头拿认证信息auth（获取认证的字段要与前台约定）
没有auth是游客，返回None
有auth进行校验
失败是非法用户，抛出异常
成功是合法用户，返回 (用户, 认证信息)
"""
def authenticate(self, request):
# 前台在请求头携带认证信息，
# 且默认规范用 Authorization 字段携带认证信息，
# 后台固定在请求对象的META字段中 HTTP_AUTHORIZATION 获取
auth = request.META.get('HTTP_AUTHORIZATION', None)
# 处理游客
if auth is None:
return None
# 设置一下认证字段小规则(两段式)："auth 认证字符串"
auth_list = auth.split()
# 校验合法还是非法用户
if not (len(auth_list) == 2 and auth_list[0].lower() == 'auth'):
raise AuthenticationFailed('认证信息有误，非法用户')
# 合法的用户还需要从auth_list[1]中解析出来
# 注：假设一种情况，信息为abc.123.xyz，就可以解析出admin用户；实际开发，该逻辑一定是校验用户的正常逻辑
if auth_list[1] != 'abc.123.xyz': # 校验失败
raise AuthenticationFailed('用户校验失败，非法用户')
user = models.User.objects.filter(username='admin').first()
if not user:
raise AuthenticationFailed('用户数据有误，非法用户')
return (user, None)
# 自定义权限类：
from rest_framework.permissions import BasePermission
from django.contrib.auth.models import Group
class MyPermission(BasePermission):
def has_permission(self, request, view):
# 只读接口判断
r1 = request.method in ('GET', 'HEAD', 'OPTIONS')
# group为有权限的分组
group = Group.objects.filter(name='管理员').first()
# groups 为当前用户所属的所有分组([{对象}])
groups = request.user.groups.all()
r2 = group and groups
r3 = group and groups
# 读接口大家都有权限，写接口必须为指定分组下的登陆用户
return r1 or (r2 and r3)
视图类：
from rest_framework.views import APIView
from utils.response import APIResponse
class TestAPIView(APIView):
def get(self, request, *args, **kwargs):
# 如果通过的认证组件，request.user就一定有值
# 游客：AnonymousUser
# 用户：User表中的具体用户对象
print(request.user) # AnonymousUser显示游客登录
return APIResponse(0, 'test get ok')
# 只有登录后才能访问
from rest_framework.permissions import IsAuthenticated
class TestAAuthenticated(APIView):
permission_classes = [IsAuthenticated] # 用户必须登录才能访问
def get(self, request, *args, **kwargs):
print(request.user)
return APIResponse(0, 'test 登录过后才能访问的接口 ok')
# 游客只读，登录无限制 IsAuthenticatedOrReadOnly
from rest_framework.permissions import IsAuthenticatedOrReadOnly
class TestAuthenticatedOrReadOnly(APIView):
permission_classes = [IsAuthenticatedOrReadOnly]
'''
def has_permission(self, request, view):
return bool(
request.method in SAFE_METHODS or
request.user and
request.user.is_authenticated
里面是has_permission（）如果返回值是True，则正常访问（get请求和登陆正常的用户），
相反，user没有值或没有校验通过都是False，则不能post访问
)
'''
def get(self, request, *args, **kwargs):
return APIResponse(0, '读 OK')
def post(self, request, *args, **kwargs):
return APIResponse(0, '写 OK')
# 游客只读，登陆 用户只读，只有登录用户属于 管理员 分组，才可以增删改
from .permissions import MyPermission
class TestAdminOrReadOnlyAPIView(APIView):
permission_classes = [MyPermission]
def get(self,request,*args,**kwargs):
return APIResponse(0,'自定义读 ok')
def post(self,request,*args,**kwargs):
return APIResponse(0,'自定义写 ok')
## 自定义频率类
# 1) 自定义一个继承 SimpleRateThrottle 类 的频率类
# 2) 设置一个 scope 类属性，属性值为任意见名知意的字符串
# 3) 在settings配置文件中，配置drf的DEFAULT_THROTTLE_RATES，格式为 {scope字符串: '次数/时间'}
# 4) 在自定义频率类中重写 get_cache_key 方法
# 限制的对象返回 与限制信息有关的字符串
# 不限制的对象返回 None (只能放回None，不能是False或是''等)
#### 短信接口 3/min 频率限制
##### 频率：api/throttles.py
自定义频率条件：
from rest_framework.throttling import SimpleRateThrottle
class SMSRateThrottle(SimpleRateThrottle):
scope = 'sms'
# 只对提交手机号的get方法进行限制
def get_cache_key(self, request, view):
mobile = request.query_params.get('mobile')
# 没有手机号，就不做频率限制
if not mobile:
return None
# 返回可以根据手机号动态变化，且不易重复的字符串，作为操作缓存的key
return 'throttle_%(scope)s_%(ident)s' % {'scope': self.scope, 'ident': mobile}
##### 配置：settings.py
# drf配置
REST_FRAMEWORK = {
# 频率限制条件配置
'DEFAULT_THROTTLE_RATES': {
'sms': '3/min'
},
}
```
##### 视图：views.py
from .throttles import SMSRateThrottle
class TestSMSAPIView(APIView):
# 局部配置频率认证
throttle_classes = [SMSRateThrottle]
def get(self, request, *args, **kwargs):
return APIResponse(0, 'get 获取验证码 OK')
def post(self, request, *args, **kwargs):
return APIResponse(0, 'post 获取验证码 OK')
```
##### 路由：api/url.py
url(r'^sms/$', views.TestSMSAPIView.as_view()),
##### 限制的接口
# 只会对 /api/sms/?mobile=具体手机号 接口才会有频率限制
# 1）对 /api/sms/ 或其他接口发送无限制
# 2）对数据包提交mobile的/api/sms/接口无限制
# 3）对不是mobile（如phone）字段提交的电话接口无限制
## JWT认证
##### 优点
1) 服务器不要存储token，token交给每一个客户端自己存储，服务器压力小
2）服务器存储的是 签发和校验token 两段算法，签发认证的效率高
3）算法完成各集群服务器同步成本低，路由项目完成集群部署（适应高并发）
##### 格式
"""
1) jwt token采用三段式：头部.载荷.签名
2）每一部分都是一个json字典加密形参的字符串
3）头部和载荷采用的是base64可逆加密（前台后台都可以解密）
4）签名采用hash256不可逆加密（后台校验采用碰撞校验）
5）各部分字典的内容：
头部：基础信息 - 公司信息、项目组信息、可逆加密采用的算法
载荷：有用但非私密的信息 - 用户可公开信息、过期时间
签名：头部+载荷+秘钥 不可逆加密后的结果
注：服务器jwt签名加密秘钥一定不能泄露
签发token：固定的头部信息加密.当前的登陆用户与过期时间加密.头部+载荷+秘钥生成不可逆加密
校验token：头部可校验也可以不校验，载荷校验出用户与过期时间，头部+载荷+秘钥完成碰撞检测校验token是否被篡改
"""
```
## drf-jwt插件
##### 官网
```
https://github.com/jpadilla/django-rest-framework-jwt
```
##### 安装
>: pip3 install djangorestframework-jwt
##### 登录 - 签发token：api/urls.py
# ObtainJSONWebToken视图类就是通过username和password得到user对象然后签发token
from rest_framework_jwt.views import ObtainJSONWebToken, obtain_jwt_token
urlpatterns = [
# url(r'^jogin/$', ObtainJSONWebToken.as_view()),
url(r'^jogin/$', obtain_jwt_token),
]
##### 认证 - 校验token：全局或局部配置drf-jwt的认证类 JSONWebTokenAuthentication
# 必须登录才能访问 - 通过认证权限，用户校验token
from rest_framework.permissions import IsAuthenticated
from rest_framework_jwt.authentication import JSONWebTokenAuthentication
class UserDetail(APIView):
permission_classes = [IsAuthenticated] # 必须登录
authentication_classes = [JSONWebTokenAuthentication] # jwt用户登陆认证规则
def get(self, request, *args, **kwargs):
return APIResponse(results={'username': request.user.username})
##### 路由与接口测试
# 路由
url(r'^user/detail/$', views.UserDetail.as_view()),
# 接口：/api/user/detail/
# 认证信息：必须在请求头的 Authorization 中携带 "jwt 后台签发的token" 格式的认证字符串
```