使用 Django 的验证系统Link to this heading#

选择验证后端Link to this heading#

当用户登录时，用户 ID 和用于身份验证的后端会被保存在用户会话中。允许相同的 authentication backend 在未来的请求中获取用户详情。选择要在会话中保存的验证后端如下：

1. 使用提供了的可选 backend 参数值。

2. 使用 user.backend  的值。允许配对 authenticate()  和 login() ：当返回用户对象时 authenticate() 设置 user.backend 属性。

3. 使用 AUTHENTICATION_BACKENDS 存在的 backend 。

4. 否则，抛出一个异常。

在1和2中，backend 参数和 user.backend 属性应该是完整的导入路径（像 AUTHENTICATION_BACKENDS 里的路径一样），而不是真实的后端类。

原始方式Link to this heading#

限制访问页面最简单的办法就是检查 request.user.is_authenticated 并重定向到登录页面。

from django.conf import settings
from django.shortcuts import redirect

def my_view(request):
    if not request.user.is_authenticated:
        return redirect('%s?next=%s' % (settings.LOGIN_URL, request.path))
    # ...

或者显示一个错误信息：

from django.shortcuts import render

def my_view(request):
    if not request.user.is_authenticated:
        return render(request, 'myapp/login_error.html')
    # ...

login_required 装饰器Link to this heading#

login_required(redirect_field_name='next', login_url=None)Link to this definition#

作为快捷方式，你可以使用 login_required() 装饰器:

Code

from django.contrib.auth.decorators import login_required

@login_required
def my_view(request):
    ...

login_required() 会执行以下操作：

• 如果用户没有登录，会重定向到 settings.LOGIN_URL ，并传递绝对路径到查询字符串中。例如： /accounts/login/?next=/polls/3/ 。

• 如果用户已经登录，则正常执行视图。视图里的代码可以假设用户已经登录了。

默认情况下，成功验证时用户跳转的路径保存在名为 "next" 的查询字符串参数中。如果你希望这个参数使用不同名称，请在 login_required() 中传递可选参数 redirect_field_name ：

Code

from django.contrib.auth.decorators import login_required

@login_required(redirect_field_name='my_redirect_field')
def my_view(request):
    ...

注意，如果你提供了 redirect_field_name 值，则很可能也需要自定义登录模板，因为存储重定向路径的模板上下文变量使用的是 redirect_field_name 值，而不是 "next" （默认情况下）。

login_required() 也有可选参数 login_url 。例如：

Code

from django.contrib.auth.decorators import login_required

@login_required(login_url='/accounts/login/')
def my_view(request):
    ...

注意，如果你没有指定参数 login_url ，你需要确认 settings.LOGIN_URL  和登录视图是正确关联的。例如，使用默认方式，在 URL 配置文件里添加下面这行：

Code

from django.contrib.auth import views as auth_views

path('accounts/login/', auth_views.LoginView.as_view()),

settings.LOGIN_URL 也接受视图方法名和 named URL patterns 。这样你可以在 URLconf 里自由地重新映射你的登录视图，而不需更新配置文件。

LoginRequired MixinLink to this heading#

使用基于类的视图时，可以使用 LoginRequiredMixin 实现和 login_required 相同的行为。这个 Mixin 应该在继承列表中最左侧的位置。

class LoginRequiredMixinLink to this definition#

如果一个视图使用 Mixin ，那么未经验证用户的所有请求都会被重定向到登录页面或者显示 HTTP 403 Forbidden 错误，这取决于 raise_exception 参数。

你可以设置 AccessMixin 的任何参数来自定义未验证用户的处理：

Code

from django.contrib.auth.mixins import LoginRequiredMixin

class MyView(LoginRequiredMixin, View):
    login_url = '/login/'
    redirect_field_name = 'redirect_to'

限制对通过测试的登录用户的访问Link to this heading#

根据某些权限或者其他测试来限制访问，你基本上可以执行和上一节所述同样的操作。

最简单的方法是在视图里直接对 request.user 进行测试。举例，这个视图检查用户是否拥有特定域名的邮箱，否则会重定向到登录页：

from django.shortcuts import redirect

def my_view(request):
    if not request.user.email.endswith('@example.com'):
        return redirect('/login/?next=%s' % request.path)
    # ...

user_passes_test(test_func, login_url=None, redirect_field_name='next')Link to this definition#

作为快捷方式，你可以方便的调用 user_passes_test 装饰器，当调用返回 False 时会执行重定向。

Code

from django.contrib.auth.decorators import user_passes_test

def email_check(user):
    return user.email.endswith('@example.com')

