验证和授权

最新推荐文章于 2024-02-14 16:08:52 发布

*Major*

最新推荐文章于 2024-02-14 16:08:52 发布

阅读量321

点赞数

本文链接：https://blog.csdn.net/qq_41375318/article/details/107611408

版权

$验证和授权$

1.验证和授权系统概述
2.内置User模型的基本使用
3.扩展User模型-使用Proxy模型
4.扩展User模型-一对一方式扩展
5.扩展User模型-继承AbstractUser
6.扩展User模型-继承AbstractBaseUser
7.登录、退出登录以及登录限制案例
8.权限-添加权限的两种方式
9.权限-用户和权限相关操作
10.权限-权限验证装饰器
11.分组-group、permission、user的操作
12.补充-在模板中添加权限控制

1. 验证和授权系统概述

Django 有一个内置的授权系统。他用来处理用户、分组、权限以及基于 cookie 的会话系
统。
Django 的授权系统包括验证和授权两个部分。验证是验证这个用户是否是他声称的人（比如
用户名和密码验证，角色验证），授权是给与他相应的权限。 Django 内置的权限系统包括以下方面：

用户。
权限。
分组。
一个可以配置的密码哈希系统。
一个可插拔的后台管理系统。

使用授权系统：

默认中创建完一个 django 项目后，其实就已经集成了授权系统。那哪些部分是跟授权系统相关的配置呢。以下做一个简单列表：
INSTALLED_APPS ：

django.contrib.auth ：包含了一个核心授权框架，以及大部分的模型定义。
django.contrib.contenttypes ： Content Type 系统，可以用来关联模型和权限。

中间件：

SessionMiddleware ：用来管理 session 。
AuthenticationMiddleware ：用来处理和当前 session 相关联的用户。

2.内置User模型的基本使用

User模型

User 模型是这个框架的核心部分。他的完整的路径是在 django.contrib.auth.models.User 。以
下对这个 User 对象做一个简单了解：
字段：
内置的 User 模型拥有以下的字段：

username ：用户名。150个字符以内。可以包含数字和英文字符，以及 _ 、 @ 、 + 、 . 和 - 字符。不能为空，且必须唯一！
first_name ：歪果仁的 first_name ，在30个字符以内。可以为空。
last_name ：歪果仁的 last_name ，在150个字符以内。可以为空。
email ：邮箱。可以为空。
password ：密码。经过哈希过后的密码。
groups ：分组。一个用户可以属于多个分组，一个分组可以拥有多个用户。 groups 这个字段是跟 Group 的一个多对多的关系。
user_permissions ：权限。一个用户可以拥有多个权限，一个权限可以被多个用户所有用。和 Permission 属于一种多对多的关系。
is_staff ：是否可以进入到 admin 的站点。代表是否是员工。
is_active ：是否是可用的。对于一些想要删除账号的数据，我们设置这个值为 False 就可以了，而不是真正的从数据库中删除。
is_superuser ：是否是超级管理员。如果是超级管理员，那么拥有整个网站的所有权限。
last_login ：上次登录的时间。
date_joined ：账号创建的时间。

User模型的基本用法：

创建用户：
通过 create_user 方法可以快速的创建用户。这个方法必须要传
递 username 、 email 、 password 。示例代码如下：

from django.contrib.auth.models import User
user = User.objects.create_user('zhiliao','hynever@zhiliao.com','111111')

此时user对象已经存储到数据库中了。当然你还可以继续使用user对象进行一些修改

user.last_name = 'abc'
user.save()

创建超级用户：
创建超级用户有两种方式。第一种是使用代码的方式。用代码创建超级用户跟创建普通用户非常的
类似，只不过是使用 create_superuser 。示例代码如下：

from django.contrib.auth.models import User
User.objects.create_superuser('admin','admin@163.com','111111')

也可以通过命令行的方式。命令如下：

python manage.py createsuperuser

后面就会提示你输入用户名、邮箱以及密码。

修改密码：

因为密码是需要经过加密后才能存储进去的。所以如果想要修改密码，不能直接修改 password 字
段，而需要通过调用 set_password 来达到修改密码的目的。示例代码如下：

from django.contrib.auth.models import User
user = User.objects.get(pk=1)
user.set_password('新的密码')
user.save()

