drf JWT认证模块与自定制

Django 前端之家
前端之家收集整理的这篇文章主要介绍了drf JWT认证模块与自定制，前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。

JWT模块

　　 在djangorestframework中，有一款扩展模块可用于做JWT认证，使用如下命令进行安装：

  1. pip install djangorestframework-jwt

　　 现在，就让我们开始使用它吧。

JWT配置

　　 该模块的所有配置都会从settings.py中进行读取，与drf一样，它会先去读取项目全局文件夹下的settings.py，再去读取自身的settings.py，所以如果我们要对JWT进行配置，则在项目全局文件夹下的settings.py中进行配置即可：

  1. import datetime
  2. JWT_AUTH = {
  3.     # 配置过期时间
  4.     'JWT_EXPIRATION_DELTA': datetime.timedelta(days=7),# 配置请求头中携带token的前缀
  5.     'JWT_AUTH_HEADER_PREFIX': 'JWT',}

　　 如果你想了解更多配置，则可查看该模块读取的默认配置文件。

  1. from rest_framework_jwt import settings

　　 在默认配置文件中，你可以看到如下代码，它会先去全局中找配置，再到局部中找配置：

  1. USER_SETTINGS = getattr(settings,'JWT_AUTH',None)

auth组件

　　 下面将介绍如何使用auth组件与JWT配套使用，这当然非常方便，auth组件可以说是Django的核心。

　　 我打算这样做，对内置的user表做扩展，添加头像字段，只有用户登录后才能修改头像，否则将会采用默认头像。

准备工作

　　 首先我们需要对内置的auth_user表做扩展，如下所示：

  1. from django.db import models
  2. from django.contrib.auth.models import AbstractUser
  4. class User(AbstractUser):
  5.     avatar = models.FileField(upload_to="avatar",default="avatar/default.png")

　　 其次配置上传文件的路径，声明media所在的位置，以及声明我们对内置的auth_user表做了扩展：

  1. MEDIA_ROOT = BASE_DIR / "media"
  2. AUTH_USER_MODEL = "app01.User"
  4. # python manage.py makemigrations
  5. # python manage.py migrate

　　 最后打开资源暴露接口：

  1. from django.contrib import admin
  2. from django.urls import path,re_path
  3. from django.views.static import serve
  4. from django.conf import settings
  6. urlpatterns = [
  7.     path('admin/',admin.site.urls),re_path(r"^media/(?P<path>.*)",serve,{"document_root": settings.MEDIA_ROOT}),]

注册API

　　 现在，我们需要来做一个注册的API接口，如下所示：

  1. class Register(ViewSet):
  2.     def register(self,request,*args,**kwargs):
  3.         serializer = UserModelSerializer(data=request.data)
  4.         if serializer.is_valid():
  5.             serializer.save()
  6.             return Response(data=serializer.data,status=status.HTTP_201_CREATED)
  7.         return Response(data=serializer.errors,status=status.HTTP_401_UNAUTHORIZED)

　　 我们可以规定register这个方法必须是POST请求才能访问，在url中进行配置（ViewSet是ViewSetMixin的子类，所以有actions参数）：

  1. path('register/',views.Register.as_view(actions={"post":"register"})),

　　 由于auth_user的密码需要密文，所以我们重写了模型序列化器的create方法。

  1. from rest_framework import serializers
  2. from rest_framework.exceptions import ValidationError
  4. from app01 import models
  6. class UserModelSerializer(serializers.ModelSerializer):
  7.     re_password = serializers.CharField(required=True,write_only=True)
  8.     # 数据表中不存在该字段，我们自己写一个
  10.     class Meta:
  11.         model = models.User
  12.         fields = ("username","password","re_password","email")
  13.         extra_kwargs = {
  14.             "password":{"write_only":True}
  15.         }
  17.     def create(self,validated_data):
  18.         password = validated_data.get("password")
  19.         re_password = validated_data.get("re_password")
  20.         email = validated_data.get("email")
  23.         if re_password != password:
  24.             raise ValidationError("两次密码输入不一致")
  26.         if models.User.objects.filter(email=email):
  27.             raise ValidationError("邮箱已被注册")
  30.         validated_data.pop("re_password")  # 删除即可，然后写入
  31.         user_obj = models.User.objects.create_user(**validated_data)  # 加密创建
  32.         return user_obj

签发token

　　 下面将实现登录接口，如果你使用了auth组件作为扩展那么登录接口将十分的简单。

