Django初窥门径-自定义用户模型

前言

自定义用户模型在Django应用中是一个重要的话题，它涉及到如何根据您的项目需求以及特定的用户身份验证和授权需求来调整用户模型。在以下前言中，我将讲述为什么自定义用户模型是如此重要以及其潜在的优势：

随着Web应用的不断发展，用户身份认证和授权的需求也变得越来越多样化。在默认情况下，Django提供了一个名为django.contrib.auth.models.User的用户模型，它包含了常见的用户属性和方法，但不一定满足所有项目的要求。因此，自定义用户模型成为了一个必要的选择，它允许我们根据项目的具体需求来调整用户模型。

自定义用户模型的优势无处不在。首先，它使我们能够添加、修改或删除用户模型中的字段，以适应项目的特定数据。您可以为用户模型添加新的属性，如个人资料信息、头像、联系方式等，从而更好地满足项目需求。其次，自定义用户模型也允许您更好地集成社交媒体登录、第三方身份验证等功能，以提供更多的用户便利性。

此外，自定义用户模型还可以增强安全性。通过添加自定义字段，您可以更好地管理密码策略，实施多因素身份验证，记录安全审计日志等。最重要的是，自定义用户模型为您提供了更大的灵活性，以适应未来的项目需求和扩展。

总之，自定义用户模型不仅仅是一种实现特定项目需求的手段，更是提高Web应用的灵活性、安全性和可维护性的重要工具。在接下来的文章中，我们将深入探讨如何创建和使用自定义用户模型，以及它如何帮助我们构建更强大的Django应用。

Django用户模型

Django用户模型是Django框架的一个关键组件，用于处理用户认证和用户管理的任务。它为您提供了一种便捷的方式来创建、注册、登录和管理用户，同时也支持用户自定义以满足特定项目需求。

内置用户模型

Django提供了一个内置的用户模型 (django.contrib.auth.models.User)，其中包含以下常见用户属性：

用户名
密码
电子邮件地址
名字
姓氏

您可以轻松地在Django项目中启用这个内置用户模型并使用它来实现用户认证功能。

用户认证

Django用户模型简化了用户认证流程。以下是一些与用户认证相关的功能：

用户注册
用户登录
用户注销
密码重置
用户会话管理

Django提供了内置视图和装饰器，以帮助您轻松实现这些功能。

用户自定义

如果需要更多用户属性或者用户模型的不同结构，您可以自定义用户模型。通常的做法是创建一个自定义用户模型，继承自 AbstractUser，然后为其添加额外的字段，以满足项目的需求。

from django.contrib.auth.models import AbstractUser

class CustomUser(AbstractUser):
    # 自定义字段
    age = models.PositiveIntegerField()

用户认证后端

Django允许您使用不同的用户认证后端。默认情况下，Django使用用户名和密码进行认证，但您可以实现其他认证方法，如社交媒体登录、LDAP认证等。

权限和组

Django用户模型也支持用户权限和用户组的管理。您可以为用户分配不同的权限，并将用户组用于更好地管理这些权限。

用户管理界面

Django提供了一个内置的管理界面，可用于管理用户、组和权限，使用户管理变得更加便捷。
这些是Django用户模型的一些重要方面，它们可用于构建强大的用户认证和管理系统，同时也具备灵活性，以满足不同项目的需求。

创建自定义模型

创建一个`account`应用

python manage.py startapp account

创建自定义用户管理器

由于我们需要对默认用户模型的字段进行增删，所以需要自己实现一个用户管理器来管理我们的自定义模型。

class UserManager(BaseUserManager):
    """用户管理器"""
    use_in_migrations = True

    def _create_user(self, username, email, password, **extra_fields):
        if not username:
            raise ValueError('The given username must be set')
        email = self.normalize_email(email)
        username = self.model.normalize_username(username)
        user = self.model(username=username, email=email, password=password, **extra_fields)
        user.save(using=self._db)
        return user

    def create_user(self, username, email=None, password=None, **extra_fields):
        extra_fields.setdefault('is_active', False)
        extra_fields.setdefault('is_superuser', False)
        return self._create_user(username, email, password, **extra_fields)

    def create_superuser(self, username, email, password, **extra_fields):
        extra_fields.setdefault('is_active', True)
        extra_fields.setdefault('is_superuser', True)

        if extra_fields.get('is_active') is not True:
            raise ValueError('Superuser must have is_active=True.')
        if extra_fields.get('is_superuser') is not True:
            raise ValueError('Superuser must have is_superuser=True.')
        return self._create_user(username, email, password, **extra_fields)