登录验证：
Django 的验证系统已经帮我们实现了登录验证的功能。通
过 django.contrib.auth.authenticate 即可实现。这个方法只能通过 username 和 password 来进
行验证。示例代码如下：

from django.contrib.auth import authenticate
user = authenticate(username='zhiliao', password='111111')

如果验证通过了，那么就会返回一个user对象。
if user is not None:
执行验证通过后的代码
else:
执行验证没有通过的代码。

3.扩展User模型-使用Proxy模型

扩展用户模型：

Django 内置的 User 模型虽然已经足够强大了。但是有时候还是不能满足我们的需求。比如在验
证用户登录的时候，他用的是用户名作为验证，而我们有时候需要通过手机号码或者邮箱来进行验
证。还有比如我们想要增加一些新的字段。那么这时候我们就需要扩展用户模型了。扩展用户模型
有多种方式。这里我们来一一讨论下。

设置Proxy模型：

如果你对 Django 提供的字段，以及验证的方法都比较满意，没有什么需要改的。但是只是需要在
他原有的基础之上增加一些操作的方法。那么建议使用这种方式。示例代码如下：

class Person(User):
   class Meta:
      proxy = True
   def get_blacklist(self):
      return self.objects.filter(is_active=False)

在以上，我们定义了一个 Person 类，让他继承自 User ，并且在 Meta 中设置 proxy=True ，说明这个只是 User 的一个代理模型。他并不会影响原来 User 模型在数据库中表的结构。以后如果你想方便的获取所有黑名单的人，那么你就可以通过 Person.get_blacklist() 就可以获取到。并且 User.objects.all() 和 Person.objects.all() 其实是等价的。因为他们都是从 User 这个模型中获取所有的数据。

4.扩展User模型-一对一方式扩展

一对一外键：

如果你对用户验证方法 authenticate 没有其他要求，就是使用 username 和 password 即可完成。但是想要在原来模型的基础之上添加新的字段，那么可以使用一对一外键的方式。示例代码如
下：

from django.contrib.auth.models import User
from django.db import models
from django.dispatch import receiver
from django.db.models.signals import post_save
class UserExtension(models.Model):
	user = models.OneToOneField(User,on_delete=models.CASCADE,related_name='extension')
	birthday = models.DateField(null=True,blank=True)
	school = models.CharField(max_length=100)
	
@receiver(post_save,sender=User)
def create_user_extension(sender,instance,created,**kwargs):
	if created:
	UserExtension.objects.create(user=instance)
	else:
	instance.extension.save()

以上定义一个 UserExtension 的模型，并且让她和 User 模型进行一对一的绑定，以后我们新增的
字段，就添加到 UserExtension 上。并且还写了一个接受保存模型的信号处理方法，只要
是 User 调用了 save 方法，那么就会创建一个 UserExtension 和 User 进行绑定。

def my_authenticate(telephone,password):
    user = User.objects.filter(extension__telephone = telephone).first()
    if user:
        is_correct =user.check_password(password)
        if is_correct:
            return user
        else:
            return None
    else:
        return None


def one_view(request):
    #user = User.objects.create_user(username='major1',email='1171657161@qq.com',password='1234561')
    # user = User.objects.create_user(username='major2', email='1171657161@qq.com', password='1234561')
    # user.extension.telephone='18896653148'
    # user.save()
    telephone = request.GET.get('telephone')
    password = request.GET.get('password')
    user = my_authenticate(telephone,password)
    if user:
        print('验证成功: %s'%user.username)
    else:
        print('验证失败')

    return HttpResponse('一对一扩展')

5. 扩展User模型-继承AbstractUser

继承自 AbstractUser ：

在这里插入图片描述

对于 authenticate 不满意，并且不想要修改原来 User 对象上的一些字段，但是想要增加一些字段，那么这时候可以直接继承自 django.contrib.auth.models.AbstractUser ，其实这个类也是 django.contrib.auth.models.User 的父类。比如我们想要在原来 User 模型的基础之上添加一个 telephone 和 school 字段。示例代码如下：