@user_passes_test(email_check)
def my_view(request):
    ...

user_passes_test() 接受一个必要的参数：一个带有:class:~django.contrib.auth.models.User 对象的调用，如果允许用户访问这个页面，则返回 True 。注意，user_passes_test() 不会自动检查用户是否匿名。

user_passes_test() 可以传递两个可选参数：

login_url

允许你指定用户没有通过测试时跳转的地址。它可能是一个登录页面，如果你没指定，默认是 settings.LOGIN_URL 。

redirect_field_name

与 login_required() 相同。如果你想把没通过检查的用户重定向到没有 "next page" 的非登录页面时，把它设置为 None ，这样它会在 URL 中移除。

例如:

Code

@user_passes_test(email_check, login_url='/login/')
def my_view(request):
    ...

class UserPassesTestMixinLink to this definition#

使用基于类的视图时，可以使用 UserPassesTestMixin 执行此操作。

test_func()Link to this definition#

你必须覆盖类方法 test_func() 以提供执行的测试。此外，还可以设置 AccessMixin 的任何参数来自定义处理未授权用户：

Code

from django.contrib.auth.mixins import UserPassesTestMixin

class MyView(UserPassesTestMixin, View):

    def test_func(self):
        return self.request.user.email.endswith('@example.com')

get_test_func()Link to this definition#

你也可以覆盖 get_test_func() 方法，以使 mixin 对其检查使用不同名称的函数（而不是 test_func() ）。

permission_required 装饰器Link to this heading#

permission_required(perm, login_url=None, raise_exception=False)Link to this definition#

It's a relatively common task to check whether a user has a particular permission. For that reason, Django provides a shortcut for that case: the permission_required() decorator.:

Code

from django.contrib.auth.decorators import permission_required

@permission_required('polls.can_vote')
def my_view(request):
    ...

Just like the has_perm() method, permission names take the form "<app label>.<permission codename>" (i.e. polls.can_vote for a permission on a model in the polls application).

The decorator may also take an iterable of permissions, in which case the user must have all of the permissions in order to access the view.

Note that permission_required() also takes an optional login_url parameter:

Code

from django.contrib.auth.decorators import permission_required

@permission_required('polls.can_vote', login_url='/loginpage/')
def my_view(request):
    ...

As in the login_required() decorator, login_url defaults to settings.LOGIN_URL.

If the raise_exception parameter is given, the decorator will raise PermissionDenied, prompting the 403 (HTTP Forbidden) view instead of redirecting to the login page.

If you want to use raise_exception but also give your users a chance to login first, you can add the login_required() decorator:

Code

from django.contrib.auth.decorators import login_required, permission_required

@login_required
@permission_required('polls.can_vote', raise_exception=True)
def my_view(request):
    ...

This also avoids a redirect loop when LoginView's redirect_authenticated_user=True and the logged-in user doesn't have all of the required permissions.

The PermissionRequiredMixin mixinLink to this heading#

To apply permission checks to class-based views, you can use the PermissionRequiredMixin:

class PermissionRequiredMixinLink to this definition#

This mixin, just like the permission_required decorator, checks whether the user accessing a view has all given permissions. You should specify the permission (or an iterable of permissions) using the permission_required parameter:

Code

from django.contrib.auth.mixins import PermissionRequiredMixin

class MyView(PermissionRequiredMixin, View):
    permission_required = 'polls.can_vote'
    # Or multiple of permissions:
    permission_required = ('polls.can_open', 'polls.can_edit')

You can set any of the parameters of AccessMixin to customize the handling of unauthorized users.

你可能同样需要重写这些方法：

get_permission_required()Link to this definition#

Returns an iterable of permission names used by the mixin. Defaults to the permission_required attribute, converted to a tuple if necessary.

has_permission()Link to this definition#

Returns a boolean denoting whether the current user has permission to execute the decorated view. By default, this returns the result of calling has_perms() with the list of permissions returned by get_permission_required().

Session invalidation on password changeLink to this heading#

If your AUTH_USER_MODEL inherits from AbstractBaseUser or implements its own get_session_auth_hash() method, authenticated sessions will include the hash returned by this function. In the AbstractBaseUser case, this is an HMAC of the password field. Django verifies that the hash in the session for each request matches the one that's computed during the request. This allows a user to log out all of their sessions by changing their password.

The default password change views included with Django, PasswordChangeView and the user_change_password view in the django.contrib.auth admin, update the session with the new password hash so that a user changing their own password won't log themselves out. If you have a custom password change view and wish to have similar behavior, use the update_session_auth_hash() function.

