＜学习笔记＞从零开始自学Python-之-web应用框架Django（ 十一）用户系统和身份验证

用户系统是现代网站的重要组成部分，对用户进行分组权限管理是非常必要的。

Django内置了一套用户和身份验证系统，不用太多代码开发就可以使用这个系统。

Django 的身份验证系统包括：

• 用户

• 权限：二元（是或否）旗标，指明用户是否能执行特定的任务

• 分组：把标注和权限赋予多个用户的通用方式

• 可配置的密码哈希系统

• 管理身份验证和权限核准的表单

• 登录用户或限制内容的视图工具

• 可更换的后端系统

Django 的身份验证系统十分通用，没有提供 Web 身份验证系统中某些常用的功能。

某些常用功能通过第三 方包实现：

• 密码强度检查

• 登录尝试次数限制

• 通过第三方验证身份（如 OAuth）

1、User对象

User 对象是这个身份验证系统的核心，通常用于标识与网站交互的人，还用于限制访问、记录用户资料，以 及把内容与创建人关联起来，等等。

在 Django 的身份验证框架中，只有一个用户类存在，因此 superusers 或管理后台的 staff 用户只是设定了特殊属性的用户对象，而不是分属不同类的用户对象。

默认用户主要有 下面几个属性：

• username

• password

• email

• first_name

• last_name

1.1 创建超级用户

超级用户使用 createsuperuser 命令创建：

python manage.py createsuperuser --username=teacherWang --email=wangchongyang@126.com

上述命令会提示你输入密码。输入密码后，立即创建指定的超级用户。

如果没有指定 --username 或 --email 选项，会提示你输入这两个值。

Email address: wangchongyang@126.com
Password: 
Password (again):
This password is too short. It must contain at least 8 characters.
This password is too common.
Bypass password validation and create user anyway? [y/N]: n
Password: 
Password (again):
This password is too common.
Bypass password validation and create user anyway? [y/N]: y
Superuser created successfully.

最终看到 Superuser created successfully说明创建成功了。

1.2 创建用户

创建和管理用户最简单、最不易出错的方式是使用 Django 管理后台。

管理后台的使用我们在第七章（(1条消息) ＜学习笔记＞从零开始自学Python-之-web应用框架Django（ 七）Django管理后台_阿尔法羊的博客-CSDN博客）详细讲过了

当然也可以用Django内置的辅助函数create_user()来实现同样的功能

from django.contrib.auth.models import User 
user = User.objects.create_user('teacherWang', 'wangchongyang@126.com', 'password') 
# 此时，user 是一个 User 对象，而且已经保存到数据库中 
# 如果想修改其他字段的值，可以继续修改属性 
user.last_name = 'wang' 
user.save()

1.3 在 Web 请求中验证身份

Django 使用会话和中间件把身份验证系统插入 request 对象，为每个请求提供 request.user 属性，表示当前用户。如果未登陆，这个属性的值是一个 AnonymousUser 实例，否则是是一个 User 实例。

这两种情况可以使 用 is_authenticated() 方法区分，例如：

if request.user.is_authenticated(): 
    # 处理通过身份验证的用户 
 
else: 
    # 处理匿名用户

2、在视图中操作身份验证

2.1 登录与退出

2.1.1 在视图中使用 login() 登录用户。

它的参数是一个 HttpRequest 对象和一个 User 对象。login() 使用 Django 的会话框架把用户的 ID 保存到会话中。注意，匿名期间设定的会话数据在用户登录后依然存在。

下述示例 展示 authenticate() 和 login() 的用法：

from django.contrib.auth import authenticate, login 
def my_view(request): 
    username = request.POST['username'] 
    password = request.POST['password']
    user = authenticate(username=username, password=password) 
    if user is not None: 
        if user.is_active: 
            login(request, user) 
            # 重定向到成功登录页面 
        else: 
            # 返回“账户未激活”错误消息 
    else: 
        # 返回“无效登录”错误消息

注意：自己动手登录用户时，必须在 login() 之前调用 authenticate()。authenticate() 在 User 对象 上设定一个属性，指明成功验证用户身份的是哪个身份验证后端，而登录过程中需要使用这个信息。如果直接登录从数据库中检索的用户对象，Django 会报错。