from django.contrib.auth.models import AbstractUser
class User(AbstractUser):
		telephone = models.CharField(max_length=11,unique=True)
		school = models.CharField(max_length=100)
		# 指定telephone作为USERNAME_FIELD，以后使用authenticate
		# 函数验证的时候，就可以根据telephone来验证
		# 而不是原来的username
		USERNAME_FIELD = 'telephone'
		REQUIRED_FIELDS = []
		# 重新定义Manager对象，在创建user的时候使用telephone和
		# password，而不是使用username和password
		objects = UserManager()

class UserManager(BaseUserManager):
		use_in_migrations = True
		def _create_user(self,telephone,password,**extra_fields):
		if not telephone:
		    raise ValueError("请填入手机号码！")
		user = self.model(telephone=telephone,*extra_fields)
		user.set_password(password)
		user.save()
		    return user
		def create_user(self,telephone,password,**extra_fields):
		    extra_fields.setdefault('is_superuser',False)
		    return self._create_user(telephone,password)
		def create_superuser(self,telephone,password,**extra_fields):
		    extra_fields['is_superuser'] = True
		   return self._create_user(telephone,password)

然后再在 settings 中配置好 AUTH_USER_MODEL=youapp.User 。
这种方式因为破坏了原来User模型的表结构，所以必须要在第一次 migrate 前就先定义好。

class UserMannger(BaseUserManager):
    def _create_user(self,telephone,username,password,**kwargs):
        if not telephone:
            raise  ValueError('必须传递手机号码')
        if not password:
            raise  ValueError('必须传递密码')
        user = self.model(telephone=telephone,username=username,**kwargs)
        user.set_password(password)
        user.save()
        return user
    def create_user(self,telephone,username,password,**kwargs):
        kwargs['is_superuser'] = False
        return self._create_user(telephone=telephone,username=username,password=password,**kwargs)
    def create_superuser(self,telephone,username,password,**kwargs):
        kwargs['is_superuser'] = True
        return self._create_user(telephone=telephone,username=username,password=password,**kwargs)

class User(AbstractUser):
    telephone = models.CharField(max_length=11,unique=True)
    school = models.CharField(max_length=100)

    USERNAME_FIELD = 'telephone'
    objects = UserMannger()

def inherit_view(request):
    telephone = '17788889999'
    password = '123456'
    username = 'major666'
    user = User.objects.create_user(telephone=telephone,username=username,password=password)
    print(user.username)
    return  HttpResponse('继承AbstractUser')

6.扩展User模型-继承AbstractBaseUser

继承自 AbstractBaseUser 模型：

class UserMannger(BaseUserManager):
    def _create_user(self,telephone,username,password,**kwargs):
        if not telephone:
            raise  ValueError('必须传递手机号码')
        if not password:
            raise  ValueError('必须传递密码')
        user = self.model(telephone=telephone,username=username,**kwargs)
        user.set_password(password)
        user.save()
        return user
    def create_user(self,telephone,username,password,**kwargs):
        kwargs['is_superuser'] = False
        return self._create_user(telephone=telephone,username=username,password=password,**kwargs)
    def create_superuser(self,telephone,username,password,**kwargs):
        kwargs['is_superuser'] = True
        return self._create_user(telephone=telephone,username=username,password=password,**kwargs)


class User(AbstractBaseUser,PermissionsMixin):
    telephone = models.CharField(max_length=11,unique=True)
    email = models.CharField(max_length=100,unique=True)
    username = models.CharField(max_length=100)
    is_active = models.BooleanField(default=True)
    USERNAME_FIELD ='telephone'
    REQUIRED_FIELDS = []
    objects= UserMannger()
    def get_full_name(self):
        return self.username
    def get_short_name(self):
        return self.username