特征	自定义管理器 (`UserManager`)	默认管理器 (`django.contrib.auth.models.UserManager`)
创建用户方法	提供 `_create_user`, `create_user` 和 `create_superuser` 方法，允许根据特定需求创建用户对象。	提供 `create_user` 和 `create_superuser` 方法，用于创建普通用户和超级用户，但可能不够灵活以满足特定需求。
默认值设置	允许设置特定的默认值，如 `is_active` 和 `is_superuser`，以确保创建的用户对象具有所需属性。	提供一组默认值，通常创建的用户是活动的和非超级用户，可能需要进一步修改属性。
私有方法	包含 `_create_user` 方法，它是私有的，不直接暴露给外部调用，而是通过公共方法 `create_user` 和 `create_superuser` 访问。	默认管理器没有私有方法，所有方法都是公共的，可以直接调用。
自定义性	提供更灵活的方式来定义用户创建逻辑，包括额外字段的处理和验证。	提供通用的用户创建方法，适用于大多数情况，但可能不满足特定项目的自定义需求。
用途	适用于需要特定用户创建逻辑和更多控制的项目。	适用于大多数一般情况下的项目，需要快速创建用户对象。

通过上述比较，您可以看到自定义管理器和默认管理器之间的一些关键区别，自定义管理器更适合在需要更多控制和自定义的项目中使用。默认管理器适用于一般情况下，可以快速创建用户对象，而自定义管理器则提供了更多的弹性和灵活性。

创建抽象用户模型

创建自定义权限混合模型

#!/usr/bin/python
# -*- coding: utf-8 -*-
from django.contrib.auth.models import _user_has_perm, _user_has_module_perms
from django.db import models


class PermissionsMixin(models.Model):
    """超级用户权限混合模型"""
    is_superuser = models.BooleanField('超级用户状态', default=False, help_text='指明该用户缺省拥有所有权限。')

    class Meta:
        abstract = True

    def has_perm(self, perm, obj=None):
        """
        Return True if the user has the specified permission. Query all
        available auth backends, but return immediately if any backend returns
        True. Thus, a user who has permission from a single auth backend is
        assumed to have permission in general. If an object is provided, check
        permissions for that object.
        """
        # Active superusers have all permissions.
        if self.is_superuser:
            return True

        # Otherwise we need to check the backends.
        return _user_has_perm(self, perm, obj)

    def has_module_perms(self, app_label):
        """
        Return True if the user has any permissions in the given app label.
        Use simlar logic as has_perm(), above.
        """
        # Active superusers have all permissions.
        if self.is_superuser:
            return True

        return _user_has_module_perms(self, app_label)

PermissionsMixin 是一个抽象模型，用于将超级用户的权限特性添加到用户模型中。我们的自定义PermissionsMixin 与Django默认的用户模型（User）之间的主要区别在于权限管理。

特征	`PermissionsMixin`	默认的 `User` 模型
超级用户标识字段（is_superuser）	存在，并且是一个布尔字段，用于表示用户是否是超级用户。默认情况下，用户不是超级用户。	默认 `User` 模型中也存在 `is_superuser` 字段，但在创建用户时通常不会指定该字段，它会默认为 `False`。
检查用户权限的方法（has_perm）	`PermissionsMixin` 提供了 `has_perm` 方法，用于检查用户是否具有指定的权限。如果用户是超级用户，直接返回 `True`。	默认 `User` 模型中也有 `has_perm` 方法，但其行为可能会因所使用的身份验证后端而异。
检查应用程序权限的方法（has_module_perms）	`PermissionsMixin` 提供了 `has_module_perms` 方法，用于检查用户是否在给定应用程序标签中具有任何权限。	默认 `User` 模型中没有 `has_module_perms` 方法，检查应用程序权限通常需要自己实现。
使用场景	适用于需要超级用户权限相关功能的应用，可以与自定义用户模型一起使用。	适用于一般情况下的应用，通常不需要额外的超级用户权限功能。
默认值设置	`is_superuser` 默认为 `False`，表示用户不是超级用户。需要在用户创建时手动设置为 `True`。	`is_superuser` 默认为 `False`，在创建用户时通常不需要显式设置。
帮助文本	提供了帮助文本，解释了 `is_superuser` 字段的作用，即指明该用户是否默认拥有所有权限。	默认 `User` 模型中的 `is_superuser` 字段通常没有相应的帮助文本。