2.1.2 在视图中使用logout()退出

在视图中退出通过 login() 登录的用户使用 logout()。这个函数的参数是一个 HttpRequest 对象，而且没有返回值。

例如：

from django.contrib.auth import logout 
def logout_view(request): 
    logout(request) 
    # 重定向到成功退出页面 

注意，如果用户未登录，logout() 函数不报错。调用 logout() 函数后，当前请求的会话数据完全清除，所有 数据将被删除。这样能避免其他人在登录的 Web 浏览器中访问用户之前的会话数据。 如果想让会话中的数据在退出后依然可用，调用 logout() 函数之后再把数据存入会话。

2.2 限制已登录用户的访问

2.2.1 直接方式

限制访问页面简单直接的方式是检查 request.user.is_authenticated()，如果未通过，可以重定向到登录页面：

from django.shortcuts import redirect 
def my_view(request): 
    if not request.user.is_authenticated(): 
        return redirect('/login/?next=%s' % request.path) 
        
# ... 也可以显示一个错误消息： 
from django.shortcuts import render 
def my_view(request): 
    if not request.user.is_authenticated():
        return render(request, 'books/login_error.html') 

2.2.2 装饰器

也可以使用便利的 login_required() 装饰器：

from django.contrib.auth.decorators import login_required 
 
@login_required 
def my_view(request): 
    ...

login_required() 的作用如下：

• 如果用户未登录，重定向到 LOGIN_URL，并把当前绝对路径添加到查询字符串中。

例如：/accounts/ login/?next=/reviews/3/。

• 如果用户已登录，正常执行视图。视图代码可以放心假定用户已登录。

默认，成功通过身份验证后重定向的目标路径存储在名为 next 的查询字符串参数中。如果想为这个参数提供 其他名称，可以设定 login_required() 可选的 redirect_field_name 参数：

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 参 数。例如：

from django.contrib.auth.decorators import login_required
 
@login_required(login_url='/accounts/login/') 
def my_view(request): 
    ...

注意，如果不指定 login_url 参数，要确保把 LOGIN_URL 设为正确的登录视图。例如，使用默认配置时，要 把下述代码添加到 URL 配置中：

from django.contrib.auth import views as auth_views 
 
url(r'^accounts/login/$', auth_views.login),

LOGIN_URL 的值还可以是视图函数名称或具名 URL 模式。这样，无需修改设置就可以在 URL 配置中自由映射登录视图。

2.3 permission_required 装饰器

检查用户有没有特定权限是比较常见的任务。鉴于此，Django 提供了一种简便的方式——permission_required() 装饰器：

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

与 has_perm() 方法一样，参数名称的形式为“.”（例如，reviews.can_vote 是 reviews 应用中某个模型定义的权限）。这个装饰器的参数也可以是一个权限列表。注意，permission_required() 也有可选的 login_url 参数。例如：

from django.contrib.auth.decorators import permission_required @permission_required('reviews.can_vote', login_url='/loginpage/') 
def my_view(request):
    ...

与 login_required() 装饰器一样，login_url 的默认值是 LOGIN_URL。如果指定了 raise_exception 参数，这 个装饰器不会重定向到登录页面，而是抛出 PermissionDenied 异常，显示 403（HTTP Forbidden）视图。

2.4、身份验证视图

Django 为登录、退出和密码管理提供了视图。这些视图使用 auth 包中内置的表单，不过也可以传入自己编写的视图。Django 没有为身份验证视图提供默认的模板，不过下文将说明各个视图的模板上下文。

在项目中使用这些视图要实现不同的方法，不过最简单也是最常见的做法是把 django.contrib.auth.urls 提 供的 URL 配置添加到项目的 URL 配置中。例如：

urlpatterns = [url('^', include('django.contrib.auth.urls'))]

这样，各个视图在默认的 URL 上（后文详述）。 这些内置的视图都返回一个 TemplateResponse 实例，这样便于在渲染之前定制响应数据。多数内置的身份验 证视图提供了 URL 名称，易于引用。

2.4.1 login 视图

登录用户。

默认 URL：/login/。

可选参数：

• template_name：这个视图使用的模板名称。默认为 registration/login.html。

• redirect_field_name：GET 参数中指定登录后重定向 URL 的字段名称。默认为 next。

