认证校验
认证校验是十分重要的，如用户如果不登陆就不能访问某些接口。
drf中认证的写法流程如下：
1.写一个类，继承BaseAuthentication，并且覆写其authenticate方法
2.当认证通过后应该返回两个值，并且第一个值会传递给request.user这个属性中，第二个值将会传递给request.auth这个属性中
3.如果认证失败，则抛出异常APIException或者AuthenticationFailed，它会自动捕获并返回
4.当前认证类设置是全局使用还是局部使用
准备工作
我们有一个登录功能，并且还有一个查询商品的接口，只有当用户登录后才能进行查询，否则就不可以。
模型表
两张表如下：
from django.db import models
class User(models.Model):
# 用户
user_id = models.AutoField(primary_key=True)
user_name = models.CharField(max_length=32)
user_password = models.CharField(max_length=32)
user_token = models.CharField(max_length=64,unique=True,null=True) # token，唯一
def __str__(self):
return self.user_name
class Meta:
db_table = ""
managed = True
verbose_name = "User"
verbose_name_plural = "Users"
class Merchandise(models.Model):
# 商品
merchandise_id = models.AutoField(primary_key=True)
merchandise_name = models.CharField(max_length=32)
merchandise_price = models.IntegerField()
def __str__(self):
return self.merchandise_name
class Meta:
db_table = ""
managed = True
verbose_name = "Merchandise"
verbose_name_plural = "Merchandises"
用户表的数据如下：
商品表的数据如下：
现在，只有当用户登录后，才能够访问商品的接口。
也就是说，用户的token自动如果为空，将会被认为没有登陆。
序列类
下面是序列类，我们只展示商品，用户列表将不会展示：
from rest_framework.serializers import ModelSerializer
from . import models
class MerchandiseModelSerializer(ModelSerializer):
class Meta:
model = models.Merchandise
fields = "__all__"
视图
视图，我们只写了关于用户登录与商品的接口：
from uuid import uuid4
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.viewsets import ModelViewSet
from . import models
from . import ser
from . import authLogin # 导入认证的文件
class MerchandiseAPI(ModelViewSet):
queryset = models.Merchandise.objects.all()
serializer_class = ser.MerchandiseModelSerializer
class Login(APIView):
def post(self,request):
# 代表用户登录
login_msg = {
"user_name": request.data.get("user_name"),
"user_password": request.data.get("user_password"),
}
user_obj = models.User.objects.filter(**login_msg).first()
if user_obj:
token = uuid4() # 生成随机字符串
user_obj.user_token = token
user_obj.save()
return Response(data="登录成功",headers={"token":token}) # 返回随机字符串
else:
return Response(data="登录失败，用户名或密码错误")
url
使用自动生成路由：
from django.contrib import admin
from django.urls import path, re_path
from rest_framework.routers import SimpleRouter
from app01 import views
router = SimpleRouter()
router.register("merchandises",views.MerchandiseAPI)
urlpatterns = [
path('admin/', admin.site.urls),
path('login/',views.Login.as_view()),
]
urlpatterns.extend(router.urls)
基本使用
认证类
接下来我们要书写一个认证类：
from rest_framework.authentication import BaseAuthentication # 继承的基类
from rest_framework.exceptions import AuthenticationFailed # 异常
from . import models
from django.http import request
class LoginVerify(BaseAuthentication):
def authenticate(self, request):
token = request.META.get("HTTP_TOKEN")
# 如果在请求头中设置的是token的key名，获取时一定要全大写并加上HTTP
if not token:
raise AuthenticationFailed("请求失败，请求头中缺少token")
else:
user_obj = models.User.objects.filter(user_token=token).first() # 获取用户对象
if user_obj:
return user_obj,user_obj.user_token # 返回用户本身和token。这样request.user里面就能拿到该用户了
else:
raise AuthenticationFailed("token不存在，用户不存在，请不要伪造登录")
局部使用
只需要在商品接口中设置一个类属性，该接口便会进行认证。
class MerchandiseAPI(ModelViewSet):
authentication_classes = [authLogin.LoginVerify] # 使用认证
queryset = models.Merchandise.objects.all()
serializer_class = ser.MerchandiseModelSerializer
全局使用
只需要在settings.py中进行配置。
REST_FRAMEWORK={
"DEFAULT_AUTHENTICATION_CLASSES":["app01.authLogin.LoginVerify",]
}
如果想取消某个接口的认证，则在其中设置类属性authentication_classes是一个空列表。
如下所示，登录功能不需要验证，我们对他取消掉即可。
class Login(APIView):
authentication_classes = []
源码分析
流程分析
由于modelViewSet继承自APIView，所以我们直接看as_view()，在下面这一句代码中，将会对request进行二次封装。
def dispatch(self, request, *args, **kwargs):
self.args = args
self.kwargs = kwargs
request = self.initialize_request(request, *args, **kwargs) # 这里
self.request = request
self.headers = self.default_response_headers # deprecate?
在二次封装中，实例化出了一个Request对象并返回了，在实例化时，会调用self.get_authenticators()方法，此时的self是我们自定义的视图类，切记这一点。
def initialize_request(self, request, *args, **kwargs):
"""
Returns the initial request object.
"""
parser_context = self.get_parser_context(request)
return Request(
request,
parsers=self.get_parsers(),
authenticators=self.get_authenticators(), # 看这里，获取认方式
negotiator=self.get_content_negotiator(),
parser_context=parser_context
)
下面是get_authenticators()的代码，可以看见它会循环self.authentication_classes这个可迭代对象，如果你没有传递这个可迭代对象，那么该对象是一个默认的设置。
def get_authenticators(self):
return [auth() for auth in self.authentication_classes] # ( authLogin.LoginVerify调用，实例化 )
如果没有传递，将会找到APIView中的默认设置：
class APIView(View):
renderer_classes = api_settings.DEFAULT_RENDERER_CLASSES
parser_classes = api_settings.DEFAULT_PARSER_CLASSES
authentication_classes = api_settings.DEFAULT_AUTHENTICATION_CLASSES # 默认的设置，默认的认证类，可以自己看一下
如果有进行传递，可以发现它是使用了一个括号，这就代表会调用，由于传入的是一个类，所以它会进行实例化。
所以我们可以认为request.authenticators这个参数是一个tuple，里面包含了认证类的实例化对象。
然后，request就被二次包装完毕了。接下来执行 self.initial()，现在的self依然是我们自定义的视图类。
def dispatch(self, request, *args, **kwargs):
"""
`.dispatch()` is pretty much the same as Django's regular dispatch,
but with extra hooks for startup, finalize, and exception handling.
"""
self.args = args
self.kwargs = kwargs
request = self.initialize_request(request, *args, **kwargs)
self.request = request
self.headers = self.default_response_headers # deprecate?
try:
self.initial(request, *args, **kwargs)
下面是self.inital()的代码，
def initial(self, request, *args, **kwargs):
self.format_kwarg = self.get_format_suffix(**kwargs)
self.perform_authentication(request) # 只看这个，认证相关的
self.check_permissions(request)
self.check_throttles(request)
到了self.perform_authentication()时，它传递进了个request，并且会去找user这个属性抑或是被property装饰的方法，所以我们需要到Request这个类中去找，需要注意的是如果user是一个方法，这代表会自动传递进self，此时的self则是我们经过二次封装的request对象。
可以发现它是一个被装饰的方法。很显然我们没有_user这个方法或属性，会执行with语句，其实直接看self._authenticate()即可。再次强调，此次的self是二次封装的request对象。
@property
def user(self):
if not hasattr(self, '_user'):
with wrap_attributeerrors():
self._authenticate()
return self._user
下面是整个代码的核心。
def _authenticate(self):
for authenticator in self.authenticators: # 循环认证类对象 ( authLogin.LoginVerify的实例化 )
try:
user_auth_tuple = authenticator.authenticate(self) # 这里会找authenticate方法并将request对象进行传递，我们的认证类继承了BaseAuthentication这个类，它会实现一个接口方法， 但会抛出异常。
except exceptions.APIException: # 如果没有实现接口方法，或在验证时抛出异常都会被这里捕获
self._not_authenticated() # 执行这里 self.user将会是匿名用户AnonymousUser，而self.auth则是None
raise
if user_auth_tuple is not None: # 如果返回的值不是空
self._authenticator = authenticator
self.user, self.auth = user_auth_tuple # 分别赋值给self.user，以及self.auth中
return # 返回
self._not_authenticated() # 上面有认证对象就会return，没有还是设置匿名用户和None
最后总结
其实看了源码后，你可以发现我们的认证类可以不继承BaseAuthentication，但是推荐继承会更规范，因为这个基类实现了抽象接口。
其次，它将返回的两个值分别赋值给了request.user以及request.auth。
如果你没有返回值，那么对应的，request.user就是匿名用户，request.auth就是None。
如果你没有配置认证类，其实它会走默认的认证类。
老规矩，关于配置认证类时依旧是先用局部的，再用全局的，最后是用默认的，如果你的上面的源码确实有感觉了的话，应该能够看懂。