Django用户认证权限

Django 提供了一个强大且灵活的认证和权限系统，可以轻松处理用户认证、授权和权限管理。
1、认证系统架构

启用配置

1. # settings.py
2. INSTALLED_APPS = [
3.     # ...
4.     'django.contrib.auth',  # 核心认证框架
5.     'django.contrib.contenttypes',  # 权限系统依赖
6.     # ...
7. ]
9. MIDDLEWARE = [
10.     # ...
11.     'django.contrib.auth.middleware.AuthenticationMiddleware',  # 关联用户与请求
12.     # ...
13. ]

复制代码

1.1 User 模型

存储用户信息的核心模型
1.1.1 模型源码

1. class PermissionsMixin(models.Model):
2.     # 是否为超级用户
3.     is_superuser = models.BooleanField(
4.         _("superuser status"),
5.         default=False,
6.         help_text=_(
7.             "Designates that this user has all permissions without "
8.             "explicitly assigning them."
9.         ),
10.     )
11.     groups = models.ManyToManyField(
12.         Group,
13.         verbose_name=_("groups"),
14.         blank=True,
15.         help_text=_(
16.             "The groups this user belongs to. A user will get all permissions "
17.             "granted to each of their groups."
18.         ),
19.         related_name="user_set",
20.         related_query_name="user",
21.     )
22.     user_permissions = models.ManyToManyField(
23.         Permission,
24.         verbose_name=_("user permissions"),
25.         blank=True,
26.         help_text=_("Specific permissions for this user."),
27.         related_name="user_set",
28.         related_query_name="user",
29.     )
31.     class Meta:
32.         abstract = True
35. class AbstractBaseUser(models.Model):
36.     # 哈希后的密码
37.     password = models.CharField(_("password"), max_length=128)
38.     last_login = models.DateTimeField(_("last login"), blank=True, null=True)
40.     is_active = True
42.     REQUIRED_FIELDS = []
44.     _password = None
46.     class Meta:
47.         abstract = True
49.     def __str__(self):
50.         return self.get_username()
53. class AbstractUser(AbstractBaseUser, PermissionsMixin):
54.     """
55.     抽象用户模型，提供了完整的用户功能
56.     """
58.     username_validator = UnicodeUsernameValidator()
60.     # 用户名（唯一标识）
61.     username = models.CharField(
62.         _("username"),
63.         max_length=150,
64.         unique=True,
65.         help_text=_(
66.             "Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only."
67.         ),
68.         validators=[username_validator],
69.         error_messages={
70.             "unique": _("A user with that username already exists."),
71.         },
72.     )
73.     first_name = models.CharField(_("first name"), max_length=150, blank=True)
74.     last_name = models.CharField(_("last name"), max_length=150, blank=True)
75.     email = models.EmailField(_("email address"), blank=True)
76.     # 是否可以登录管理后台
77.     is_staff = models.BooleanField(
78.         _("staff status"),
79.         default=False,
80.         help_text=_("Designates whether the user can log into this admin site."),
81.     )
82.     # 账号是否激活
83.     is_active = models.BooleanField(
84.         _("active"),
85.         default=True,
86.         help_text=_(
87.             "Designates whether this user should be treated as active. "
88.             "Unselect this instead of deleting accounts."
89.         ),
90.     )
91.     date_joined = models.DateTimeField(_("date joined"), default=timezone.now)
93.     objects = UserManager()
95.     EMAIL_FIELD = "email"
96.     USERNAME_FIELD = "username"
97.     REQUIRED_FIELDS = ["email"]
99.     class Meta:
100.         verbose_name = _("user")
101.         verbose_name_plural = _("users")
102.         abstract = True
104.     def clean(self):
105.         super().clean()
106.         self.email = self.__class__.objects.normalize_email(self.email)
109. class User(AbstractUser):
110.     # 默认用户模型，继承自 AbstractUser
111.     class Meta(AbstractUser.Meta):
112.         swappable = "AUTH_USER_MODEL"

复制代码

1.1.2 自定义用户模型

最佳实践是项目开始时创建自定义用户模型

