Django笔记:内置的用户系统
Django中有一个内置的用户系统,包含了用户模型的定义、用户的分组、登录验证、权限的定义和管理等,可以帮助我们非常快速地创建用户模型以及实现用户管理相关的一系列功能。当然,也可以不采用内置的用户管理系统,自己重新定义用户模型和对用户的管理操作,具体使用哪种方式还是需要看个人习惯和实际工作来定。
一、用户模型
1. 默认的用户模型
默认的用户模型,即User
模型类,这是Django内置用户系统的核心,源码位置在django.contrib.auth.models.User
。User
模型的主要字段如下:
username
:用户名。不能为空,且必须唯一。first_name
:姓名的first_name
。可以为空。last_name
:姓名的last_name
。可以为空。email
:邮箱。可以为空。password
:密码。经过哈希过后的密码。groups
:分组。一个用户可以属于多个分组,一个分组也可以拥有多个用户。和Group
模型是多对多的关系。user_permissions
:权限。一个用户可以拥有多个权限,一个权限也可以被多个用户使用。和Permission
模型是多对多的关系。is_staff
:是否是员工。表示是否可以进入到admin
(管理员)的站点。is_active
:是否可用。对于一些不再使用或者暂时不使用的账号数据,可以将这个值设置为False
即可。is_superuser
:是否是超级管理员。通常超级管理员拥有整个网站的所有权限。last_login
:上次登录的时间。date_joined
:账号创建的时间。
2. 常用基础操作
这里介绍一些常用的基础操作,只是作为参考,深入了解后可以根据自身需要来使用。
创建用户
可以通过create_user
方法快速创建一个普通用户,通过create_superuser
方法快速创建一个超级用户,创建超级用户还可以通过终端命令行的方式python manage.py createsuperuser
。
# 导入内置的User模型from django.contrib.auth.models import User
from django.http import HttpResponse
def index(request):
# create_user创建一个普通用户
user = User.objects.create_user(username="zhangsan", email="zhangsan@qq.com", password="123456")
# create_superuser创建一个超级用户
super_user = User.objects.create_superuser(username="lisi", email="lisi@qq.com", password="123456")
return HttpResponse("index")
修改密码
在Django内置的用户系统中有一个针对密码的密码哈希系统,密码是经过加密后存储在数据库中的,修改用户的密码时不能直接使用password=xxx
重新赋值的方式来修改,需要使用特定的方法set_password
来重置密码。因为涉及到密码的加密和解密,所以其他关于密码的操作大多也是需要使用特定的方法来进行操作的。
from django.contrib.auth.models import User# 随意获取一个用户,并给他重置密码
user = User.objects.get(pk=1)
user.set_password("654321")
user.save()
密码验证
可以使用authenticate
函数进密码验证,会同时验证用户名和密码,验证成功后会返回一个User
对象。
from django.contrib.auth import authenticatefrom django.http import HttpResponse
def index(request):
username = "zhangsan"
password = "123456"
user = authenticate(request, username=username, password=password)
if user:
return HttpResponse("验证成功!")
else:
return HttpResponse("用户名或密码错误!")
3. 扩展User模型
默认的User
模型肯定是不能满足我们的实际需要的,比如我们一般不用first_name
和last_name
两个字段来定义一个人的姓名,再比如我们通常使用邮箱或者手机号作为用户的唯一标识,而不是使用username
,所以我们就需要根据实际情况来扩展或自定义User
模型。扩展或自定义User
模型主要有以下四种方法,可以根据实际需要来使用。
1)proxy代理扩展
这种方式需要定义一个代理类,通过操作代理类以达到扩展User
模型的目的。代理类的定义方式Django已经为我们规定好了:代理类继承User
模型,并在内部类Meta
中指定proxy
为True
即可,随后可以根据自身需要定义额外的属性和方法了。
但是需要注意,Django内置的这种代理是不能在代理类中添加新的字段的,如telephone = models.CharField(max_length=11)
,但是可以添加其他普通的属性和方法。所以使用代理的方式缺点也比较明显,就是扩展性较差。
from django.contrib.auth.models import User# 代理类需要继承User
class Person(User):
# 在内部类Meta中指定proxy=True
class Meta:
proxy = True
# 添加额外的方法
@classmethod
def get_blacklist(cls):
return cls.objects.filter(is_active=False)
2)一对一关系外键扩展
这种方式是将User
模型当作一个外键,但是需要定义为一对一的关系,同时还需要定义一个信号去监听User
模型的save
方法,以保证扩展的类和User
模型在修改上的同步。
这种方式相比于代理的方式,优势在于可以添加一些额外的字段了。
from django.db import modelsfrom django.contrib.auth.models import User
from django.dispatch import receiver
from django.db.models.signals import post_save
class UserExtension(models.Model):
# 创建一个新的模型,将User映射为一对一关系的外键
user = models.OneToOneField(User, on_delete=models.CASCADE, related_name="userextension")
# 添加一些额外的字段
telephone = models.CharField(max_length=11)
school = models.CharField(max_length=100)
# 定义一个信号,监听User的save操作
@receiver(post_save, sender=User)
def handler_user_extension(sender, instance, created, **kwargs):
"""
:param sender: 发送者,即User模型
:param instance: User实例
:param created: 是否是第一次创建User实例
:param kwargs: 其他参数定义
"""
# 如果是第一次创建User实例,则同时创建UserExtension实例,
# 并将User实例绑定到UserExtension实例上
if created:
UserExtension.objects.create(user=instance)
# 否则,在User实例save后,UserExtension实例也需要同步save
else:
instance.extension.save()
3)继承AbstractUser重新定义User模型
其实User
模型类本身也是直接继承自AbstractUser
,所以自定义一个继承自AbstractUser
的子类就相当于是定义另一个新的User
类,但是由源码可知,继承AbstractUser
其实是一种较“浅”自定义方式,因为自定义的新User
类还是拥有原User
类的所有字段,只不过是用新的User
类代替了原User
类的使用,当然,在新的User
类中也是可以添加额外的字段以及其他方法的。
settings配置:自定义的User
类还需要在settings.py
中配置AUTH_USER_MODEL
,该配置项的值为新User
类的位置,但是需要注意,该User
类必须定义在APP的models.py
中,比如User
类定义在名为front
的APP下的models.py
中,那么配置时就应配置为AUTH_USER_MODEL="front.User"
,Django就会在对应APP的models.py
中寻找User
类。并且配置了该配置项后,可以通过from django.contrib.auth import get_user_model
来获取配置的User
模型。
objects对象重新定义:通常重新定义User
模型后,也需要重新定义它的objects
对象,因为原来的objects
对象还是使用的是原User
模型中的字段,自然就不能再用了。重新定义objects
对象只需要定义一个继承自from django.contrib.auth.models import BaseUserManager
的子类,然后将新的User
类中的objects
属性指定为新的objects
类即可。
注:不同于之前的两种方式,代理和一对一关系外键的方式更注重“扩展”的概念,而使用继承AbstractUser
的方式,虽然不是完全的自定义,但也是偏向于“重新定义”的概念。
from django.contrib.auth.models import AbstractUser# 新定义一个User类,添加一个额外的字段
class User(AbstractUser):
telephone = models.CharField(max_length=11)
# 默认该属性为username,重新指定后from django.contrib.auth import authenticate就会使用该字段替代username来进行验证了
USERNAME_FIELD = "telephone"
# 重新指定objects对象
objects = UserManager()
from django.contrib.auth.models import BaseUserManager# 原User模型默认的objects对象也是继承自BaseUserManager,
# 所以可以自定义一个新的objects子类来完成一些特殊的需要
class UserManager(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
# 重写create_user,默认是需要传入username属性,这里修改为传入telephone
def create_user(self, telephone, username, password, **kwargs):
# 设置为非超级管理员
kwargs["is_superuser"] = False
return self._create_user(telephone=telephone, username=username, password=password, **kwargs)
# 重写create_superuser方法
def create_superuser(self, telephone, username, password, **kwargs):
# 设置为超级管理员
kwargs["is_superuser"] = True
return self._create_user(telephone=telephone, username=username, password=password, **kwargs)
4)继承AbstractBaseUser重新定义User模型
这种方式就相当于创建一个全新的User
模型,舍弃了原User
模型中的大多字段,只保留password
、last_login
等基础的字段,这种方式同样也需要在settings.py
中配置AUTH_USER_MODEL
,以及重新定义objects
对象。
通常除了继承AbstractBaseUser
类外,还需要继承PermissionsMixin
类,这个类是用于权限管理的,原User
也是继承的这两个基础类。如果不是有特殊要求,User
类的定义应该尽量和原User
类保持一致,以免Django内置的方法在使用新的User
模型时发生不必要的错误。
from django.contrib.auth.base_user import AbstractBaseUserfrom django.contrib.auth.models import PermissionsMixin
# 继承两个基础类:AbstractBaseUser, PermissionsMixin
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是必须定义的,Django中许多内置的方法都会用到这个字段
is_active = models.BooleanField(default=True)
USERNAME_FIELD = "telephone"
# 这个属性是用于指定在终端使用命令create_superuser时提示用户需要填写哪些字段,如果是空列表,则默认只有username和password两个字段
REQUIRED_FIELDS = []
# 也是需要重新定义一个新的objects对象
objects = UserManager()
# 定义方法时,应该尽量模仿Django内置的User模型的方法,以避免Django在调用某些方法时使用了自定义User类没有的方法
def get_full_name(self):
return self.username
def get_short_name(self):
return self.username
二、登录验证
1. 登录和注销
可以使用内置的from django.contrib.auth import login
函数进行登录,此函数会自动将用户信息添加到session当中。同样的,注销也可以使用内置的from django.contrib.auth import logout
函数,此函数会自动将用户信息从session中清除。
from django.shortcuts import render, redirect, reversefrom django.contrib.auth import login
from .forms import LoginForm
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")
user = authenticate(request, username=telephone, password=password)
# 如果该用户在数据库中存在并且有效
if user and user.is_active:
# 内置login函数会将用户信息添加到session中
login(request, user)
return HttpResponse("登录成功!")
else:
return HttpResponse("用户名或密码错误!")
else:
print(form.errors)
return redirect(reverse("login"))
2. 登录验证
当某个url需要登录之后才能访问时,可以使用内置的from django.contrib.auth.decorators import login_required
装饰器来检查用户是否登录。
from django.contrib.auth.decorators import login_required# 如果访问该视图时没有登录,则会自动跳转到登录页面
# Django内置的登录url为`/accounts/login/`,可以通过参数login_url重新指定登录的url
@login_required(login_url="/login/")
def profile(request):
return HttpResponse("这是一个需要登录的页面!")
三、权限管理
Django中内置的权限定义是针对表或模型级别的,比如表Article
具有增加和查看两种权限操作,那么一个用户对于该表中的数据最多就只能拥有这两种权限,相当于表中的一个权限就对应了对该表中数据的一种操作,用户拥有对应的权限就可以执行对应操作,反之则不能操作。
Django存储权限信息的表在auth_permission
表中,可以查看默认的权限信息及其他新添加的权限信息。但是需要注意,内置的权限管理系统并没有限定具体的操作,只是创建了对应的权限标识,开发者需要根据权限标识自己完成相应的判断和操作。
1. 添加权限
如果想要给某个模型或者表添加额外的权限,有两种方式可以做到,一种是直接在定义模型的时候指定具体的权限,另一种方式就是动态添加权限。注意,这两种方式添加的权限都是针对表级别的,即该表中的所有数据都会有相同的权限。
class Article(models.Model): ...
class Meta:
# 元组的第一个元素是权限名称,第二个是权限的描述
permissions = [
("view_article", "查看文章的权限"),
]
from django.contrib.auth.models import Permission, ContentTypefrom .models import Article
def edit_permission(request):
content_type = ContentType.objects.get_for_model(Article)
permission = Permission.objects.create(codename="edit_article", name="编辑文章的权限", content_type=content_type)
return HttpResponse("添加权限成功!")
2. 常用权限操作
示例代码如下:
def operate_permission(request): # 给某个用户添加所有的关于“文章”表的权限
user = User.objects.first()
content_type = ContentType.objects.get_for_model(Article)
permissions = Permission.objects.filter(content_type=content_type)
# 以列表形式添加一个或多个权限
user.user_permissions.set(permissions)
# 清除所有权限
user.user_permissions.clear()
# 以参数形式添加一个或多个权限
user.user_permissions.add(permissions[0], permissions[1])
# user.user_permissions.add(*permissions)
# 以参数形式移除一个或多个权限
user.user_permissions.remove(permissions[0], permissions[1])
# user.user_permissions.remove(*permissions)
# 判断用户是否拥有某个权限,参数是一个字符串app_name.codename的格式
# 另一个方法has_perms则需要传入一个权限列表,表示判断用户是否拥有多个权限
if user.has_perm("front.view_article"):
print("拥有view_article权限!")
else:
print("没有view_article权限!")
# 获取用户的所有权限
print(user.get_all_permissions())
return HttpResponse("操作权限成功!")
3. 权限验证
执行某个视图时可能要求用户需要具有某个特殊的权限,对于这种权限的验证,也可以使用内置的装饰器from django.contrib.auth.decorators import permission_required
来进行验证。
from django.contrib.auth.decorators import login_required, permission_required# 用户只有登录之后,并且拥有add_article权限才能进入视图,如果需要验证多个权限,则传入一个列表即可,权限字符串格式为app_name.codename
# 如果没有登录或者权限验证不通过,则会重定向到默认的登录url,也可以通过login_url重新指定登录的url
# 如果登录成功,但是没有指定的权限,又不想重定向到登录页面,可以指定raise_exception为True,此时没有权限就会重定向到一个403错误页面了
@permission_required("front.add_article", login_url="/login/", raise_exception=True)
def add_article(request):
...
return HttpResponse("添加文章成功!")
4. HTML模板中进行权限验证
Django默认在settings.TEMPLATES.OPTIONS.context_processors
中添加django.contrib.auth.context_processors.auth
上下文处理器,所以我们可以在模板中直接使用perms
来判断用户是否拥有某个权限。
{% if perms.front.add_article %} <a href="#">添加文章</a>
{% endif %}
四、分组管理
分组可以使用Django内置的分组模型from django.contrib.auth.models import Group
,这个模型中除了外键就只有id
和name
两个普通字段。常用分组操作示例代码如下:
def operate_group(request): content_type = ContentType.objects.get_for_model(Article)
permissions = Permission.objects.filter(content_type=content_type)
# 创建一个分组,并在分组中添加若干权限
# group.permissions另外还有add/remove/clear等方法
group = Group.objects.create(name="文章作者")
group.permissions.set(permissions)
group.save()
# 给用户添加分组
group = Group.objects.filter(name="文章作者").first()
user = User.objects.first()
user.groups.add(group)
user.save()
# 获取用户的所有分组的权限
print(user.get_group_permissions())
# 获取用户的所有分组
print(user.groups)
return HttpResponse("操作分组成功!")
注:本文为学习笔记,发现错误欢迎指出。
以上是 Django笔记:内置的用户系统 的全部内容, 来源链接: utcz.com/z/530548.html