　　 JWT模块已经全部帮你完成了，你只需要向下面这么做：

  1. from rest_framework_jwt.views import obtain_jwt_token  # 导入视图，它都写好了的，并且会做验证
  2. from rest_framework_jwt.views import ObtainJSONWebToken  # 上面是一个变量，内部实际上是 obtain_jwt_token=ObtainJSONWebToken.as_view()
  4. urlpatterns = [
  5. 	path('login/',obtain_jwt_token),# path('login/',ObtainJSONWebToken.as_view()),]

　　 现在，当我们向该接口发送POST请求时，如果校验全部通过，则会发送给我们一个JWT

  1. eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VyX2lkIjozLCJ1c2VybmFtZSI6Inl1bnlhIiwiZXhwIjoxNjA0NTYyMzcyLCJlbWFpbCI6IjIzMjNAcXEuY29tIn0._SmZ0e0mj5QVOKUftAwI3xBX4_BOw1ZNjAi94_U3mXg

JWT认证

　　 下面我们来实现修改头像，头像必须先登录才能修改，所以要添加JWT认证。

  1. from rest_framework.permissions import IsAuthenticated  # 导入权限
  2. from rest_framework_jwt.authentication import JSONWebTokenAuthentication  # 导入认证
  4. class SetAvatar(ViewSet):
  6.     authentication_classes = [JSONWebTokenAuthentication]  # 存储到request.user，如果只配置这个，则不登陆也能访问
  7.     permission_classes = [IsAuthenticated]  # 必须已经登陆，即request.user不能是匿名用户
  9.     def set_avatar(self,**kwargs):
  10.         serializer = UserSetAvatar(instance=request.user,data=request.FILES)
  11.         if serializer.is_valid():
  12.             serializer.save()
  13.             return Response(data="修改成功",status=status.HTTP_205_RESET_CONTENT)
  14.         return Response(data="修改失败",status=status.HTTP_401_UNAUTHORIZED)

　　 序列类如下：

  1. class UserSetAvatar(serializers.ModelSerializer):
  2.     class Meta:
  3.         model = models.User
  4.         fields = ("avatar",)
  5.         extra_kwargs = {
  6.             "avatar":{"write_only":True},}

　　 url配置：

  1. path('setavatar/',views.SetAvatar.as_view(actions={"post":"set_avatar"})),

　　 现在，我们使用POSTMAN来发送请求，首先要先登录，获得JWT:

　　

image-20201105155846022

　　 然后需要在请求头中添加JWT认证，并且在body体中添加新头像：

　　 需要注意的是在添加JWT认证时，需要在VALUE处添加前缀JWT 随机字符串，以这样的格式提交，这是因为settings.py中设置了前缀。

　　

image-20201105155937569

　　

image-20201105155949700

　　 最后点击send，将会提示我们修改成功。

全局使用

　　 要在全局使用JWT认证，方式如下，它将作用于所有视图：

  1. REST_FRAMEWORK = {
  2.     # 认证模块
  3.     'DEFAULT_AUTHENTICATION_CLASSES': (
  4.         'rest_framework_jwt.authentication.JSONWebTokenAuthentication',),'DEFAULT_PERMISSION_CLASSES':{
  5.     	'rest_framework.permissions.IsAuthenticated',}
  6. }

　　 如果你想取消某一个视图的认证功能，则添加空列表即可：

  1. authentication_classes = []  
  2. permission_classes = []

　　 局部使用参见JWT认证中的书写。

JWT认证通过返回信息定制

　　 在上面的示例中，我们可以看见在用户登录之后，返回信息只有一个JWT字符串，那么我们可不可以将已登录的用户名字返回呢？也是可以的。

　　 jwt_response_payload_handler()这个函数就是控制返回格式的，我们可以覆写它然后在settings.py中进行配置。

　　 如下所示：

  1. def jwt_response_payload_handler(token,user=None,request=None):
  2.     return {
  3.         'status': 0,'msg': 'ok','data': {
  4.             'token': token,'user': UserModelSerializers(user).data
  5.         }
  6.     }

　　 在settings.py中进行配置，该项配置是配置在REST_FRAMEWORK中，而不是JWT_AUTH中，一定要注意：

  1. REST_FRAMEWORK = {
  2.     # 配置自定义登录成功后的返回信息
  3.     'JWT_RESPONSE_PAYLOAD_HANDLER':"utils.jwt_response_payload_handler",}

　　 最后登录完成的结果如下：

  1. {
  2.     "token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VyX2lkIjozLCJ1c2VybmFtZSI6Inl1bnlhIiwiZXhwIjoxNjA0NTY0Njk3LCJlbWFpbCI6IjIzMjNAcXEuY29tIn0.cvmM6LvoVkSQETybss3fVVGZNXT099o8U21tzDvdFe4","username": "yunya"
  3. }

JWT认证流程源码阅读

　　 又开始愉快的读源码环节了，那么JWT的源码还是比较简单的，下面一起看一看。

签发流程

　　 首先，我们来分析一下为什么只写了下面一个登录接口，甚至都没写视图，就可以完成签发。

  1. from rest_framework_jwt.views import obtain_jwt_token  # 导入视图，它都写好了的，并且会做验证
  2. from rest_framework_jwt.views import ObtainJSONWebToken  # 上面是一个变量，内部实际上是 obtain_jwt_token=ObtainJSONWebToken.as_view()
  4. urlpatterns = [
  5. 	path('login/',]

　　 先看obtain_jwt_token，可以发现这个代码：

  1. obtain_jwt_token = ObtainJSONWebToken.as_view()

　　 我们发现了一个ObtainJSONWebToken这个类，它会执行as_view()方法，先不管，看看它继承了谁：

　　

@H_51_301@

　　 它继承了JSONWebTokenAPIView，并且该类又继承了APIView，那么这个APIView的视图的源码已经阅读过不下五次了，可以查看之前的文章。我们直接来看关于登录的认证，JSONWebTOkenAPIView中实现了一个post方法：

  1.     def post(self,**kwargs):
  2.         serializer = self.get_serializer(data=request.data)  # 可以发现它有一个自带的序列化器
  3.         if serializer.is_valid():  # 直接进行验证
  4.             user = serializer.object.get('user') or request.user
  5.             token = serializer.object.get('token')
  6.             response_data = jwt_response_payload_handler(token,user,request)
  7.             response = Response(response_data)
  8.             if api_settings.JWT_AUTH_COOKIE:
  9.                 expiration = (datetime.utcnow() +
  10.                               api_settings.JWT_EXPIRATION_DELTA)
  11.                 response.set_cookie(api_settings.JWT_AUTH_COOKIE,token,expires=expiration,httponly=True)
  12.             return response
  14.         return Response(serializer.errors,status=status.HTTP_400_BAD_REQUEST)

　　 现在看到序列化器对吧，序列化器其实在这里：

  1. class ObtainJSONWebToken(JSONWebTokenAPIView):
  2.     serializer_class = JSONWebTokenSerializer

　　 这个是序列化器的源码，在__init__方法中实现了字段：

  1. class JSONWebTokenSerializer(Serializer):
  3.     def __init__(self,**kwargs):
  5.         super(JSONWebTokenSerializer,self).__init__(*args,**kwargs)
  6.         self.fields[self.username_field] = serializers.CharField()  # username字段
  7.         self.fields['password'] = PasswordField(write_only=True)  # password字段
  9.     @property
  10.     def username_field(self):
  11.         return get_username_field()
  13.     def validate(self,attrs):
  14.         credentials = {
  15.             self.username_field: attrs.get(self.username_field),'password': attrs.get('password')
  16.         }
  18.         if all(credentials.values()):
  19.             user = authenticate(**credentials)  # 这里是执行认证。
  21.             if user:
  22.                 if not user.is_active:
  23.                     msg = _('User account is disabled.')
  24.                     raise serializers.ValidationError(msg)
  26.                 payload = jwt_payload_handler(user)  # 拿到荷载信息
  28.                 return {
  29.                     'token': jwt_encode_handler(payload),# 荷载信息放进去，来生成JWT的token字符串
  30.                     'user': user
  31.                 }
  32.             else:
  33.                 msg = _('Unable to log in with provided credentials.')
  34.                 raise serializers.ValidationError(msg)
  35.         else:
  36.             msg = _('Must include "{username_field}" and "password".')
  37.             msg = msg.format(username_field=self.username_field)
  38.             raise serializers.ValidationError(msg)

　　 也就是说，在执行JSONWebTOkenAPIView的post()方法时，会走一次数据库查询，根据提交的用户名和密码来拿到用户对象。并且在序列化器中，会生成token()信息。他们都是配置好的一些函数：

  1. jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
  2. jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER
  3. jwt_decode_handler = api_settings.JWT_DECODE_HANDLER
  4. jwt_get_username_from_payload = api_settings.JWT_PAYLOAD_GET_USERNAME_HANDLER

　　 （我们可不可以自己写一个验证类来覆盖它，然后用于多端登录呢？手机号，邮箱等都可以登录）

　　 我们继续来看post()方法：

  1.     def post(self,**kwargs):
  2.         serializer = self.get_serializer(data=request.data)  # 可以发现它有一个自带的序列化器
  3.         if serializer.is_valid():  # 直接进行验证
  4.             user = serializer.object.get('user') or request.user # request.user等于已经登录的用户
  5.             token = serializer.object.get('token')  # token等于生成的jwt随机字符串
  6.             response_data = jwt_response_payload_handler(token,request)  # 设置返回信息
  7.             response = Response(response_data) 
  8.             if api_settings.JWT_AUTH_COOKIE:  # 未设置，不走
  9.                 expiration = (datetime.utcnow() +
  10.                               api_settings.JWT_EXPIRATION_DELTA)
  11.                 response.set_cookie(api_settings.JWT_AUTH_COOKIE,httponly=True)
  12.             return response  # 直接返回
  14.         return Response(serializer.errors,status=status.HTTP_400_BAD_REQUEST)  # 没验证通过

　　 OK，自动签发的流程已经走完了。

　　 大概的缕一缕，它自己有序列化器，并且在序列化器中完成了JWT字符串的拼接，最后进行返回。

验证流程

　　 现在我们再来看一下，当用户登录后，再次访问的验证流程，最开始肯定走认证：

  1. authentication_classes = [JSONWebTokenAuthentication]

　　 我们都知道，在APIView中的dispatch()方法中的initial()方法中，会有下面这三条代码：

  1. self.perform_authentication(request)
  2. self.check_permissions(request)
  3. self.check_throttles(request)
  5. # 详细的这三个代码的执行步骤，尤其是认证，可以查看之前的文章

　　 也就是先走认证，走认证时会统一执行一个叫做authenticators()的方法。我们直接找JSONWebTokenAuthentication中的authenticators()方法即可。

　　 这个类没有authenticators()这个方法，所以它继承类谁呢？

  1. class JSONWebTokenAuthentication(BaseJSONWebTokenAuthentication):

　　 所以我们要找的其实是BaseJSONWebTokenAuthentication中的authenticators()方法。

　　 终于，找到了：

  1.     def authenticate(self,request):
  3.         jwt_value = self.get_jwt_value(request)  # 获取jwt字符串，进行解析。也就是[ JWT  字符串 ]，这个字符串的内容，排除前缀，感兴趣可以看看
  4.         if jwt_value is None:
  5.             return None  # 如果没有JWT验证字符串，则返回None
  7.         try:  # 一系列的异常捕获，均来自于内置的jwt模块
  8.             payload = jwt_decode_handler(jwt_value)  # 解码荷载部分
  9.         except jwt.ExpiredSignature:
  10.             msg = _('Signature has expired.')  # 签证已过期
  11.             raise exceptions.AuthenticationFailed(msg)
  12.         except jwt.DecodeError:
  13.             msg = _('Error decoding signature.')  # 解码签证时出错
  14.             raise exceptions.AuthenticationFailed(msg)
  15.         except jwt.InvalidTokenError:
  16.             raise exceptions.AuthenticationFailed()  # 无效令牌
  18.         user = self.authenticate_credentials(payload)  # 如果都没出错，则执行这里
  20.         return (user,jwt_value)  # 返回user对象，这个会赋值给reque.user,这个会jwt字符串会赋值给request.auth
  21.         
  22. =================Request.user中关于权限认证的地方
  24.         for authenticator in self.authenticators:
  25.             try:
  26.                 user_auth_tuple = authenticator.authenticate(self)  # 这里会返回一个user
  27.             except exceptions.APIException:
  28.                 self._not_authenticated()
  29.                 raise
  31.             if user_auth_tuple is not None:
  32.                 self._authenticator = authenticator
  33.                 self.user,self.auth = user_auth_tuple  # 进行赋值 self.user=user ，self.auth = jwt_value
  34.                 return

　　 我们来看看user是怎么弄出来的。它是在BaseJSONWebTokenAuthentication类中定义的：

  1.     def authenticate_credentials(self,payload):
  3.         User = get_user_model() # 返回模型！！不是记录对象 ，通过settings.py中的AUTH_USER_MODEL进行获取
  4.         username = jwt_get_username_from_payload(payload)  # 获取payload中的用户名
  6.         if not username:  # 如果没有用户名就抛出异常
  7.             msg = _('Invalid payload.')
  8.             raise exceptions.AuthenticationFailed(msg)
  10.         try:  # 根据荷载中的用户名，在模型User中试图获取出用户的记录对象，也就是说这里会走数据库查询。
  11.             user = User.objects.get_by_natural_key(username)
  12.         except User.DoesNotExist:  # 如果User这个模型不存在则抛出异常，说明
  13.             msg = _('Invalid signature.')
  14.             raise exceptions.AuthenticationFailed(msg)
  15.  
  16.         if not user.is_active:  # 判断账户是否被禁用
  17.             msg = _('User account is disabled.')
  18.             raise exceptions.AuthenticationFailed(msg)
  20.         return user  # 返回user

不用auth组件

　　 看完了上面的源码分析后，我们再来想一想，如果不用auth模块该怎么办？

　　 其实也很简单，我们自己造一个jwt然后将token这个随机字符串返回就好了。

　　 认证的时候我们重写一下认证类就好了，反正都是那一套逻辑。

　　

手动签发

　　 我们的表中要有username以及password字段，使用JWT模块中生成token的几个函数，自己造就一个token。

  1. # views.py
  3. from rest_framework_jwt.settings import api_settings
  4. jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
  5. jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER
  6. from users.models import User
  9. class LoginView(APIView):  # 登录的时候签发token
  10.     authentication_classes = []
  11.     
  12.     def post(self,request):
  13.         username=request.data.get('username')
  14.         password=request.data.get('password')
  15.         user=User.objects.filter(username=username,password=password).first()
  16.         if user: # 能查到，登陆成功，手动签发
  17.             payload = jwt_payload_handler(user)
  18.             token = jwt_encode_handler(payload)
  19.             return CommonResponse('100','登陆成功',data={'token':token})
  20.         else:
  21.             return CommonResponse('101','登陆失败')

　　 如果你想实现多端登录，手机、用户名、邮箱等都能登录，这里也有一份代码，只不过配合了序列化器使用，比较复杂：

  1. # 使用用户名，手机号，邮箱，都可以登录#
  2. # 前端需要传的数据格式
  3. {
  4. 	"username":"lqz/1332323223/33@qq.com",# 用户名、或者手机号、或者邮箱
  5. 	"password":"lqz12345"
  6. }
  9. # 视图
  10. from rest_framework.views import APIView
  11. from rest_framework.viewsets import ViewSetMixin,ViewSet
  12. from app02 import ser
  13. class Login2View(ViewSet):  # 跟上面完全一样
  14.     def login(self,**kwargs):
  15.         # 1 需要 有个序列化的类
  16.         login_ser = ser.LoginModelSerializer(data=request.data,context={'request':request})  # context参数类似与管道，与序列化器进行连接
  17.         # 2 生成序列化类对象
  18.         # 3 调用序列号对象的is_validad
  19.         login_ser.is_valid(raise_exception=True)
  20.         token=login_ser.context.get('token')  # 从管道中取出token并返回
  21.         # 4 return
  22.         return Response({'status':100,'msg':'登录成功','token':token,'username':login_ser.context.get('username')})
  23.     
  24.     
  25.     
  26. # 序列化类
  27. from rest_framework import serializers
  28. from api import models
  29. import re
  30. from rest_framework.exceptions import ValidationError
  32. from rest_framework_jwt.utils import jwt_encode_handler,jwt_payload_handler
  33. class LoginModelSerializer(serializers.ModelSerializer):
  34.     username=serializers.CharField()  # 重新覆盖username字段，数据中它是unique，post，认为你保存数据，自己有校验没过
  35.     class Meta:
  36.         model=models.User
  37.         fields=['username','password']
  39.     def validate(self,attrs):
  41.         print(self.context)
  43.         # 在这写逻辑
  44.         username=attrs.get('username') # 用户名有三种方式
  45.         password=attrs.get('password')
  46.         # 通过判断，username数据不同，查询字段不一样
  47.         # 正则匹配，如果是手机号
  48.         if re.match('^1[3-9][0-9]{9}$',username):
  49.             user=models.User.objects.filter(mobile=username).first()
  50.         elif re.match('^.+@.+$',username):# 邮箱
  51.             user=models.User.objects.filter(email=username).first()
  52.         else:
  53.             user=models.User.objects.filter(username=username).first()
  54.         if user: # 存在用户
  55.             # 校验密码,因为是密文，要用check_password
  56.             if user.check_password(password):
  57.                 # 签发token
  58.                 payload = jwt_payload_handler(user)  # 把user传入，得到payload
  59.                 token = jwt_encode_handler(payload)  # 把payload传入，得到token
  60.                 self.context['token']=token
  61.                 self.context['username']=user.username
  62.                 return attrs
  63.             else:
  64.                 raise ValidationError('密码错误')
  65.         else:
  66.             raise ValidationError('用户不存在')

JWT验证

　　 验证的时候，继承BaseAuthentication类，重写一下验证方法：

  1. # app_auth.py
  3. from users.models import User
  5. class MyJSONWebTokenAuthentication(BaseAuthentication):
  7.     def authenticate(self,request):
  8.         jwt_value = get_authorization_header(request)
  9.         if not jwt_value:
  10.             raise AuthenticationFailed('Authorization 字段是必须的')
  11.         try:
  12.             payload = jwt_decode_handler(jwt_value)
  13.         except jwt.ExpiredSignature:
  14.             raise AuthenticationFailed('签名过期')
  15.         except jwt.InvalidTokenError:
  16.             raise AuthenticationFailed('非法用户')
  17.         username = jwt_get_username_from_payload(payload)
  18.         print(username)
  19.         user = User.objects.filter(username=username).first()
  20.         print(user)
  22.         return user,jwt_value

　　 然后你的某一个视图必须登录后才可以访问，把他添加到认证中就OK了。

  1. from users.app_auth import JSONWebTokenAuthentication,MyJSONWebTokenAuthentication
  2. class OrderView(APIView):
  3.     # authentication_classes = [JSONWebTokenAuthentication]  # 不用默认的了，用我们自己的
  4.     authentication_classes = [MyJSONWebTokenAuthentication]  # 由于不是auth_user表，所以不需要判断是否为匿名用户。
  5.     def get(self,request):
  6.         print(request.user)
  7.         return CommonResponse('100','成功',{'数据':'测试'})

最后我想说

　　1.注意前缀，JWT开头，一个空格，后面是JWT的token字符串

　　2.如果你不用auth组件，则需要手动生成JWT的token字符串与手动进行校验。这很麻烦，所幸JWT这个模块给我们很多方便之处。

　　3.多阅读源码，有好处的

猜你在找的Django相关文章

做了一个比较完善的课程管理与推荐系统
Web 端：https://github.com/jacob-lcs/awesome-curriculum-web Android 端：https://gith...
Django ORM操作
Django中集成了ORM框架，可以直接使用orm对数据库进行增删查改等操作，相对sql语句来说，o...
关于django.conf.urls的路由匹配问题
1. 问题 目前自己在写一个网站，但是在后端写好api前端请求的时候，无论如何都请求不到对应...
drf JWT认证模块与自定制
JWT模块 在djangorestframework中，有一款扩展模块可用于做JWT认证，使用如下命令进行安装...
drf 过滤与排序
django-filter drf中如果想在url中直接写过滤与排序，则需要安装第三方模块。 pip install...
CORS与Django
前言 在前后端分离项目中，如何解决跨域请求是一个必须要面对的问题。因为前端和后端的数据...
drf 自动生成接口文档
coreapi 在drf中，能够支持我们自动生成API文档的模块有很多，这里使用的是coreapi。 pip ...
了解JWT认证
JWT介绍 JWT的全称为Json web token，是为了在网络应用环境间传递声明而执行的一种基于JSO...
Django 缓存机制
缓存作用 当一个网站的并发量特别高的时候，频繁的对数据库进行增删查改操作势必会让访问速...
drf 权限校验设置与源码分析
权限校验 权限校验和认证校验必须同时使用，并且权限校验是排在认证校验之后的，这在源码中...
PHPJavaJava SEPythonC#C&C++RubyVBasp.NetGoPerlnettyDjangoDelphiJsp.NET CoreSpringFlaskSpringbootSpringMVCLuaLaravelMybatisAspGroovyThinkPHPYiiswoole
文件时间pythonm相等性PHP Warning时间问题问题解决pcntl_signal采样点wav模块动态文本调用频率限制对外暴露多个访问请求更新数据表模型结构type()方法比较速度手写体sobel算子保存模型Image类nn.Conv2dpytorch1.0kaggleDCGAN交并比range()用法打印模型反卷积卷积