1. # models.py
2. from django.contrib.auth.models import AbstractUser
3. from django.db import models
5. class CustomUser(AbstractUser):
6.     # 添加额外字段
7.     phone_number = models.CharField(max_length=15, blank=True)
8.     date_of_birth = models.DateField(null=True, blank=True)
9.    
10.     # 使用邮箱作为用户名
11.     REQUIRED_FIELDS = ['username']  # 创建超级用户时需要的字段

复制代码

在 settings.py 中指定：

1. AUTH_USER_MODEL = 'myapp.CustomUser'

复制代码

1.2 权限模型

1.2.1 模型源码

1. class Permission(models.Model):
2.     """
3.     权限模型，存储所有权限信息
4.     """
5.     name = models.CharField(_("name"), max_length=255)
6.     content_type = models.ForeignKey(
7.         ContentType,
8.         models.CASCADE,
9.         verbose_name=_("content type"),
10.     )
11.     codename = models.CharField(_("codename"), max_length=100)
13.     objects = PermissionManager()
15.     class Meta:
16.         verbose_name = _("permission")
17.         verbose_name_plural = _("permissions")
18.         unique_together = [["content_type", "codename"]]
19.         ordering = ["content_type__app_label", "content_type__model", "codename"]
21.     def __str__(self):
22.         return "%s | %s" % (self.content_type, self.name)
24.     def natural_key(self):
25.         return (self.codename,) + self.content_type.natural_key()
27.     natural_key.dependencies = ["contenttypes.contenttype"]

复制代码

Django 自动为每个模型创建四个基本权限，在模型迁移时自动创建

• add_ - 添加权限
  
• change_ - 修改权限
  
• delete_ - 删除权限
  
• view_ - 查看权限
  

1.2.2 自定义权限

可以在模型的 Meta 类中定义自定义权限：

1. class Book(models.Model):
2.     title = models.CharField(max_length=100)
3.     author = models.CharField(max_length=100)
4.    
5.     class Meta:
6.         permissions = [
7.             ("can_publish", "Can publish book"),
8.             ("can_edit_cover", "Can edit book cover"),
9.         ]

复制代码

1.2.2 权限检查

1. # django\contrib\auth\models.py
3. def _user_has_perm(user, perm, obj):
4.     """
5.     检查用户是否有特定权限
6.     """
7.     for backend in auth.get_backends():
8.         if not hasattr(backend, "has_perm"):
9.             continue
10.         try:
11.             if backend.has_perm(user, perm, obj):
12.                 return True
13.         except PermissionDenied:
14.             return False
15.     return False

复制代码

1.3 组

用户组，用于批量权限分配
1.3.1 模型源码

1. class Group(models.Model):
2.     """
3.     组模型，用于批量分配权限
4.     """
5.     name = models.CharField(_("name"), max_length=150, unique=True)
6.     permissions = models.ManyToManyField(
7.         Permission,
8.         verbose_name=_("permissions"),
9.         blank=True,
10.     )
12.     objects = GroupManager()
14.     class Meta:
15.         verbose_name = _("group")
16.         verbose_name_plural = _("groups")
18.     def __str__(self):
19.         return self.name
21.     def natural_key(self):
22.         return (self.name,)

复制代码

1.4 认证后端

Django 认证系统支持多个认证后端，按顺序尝试认证，authenticate()函数会遍历 AUTHENTICATION_BACKENDS设置中指定的所有后端。默认使用的是 ModelBackend，其核心逻辑是根据 username查询用户，并验证其密码和 is_active状态

1. # settings.py
2. AUTHENTICATION_BACKENDS = [
3.     'django.contrib.auth.backends.ModelBackend',  # 默认后端
4.     'myapp.backends.EmailBackend',  # 自定义后端
5. ]

复制代码

1.4.1 ModelBackend源码