update_session_auth_hash(request, user)Link to this definition#

This function takes the current request and the updated user object from which the new session hash will be derived and updates the session hash appropriately. It also rotates the session key so that a stolen session cookie will be invalidated.

Example usage:

Code

from django.contrib.auth import update_session_auth_hash

def password_change(request):
    if request.method == 'POST':
        form = PasswordChangeForm(user=request.user, data=request.POST)
        if form.is_valid():
            form.save()
            update_session_auth_hash(request, form.user)
    else:
        ...

Using the viewsLink to this heading#

There are different methods to implement these views in your project. The easiest way is to include the provided URLconf in django.contrib.auth.urls in your own URLconf, for example:

urlpatterns = [
    path('accounts/', include('django.contrib.auth.urls')),
]

This will include the following URL patterns:

accounts/login/ [name='login']
accounts/logout/ [name='logout']
accounts/password_change/ [name='password_change']
accounts/password_change/done/ [name='password_change_done']
accounts/password_reset/ [name='password_reset']
accounts/password_reset/done/ [name='password_reset_done']
accounts/reset/<uidb64>/<token>/ [name='password_reset_confirm']
accounts/reset/done/ [name='password_reset_complete']

The views provide a URL name for easier reference. See the URL documentation for details on using named URL patterns.

If you want more control over your URLs, you can reference a specific view in your URLconf:

from django.contrib.auth import views as auth_views

urlpatterns = [
    path('change-password/', auth_views.PasswordChangeView.as_view()),
]

The views have optional arguments you can use to alter the behavior of the view. For example, if you want to change the template name a view uses, you can provide the template_name argument. A way to do this is to provide keyword arguments in the URLconf, these will be passed on to the view. For example:

urlpatterns = [
    path(
        'change-password/',
        auth_views.PasswordChangeView.as_view(template_name='change-password.html'),
    ),
]

All views are class-based, which allows you to easily customize them by subclassing.

All authentication viewsLink to this heading#

This is a list with all the views django.contrib.auth provides. For implementation details see Using the views.

class LoginViewLink to this definition#

URL name: login

See the URL documentation for details on using named URL patterns.

Attributes:

• template_name: The name of a template to display for the view used to log the user in. Defaults to registration/login.html.

• redirect_field_name: The name of a GET field containing the URL to redirect to after login. Defaults to next.

• authentication_form: A callable (typically just a form class) to use for authentication. Defaults to AuthenticationForm.

• extra_context: A dictionary of context data that will be added to the default context data passed to the template.

• redirect_authenticated_user: A boolean that controls whether or not authenticated users accessing the login page will be redirected as if they had just successfully logged in. Defaults to False.

• success_url_allowed_hosts: A set of hosts, in addition to request.get_host(), that are safe for redirecting after login. Defaults to an empty set.

Here's what LoginView does:

• If called via GET, it displays a login form that POSTs to the same URL. More on this in a bit.

• If called via POST with user submitted credentials, it tries to log the user in. If login is successful, the view redirects to the URL specified in next. If next isn't provided, it redirects to settings.LOGIN_REDIRECT_URL (which defaults to /accounts/profile/). If login isn't successful, it redisplays the login form.

It's your responsibility to provide the html for the login template , called registration/login.html by default. This template gets passed four template context variables:

• form: A Form object representing the AuthenticationForm.

• next: The URL to redirect to after successful login. This may contain a query string, too.

• site: The current Site, according to the SITE_ID setting. If you don't have the site framework installed, this will be set to an instance of RequestSite, which derives the site name and domain from the current HttpRequest.

• site_name: An alias for site.name. If you don't have the site framework installed, this will be set to the value of request.META['SERVER_NAME']. For more on sites, see The "sites" framework.

If you'd prefer not to call the template registration/login.html, you can pass the template_name parameter via the extra arguments to the as_view method in your URLconf. For example, this URLconf line would use myapp/login.html instead:

Code

path('accounts/login/', auth_views.LoginView.as_view(template_name='myapp/login.html')),

You can also specify the name of the GET field which contains the URL to redirect to after login using redirect_field_name. By default, the field is called next.

Here's a sample registration/login.html template you can use as a starting point. It assumes you have a base.html template that defines a content block:

Django template

{% extends "base.html" %}

{% block content %}

{% if form.errors %}
<p>Your username and password didn't match. Please try again.</p>
{% endif %}

{% if next %}
    {% if user.is_authenticated %}
    <p>Your account doesn't have access to this page. To proceed,
    please login with an account that has access.</p>
    {% else %}
    <p>Please login to see this page.</p>
    {% endif %}
{% endif %}

