认证组件
需求：
有的接口需要登录后才能访问，有的接口，不登录就能访问——这就是登录认证的限制
简单实现的方式：写一个登录接口，返回token，以后只要带着token过来，就是登录了，不带，就没有登录。条件如下：
- 查询所有不需要登录就能访问
- 查询单个，需要登录才能访问
登录接口
# 认证是基于登录的接口上面操作的 所以前戏编写一个简单的登录接口
models.py
class User(models.Model): # 简易的用户信息账号密码
username = models.CharField(max_length=32)
password = models.CharField(max_length=32)
def __str__(self):
return self.username
'跟User表是一对一外键关联，存储用户登录状态用的 [这个表可以没有，如果没有，把字段直接写在User表上也可以]'
class UserToken(models.Model): # 用户信息登录记录表
user = models.OneToOneField(to='User', on_delete=models.CASCADE) # 一对一关联
token = models.CharField(max_length=32, null=True) # 如果用户没有登录则没有值 如果登录则有值
views.py
'登录接口功能:自动生成路由+登录功能，不用序列化，因此继承ViewSet即可'
class UserView(ViewSet):
@action(methods=['POST'], detail=False, url_path='login', url_name='login')
def login(self, request):
username = request.data.get('username') # 获取用户名与密码
password = request.data.get('password')
user = User.objects.filter(username=username, password=password).first() # 比对用户名与密码
if user:
token = str(uuid.uuid4())
# uuid4 随机获得永不重复的字符串 机制跟Cookie中的验证码一样
# 在userToken表中存储一下：1 从来没有登录过，插入一条， 2 登录过，修改记录
UserToken.objects.update_or_create(defaults={'token': token}, user=user)
# 通过user去UserToken表中查数据，如果能查到，使用defaults的数据更新，如果查不到，直接通过user和defaults的数据新增
# kwargs 传入的东西查找，能找到，使用defaults的更新，否则新增一条
return Response({'code': 100, 'msg': '登录成功', 'token': token})
else:
return Response({'code': 101, 'msg': '用户名或密码错误'})
urls.py
from rest_framework.routers import SimpleRouter, DefaultRouter
router = SimpleRouter()
router.register('users', views.UserView, 'users')
urlpatterns += router.urls
'''这个时候一个简单的登录接口就写好了 每次登录都会更新Token 相当于登录了之前的设备就无效了 '''
update_or_create源码如下
def update_or_create(self, defaults=None, **kwargs):
defaults = defaults or {}
self._for_write = True
with transaction.atomic(using=self.db):
try:
obj = self.select_for_update().get(**kwargs)
except self.model.DoesNotExist:
params = self._extract_model_params(defaults, **kwargs)
obj, created = self._create_object_from_params(kwargs, params, lock=True)
if created:
return obj, created
for k, v in defaults.items():
setattr(obj, k, v() if callable(v) else v)
obj.save(using=self.db)
return obj, False
认证组件使用步骤
- 1、需要写一个认证类，因此我们需要在应用中另外创建一个py文件编写认证类，需要继承BaseAuthentication这个类
通过查看源码我们可以发现有个authenticate方法需要我们重写，否则就会报错，这就是我们需要编写认证功能的类。
class BaseAuthentication:
def authenticate(self, request):
raise NotImplementedError(".authenticate() must be overridden.")
def authenticate_header(self, request):
pass
- 2、重写authenticate方法，在该方法在中实现登录认证
token在哪带的？如何认证它是登录了的？
用token来判断是否登陆，登陆了在访问的时候带上token，目前阶段我们直接在地址栏中携带token的数据，后面可以在请求头中添加token的数据
- 3、如果认证成功，返回两个值【返回None或两个值（固定的：当前登录用户，token）】
- 4、认证不通过，用AuthenticationFailed类抛异常
代码如下：
authenticate.py(认证类)
# 自己写的认证类，继承某个类
from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed
from .models import UserToken
class LoginAuth(BaseAuthentication):
def authenticate(self, request):
# 在这里实现认证，如果是登录的，继续往后走返回两个值，如果不是抛异常
# 请求中是否携带token，判断是否登录，放在地址栏中
token = request.query_params.get('token', None) # 查找是否有token这个变量名的值，如果没有就返回None，默认好像返回的是数字
if token: # 前端传入token了，去表中查，如果能查到，登录了，返回两个值[固定的：当前登录用户，token]
user_token = UserToken.objects.filter(token=token).first()
if user_token:
return user_token.user, token
else:
# 没有登录抛异常
raise AuthenticationFailed('token认证失败')
else:
raise AuthenticationFailed('token没传')
# 前端传入的请求头中的数据从哪取？ GET，body，POST，data
- 5、认证类的使用
当我们编写好了认证类中的认证代码，接着就需要导入到视图层然后使用他。
from rest_framework.generics import ListAPIView, RetrieveAPIView
from rest_framework.viewsets import ViewSetMixin
from .authenticate import LoginAuth
# 查询所有
class BookView(ViewSetMixin, ListAPIView):
queryset = Book.objects.all()
serializer_class = BookSerializer
class BookDetailView(ViewSetMixin, RetrieveAPIView):
queryset = Book.objects.all()
serializer_class = BookSerializer
authentication_classes = [LoginAuth] # 需要写一个认证类，需要咱们自行编写
- 6、局部使用和全局使用
局部使用：只在某个视图类中使用【当前视图类管理的所有接口】
class BookDetailView(ViewSetMixin, RetrieveAPIView):
authentication_classes = [LoginAuth]
全局使用：在配置文件settings.py中编写，全局所有接口都生效
REST_FRAMEWORK = {
'DEFAULT_AUTHENTICATION_CLASSES':['app01.authenticate.LoginAuth']
}
注意事项：不要在配置文件中乱导入不使用的东西，否则会报错，但是在导入类似认证类这样的文件时，可以写上导入的代码然后再修改，最后写进配置中，这样可以减少错误。
局部禁用：（登陆接口很明显是不需要校验是否登陆的，因此有了这个局部禁用的需求，我们把他的authentication_classes配置成空就是局部禁用）
class BookDetailView(ViewSetMixin, RetrieveAPIView):
authentication_classes = []
- 7、测试路由参考
整体代码
views.py
# 查询所有
class BookView(ViewSetMixin, ListAPIView):
queryset = Book.objects.all()
serializer_class = BookSerializer
# 查询单个
class BookDetailView(ViewSetMixin, RetrieveAPIView):
queryset = Book.objects.all()
serializer_class = BookSerializer
authentication_classes = [LoginAuth] # 需要写一个认证类，需要咱们自行编写
authenticate.py(认证类)
# 自己写的认证类，继承某个类
from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed
from .models import UserToken
class LoginAuth(BaseAuthentication):
def authenticate(self, request):
# 在这里实现认证，如果是登录的，继续往后走返回两个值，如果不是抛异常
# 请求中是否携带token，判断是否登录，放在地址栏中
token = request.query_params.get('token', None) # 查找是否有token这个变量名的值，如果没有就返回None，默认好像返回的是数字
if token: # 前端传入token了，去表中查，如果能查到，登录了，返回两个值[固定的：当前登录用户，token]
user_token = UserToken.objects.filter(token=token).first()
if user_token:
return user_token.user, token
else:
# 没有登录抛异常
raise AuthenticationFailed('token认证失败')
else:
raise AuthenticationFailed('token没传')
# 前端传入的请求头中的数据从哪取？ GET，body，POST，data
urls.py
from django.contrib import admin
from django.urls import path, include
from app01 import views
from rest_framework.routers import SimpleRouter
router = SimpleRouter() # 后面这个少的用的多,
router.register('user', views.UserView, 'user')
router.register('books', views.BookView, 'books')
router.register('books', views.BookDetailView, 'books')
urlpatterns = [
path('admin/', admin.site.urls),
path('api/v1/', include(router.urls)),
]
认证时cookie的获取方式
- 当前端从地址栏中返回cookie时，就跟我们代码中返回token是一样的，获取方式：
request.query_params.get('token')
- 原生djangozhong ，取出前端传入cookie(即前端直接传入cookie)，从哪取的？
request.COOKIE.get('sessionid')
- 后期如果想从请求头中取cookie
request.META.get('HTTP_TOKEN')
权限组件
需求分析：
在一些软件中即便我们登陆成功了有些接口，还是不能访问，因为没有权限。
这里我们的需求是：
-查询单个需要超级管理员才能访问
-查询所有，所有登录用户都能访问
而我们的User表中并没有字段用于区分用户权限，因此这里我们需要手动创建一个新的user_type字段：
class User(models.Model):
username = models.CharField(max_length=32)
password = models.CharField(max_length=32)
user_type = models.IntegerField(choices=((1, '超级管理员'), (2, '普通用户'), (3, '2B用户')), default=2)
权限的使用
- 1、跟认证类的使用类似，需要先创建一个py文件编写权限类，需要继承BasePermission父类
- 2、这里我们需要重写has_permission方法，在该方法在中实现权限认证，在这方法中，request.user就是当前登录用户（简单来说就是因为认证组件校验的时候返回的是user，这里不展开讲解，后面会讲）
- 3、如果有权限，返回True。没有权限，返回False，并给当前对象产生一个定制的返回信息： self.message='中文'
- 4、在视图层中导入使用（测试的时候路由跟认证组件中的一样）
- 5、局部使用和全局使用
局部使用：只在某个视图类中使用【当前视图类管理的所有接口】
class BookDetailView(ViewSetMixin, RetrieveAPIView):
permission_classes = [CommonPermission]
全局使用：在配置文件settings.py中编写，全局所有接口都生效
REST_FRAMEWORK = {
'DEFAULT_PERMISSION_CLASSES': [
'app01.permissions.CommonPermission',
],
}
局部禁用：局部配置中的配置信息改成空就可以设置成局部禁用
class BookDetailView(ViewSetMixin, RetrieveAPIView):
permission_classes = []
代码
整体部分不需要修改，跟认证组件末尾的代码一样，需要修改的代码如下：
models.py（修改User表的配置后需要重新进行数据库迁移）
class User(models.Model):
username = models.CharField(max_length=32)
password = models.CharField(max_length=32)
user_type = models.IntegerField(choices=((1, '超级管理员'), (2, '普通用户'), (3, '2B用户')), default=2)
permission.py（权限类）
# 写权限类，写一个类，继承基类BasePermission，重写has_permission方法，在方法中实现权限认证,如果有权限return True ，如果没有权限，返回False
from rest_framework.permissions import BasePermission
class CommonPermission(BasePermission):
def has_permission(self, request, view):
# 实现权限的控制 ---》知道当前登录用户是谁？当前登录用户是 request.user
if request.user.user_type == 1:
return True
else:
# 没有权限，向对象中放一个属性 message
# 如果表模型中，使用了choice，就可以通过 get_字段名_display() 拿到choice对应的中文
self.message = '您是【%s】，您没有权限' % request.user.get_user_type_display()
return False
views.py
别的部分也不需要改，主要是查询单个部分需要改
from .permissions import CommonPermission
class BookDetailView(ViewSetMixin, RetrieveAPIView):
queryset = Book.objects.all()
serializer_class = BookSerializer
# authentication_classes = [LoginAuth] # 需要写一个认证类，需要咱们写
permission_classes = [CommonPermission]
频率组件
需求分析：
我们需要控制某个接口被访问的频率（次数）
通常来说我们是想着某个ip的访问次数
使用步骤
- 1、跟前两个组件类似，需要先创建一个py文件编写频率类，需要继承SimpleRateThrottle父类
- 2、重写get_cache_key方法（可以在源码中发现这个方法不重写会报错），这个方法返回什么，就以什么做限制，比如我们返回ip，就以用户id做限制
- 3、编写完方法后我们在频率类中还需要配置一个scope属性，这个属性影响着配置文件中的使用
- 4、在settings.py中添加配置，设置限制的方式
'DEFAULT_THROTTLE_RATES': {
'lqz': '5/h',
},
我们在scope属性中写什么，这里的配置的key就是什么，后面的value是频率限制的方式，有以下几种：3/m（分） 3/h（小时） 3/s（秒） 3/d（天），这里只要开头字母符合条件即可，写成mxxx也会自动识别到的。
- 5、接着我们在视图类中以类似前面两个组件的方式使用即可（测试路由也基本一样）
- 6、局部使用和全局使用
局部使用：只在某个视图类中使用【当前视图类管理的所有接口】
from .throttling import CommonThrottle
class BookDetailView(ViewSetMixin, RetrieveAPIView):
throttle_classes = [CommonThrottle]
全局使用：在配置文件settings.py中编写，全局所有接口都生效
REST_FRAMEWORK = {
'DEFAULT_THROTTLE_CLASSES': ['app01.throttling.CommonThrottle'],
}
局部禁用:局部配置中的配置信息改成空就可以设置成局部禁用
class BookDetailView(ViewSetMixin, RetrieveAPIView):
throttle_classes = []
代码
throttling.py（频率类）
# 频率类，不继承BaseThrottle，继承SimpleRateThrottle，少写代码
from rest_framework.throttling import BaseThrottle, SimpleRateThrottle
class CommonThrottle(SimpleRateThrottle):
# 类属性，属性值随便写
# 配置文件中配置
scope = 'lqz'
def get_cache_key(self, request, view):
# 返回什么，就以什么做频率限制【可以返回ip 或用户ID】
# 客户端的ip地址从哪里拿？
return request.META.get('REMOTE_ADDR') # 以ip做限制
# return request.user.pk # 以用户id做限制
settings.py
# 以后这个配置项，就是该项目drf的自有配置
REST_FRAMEWORK = {
'DEFAULT_THROTTLE_RATES': {
'lqz': '5/h',
},
'DEFAULT_THROTTLE_CLASSES': ['app01.throttling.CommonThrottle'],
}
'最后这个是全局配置的配置代码'
views.py
from .throttling import CommonThrottle
class BookDetailView(ViewSetMixin, RetrieveAPIView):
queryset = Book.objects.all()
serializer_class = BookSerializer
# authentication_classes = [LoginAuth] # 需要写一个认证类，需要咱们写
# permission_classes = [CommonPermission]
throttle_classes = [CommonThrottle]
权限组件源码分析
# 0 目标
1 为什么写一个类继承BasePermission，重写has_permission
-可以不继承这个类，只重写这个方法也可以
2 权限类中 self.message 会返回给前端
3 局部配置：放在视图类中：permission_classes = [CommonPermission]
4 全局配置，配置在配置文件中也可以--》视图类中就没有
就会使用：permission_classes = api_settings.DEFAULT_PERMISSION_CLASSES
优先从你项目的配置文件配置的DEFAULT_PERMISSION_CLASSES取，如果没有
就会去drf的配置文件DEFAULT_PERMISSION_CLASSES取
# 1 从哪里开始找？
-继承APIView后，权限是在执行视图类的方法之前执行的
-执行视图类的方法---》dispath中
def dispatch(self, request, *args, **kwargs):
try:
# 三大认证：认证，权限，频率
self.initial(request, *args, **kwargs)
####执行视图类的方法开始###
if request.method.lower() in self.http_method_names:
handler = getattr(self, request.method.lower(),
self.http_method_not_allowed)
else:
handler = self.http_method_not_allowed
response = handler(request, *args, **kwargs)
####执行视图类的方法结束###
except Exception as exc:
response = self.handle_exception(exc)
return self.response
#2 找到APIView的initial
def initial(self, request, *args, **kwargs):
self.perform_authentication(request)#认证
self.check_permissions(request)#权限
self.check_throttles(request)#频率
# 3 self.check_permissions(request)---APIView
def check_permissions(self, request):
# self是 视图类的对象
#self.get_permissions [CommonPermission(),]--->咱们配置的一个个权限类的对象，放到列表中
# permission 权限类的对象
for permission in self.get_permissions():
# 咱们写的权限类，要重写has_permission，传了俩参数
# 参数：request 是新的request
# 参数：self 是？视图类的对象，就是咱么在视图类中写的self，它里面有
# request和action等
if not permission.has_permission(request, self):
# 视图类的对象，没有权限
self.permission_denied(
request,
# 从权限类的对象中反射了message，就是写的给前端看的文字
message=getattr(permission, 'message', None),
#响应状态码
code=getattr(permission, 'code', None)
)
# 4 self.get_permissions() ---> APIView的
def get_permissions(self):
# 咱么视图类上配置的 permission_classes = [CommonPermission]
# 返回值是 [CommonPermission(),]--->咱们配置的一个个权限类的对象，放到列表中
return [permission() for permission in self.permission_classes]
# 5 self.permission_denied --》APIView中
def permission_denied(self, request, message=None, code=None):
if request.authenticators and not request.successful_authenticator:
raise exceptions.NotAuthenticated()
# 抛了异常，会被全局异常捕获，detai会放在响应体中，code会放在响应状态码中
raise exceptions.PermissionDenied(detail=message, code=code)
认证类源码
-继承APIView后，权限是在执行视图类的方法之前执行的
-执行视图类的方法---》dispath中
def dispatch(self, request, *args, **kwargs):
try:
# 三大认证：认证，权限，频率
self.initial(request, *args, **kwargs)
####执行视图类的方法开始###
if request.method.lower() in self.http_method_names:
handler = getattr(self, request.method.lower(),
self.http_method_not_allowed)
else:
handler = self.http_method_not_allowed
response = handler(request, *args, **kwargs)
####执行视图类的方法结束###
except Exception as exc:
response = self.handle_exception(exc)
return self.response
#2 找到APIView的initial
def initial(self, request, *args, **kwargs):
self.perform_authentication(request)#认证
self.check_permissions(request)#权限
self.check_throttles(request)#频率
# 3 self.perform_authentication(request)
def perform_authentication(self, request):
request.user # 新的request对象
# 4 Request类中找 user 方法包装成了数据属性
from rest_framework.request import Request
@property
def user(self):
if not hasattr(self, '_user'):
with wrap_attributeerrors():
# self是 新的request对象
self._authenticate() # 一开始没有，就走了self._authenticate()
return self._user
# 5 Request类中找_authenticate()
def _authenticate(self):
# 拿出你配置在视图类上一个个认证类的对象 LoginAuth()
# authenticator就是LoginAuth()
for authenticator in self.authenticators:
try:
# 为什么咱么要重写 authenticate
#self是谁？request就是认证类的 def authenticate(self, request):
# 正常返回两个值：return user, user_token
# 如果抛了异常：AuthenticationFailed--》捕获了APIException
user_auth_tuple = authenticator.authenticate(self)
except exceptions.APIException:
self._not_authenticated()
raise
if user_auth_tuple is not None:#正常返回了两个值
self._authenticator = authenticator
# 解压赋值：self是request
#后续在视图类中 request.user 就是当前登录用户
self.user, self.auth = user_auth_tuple
return
self._not_authenticated()
# 6 咱们视图类中得认证类可以配置多个
-如果 第一个认证类，就返回了两个值
-后续的认证类就不走了
-如果认证类中要返回两个值，视图类中配了多个---》把返回两个值的放在最后
-返回的两个值，第一个给了request.user,第一个给了request.auth，后续视图类中可以取出来
# 7 self.authenticators ---》 Request中
# Request类实例化得到对象，传入authenticators 最终给了
def __init__(self, request, parsers=None, authenticators=None,negotiator=None, parser_context=None):
self.authenticators = authenticators or ()
# 8 哪里对Request类实例化了？ APIView中
APIView 中dispatch中---》包装了新的request
request = self.initialize_request(request, *args, **kwargs)
def initialize_request(self, request, *args, **kwargs):
return Request(
request,
parsers=self.get_parsers(),
authenticators=self.get_authenticators(),
negotiator=self.get_content_negotiator(),
parser_context=parser_context
)
# 9 self.get_authenticators() 在APIView中 self是视图类的对象
def get_authenticators(self):
return [auth() for auth in self.authentication_classes]
# 总结：
1 写一个类，重写authenticate
2 校验失败抛异常--》捕获
3 通过返回两个值 当前登录用户，token
不返回两个值--》后续的request.user 不是当前登录用户
4 视图类上局部配置和配置文件全局配置跟 权限一模一样