class Article(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()
    author = models.ForeignKey(get_user_model(),on_delete=models.CASCADE)

def inherit_view(request):
    # User.objects.create_user(telephone='18896653140',password='123456',username="major888")
    user = authenticate(request,username='18896653140',password='123456')
    if user:
        print(user.username)
        print('success')
    else:
        print('failure')

    return HttpResponse('继承BaseAbstractUser')

如果你想修改默认的验证方式，并且对于原来 User 模型上的一些字段不想要，那么可以自定义一
个模型，然后继承自 AbstractBaseUser ，再添加你想要的字段。这种方式会比较麻烦，最好是确
定自己对 Django 比较了解才推荐使用。步骤如下：

1.创建模型。示例代码如下：

class User(AbstractBaseUser,PermissionsMixin):
	email = models.EmailField(unique=True)
	username = models.CharField(max_length=150)
	telephone = models.CharField(max_length=11,unique=True)
	is_active = models.BooleanField(default=True)
	USERNAME_FIELD = 'telephone'
	REQUIRED_FIELDS = []
	objects = UserManager()
def get_full_name(self):
	return self.username
def get_short_name(self):
	return self.username

其中 password 和 last_login 是在 AbstractBaseUser 中已经添加好了的，我们直接继承就可
以了。然后我们再添加我们想要的字段。比如 email 、 username 、 telephone 等。这样就
可以实现自己想要的字段了。但是因为我们重写了 User ，所以应该尽可能的模拟 User 模
型：

USERNAME_FIELD ：用来描述 User 模型名字字段的字符串，作为唯一的标识。如果没有修改，那么会使用 USERNAME 来作为唯一字段。
REQUIRED_FIELDS ：一个字段名列表，用于当通过 createsuperuser 管理命令创建一个用户时的提示。
is_active ：一个布尔值，用于标识用户当前是否可用。
get_full_name() ：获取完整的名字。
get_short_name() ：一个比较简短的用户名。.

重新定义 UserManager ：我们还需要定义自己的 UserManager ，因为默认的 UserManager 在
创建用户的时候使用的是 username 和 password ，那么我们要替换成 telephone 。示例代码
如下：

class UserManager(BaseUserManager):
	use_in_migrations = True
	def _create_user(self,telephone,password,**extra_fields):
	if not telephone:
		raise ValueError("请填入手机号码！")
		user = self.model(telephone=telephone,*extra_fields)
		user.set_password(password)
		user.save()
		return user
	def create_user(self,telephone,password,**extra_fields):
		extra_fields.setdefault('is_superuser',False)
		return self._create_user(telephone,password)
	def create_superuser(self,telephone,password,**extra_fields):
		extra_fields['is_superuser'] = True
		return self._create_user(telephone,password)

在创建了新的 User 模型后，还需要在 settings 中配置好。配
置 AUTH_USER_MODEL=‘appname.User’ 。
如何使用这个自定义的模型：比如以后我们有一个 Article 模型，需要通过外键引用这
个 User 模型，那么可以通过以下两种方式引用。
第一种就是直接将 User 导入到当前文件中。示例代码如下：

from django.db import models
from myauth.models import User
class Article(models.Model):
	title = models.CharField(max_length=100)
	content = models.TextField()
	author = models.ForeignKey(User, on_delete=models.CASCADE)

这种方式是可以行得通的。但是为了更好的使用性，建议还是将 User 抽象出来，使
用 settings.AUTH_USER_MODEL 来表示。示例代码如下：

from django.db import models
from django.conf import settings
class Article(models.Model):
	title = models.CharField(max_length=100)
	content = models.TextField()
	author = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)

这种方式因为破坏了原来User模型的表结构，所以必须要在第一次 migrate 前就先定义好

7.登录、退出登录以及登录限制案例

注销：

注销，或者说退出登录。我们可以通过 django.contrib.auth.logout 来实现。他会清理掉这个用
户的 session 数据。

登录限制：

有时候，某个视图函数是需要经过登录后才能访问的。那么我们可以通
过 django.contrib.auth.decorators.login_required 装饰器来实现。示例代码如下：

from django.contrib.auth.decorators import login_required
# 在验证失败后，会跳转到/accounts/login/这个url页面
@login_required(login_url='/accounts/login/')
def my_view(request):
pass

def my_login(request):
    if request.method == "GET":
        return render(request,'login.html')
    else:
        form = LoginForm(request.POST)
        if form.is_valid():
            telephone = form.cleaned_data.get('telephone')
            password = form.cleaned_data.get('password')
            remember = form.cleaned_data.get('remember')
            #print(password)
            user = authenticate(request,username = telephone, password= password)
            if user and user.is_active:
                login(request,user)
                if remember:
                    request.session.set_expiry(None)
                else:
                    request.session.set_expiry(0)
                next_url = request.GET.get('next')
                if next_url:
                    return redirect(next_url)
                else:
                    return HttpResponse('登录成功')
            else:
                return  HttpResponse("用户名或手机号错误")
        else:
            print(form.errors)
            return redirect(reverse('login'))