1. class ModelBackend(BaseBackend):
2.     """
3.     基于模型的认证后端
4.     """
5.     def authenticate(self, request, username=None, password=None, **kwargs):
6.         if username is None:
7.             username = kwargs.get(UserModel.USERNAME_FIELD)
8.         if username is None or password is None:
9.             return
10.         try:
11.             user = UserModel._default_manager.get_by_natural_key(username)
12.         except UserModel.DoesNotExist:
13.             # 模拟密码哈希以防止时序攻击
14.             UserModel().set_password(password)
15.         else:
16.             if user.check_password(password) and self.user_can_authenticate(user):
17.                 return user
20.     def user_can_authenticate(self, user):
21.         """
22.         检查用户是否可以认证（是否激活）
23.         """
24.         return getattr(user, "is_active", True)
26.     def _get_user_permissions(self, user_obj):
27.         # 获取用户权限的实现
28.         return user_obj.user_permissions.all()
30.     def _get_group_permissions(self, user_obj):
31.         return Permission.objects.filter(group__in=user_obj.groups.all())
33.     def _get_permissions(self, user_obj, obj, from_name):
34.         # 获取权限
35.         if not user_obj.is_active or user_obj.is_anonymous or obj is not None:
36.             return set()
38.         perm_cache_name = "_%s_perm_cache" % from_name
39.         if not hasattr(user_obj, perm_cache_name):
40.             if user_obj.is_superuser:
41.                 perms = Permission.objects.all()
42.             else:
43.                 perms = getattr(self, "_get_%s_permissions" % from_name)(user_obj)
44.             perms = perms.values_list("content_type__app_label", "codename").order_by()
45.             setattr(
46.                 user_obj, perm_cache_name, {"%s.%s" % (ct, name) for ct, name in perms}
47.             )
48.         return getattr(user_obj, perm_cache_name)
51.     def get_user_permissions(self, user_obj, obj=None):
52.         # 获取用户权限
53.         return self._get_permissions(user_obj, obj, "user")
55.    
56.     def get_group_permissions(self, user_obj, obj=None):
57.         # 获取组权限
58.         return self._get_permissions(user_obj, obj, "group")
61.     def get_all_permissions(self, user_obj, obj=None):
62.         # 获取所有权限
63.         if not user_obj.is_active or user_obj.is_anonymous or obj is not None:
64.             return set()
65.         if not hasattr(user_obj, "_perm_cache"):
66.             user_obj._perm_cache = super().get_all_permissions(user_obj)
67.         return user_obj._perm_cache
69.     def has_perm(self, user_obj, perm, obj=None):
70.         # 检查用户是否有特定权限
71.         return user_obj.is_active and super().has_perm(user_obj, perm, obj=obj)
74.     def get_user(self, user_id):
75.         try:
76.             user = UserModel._default_manager.get(pk=user_id)
77.         except UserModel.DoesNotExist:
78.             return None
79.         return user if self.user_can_authenticate(user) else None

复制代码

1.4.2 自定义认证后端

1. # backends.py
2. from django.contrib.auth.backends import BaseBackend
3. from django.contrib.auth import get_user_model
4. from django.db.models import Q
6. class EmailBackend(BaseBackend):
7.     """
8.     使用邮箱认证的后端
9.     """
10.     def authenticate(self, request, username=None, password=None, **kwargs):
11.         UserModel = get_user_model()
12.         try:
13.             # 使用邮箱或用户名认证
14.             user = UserModel.objects.get(
15.                 Q(username__iexact=username) | Q(email__iexact=username)
16.             )
17.         except UserModel.DoesNotExist:
18.             # 运行默认密码哈希器以防计时攻击
19.             UserModel().set_password(password)
20.             return None
21.         except UserModel.MultipleObjectsReturned:
22.             # 如果找到多个用户，返回第一个
23.             user = UserModel.objects.filter(
24.                 Q(username__iexact=username) | Q(email__iexact=username)
25.             ).first()
26.         
27.         if user and user.check_password(password):
28.             return user
29.         return None
30.    
31.     def get_user(self, user_id):
32.         UserModel = get_user_model()
33.         try:
34.             return UserModel.objects.get(pk=user_id)
35.         except UserModel.DoesNotExist:
36.             return None

复制代码

1.4.3 authenticate和login方法

