1.drf-jwt源码执行流程
1.1 签发(登录)
1.代码: urls.py: from rest_framework_jwt.views import obtain_jwt_token urlpatterns = [ path('login/',obtain_jwt_token), ] 2.我们点进obtain_jwt_token源码: drf/views.py: obtain_jwt_token = ObtainJSONWebToken.as_view() refresh_jwt_token = RefreshJSONWebToken.as_view() verify_jwt_token = VerifyJSONWebToken.as_view() 3.login需要提交用户名和密码，所以是post请求，我们需要在其父类中找到post方法: ObtainJSONWebToken>>>JSONWebTokenAPIView，在JSONWebTokenAPIView中找到了post方法: def post(self, request, *args, **kwargs): # serializer是序列化类的对象 serializer = self.get_serializer(data=request.data) # 校验，如果校验通过: if serializer.is_valid(): # 拿到user和token user = serializer.object.get('user') or request.user token = serializer.object.get('token') # 拿到返回格式，之前我们自定义过token的返回格式。 """ 当我们点击方法:jwt_response_payload_handler(token, user, request)，跳转到了rest_framework_jwt:jwt_response_payload_handler = api_settings.JWT_RESPONSE_PAYLOAD_HANDLER。说明JWT_RESPONSE_PAYLOAD_HANDLER需要在配置中指定返回格式。因此我们在设置中指定:JWT_AUTH = { 'JWT_RESPONSE_PAYLOAD_HANDLER': 'app01.jwt_response.jwt_response', }。所以返回格式才能按照我们指定的格式返回。 """
response_data = jwt_response_payload_handler(token, user, request) response = Response(response_data) return response return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) """ 执行if serializer.is_valid():这句话时就会执行序列化类中的代码，但是如何得到user和token，在序列化类的全局钩子中寻找答案: """ 4.还是回到drf/views.py中: obtain_jwt_token = ObtainJSONWebToken.as_view() refresh_jwt_token = RefreshJSONWebToken.as_view() verify_jwt_token = VerifyJSONWebToken.as_view() ObtainJSONWebToken后面跟了as_view()说明这是视图类，点进去: class ObtainJSONWebToken(JSONWebTokenAPIView): serializer_class = JSONWebTokenSerializer 说明JSONWebTokenSerializer就是序列化类。 5.JSONWebTokenSerializer代码: class JSONWebTokenSerializer(Serializer): # 这是一个全局钩子，因为上面没有单个字段的校验规则，所以此时的addr就是{'username':'max','password':'max123'} def validate(self, attrs): credentials = { # 这一步还是拿到了用户名，只不过是绕了一下 self.username_field: attrs.get(self.username_field), # 拿到密码 'password': attrs.get('password') } # 必须用户名和密码都幼值才成立 if all(credentials.values()): # auth模块中的，如果用户存在会拿到用户对象 user = authenticate(**credentials) if user: # 如果能拿到用户对象，并且用户被锁(is_active默认是1，如果用户被锁则是0) if not user.is_active: # 如果被锁则提示disabled msg = _('User account is disabled.') raise serializers.ValidationError(msg) # 通过用户对象拿到荷载 payload = jwt_payload_handler(user) # 通过payload生成token return { 'token': jwt_encode_handler(payload), 'user': user } else: msg = _('Unable to log in with provided credentials.') raise serializers.ValidationError(msg) else: msg = _('Must include "{username_field}" and "password".') msg = msg.format(username_field=self.username_field) raise serializers.ValidationError(msg)
1.2 认证 (认证类)
1.认证类需要从JSONWebTokenAuthentication中找到authenticate方法。在其父类中找到了authenticate方法。 from rest_framework_jwt.authentication import JSONWebTokenAuthentication def authenticate(self, request): """ Returns a two-tuple of `User` and token if a valid signature has been """ # jwt_value就是token字符串 jwt_value = self.get_jwt_value(request) # 如果token值没传，直接返回None if jwt_value is None: return None try: # payload是一个字典:{'user_id': 1, 'username': 'max', 'exp': 1676113688, 'email': ''} payload = jwt_decode_handler(jwt_value) # 还有几种可能拿不到，分别是:篡改token、token过期了、未知错误 except jwt.ExpiredSignature: msg = _('Signature has expired.') raise exceptions.AuthenticationFailed(msg) except jwt.DecodeError: msg = _('Error decoding signature.') raise exceptions.AuthenticationFailed(msg) except jwt.InvalidTokenError: raise exceptions.AuthenticationFailed() # 如果没有错误顺利能拿到用户对象 user = self.authenticate_credentials(payload) # 返回当前登录用户，token return (user, jwt_value) 2.接下来我们来看刚才的方法get_jwt_value(request)是如何拿到token的，该方法在类JSONWebTokenAuthentication中: def get_jwt_value(self, request): auth = get_authorization_header(request).split() 3.我们需要找到方法get_authorization_header(request)，在BaseAuthentication中找到了该方法: def get_authorization_header(request): # request.META可以拿到get请求头当中的值，结果是个字典。在数据发送到后端时键都变成了'HTTP_前端传入的键'，如果拿不到就拿一个空字符串。此时的auth是jwt dfjkdlsjf... auth = request.META.get('HTTP_AUTHORIZATION', b'') if isinstance(auth, str): # Work around django test client oddness auth = auth.encode(HTTP_HEADER_ENCODING) # 转码然后返回 return auth 4.继续回到get_jwt_value(request)方法: def get_jwt_value(self, request): # auth是个被分割列表:[jwt,dfjkdlsjf] auth = get_authorization_header(request).split() # JWT_AUTH_HEADER_PREFIX就是'JWT',转化成小写'jwt' auth_header_prefix = api_settings.JWT_AUTH_HEADER_PREFIX.lower() if not auth: # 如果请求头没带，就去cookie中取 if api_settings.JWT_AUTH_COOKIE: return request.COOKIES.get(api_settings.JWT_AUTH_COOKIE) return None # 如果列表索引0不为jwt返回None if smart_text(auth[0].lower()) != auth_header_prefix: return None if len(auth) == 1: msg = _('Invalid Authorization header. No credentials provided.') raise exceptions.AuthenticationFailed(msg) elif len(auth) > 2: msg = _('Invalid Authorization header. Credentials string ' 'should not contain spaces.') raise exceptions.AuthenticationFailed(msg) # 返回列表索引1，也就是token return auth[1]
2.自定义用户表签发和认证
2.1 签发
views.py: from rest_framework import permissions from rest_framework.response import Response from rest_framework.viewsets import ModelViewSet from rest_framework_jwt.authentication import JSONWebTokenAuthentication from rest_framework.viewsets import ViewSet from rest_framework.decorators import action from .models import Userinfo from rest_framework_jwt.settings import api_settings # 生成荷载的方法，我们直接调用drf的 jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER # 生成token的方法，我们也调用drf的 jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER class UserView(ViewSet): @action(methods=['POST'],detail=False) def login(self,request,*args,**kwargs): username = request.data.get('username') password = request.data.get('password') user = Userinfo.objects.filter(username=username,password=password).first() if user: payload = jwt_payload_handler(user) token = jwt_encode_handler(payload) return Response({'code':100,'msg':'登录成功','token':token}) else: return Response({'code':101,'msg':'用户名或密码错误'}) urls.py: router = SimpleRouter() router.register('user', UserView, 'user') # 此时路由:http://127.0.0.1:8000/api/v1/user/login/ urlpatterns = [ path('admin/', admin.site.urls), path('api/v1/', include(router.urls)) ] 通过以上步骤，我们可以自定义出功颁布token:
2.2 认证
新建一个认证类authentication.py,在其中写认证类的代码: authentication.py: from rest_framework.authentication import BaseAuthentication from rest_framework_jwt.settings import api_settings import jwt from rest_framework.exceptions import AuthenticationFailed from .models import Userinfo jwt_decode_handler = api_settings.JWT_DECODE_HANDLER class JsonWebTokenAuthentication(BaseAuthentication): def authenticate(self, request): token = request.META.get('HTTP_TOKEN') # 前端的格式可以自定义，取的时候在前面加上HTTP_就好，并且键要大写 if token: try: # jwt_decode_handler()方法仅仅是通过token找到payload,内部并没有切割字符串的方法 get_jwt_value()，所以前端在传的时候不需要加jwt和空格。 payload = jwt_decode_handler( token) print(payload) # :{'user_id': 1, 'username': 'max', 'exp': 1676113688, 'email': ''} user = Userinfo.objects.filter(pk=payload.get('user_id')).first() return user, token except jwt.ExpiredSignature: raise AuthenticationFailed('token过期') except jwt.DecodeError: raise AuthenticationFailed('token认证失败') except jwt.InvalidTokenError: raise AuthenticationFailed('token无效') except Exception as e: raise AuthenticationFailed('未知异常') raise AuthenticationFailed('token没有传 认证失败') views.py: class BookView(ModelViewSet): # 手写jwt认证只需要写认证类不用写权限类 authentication_classes = [JsonWebTokenAuthentication] def list(self, request, *args, **kwargs): return Response('success')
3.auth_user表密码加密
3.1 手动定义类似token的加密方式:
1.token的加密方式:token由三段构成，第一段声明加密算法和类型，第二段存放有效信息的地方:过期时间、签发时间、用户id、用户名等。第三段是加密后的header和base64加密后的payload。 2.我们也可以定义一中类似token的加密方式:改密码分为三段，用两个$连接起来，第一段是密码加密后的密文，第二段是随机生成的盐(不加密)，第三段是加密后的原密码和盐连接在一起(中间不加符号)，在通过md5加密。 3.代码: views.py: import uuid import hashlib def register_hash(request): """ password:原密码 res:原密码加密之后的密文 salt:随机生成的盐(不加密) pwd1:res$salt pwd_part3:password+salt res2:给pwd_part3加密之后的密文 pwd2:最终密码:pwd1+res2 """ if request.method == 'POST': username = request.POST.get('username') password = request.POST.get('password') # print(password) # 123 md51 = hashlib.md5() md51.update(password.encode('utf8')) res = md51.hexdigest() # print('res',res) # 202cb962ac59075b964b07152d234b70 # 随机生成一个盐(不加密) salt = str(uuid.uuid4()) print('salt',salt) # 将加密的原密码和不加密的盐组合起来，组成密码的前两部分 pwd1 = res + '$' + salt # 202cb962ac59075b964b07152d234b70$44590a73-2602-4f96-a718-972d83fb7ae6 # 将不加密的密码和盐组合起来，组成明文 pwd_part3 = res + salt md52 = hashlib.md5() md52.update(pwd_part3.encode('utf8')) # 原密码和盐组成的明文加密，组成密码的第三部分 res2 = md52.hexdigest() # 最终的密码 pwd2 = pwd1 + '$' + res2 print(pwd2) User_hash.objects.create(username=username,hash_pwd=pwd2) return HttpResponse('注册成功') return render(request, 'pwd.html', locals()) def login_view(request): if request.method == 'POST': username = request.POST.get('username') password = request.POST.get('password') md51 = hashlib.md5() md51.update(password.encode('utf8')) res = md51.hexdigest() user_obj = User_hash.objects.filter(username=username).first() if not user_obj: return HttpResponse('用户未注册') if not res == user_obj.hash_pwd.split('$')[0]: return HttpResponse('密码错误') salt = user_obj.hash_pwd.split('$')[1] pwd_part3 = res + salt md52 = hashlib.md5() md52.update(pwd_part3.encode('utf8')) res2 = md52.hexdigest() if not res2 == user_obj.hash_pwd.split('$')[2]: return HttpResponse('密码错误') return HttpResponse('登陆成功') return render(request,'login.html',locals()) urls.py: urlpatterns = [ path('register/',views.register_hash), path('login1/',views.login_view) ]
3.2 利用django自带的方法make_password()和check_password()来编写登录注册
1.make_password()只有一个参数，就是原密码。返回值是加密后的密码，也是django的auth_user表中的用户密码的加密方式: from django.contrib.auth.hashers import make_password, check_password from .models import User1 # 用djanngo的make_password方法注册 def register2(request): if request.method == 'POST': username = request.POST.get('username') password = request.POST.get('password') # 密码加密: pwd = make_password(password) User1.objects.create(username=username,password=pwd) return HttpResponse('注册成功') return render(request,'register2.html',locals()) 2.check_password()方法用来校验密码，里面有两个参数，第一个是明文密码，第二个参数是密文密码，如果这两个密码匹配那么结果是True,不匹配返回结果是False。 # 用django的check_password方法登陆 def login2(request): if request.method == 'POST': username = request.POST.get('username') password = request.POST.get('password') real_pwd = User1.objects.filter(username=username).first().password is_correct = check_password(password,real_pwd) if is_correct: return HttpResponse('登陆成功') return render(request,'login2.html',locals()) """ 如果超级管理员密码忘记了，可以再创建一个超级管理员，然后将新创建的管理员密码(密文)复制到前一个超级管理员的密码处，这两个管理员就会使用同一个密码。 """
4.simpleui使用
1.之前公司里，做项目，要使用权限，要快速搭建后台管理，使用djagno的admin直接搭建，django的admin界面不好。所以采用第三方软件。 2.第三方的美化: xadmin：作者弃坑了，bootstrap+jq simpleui： vue，界面更好看 3.现在阶段，一般前后端分离比较多：django+vue
4.1 使用步骤
1.安装:pip install simpleui 2.在app中注册 要注册在最上面 INSTALLED_APPS = [ 'simpleui' 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'app01', 'rest_framework', ] 然后当我们登录到admin后台管理就变成了这样:
3.然后我们在models.py中构造以下几张表，并且在admin.py中注册: models.py: class Book(models.Model): nid = models.AutoField(primary_key=True) name = models.CharField(max_length=32) price = models.DecimalField(max_digits=5, decimal_places=2) publish_date = models.DateField() publish = models.ForeignKey(to='Publish',to_field='nid',on_delete=models.CASCADE) authors=models.ManyToManyField(to='Author') def __str__(self): return self.name class Author(models.Model): nid = models.AutoField(primary_key=True) name = models.CharField(max_length=32) age = models.IntegerField() author_detail = models.OneToOneField(to='AuthorDetail',to_field='nid',unique=True,on_delete=models.CASCADE) class AuthorDetail(models.Model): nid = models.AutoField(primary_key=True) telephone = models.BigIntegerField() birthday = models.DateField() addr = models.CharField(max_length=64) class Publish(models.Model): nid = models.AutoField(primary_key=True) name = models.CharField(max_length=32) city = models.CharField(max_length=32) email = models.EmailField() admin.py: from .models import Book,Publish,AuthorDetail,Author admin.site.register(Book) admin.site.register(Publish) admin.site.register(AuthorDetail) admin.site.register(Author) 然后我们就可以在admin后台管理页看到这几张表:
4.在apps.py中加入verbose_name = '图书管理系统'，就可以将左侧列表中的app名改成自定义的名字: class App01Config(AppConfig): default_auto_field = 'django.db.models.BigAutoField' name = 'app01' verbose_name = '图书管理系统'
5.在models.py中每张表下面加入: class Meta: verbose_name_plural = '作者表' 在后台管理就可以将表名显示成中文:
然后再数据库加一些数据(可以在admin后台管理加，也可以在pycharm中加),添加好之后可以直接点进去修改，这就完成了对一个图书管理系统增删改查的创建。 """ DataTimeField字段刚开始默认是英文，如果我们想要把它设置成中文，需要在settings.py中设置:LANGUAGE_CODE = 'zh-hans'。 """
6.当我们在admin.py中注册好之后，我们在页面上只能看到书名。注册还有一种方式，在admin.py中写一个类，定义哪张表选择显示的字段就继承哪张表，用list_play=('字段名')来定义显示的字段名，但是不能上传多对多的外键字段:
7.还可以在页面上增加按钮:在刚才定义的BookAdmin中继续加内容: actions = ['custom_button'] # custom_button不能更改 def custom_button(self, request, queryset): print(queryset) # queryset就是选中对象的queryset，可以额外做一些操作 custom_button.short_description = '额外操作' # 按钮的中文名 custom_button.type = 'success' # 设置按钮颜色 8.侧边栏设置，需要在settings.py中进行如下设置: SIMPLEUI_CONFIG = { 'system_keep': False, 'menu_display': ['图书管理', '权限认证', '外链'], # 开启排序和过滤功能, 不填此字段为默认排序和全部显示, 空列表[] 为全部不显示. 'dynamic': True, # 设置是否开启动态菜单, 默认为False. 如果开启, 则会在每次用户登陆时动态展示菜单内容 'menus': [ # name要和menu_display中注册的名字保持一致 { 'name': '图书管理', 'app': 'app01', 'icon': 'fas fa-code', # models继续往下写下面的子目 'models': [ { 'name': '图书', 'icon': 'fa fa-user', 'url': '/admin/app01/book/' }, #url只能是自己在urls.py中配置的路由或者是自动生成的路由 { 'name': '出版社', 'icon': 'fa fa-user', 'url': 'app01/publish/' }, { 'name': '作者', 'icon': 'fa fa-user', 'url': 'app01/author/' }, { 'name': '作者详情', 'icon': 'fa fa-user', 'url': 'app01/authordetail/' }, ] }, { 'app': 'auth', 'name': '权限认证', 'icon': 'fas fa-user-shield', # 图标 'models': [ { 'name': '用户', 'icon': 'fa fa-user', 'url': 'auth/user/' }, { 'name': '组', 'icon': 'fa fa-user', 'url': 'auth/group/' }, ] }, { 'name': '外链', 'icon': 'fa fa-file', 'models': [ { 'name': 'Baidu', 'icon': 'far fa-surprise', # 第三级菜单 ， 'models': [ { 'name': '爱奇艺', 'url': 'https://www.iqiyi.com/dianshiju/' # 第四级就不支持了，element只支持了3级 }, { 'name': '百度问答', 'icon': 'far fa-surprise', 'url': 'https://zhidao.baidu.com/' } ] }, # 我们自己定义的页面也可以直接写路由: { 'name': '大屏展示', 'url': '/show/', 'icon': 'fab fa-github' }] } ] } 9.其他配置项: SIMPLEUI_LOGIN_PARTICLES = False #登录页面动态效果 SIMPLEUI_LOGO = 'https://avatars2.githubusercontent.com/u/13655483?s=60&v=4'#图标替换 SIMPLEUI_HOME_INFO = False #取消首页右侧github提示 SIMPLEUI_HOME_QUICK = False #快捷操作 SIMPLEUI_HOME_ACTION = False # 动作
5.权限控制
5.1 互联网项目:
alc:访问控制列表，权限放在列表中 用户表:存储用户信息，和权限表是一对多的关系 权限表:每个用户拥有的权限 比如: 权限列表:[发视频，发评论，开直播] max拥有的权限:[发视频，发评论，开直播] jerry拥有的权限:[发视频]
5.2 公司内部项目(python写公司内部项目居多):
1.rbac:是基于角色的访问控制（Role-Based Access Control ）在 RBAC 中，权限与角色相关联，用户通过成为适当角色的成员而得到这些角色的权限。这就极大地简化了权限的管理。这样管理都是层级相互依赖的，权限赋予给角色，而把角色又赋予用户，这样的权限设计很清楚，管理起来很方便。 2表关系: 用户表:用户和角色是多对多关系(一个用户可以对应多个角色) 角色表:类似于公司中的岗位 权限表:用户表不直接和用户表建立联系，而是和角色表建立联系(某个用户成为了某个角色之后才拥有某项权限)。角色表和权限表是多对多关系。 所以描述以上三者关系需要建立5张表: 用户表、角色表、权限表、用户角色表、角色权限表 3.用户和权限不直接建立联系是为了简化流程方便管理，但是也有特殊情况:比如公司人资想要获取拉取代码的权限，但是开发角色拥有的权限不仅仅是拉取代码而且还能操作代码。 如果将开发的角色赋给人资就会导致人资的权限过大。所以角色和权限直接监理联系，产生第6张表:角色权限中间表。 4.以图书管理系统为例，目前设置2个用户，一个是root(超级管理员)，一个是max(普通用户)。目前想要设置max的权限为查看书籍列表和作者列表，需要首先创建一个组(角色)，该组中规定了查看书籍列表和作者列表的权限。
在进入到用户设置列表中:首先取消该用户超级管理员身份(公司内超级管理员数量很有限)。
再登陆用户max，发现系统中只有作者和图书两个选项，并且只能查看:
5.管理员也可以直接设置用户和权限的对应关系:
6.在表中权限、组以及它们的对应关系都在以下6张表中: auth_user:用户表 auth_group:角色表，组表 auth_permission:权限表 auth_user_groups:用户和角色中间表 auth_group_permissions:角色和权限中间表 auth_user_user_permissions:用户和权限中间表
7.用管理员给用户max通过用户和权限对应关系给max添加了一个权限(不通过角色),该功能也可以叠加到max的权限中，用户max现在有三个功能:查看图书和作者(通过角色添加权限)、查看出版社(通过用户添加权限):