def my_logout(request):
    logout(request)
    return HttpResponse('退出')

@login_required(login_url='/login/')
def profile(request):
    return HttpResponse('个人信息')

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登录</title>
</head>
<body>
<form action="" method="POST">
    <table>
        <tbody>
             <tr>
                 <td>用户号码：</td>
                 <td><input type="text" name="telephone"></td>
             </tr>
             <tr>
                 <td>密码：</td>
                 <td><input type="password" name="password"></td>
             </tr>
             <tr>
                 <td>
                     <label for="">
                         <input type="checkbox" name="remember" value="1">记住我
                     </label>
                 </td>
             </tr>
             <tr>
                 <td></td>
                 <td><input type="submit" value="登录"></td>
             </tr>
        </tbody>
    </table>

</form>

</body>
</html>

class UserMannger(BaseUserManager):
    def _create_user(self,telephone,username,password,**kwargs):
        if not telephone:
            raise  ValueError('必须传递手机号码')
        if not password:
            raise  ValueError('必须传递密码')
        user = self.model(telephone=telephone,username=username,**kwargs)
        user.set_password(password)
        user.save()
        return user
    def create_user(self,telephone,username,password,**kwargs):
        kwargs['is_superuser'] = False
        return self._create_user(telephone=telephone,username=username,password=password,**kwargs)
    def create_superuser(self,telephone,username,password,**kwargs):
        kwargs['is_superuser'] = True
        return self._create_user(telephone=telephone,username=username,password=password,**kwargs)

class User(AbstractBaseUser,PermissionsMixin):
    telephone = models.CharField(max_length=11,unique=True)
    email = models.CharField(max_length=100,unique=True)
    username = models.CharField(max_length=100)
    is_active = models.BooleanField(default=True)
    USERNAME_FIELD ='telephone'
    REQUIRED_FIELDS = []
    objects= UserMannger()
    def get_full_name(self):
        return self.username
    def get_short_name(self):
        return self.username