<form method="post" action="{% url 'login' %}">
{% csrf_token %}
<table>
<tr>
    <td>{{ form.username.label_tag }}</td>
    <td>{{ form.username }}</td>
</tr>
<tr>
    <td>{{ form.password.label_tag }}</td>
    <td>{{ form.password }}</td>
</tr>
</table>

<input type="submit" value="login">
<input type="hidden" name="next" value="{{ next }}">
</form>

{# Assumes you setup the password_reset view in your URLconf #}
<p><a href="{% url 'password_reset' %}">Lost password?</a></p>

{% endblock %}

If you have customized authentication (see Customizing Authentication) you can use a custom authentication form by setting the authentication_form attribute. This form must accept a request keyword argument in its __init__() method and provide a get_user() method which returns the authenticated user object (this method is only ever called after successful form validation).

class LogoutViewLink to this definition#

Logs a user out.

URL name: logout

Attributes:

• next_page: The URL to redirect to after logout. Defaults to settings.LOGOUT_REDIRECT_URL.

• template_name: The full name of a template to display after logging the user out. Defaults to registration/logged_out.html.

• redirect_field_name: The name of a GET field containing the URL to redirect to after log out. Defaults to next. Overrides the next_page URL if the given GET parameter is passed.

• extra_context: A dictionary of context data that will be added to the default context data passed to the template.

• success_url_allowed_hosts: A set of hosts, in addition to request.get_host(), that are safe for redirecting after logout. Defaults to an empty set.

Template context:

• title: The string "Logged out", localized.

• site: The current Site, according to the SITE_ID setting. If you don't have the site framework installed, this will be set to an instance of RequestSite, which derives the site name and domain from the current HttpRequest.

• site_name: An alias for site.name. If you don't have the site framework installed, this will be set to the value of request.META['SERVER_NAME']. For more on sites, see The "sites" framework.

logout_then_login(request, login_url=None)Link to this definition#

Logs a user out, then redirects to the login page.

URL name: No default URL provided

Optional arguments:

• login_url: The URL of the login page to redirect to. Defaults to settings.LOGIN_URL if not supplied.

class PasswordChangeViewLink to this definition#

URL name: password_change

Allows a user to change their password.

Attributes:

• template_name: The full name of a template to use for displaying the password change form. Defaults to registration/password_change_form.html if not supplied.

• success_url: The URL to redirect to after a successful password change.

• form_class: A custom "change password" form which must accept a user keyword argument. The form is responsible for actually changing the user's password. Defaults to PasswordChangeForm.

• extra_context: A dictionary of context data that will be added to the default context data passed to the template.

Template context:

• form: The password change form (see form_class above).

class PasswordChangeDoneViewLink to this definition#

URL name: password_change_done

The page shown after a user has changed their password.

Attributes:

• template_name: The full name of a template to use. Defaults to registration/password_change_done.html if not supplied.

• extra_context: A dictionary of context data that will be added to the default context data passed to the template.

class PasswordResetViewLink to this definition#

URL name: password_reset

Allows a user to reset their password by generating a one-time use link that can be used to reset the password, and sending that link to the user's registered email address.

If the email address provided does not exist in the system, this view won't send an email, but the user won't receive any error message either. This prevents information leaking to potential attackers. If you want to provide an error message in this case, you can subclass PasswordResetForm and use the form_class attribute.

Users flagged with an unusable password (see set_unusable_password() aren't allowed to request a password reset to prevent misuse when using an external authentication source like LDAP. Note that they won't receive any error message since this would expose their account's existence but no mail will be sent either.

Attributes:

• template_name: The full name of a template to use for displaying the password reset form. Defaults to registration/password_reset_form.html if not supplied.

• form_class: Form that will be used to get the email of the user to reset the password for. Defaults to PasswordResetForm.

• email_template_name: The full name of a template to use for generating the email with the reset password link. Defaults to registration/password_reset_email.html if not supplied.

• subject_template_name: The full name of a template to use for the subject of the email with the reset password link. Defaults to registration/password_reset_subject.txt if not supplied.

• token_generator: Instance of the class to check the one time link. This will default to default_token_generator, it's an instance of django.contrib.auth.tokens.PasswordResetTokenGenerator.

• success_url: The URL to redirect to after a successful password reset request.

• from_email: A valid email address. By default Django uses the DEFAULT_FROM_EMAIL.

• extra_context: A dictionary of context data that will be added to the default context data passed to the template.

• html_email_template_name: The full name of a template to use for generating a text/html multipart email with the password reset link. By default, HTML email is not sent.

• extra_email_context: A dictionary of context data that will be available in the email template.

Template context:

• form: The form (see form_class above) for resetting the user's password.

Email template context:

• email: An alias for user.email

• user: The current User, according to the email form field. Only active users are able to reset their passwords (User.is_active is True).

• site_name: An alias for site.name. If you don't have the site framework installed, this will be set to the value of request.META['SERVER_NAME']. For more on sites, see The "sites" framework.

• domain: An alias for site.domain. If you don't have the site framework installed, this will be set to the value of request.get_host().

• protocol: http or https

• uid: The user's primary key encoded in base 64.

• token: Token to check that the reset link is valid.

Sample registration/password_reset_email.html (email body template):

Django template

Someone asked for password reset for email {{ email }}. Follow the link below:
{{ protocol}}://{{ domain }}{% url 'password_reset_confirm' uidb64=uid token=token %}

The same template context is used for subject template. Subject must be single line plain text string.

class PasswordResetDoneViewLink to this definition#

URL name: password_reset_done

The page shown after a user has been emailed a link to reset their password. This view is called by default if the PasswordResetView doesn't have an explicit success_url URL set.

Attributes:

• template_name: The full name of a template to use. Defaults to registration/password_reset_done.html if not supplied.

• extra_context: A dictionary of context data that will be added to the default context data passed to the template.

class PasswordResetConfirmViewLink to this definition#

URL name: password_reset_confirm

Presents a form for entering a new password.

Keyword arguments from the URL:

• uidb64: The user's id encoded in base 64.

• token: Token to check that the password is valid.

Attributes:

• template_name: The full name of a template to display the confirm password view. Default value is registration/password_reset_confirm.html.

• token_generator: Instance of the class to check the password. This will default to default_token_generator, it's an instance of django.contrib.auth.tokens.PasswordResetTokenGenerator.

• post_reset_login: A boolean indicating if the user should be automatically authenticated after a successful password reset. Defaults to False.

• post_reset_login_backend: A dotted path to the authentication backend to use when authenticating a user if post_reset_login is True. Required only if you have multiple AUTHENTICATION_BACKENDS configured. Defaults to None.

• form_class: Form that will be used to set the password. Defaults to SetPasswordForm.

• success_url: URL to redirect after the password reset done. Defaults to 'password_reset_complete'.

• extra_context: A dictionary of context data that will be added to the default context data passed to the template.

Template context:

• form: The form (see form_class above) for setting the new user's password.

• validlink: Boolean, True if the link (combination of uidb64 and token) is valid or unused yet.

class PasswordResetCompleteViewLink to this definition#

URL name: password_reset_complete

Presents a view which informs the user that the password has been successfully changed.

Attributes:

• template_name: The full name of a template to display the view. Defaults to registration/password_reset_complete.html.

• extra_context: A dictionary of context data that will be added to the default context data passed to the template.

UsersLink to this heading#

When rendering a template RequestContext, the currently logged-in user, either a User instance or an AnonymousUser instance, is stored in the template variable {{ user }}:

{% if user.is_authenticated %}
    <p>Welcome, {{ user.username }}. Thanks for logging in.</p>
{% else %}
    <p>Welcome, new user. Please log in.</p>
{% endif %}

This template context variable is not available if a RequestContext is not being used.

权限Link to this heading#

The currently logged-in user's permissions are stored in the template variable {{ perms }}. This is an instance of django.contrib.auth.context_processors.PermWrapper, which is a template-friendly proxy of permissions.

Evaluating a single-attribute lookup of {{ perms }} as a boolean is a proxy to User.has_module_perms(). For example, to check if the logged-in user has any permissions in the foo app:

{% if perms.foo %}

Evaluating a two-level-attribute lookup as a boolean is a proxy to User.has_perm(). For example, to check if the logged-in user has the permission foo.can_vote:

{% if perms.foo.can_vote %}

以下是一个在模板中检查权限的更完整的示例：

{% if perms.foo %}
    <p>You have permission to do something in the foo app.</p>
    {% if perms.foo.can_vote %}
        <p>You can vote!</p>
    {% endif %}
    {% if perms.foo.can_drive %}
        <p>You can drive!</p>
    {% endif %}
{% else %}
    <p>You don't have permission to do anything in the foo app.</p>
{% endif %}

It is possible to also look permissions up by {% if in %} statements. For example:

{% if 'foo' in perms %}
    {% if 'foo.can_vote' in perms %}
        <p>In lookup works, too.</p>
    {% endif %}
{% endif %}