总的来说，PermissionsMixin 旨在扩展用户模型以添加超级用户权限相关的功能，如检查用户是否具有特定权限和应用程序权限。默认的 User 模型是通用的，适用于大多数一般情况，但不包括额外的超级用户权限管理功能。可以根据项目需求选择是否使用 PermissionsMixin 或默认的 User 模型。

创建自定义校验器

#!/usr/bin/python
# -*- coding: utf-8 -*-
from django.core import validators
from django.utils.deconstruct import deconstructible


@deconstructible
class UsernameValidator(validators.RegexValidator):
    """用户名校验"""
    regex = r'^[a-zA-Z0-9_.]{4,16}$'
    message = '请输入4-16位字母数字以及下划线和点的组合'
    flags = 0

我们创建了一个自定义的用户名校验器，该校验器通过继承 validators.RegexValidator 并使用 @deconstructible 装饰器来创建一个可序列化的自定义校验器。

创建抽象用户模型

class AbstractUser(AbstractBaseUser, PermissionsMixin):
    """抽象用户模型"""
    username_validator = UsernameValidator()
    username = models.CharField('用户名', max_length=150, unique=True, validators=[username_validator],
                                help_text='必填。150个字符或者更少。包含字母，数字和仅有的/./+/-/_符号。',
                                error_messages={
                                    'unique': '已存在一位使用该名字的用户。',
                                })
    email = models.EmailField('电子邮件地址', unique=True, blank=False, null=False)
    is_active = models.BooleanField('有效', default=False, help_text='指明用户是否被认为是活跃的。以反选代替删除帐号。')
    # 需要使用 Django Admin的同学必须添加该字段，不然访问会报错
    is_staff = models.BooleanField('员工', default=True)
    date_joined = models.DateTimeField('加入日期', default=timezone.now)

    objects = UserManager()

    EMAIL_FIELD = 'email'
    USERNAME_FIELD = 'username'
    REQUIRED_FIELDS = ['email']

    class Meta:
        verbose_name = '用户'
        verbose_name_plural = verbose_name
        abstract = True

关键点	描述
类的名称	AbstractUser - 这是一个抽象用户模型。
继承关系	继承自 `AbstractBaseUser` 和 `PermissionsMixin`，具备身份认证和权限管理的功能。
`username_validator`	包含了用户名校验器 `UsernameValidator`，用于验证用户名是否符合指定格式要求。
`username` 字段	表示用户的用户名，包含帮助文本和错误消息，唯一且不可为空。
`email` 字段	表示用户的电子邮件地址，唯一且不可为空。
`is_active` 字段	表示用户的活跃状态，默认为非活跃状态。
`date_joined` 字段	表示用户的加入日期，使用 `timezone.now` 作为默认值。
`objects`	用户管理器，通常是一个自定义的用户管理器，用于管理用户对象。
`EMAIL_FIELD`	用户模型中用于电子邮件地址的字段名称。
`USERNAME_FIELD`	用户模型中用于用户名的字段名称。
`REQUIRED_FIELDS`	包含了必填字段列表，包括了电子邮件地址。
`Meta` 类	定义了一些元数据，如用户模型的名称、复数形式名称，以及将其设置为抽象模型。
用途	用作其他用户模型的基础，提供了身份认证和权限管理的功能，可用于创建自定义用户模型。

这个抽象用户模型提供了一个基础，可用作其他用户模型的基础。其他用户模型可以继承此抽象用户模型，以获得身份认证和权限管理的功能，并根据需要扩展字段和行为。这样，我们可以轻松创建满足特定项目需求的用户模型。

创建用户模型

class User(AbstractUser):
    avatar = models.URLField('头像', null=True)
    last_login_ip = models.GenericIPAddressField(null=True)

    def __str__(self):
        return self.username

    class Meta:
        ordering = ['-last_login']

关键点	描述
类的名称	User - 这是一个自定义用户模型，继承自Django内置的`AbstractUser`。
继承关系	继承自`AbstractUser`，继承了`AbstractUser`中的字段和方法，并允许添加自定义字段和方法。
自定义字段	- `avatar`字段：用于存储用户的头像URL，类型为`URLField`，允许为空。
	- `last_login_ip`字段：用于存储用户的上次登录IP地址，类型为`GenericIPAddressField`，也允许为空。