class Article(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()
    author = models.ForeignKey(get_user_model(),on_delete=models.CASCADE)

权限-添加权限的两种方式

权限：

Django 中内置了权限的功能。他的权限都是针对表或者说是模型级别的。比如对某个模型上的数据是否可以进行增删改查操作。他不能针对数据级别的，比如对某个表中的某条数据能否进行增删改查操作（如果要实现数据级别的，考虑使用 django-guardian ）。创建完一个模型后，针对这个模型默认就有三种权限，分别是增/删/改/。可以在执行完 migrate 命令后，查看数据库中
的 auth_permission 表中的所有权限。

在这里插入图片描述

其中的 codename 表示的是权限的名字。 name 表示的是这个权限的作用。

通过定义模型添加权限：
如果我们想要增加新的权限，比如查看某个模型的权限，那么我们可以在定义模型的时候
在 Meta 中定义好。示例代码如下：

class Article(models.Model):
	title = models.CharField(max_length=100)
	content = models.TextField()
	author = models.ForeignKey(get_user_model(),on_delete=models.CASCADE)
	class Meta:
	  	permissions = (('view_article','can view article'),)

通过代码添加权限：

权限都是 django.contrib.auth.Permission 的实例。这个模型包含三个字
段， name 、 codename 以及 content_type ，其中的 content_type 表示这个 permission 是属于
哪个 app 下的哪个 models 。用 Permission 模型创建权限的代码如下：

from django.contrib.auth.models import Permission,ContentType
from .models import Article
content_type = ContentType.objects.get_for_model(Article)
permission = Permission.objects.create(name='可以编辑的权限',codename='edit_article',content_type=content_type)

9.权限-用户和权限相关操作

用户与权限管理：

权限本身只是一个数据，必须和用户进行绑定，才能起到作用。 User 模型和权限之间的管理，可
以通过以下几种方式来管理：

myuser.user_permissions.set(permission_list) ：直接给定一个权限的列表。
myuser.user_permissions.add(permission,permission,…) ：一个个添加权限。
myuser.user_permissions.remove(permission,permission,…) ：一个个删除权限。
myuser.user_permissions.clear() ：清除权限。
myuser.has_perm(’<app_name>.’) ：判断是否拥有某个权限。权限参数是一个字符
串，格式是 app_name.codename 。
myuser.get_all_permissons() ：获取所有的权限。

def operate_permission(request):
    user = User.objects.first()
    content_type = ContentType.objects.get_for_model(Article)
    permissions = Permission.objects.filter(content_type=content_type)
    for permission in permissions:
        print(permission)
    #user.user_permissions.set(permissions) == user.user_permissions.add(*permissions)
    #user.user_permissions.clear() == user.user_permissions.remove(*permissions)
    #user.user_permissions.add(permissions[0],permissions[1])
    #user.user_permissions.remove(permissions[0])

    #user.user_permissions.add(*permissions)
    if user.has_perm('front.view_article'):
        print('这个user拥有view_article权限')
    else:
        print('这个user没有view_article权限')

    return HttpResponse('操作权限')

10.权限-权限验证装饰器

权限限定装饰器：
使用 django.contrib.auth.decorators.permission_required 可以非常方便的检查用户是否拥有这
个权限，如果拥有，那么就可以进入到指定的视图函数中，如果不拥有，那么就会报一个 400 错
误。示例代码如下：

from django.contrib.auth.decorators import permission_required
@permission_required('front.view_article')
def my_view(request):
...

实例：

@permission_required('front.add_article',login_url='/login/',raise_exception=True)
def add_article(request):
    # if request.user.is_authenticated:
    #     print('已经登录')
    #     if request.user.has_perm('front.add_article'):
    #         return HttpResponse('添加文章页面')
    #     else:
    #         return HttpResponse('无权限',status=403)
    # else:
    #     return redirect(reverse('login'))
    return HttpResponse('添加文章页面')

11.分组-group、permission、user的操作

def operate_group(request):
    # group = Group.objects.create(name='运营')
    # content_type = ContentType.objects.get_for_model(Article)
    # permissions = Permission.objects.filter(content_type=content_type)
    # group.permissions.set(permissions)
    # group.save()

    # group = Group.objects.filter(name="运营").first()
    # user = User.objects.first()
    # user.groups.add(group)
    # user.save()

    user = User.objects.first()
    permissions = user.get_group_permissions()
    print(permissions)
    return HttpResponse('操作分组')

分组：
权限有很多，一个模型就有最少三个权限，如果一些用户拥有相同的权限，那么每次都要重复添
加。这时候分组就可以帮我们解决这种问题了，我们可以把一些权限归类，然后添加到某个分组
中，之后再把和把需要赋予这些权限的用户添加到这个分组中，就比较好管理了。分组我们使用的

是 django.contrib.auth.models.Group 模型，每个用户组拥有 id 和 name 两个字段，该模型在数
据库被映射为 auth_group 数据表。
分组操作：

Group.object.create(group_name) ：创建分组。
group.permissions ：某个分组上的权限。多对多的关系。
group.permissions.add ：添加权限。
group.permissions.remove ：移除权限。
group.permissions.clear ：清除所有权限。
user.get_group_permissions() ：获取用户所属组的权限。
user.groups ：某个用户上的所有分组。多对多的关系。

12.补充-在模板中添加权限控制

在 settings.TEMPLATES.OPTIONS.context_processors 下，因为添加了 django.contrib.auth.context_processors.auth 上下文处理器，因此在模板中可以直接通过 perms 来获取用户的所有权限。示例代码如下：

{% if perms.front.add_article %}
<a href='/article/add/'>添加文章</a>
{% endif %}

*Major*

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
验证和授权

验证和授权验证和授权验证和授权验证和授权1.验证和授权系统概述2.内置User模型的基本使用3.扩展User模型-使用Proxy模型4.扩展User模型-一对一方式扩展5.扩展User模型-继承AbstractUser6.扩展User模型-继承AbstractBaseUser7.登录、退出登录以及登录限制案例8.权限-添加权限的两种方式9.权限-用户和权限相关操作10.权限-权限验证装饰器11.分组-group、permission、user的操作12.补充-在模板中添加权限控制
复制链接

扫一扫