1. @sensitive_variables("credentials")
2. def authenticate(request=None, **credentials):
3.     # 遍历AUTHENTICATION_BACKENDS设置中指定的所有后端
4.     for backend, backend_path in _get_compatible_backends(request, **credentials):
5.         try:
6.             # 调用认证后端的authenticate核心方法
7.             user = backend.authenticate(request, **credentials)
8.         except PermissionDenied:
9.             break
10.         if user is None:
11.             continue
12.         user.backend = backend_path
13.         return user
15.     # 发送认证失败信号
16.     user_login_failed.send(
17.         sender=__name__, credentials=_clean_credentials(credentials), request=request
18.     )
21. def login(request, user, backend=None):
22.     # 主要是session的处理，保存是在session中间件完成
23.     # ...

复制代码

2、基本使用

2.1 用户认证

由 authenticate和 login函数处理

1. from django.contrib.auth import authenticate, login
2. from django.shortcuts import render, redirect
3. from django.contrib.auth.forms import UserCreationForm
5. def login_view(request):
6.     if request.method == 'POST':
7.         username = request.POST['username']
8.         password = request.POST['password']
9.         # 认证
10.         user = authenticate(request, username=username, password=password)
11.         
12.         if user is not None:
13.             # 登录(建立会话)
14.             login(request, user)
15.             return redirect('home')
16.         else:
17.             return render(request, 'login.html', {'error': 'Invalid credentials'})
18.    
19.     return render(request, 'login.html')
23. def register_view(request):
24.     if request.method == 'POST':
25.         form = UserCreationForm(request.POST)
26.         if form.is_valid():
27.             user = form.save()
28.             # 创建完成后登录(建立会话)
29.             login(request, user)
30.             return redirect('home')
31.     else:
32.         form = UserCreationForm()
33.    
34.     return render(request, 'register.html', {'form': form})

复制代码

2.2 权限检查

使用 user.has_perm、装饰器或模板变量 perms
2.2.1 视图中的权限检查

1. from django.contrib.auth.decorators import login_required, permission_required
2. from django.contrib.auth.mixins import LoginRequiredMixin, PermissionRequiredMixin
3. from django.views.generic import View
5. from django.contrib.auth.decorators import login_required, permission_required
7. @login_required  # 要求用户登录
8. def my_view(request):
9.     pass
11. @permission_required('polls.can_vote', raise_exception=True)  # 要求特定权限
12. def my_vote_view(request):
13.     pass
15. # 使用Mixin（类视图）
16. class PublishView(LoginRequiredMixin, PermissionRequiredMixin, View):
17.     permission_required = 'myapp.can_publish'
18.     login_url = '/login/'
19.    
20.     def get(self, request):
21.         return HttpResponse("Book published")

复制代码

2.2.2 模板中的权限检查

1. {% if perms.myapp.can_publish %}
2.     <button>Publish Book</button>
3. {% endif %}
5. {% if user.has_perm('myapp.can_edit_cover') %}
6.     <button>Edit Cover</button>
7. {% endif %}

复制代码

2.3 用户和权限管理

2.3.1 创建用户并分配权限

1. from django.contrib.auth.models import User, Permission
2. from django.contrib.contenttypes.models import ContentType
3. from myapp.models import Book
5. # 创建用户
6. user = User.objects.create_user('john', 'john@example.com', 'password')
8. # 获取权限
9. content_type = ContentType.objects.get_for_model(Book)
10. permission = Permission.objects.get(
11.     codename='can_publish',
12.     content_type=content_type,
13. )
15. # 分配权限给用户
16. user.user_permissions.add(permission)
18. # 检查权限
19. if user.has_perm('myapp.can_publish'):
20.     print("User can publish books")

复制代码

2.3.2 使用组管理权限

1. from django.contrib.auth.models import Group, Permission, User
3. # 1. 创建组并分配权限
4. editors_group, created = Group.objects.get_or_create(name='Editors')
5. change_article_perm = Permission.objects.get(codename='change_article')
6. editors_group.permissions.add(change_article_perm)
8. # 2. 将用户加入组
9. user = User.objects.get(username='alice')
10. user.groups.add(editors_group)
11. # 现在 user 拥有 editors_group 的所有权限

复制代码

来源：豆瓜网用户自行投稿发布，如果侵权，请联系站长删除