`__str__` 方法	定义了对象的字符串表示，返回用户的用户名作为字符串表示。
`Meta` 类	- `ordering`属性：定义查询结果的默认排序方式，按`last_login`字段降序排序，最后登录的用户排在前面。
用途	用作自定义用户模型，允许在Django应用中使用，并添加额外的字段和方法来满足特定项目的需求。

这个自定义用户模型允许我们创建具有额外功能的用户对象，例如存储用户头像和上次登录IP地址，同时继承了Django内置用户管理的功能，如身份认证和权限管理。可以根据具体项目的需求，创建自定义用户模型来满足特定的功能和字段要求。

应用自定义用户模型

AUTH_USER_MODEL = 'account.User'

AUTH_USER_MODEL 是一个Django设置，用于指定自定义用户模型的路径。AUTH_USER_MODEL 被设置为 ‘account.User’，表示自定义用户模型位于account应用中的User模型。

通过设置AUTH_USER_MODEL，告诉Django使用指定的用户模型来处理身份验证和用户相关的操作，而不是使用默认的django.contrib.auth.models.User模型。这允许我们自定义用户模型，以满足项目的特定需求。

在使用自定义用户模型时，需要确保将AUTH_USER_MODEL设置在项目的设置文件中，以便Django知道要使用哪个用户模型。这通常在项目的settings.py文件中设置。

在后续开发中，我们使用get_user_model() 用于替代硬编码用户模型的引用，以提高代码的灵活性和可维护性。在使用自定义用户模型时，它有助于确保代码与用户模型的更改保持兼容。比如：

User = get_user_model()

处理用户注册时填写的密码

#!/usr/bin/python
# -*- coding: utf-8 -*-
from django.contrib.auth import get_user_model
from django.db.models import signals
from django.dispatch import receiver

User = get_user_model()


@receiver(signals.post_save, sender=User)
def create_user(sender, instance=None, created=False, **kwargs):
    """
    创建用户信号量
    """
    if created:
        """创建用户时将明文密码改成加密格式"""
        password = instance.password
        instance.set_password(password)
        instance.save()

关键点	描述
获取用户模型（`get_user_model()`）	使用 `get_user_model()` 函数来获取当前项目中配置的用户模型，确保与项目中使用的用户模型保持一致。
信号接收器装饰器（`@receiver`）	使用 `@receiver` 装饰器注册信号接收器，指定了接收 `post_save` 信号，表示在保存用户对象后触发信号，同时指定了信号的发送者为 `User` 模型。
`create_user` 函数	信号接收器的处理函数，用于处理 `post_save` 信号。
- `created` 参数	用于判断用户对象是否是新创建的，如果 `created` 为 `True`，表示用户是新创建的。
- 密码加密	在处理函数中，从用户实例中获取明文密码，然后使用 `set_password` 方法将其转换为加密格式，最后保存用户实例以将加密后的密码存储到数据库中。
作用	该信号接收器的作用是在创建用户时，自动将明文密码转换为加密格式并保存到数据库中，以提高用户密码的安全性。

这个信号量用于确保用户的密码在创建时自动得到加密处理，而不以明文形式存储在数据库中。通常与自定义用户模型一起使用，以确保密码安全性的提高。

我们需要在apps.py中注册这个信号量：

from django.apps import AppConfig


class AccountConfig(AppConfig):
    default_auto_field = 'django.db.models.BigAutoField'
    name = 'account'

    def ready(self):
        from . import signals

ready 方法是应用配置的一个特殊方法，它在Django启动时自动执行。在这里，它导入了应用内的signals模块，以便应用的信号接收器可以注册并在应用启动时生效。

此时，千万不要忘了在配置文件里注册我们的account应用

INSTALLED_APPS = [
   ...
    'account.apps.AccountConfig',
    ...
]

重新初始化数据库

由于我们更改了用户模型，对数据库影响较大，应用到数据库的时候可能会报错，所以建议删掉所有表重新初始化。

python manage.py makemigrations
python manage.py migrate

模型的更改应用到数据库后，我们就可以生成超级用户了：

python manage.py createsuperuser

在这里插入图片描述
由上图可以看出，我们已经应用新的用户模型生成了数据库表，并且创建了超级用户。

结语

在本文中，我们探讨了Django中的用户模型、信号接收器以及数据库迁移。我们了解了如何自定义用户模型以满足特定项目需求，如何使用信号接收器处理各种操作，以及如何使用迁移来管理数据库模式的变更。这些都是Django中的关键概念，有助于构建强大的Web应用。希望本文能帮助您更深入地理解这些概念，并在您的项目中有所应用。