• authentication_form：验证身份的可调用对象（通常是一个表单类）。默认为 AuthenticationForm。

• current_app：一个提示，指明当前视图所在的应用。

• extra_context：一个字典，包含额外的上下文数据，随默认的上下文数据一起传给模板。 login 视图的作用如下：

• 如果通过 GET 调用，显示登录表单，其目标地址与当前 URL 一样。稍后详述。

• 如果通过 POST 调用，发送用户提交的凭据，尝试登录用户。如果登录成功，重定向到 next 指定的 URL。如果没有 next，重定向到 LOGIN_REDIRECT_URL（默认为 /accounts/profile/）。如果登录失败，重新显示登录表单。 登录视图的模板由你提供，模板文件默认名为 registration/login.html。

模板上下文：

• form：表示 AuthenticationForm 的 Form 对象。

• next：成功登录后重定向的目标 URL。自身可能也包含查询字符串。

• site：当前 Site，根据 SITE_ID 设置确定。如果未安装网站框架，其值默认为 RequestSite 实例，从 当前 HttpRequest 对象中获取网站名称和域名。

• site_name：site.name 的别名。如果未安装网站框架，其值为 request.META['SERVER_NAME'] 的值。 如果不想把模板命名为 registration/login.html，可以为 URL 配置提供额外的参数，设定 template_name 参数。

2.4.2 logout 视图

退出用户。

默认 URL：/logout/

可选的参数：

• next_page：退出后重定向的目标 URL。

• template_name：一个模板全名，在用户退出后显示。如果未提供这个参数，默认为 registration/ logged_out.html。

• redirect_field_name：GET 参数中指定退出后重定向 URL 的字段名称。默认为 next。如果提供这个参数，next_page 将被覆盖。

• current_app：一个提示，指明当前视图所在的应用。

• extra_context：一个字典，包含额外的上下文数据，随默认的上下文数据一起传给模板。

模板上下文：

• title：本地化之后的字符串“Logged out”。

• site：当前 Site，根据 SITE_ID 设置确定。如果未安装网站框架，其值默认为 RequestSite 实例，从 当前 HttpRequest 对象中获取网站名称和域名。

• site_name：site.name 的别名。如果未安装网站框架，其值为 request.META['SERVER_NAME'] 的值。

2.4.3 logout_then_login 视图

退出用户，然后重定向到登录页面。

默认 URL：未提供。

可选的参数：

• login_url：重定向到的登录页面的 URL。如果未提供，默认为 LOGIN_URL。

• current_app：一个提示，指明当前视图所在的应用。

• extra_context：一个字典，包含额外的上下文数据，随默认的上下文数据一起传给模板。

2.5 内置的表单

如果不想使用内置的视图，也不想为这些功能编写表单，可以使用身份验证系统在 django.contrib.auth.forms 中内置的几个表单（表 11-1）。 这些内置的表单对用户模型有些假设，如果自定义了用户模型，可能要自己动手为身份验证系统编写表单。

2.6 模板中的身份验证数据

使用 RequestContext 时，当前登录用户及其权限可通过模板上下文访问。

2.6.1 用户

渲染模板的 RequestContext 时，当前登录用户，不管是 User 实例还是 AnonymousUser 实例，都存储在模板变 量 {{ user }} 中：
 

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

如果使用的不是 RequestContext，这个模板上下文变量不可用。

2.6.2 权限

当前登录用户的权限存储在模板变量 {{ perms }} 中。它的值是 django.contrib.auth.context_processors.PermWrapper 的一个实例，对模板友好。在 {{ perms }} 对象中，单属性查找由 User.has_module_perms 代理。只要当前登录用户在 foo 应用中有权限，下述示例就返回 True：

{{ perms.foo }}

两层属性查找由 User.has_perm 代理。如果当前登录用户有 foo.can_vote 权限，下述示例返回 True：

{{ perms.foo.can_vote }}

因此，在模板中可以使用 {% if %} 语句检查权限：

{% 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 %}

此外，还可以使用 {% if in %} 语句检查权限。

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

3、案例：自己动手做一个网站用户系统

基于我们前面已经做好的网站，我们现在做一个简单的用户登录和注册系统，然后设置权限

3.1 登录系统

先写一个简单的登录页面login.html

html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登录title>
head>
<body>
<div class="container" style="margin-top: 100px">
    <div class="row">
        <div>
            <div>
                <div>
                    <h3>登录h3>
                div>
                <div>
                    <form action="" method="post" novalidate>
                        {% csrf_token %}
 
{#                        方法一： 写出form表单中的指定字段 #}
{#                        {{ login_form.username.label_tag }}:#}
{#                        {{ login_form.username }}#}
{#                        <p>{{ login_form.errors.username.0 }}p>#}
{#                        {{ login_form.password.label_tag }}:#}
{#                        {{ login_form.password }}#}
{#                        <p>{{ login_form.errors.password.0 }}p>#}
{#                        <div>{{ login_form.non_field_errors }}div>#}
 
{#                        方法二： 遍历出form表单中的所有字段 #}
                        {% for field in login_form %}
                            {{ field.label_tag }}
                            {{ field }}
                            <p>{{ field.errors.as_text }}p>
                        {% endfor %}
{#                        此处错误信息会返回clean联合校验，也就是非单个字段校验的错误信息#}
                        <span>{{ login_form.non_field_errors }}span>
 
                        <input type="submit" value="登录" class="btn">
                    form>
                div>
            div>
        div>
    div>
div>
<br>
<div>
    <a href="/register">注册a>
div>
body>
html>

然后我们在forms.py里面创建一个LoginForm类，用于接收前端表单输入的数据，并实现验证

from django import forms
from django.contrib.auth import authenticate
from django.contrib.auth.models import User
 
 
class LoginForm(forms.Form):
    username = forms.CharField(
        label="用户名",
        min_length=3,
        widget=forms.TextInput(attrs={"class": "form-control", "placeholder": "请输入用户名"}),
        error_messages={
            "required": "用户名不能为空",
            "min_length": "用户名最小长度为3位",
        },
    )
    password = forms.CharField(
        label="密码",
        min_length=6,
        error_messages={
            "min_length": "密码最小长度为6位",
            "required": "密码不能为空",
        },
        widget=forms.PasswordInput(attrs={"class": "form-control", "placeholder": "请输入密码"}),
    )
 
    def clean(self):
        username = self.cleaned_data.get("username", "")
        password = self.cleaned_data.get("password", "")
        user = authenticate(username=username, password=password)
        if not user:
            raise forms.ValidationError("用户名或密码错误")
 
        self.cleaned_data["user"] = user
        return self.cleaned_data

然后在views.py 里面写好一个登录的函数

def user_login(request):
    if request.method == "GET":
        username = request.GET.get("username")
        login_form = LoginForm()
        return render(request, "login.html", context={"login_form": login_form})
    elif request.method == "POST":
        login_form = LoginForm(request.POST)
        if login_form.is_valid():
            # 注意：验证用户名和密码是否正确放到forms中去验证了
            # login(request, request.user)  # 此处不能使用request.user,因为他还没有验证，是匿名用户
            # 所以需要在form中校验通过后传递过来user
            login(request, login_form.cleaned_data["user"])
            user = request.POST["username"]
            next = request.GET.get("next", reverse("index"))
            return redirect(next,{'user':user})
        else:
            return render(request, "login.html", {"login_form": login_form})

如果从form类返回的验证正确，就跳转到指定网页，这里指定到 index 页面，注意这里这个 index 是 路由的名字(name，就是设置path时候指定的name)。

最后在urls.py 里面加上路由

path('login/',user_login,name="login"),

我们访问http://127.0.0.1:8000/login

 因为没有加上css，界面看上去比较朴素，但是已经可以使用了

3.2 注册系统

当然这时候我们只有一个前面创建的超级用户，要想让普通用户注册使用，还要做一个注册系统

一样，先写好前端的表单页面 register.html

html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>注册title>
head>
<body>
<div class="container" style="margin-top: 100px">
    <div class="row">
        <div>
            <div>
                <div>
                    <h3>注册h3>
                div>
                <div>
                    <form action="" method="post" novalidate>
 
                        {% csrf_token %}
                        {% for field in register_form %}
                            {{ field.label_tag }}
                            {{ field }}
                            <p>{{ field.errors.as_text }}p>
                        {% endfor %}
                        <span>{{ register_form.non_field_errors }}span>
                        <input type="submit" value="注册">
 
                    form>
                div>
            div>
        div>
    div>
div>
body>
html>

在forms.py里面写一个注册用的 RegisterForm类

class RegisterForm(LoginForm):
    password_again = forms.CharField(
        label="确认密码",
        min_length=6,
        error_messages={
            "required": "确认密码不能为空",
            "min_length": "密码最小长度为6位",
        },
        widget=forms.PasswordInput(attrs={"class": "form-control", "placeholder": "确认密码"}),
    )
    email = forms.EmailField(
        label="邮箱",
        required=False,
        error_messages={
            "required": "密码不能为空",
        },
        widget=forms.EmailInput(attrs={"class": "form-control", "placeholder": "请输入邮箱"})
    )
 
    def clean_username(self):
        username = self.cleaned_data["username"]
        if User.objects.filter(username=username).exists():
            raise forms.ValidationError("用户名已存在")
        return username
 
    def clean_email(self):
        email = self.cleaned_data["email"]
        if email and User.objects.filter(email=email).exists():
            raise forms.ValidationError("邮箱已存在")
 
        return email
 
    def clean(self):
        password = self.cleaned_data.get("password", "")
        password_again = self.cleaned_data.get("password_again", "")
 
        if password != password_again:
            raise forms.ValidationError("两次密码不一致，请重新输入")
 
        return self.cleaned_data

再在views.py里面 写好视图函数

def user_register(request):
    if request.method == "GET":
        register_form = RegisterForm()
        return render(request, "register.html", context={"register_form": register_form})
    elif request.method == "POST":
        register_form = RegisterForm(request.POST)
        if register_form.is_valid():
            username = register_form.cleaned_data["username"]
            password = register_form.cleaned_data["password"]
            email = register_form.cleaned_data.get("email", "")
            # 创建用户
            user = User.objects.create_user(username, email, password)
            next = request.GET.get("next", reverse("index"))
            return redirect(next)
        else:
            return render(request, "register.html", {"register_form": register_form})

最后加上路由

path('register/',user_register,name="register"),

我们访问 http://127.0.0.1:8000/register

我们注册一个名为testone的用户，登录之后可以看到, 用户名正确显示出来了

 

3.3 退出登录

 这里我们前端加了一个退出登录的功能按钮

Django内置了一个logout 函数，实现logout功能非常容易

def user_logout(request):
 
    logout(request)
 
    return redirect("login")

3.4 设置权限

既然使用了用户系统，当然对用户访问就要做些限制，我们在主页视图函数前加上装饰器，并指定如果未登录时候的跳转页面（如果不指定，默认的跳转页面是('/accounts/login/'）

from django.contrib.auth.decorators import login_required
@login_required(login_url='/login/')
def classnotice(request):
    print(request.GET)
    now=datetime.datetime.now()
    context={}
    context['student_list']=Student.objects.all().order_by('-score')
    context['teacher']='王重阳'
    context['now']=now
    
    return render(request,'class3.html',context=context,status=200)

再访问主页，就会跳转到登录页面

最后我们再来设置一下权限。比如之前我们做了一个add_student的表单，用于增加Student模型的实例。现在我们给这个功能加上权限，这样没有权限的用户就会退到登录界面

from django.contrib.auth.decorators import permission_required
@permission_required('classManage.add_student',login_url='/login/')
def add_student(request):
    if request.method == 'GET':
        student_list = addStudent()
        return render(request,'addStudent.html',{'students':student_list},status=200)
    else:
        student_list = addStudent(request.POST)
        if student_list.is_valid():
            student_list.save()
        return render(request,'addStudent.html',{'student_list':student_list},status=200)

这时候，我们用teacherWang账户登录可以访问 ‘/add_student/’，但是用testone账户访问'/add_student'就会跳转到登录界面。

我们用程序给testone账户赋予权限

from classManage.models import Student
from django.contrib.auth.models import Group, Permission
from django.contrib.contenttypes.models import ContentType
 
user = User.objects.get(username='testone')
permission = Permission.objects.get(codename='add_student')
user.user_permissions.add(permission)

然后再用testone账户登录，再访问http://127.0.0.1:8000/add_student

发现可以访问了