Django web编程3 -- 创建用户账户

我们将建立一个用户注册和身份验证系统，让用户能够注册账户，进而登录和注销。我们将创建一个新的应用程序，其中包含与处理用户账户相关的所有功能。我们还将对模型Topic 稍做修改，让每个主题都归属于特定用户。

1、应用程序users

我们首先使用命令startapp 来创建一个名为users 的应用程序:

(ll_env)learning_log$ python manage.py startapp users
(ll_env)learning_log$ ls
db.sqlite3 learning_log learning_logs ll_env manage.py users
(ll_env)learning_log$ ls users
admin.py __init__.py migrations models.py tests.py views.py

这个命令新建一个名为users的目录，其结构与应用程序learning_logs 相同。

1.1 将应用程序users 添加到settings.py中

在settings.py中，我们需要将这个新的应用程序添加到INSTALLED_APPS 中，如下所示:

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
 
    # 我的应用程序
    'learning_logs',
    'users',
]

1.2 包含应用程序users 的URL

接下来，我们需要修改项目根目录中的urls.py，使其包含我们将为应用程序users 定义的URL:

from django.contrib import admin
from django.conf.urls import url, include
 
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'', include('learning_logs.urls',namespace='learning_logs')),
    url(r'^users/', include('users.urls', namespace='users')),
]

我们添加了一行代码，以包含应用程序users 中的文件urls.py。这行代码与任何以单词users打头的URL(如http://localhost:8000/users/login/)都匹配。我们还创建了命名空间'users' ，以便将应用程序learning_logs 的URL同应用程序users 的URL区分开来。

2、登陆页面

我们首先来实现登录页面的功能。为此，我们将使用Django提供的默认登录视图，因此URL模式会稍有不同。在目录learning_log/users/中，新建一个名为urls.py的文件，并在其中添加如下代码:

from django.conf.urls import url
from django.contrib.auth.views import LoginView
 
from . import views
app_name='users'
 
urlpatterns = [
    # 登录页面
    url(r'^login/$', LoginView.as_view(template_name='users/login.html'),
       name='login'),
 
]

我们首先导入了默认视图login 。登录页面的URL模式与URL http://localhost:8000/users/login/匹配。这个URL中的单词users让Django在users/urls.py中查找，而单词 login让它将请求发送给Django默认视图login (请注意，视图实参为login ，而不是views.login )。鉴于我们没有编写自己的视图函数，我们传递了一个字典，告诉Django 去哪里查找我们将编写的模板。这个模板包含在应用程序users 而不是learning_logs 中。

(1)模板login.html

用户请求登录页面时，Django将使用其默认视图login ，但我们依然需要为这个页面提供模板。为此，在目录learning_log/users/中，创建一个名为templates的目录，并在其中创建一个名为users的目录。以下是模板login.html，你应将其存储到目录learning_log/users/templates/users/中:

{% extends "learning_logs/base.html" %}
 
{% block content %}
 
{% if form.errors %}
  <p>Your username and password didn't match. Please try again.</p>
{% endif %}
 
  <form method="post" action="{% url 'users:login' %}">
  {% csrf_token %}
  {{ form.as_p }}
 
  <button name="submit">log in</button>
  <input type="hidden" name="next" value="{% url 'learning_logs:index' %}" />
  </form>
 
{% endblock content %}

这个模板继承了base.html，旨在确保登录页面的外观与网站的其他页面相同。请注意，一个应用程序中的模板可继承另一个应用程序中的模板。
如果表单的errors 属性被设置，我们就显示一条错误消息，指出输入的用户名—密码对与数据库中存储的任何用户名—密码对都不匹配。

我们要让登录视图处理表单，因此将实参action 设置为登录页面的URL。登录视图将一个表单发送给模板，在模板中，我们显示这个表单并添加一个提交按钮。我们包含了一个隐藏的表单元素——'next' ，其中的实参value 告诉Django在用户成功登录后将其重定向到什么地方——在这里是主页。

(2)链接到登陆页面

下面在learning_logs/templates/learning_logs/base.html中添加到登录页面的链接，让所有页面都包含它。用户已登录时，我们不想显示这个链接，因此将它嵌套在一个{% if %}标签中:

<p>
    <a href="{% url 'learning_logs:index' %}">Learning Log</a>
    <a href="{% url 'learning_logs:topics' %}">Topics</a>
    {% if user.is_authenticated %}
      Hello, {{ user.username }}.
    {% else %}
        <a href="{% url 'users:login' %}">log in</a>
    {% endif %}
</p>
 
{% block content %}{% endblock content %}

在Django身份验证系统中，每个模板都可使用变量user ，这个变量有一个is_authenticated 属性:如果用户已登录，该属性将为True ，否则为False 。这让你能够向已通过身份验证的用户显示一条消息，而向未通过身份验证的用户显示另一条消息。
在这里，我们向已登录的用户显示一条问候语。对于已通过身份验证的用户，还设置了属性username ，我们使用这个属性来个性化问候语，让用户知道他已登录。对于还未通过身份验证的用户，我们再显示一个到登录页面的链接。
（3）使用登陆页面

前面建立了一个用户账户，下面来登录一下，看看登录页面是否管用。请访问http://localhost:8000/admin/，如果你依然是以管理员的身份登录的，请在页眉上找到注销链接并单击
它。
注销后，访问http://localhost:8000/users/login/，你将看到类似于图19-4所示的登录页面。输入你在前面设置的用户名和密码，将进入页面index。。在这个主页的页眉中，显示了一条个性化问候语，其中包含你的用户名。

3、注销

现在需要提供一个让用户注销的途径。我们不创建用于注销的页面，而让用户只需单击一个链接就能注销并返回到主页。为此，我们将为注销链接定义一个URL模式，编写一个视图函数，并在base.html中添加一个注销链接。

（1）注销url

下面的代码为注销定义了URL模式，该模式与URL http://locallwst:8000/users/logout/匹配。修改后的users/urls.py如下:

from django.conf.urls import url
from django.contrib.auth.views import LoginView
 
from . import views
app_name='users'
 
urlpatterns = [
    # 登录页面
    url(r'^login/$', LoginView.as_view(template_name='users/login.html'),
       name='login'),
 
    # 注销
    url(r'^logout/$', views.logout_view, name='logout'),
]

这个URL模式将请求发送给函数logout_view() 。这样给这个函数命名，旨在将其与我们将在其中调用的函数logout() 区分开来。

2. 视图函数logout_view()

函数logout_view() 很简单:只是导入Django函数logout() ，并调用它，再重定向到主页。请打开users/views.py，并输入下面的代码:

from django.shortcuts import render
from django.http import HttpResponseRedirect
from django.urls import reverse
from django.contrib.auth import logout
 
def logout_view(request):
    """注销用户"""
    logout(request)
    return HttpResponseRedirect(reverse('learning_logs:index'))

我们从django.contrib.auth中导入了函数logout()。我们调用了函数logout() ，它要求将request 对象作为实参。然后，我们重定向到主页。

（3）链接到注销页面

现在我们需要添加一个注销链接。我们在learning_logs/templates/learning_logs/base.html 中添加这种链接，让每个页面都包含它;我们将它放在标签{% if user.is_authenticated %}中，使得仅当用户登录后才能看到它:

<p>
    <a href="{% url 'learning_logs:index' %}">Learning Log</a>
    <a href="{% url 'learning_logs:topics' %}">Topics</a>
    {% if user.is_authenticated %}
      Hello, {{ user.username }}.
      <a href="{% url 'users:logout' %}">log out</a>
    {% else %}
        <a href="{% url 'users:login' %}">log in</a>
    {% endif %}
</p>
 
{% block content %}{% endblock content %}

下图显示了用户登录后看到的主页。这里的重点是创建能够正确工作的网站，因此几乎没有设置任何样式。确定所需的功能都能正确运行后，我们将设置这个网站的样式，使其看起来更专业。

4、注册页面

下面来创建一个让新用户能够注册的页面。我们将使用Django提供的表单UserCreationForm，但编写自己的视图函数和模板。

（1）注册页面的URL模式

下面的代码定义了注册页面的URL模式，它也包含在users/urls.py中:

from django.conf.urls import url
from django.contrib.auth.views import LoginView
 
from . import views
app_name='users'
 
urlpatterns = [
    # 登录页面
    url(r'^login/$', LoginView.as_view(template_name='users/login.html'),
       name='login'),
 
    # 注销
    url(r'^logout/$', views.logout_view, name='logout'),
 
    # 注册页面
    url(r'^register/$', views.register, name='register'),
]

(2). 视图函数register()

在注册页面首次被请求时，视图函数register() 需要显示一个空的注册表单，并在用户提交填写好的注册表单时对其进行处理。如果注册成功，这个函数还需让用户自动登录。请在users/views.py中添加如下代码:

from django.shortcuts import render
from django.http import HttpResponseRedirect
from django.urls import reverse
from django.contrib.auth import login, logout, authenticate
from django.contrib.auth.forms import UserCreationForm
 
def logout_view(request):
    """注销用户"""
    logout(request)
    return HttpResponseRedirect(reverse('learning_logs:index'))
 
def register(request):
    """注册新用户"""
    if request.method != 'POST':
        # 显示空的注册表单
        form = UserCreationForm()
    else:
        # 处理填写好的表单
        form = UserCreationForm(data=request.POST)
 
        if form.is_valid():
            new_user = form.save()
            # 让用户自动登录，再重定向到主页
            authenticated_user = authenticate(username=new_user.username,
                password=request.POST['password1'])
            login(request, authenticated_user)
            return HttpResponseRedirect(reverse('learning_logs:index'))
 
    context = {'form': form}
    return render(request, 'users/register.html', context)

我们首先导入了函数render() ，然后导入了函数login() 和authenticate() ，以便在用户正确地填写了注册信息时让其自动登录。我们还导入了默认表单UserCreationForm 。
在函数register() 中，我们检查要响应的是否是POST请求。如果不是，就创建一个UserCreationForm 实例，且不给它提供任何初始数据。如果响应的是POST请求，我们就根据提交的数据创建一个UserCreationForm 实例，并检查这些数据是否有效:就这里而言，是用户名未包含非法字符，输入的两个密码相同，以及用户没有试图做恶意的事情。
如果提交的数据有效，我们就调用表单的方法save() ，将用户名和密码的散列值保存到数据库中。方法save() 返回新创建的用户对象，我们将其存储在new_user 中。
保存用户的信息后，我们让用户自动登录，这包含两个步骤。首先，我们调用authenticate() ，并将实参new_user.username 和密码传递给它。用户注册时，被要求输入密码两次;由于表单是有效的，我们知道输入的这两个密码是相同的，因此可以使用其中任何一个。在这里，我们从表单的POST数据中获取与键'password1' 相关联的值。如果用户名和密码无误，方法authenticate() 将返回一个通过了身份验证的用户对象，而我们将其存储在authenticated_user 中。
我们调用函数login() ，并将对象request 和authenticated_user 传递给它，这将为新用户创建有效的会话。最后，我们将用户重定向到主页，其页眉中显示了一条个性化的问候语，让用户知道注册成功了。

(3)注册模板

注册页面的模板与登录页面的模板类似，请务必将其保存到login.html所在的目录中:

{% extends "learning_logs/base.html" %}
 
{% block content %}
 
  <form method="post" action="{% url 'users:register' %}">
  {% csrf_token %}
  {{ form.as_p }}
 
  <button name="submit">register</button>
  <input type="hidden" name="next" value="{% url 'learning_logs:index' %}" />
</form>
 
{% endblock content %}

这里也使用了方法as_p ，让Django在表单中正确地显示所有的字段，包括错误消息——如果用户没有正确地填写表单。

（4）链接到注册页面

我们在learning_logs/templates/learning_logs/base.html添加这样的代码，即在用户没有登录时显示到注册页面的链接:

<p>
    <a href="{% url 'learning_logs:index' %}">Learning Log</a>
    <a href="{% url 'learning_logs:topics' %}">Topics</a>
    {% if user.is_authenticated %}
      Hello, {{ user.username }}.
      <a href="{% url 'users:logout' %}">log out</a>
    {% else %}
        <a href="{% url 'users:register' %}">register</a>
        <a href="{% url 'users:login' %}">log in</a>
    {% endif %}
</p>
 
{% block content %}{% endblock content %}

现在，已登录的用户看到的是个性化的问候语和注销链接，而未登录的用户看到的是注册链接和登录链接。请尝试使用注册页面创建几个用户名各不相同的用户账户。
注意这里的注册系统允许用户创建任意数量的账户。有些系统要求用户确认其身份:发送一封确认邮件，用户回复后其账户才生效。通过这样做，系统生成的垃圾账户将比这里使用的简单系统少。然而，学习创建应用程序时，完全可以像这里所做的那样，使用简单的用户注册系统。

5、让用户拥有自己的数据

用户应该能够输入其专有的数据，因此我们将创建一个系统，确定各项数据所属的用户，再限制对页面的访问，让用户只能使用自己的数据。
在本节中，我们将修改模型Topic ，让每个主题都归属于特定用户。这也将影响条目，因为每个条目都属于特定的主题。我们先来限制对一些页面的访问。

5.1、使用@login_required 限制访问

Django提供了装饰器@login_required ，让你能够轻松地实现这样的目标:对于某些页面，只允许已登录的用户访问它们。装饰器 (decorator)是放在函数定义前面的指令，Python在函数运行前，根据它来修改函数代码的行为。下面来看一个示例。
1. 限制对topics 页面的访问
每个主题都归特定用户所有，因此应只允许已登录的用户请求topics 页面。为此，在learning_logs/views.py中添加如下代码: views.py

from django.shortcuts import render
from django.http import HttpResponseRedirect
from django.urls import reverse
from django.contrib.auth.decorators import login_required
 
from .models import Topic, Entry
from .forms import TopicForm,EntryForm
 
def index(request):
    """学习笔记的主页"""
    return render(request, 'learning_logs/index.html')
 
@login_required
def topics(request):
    """显示所有的主题"""
    topics = Topic.objects.order_by('date_added')
    context = {'topics': topics}
    return render(request, 'learning_logs/topics.html', context)
 
def topic(request, topic_id):
    """显示特定主题的详细页面"""
    topic = Topic.objects.get(id=topic_id)
    entries = topic.entry_set.order_by('-date_added')
    context = {'topic': topic, 'entries': entries}
    return render(request, 'learning_logs/topic.html', context)
 
def new_topic(request):
    """添加新主题"""
    if request.method != 'POST':
        # 未提交数据:创建一个新表单
        form = TopicForm()
    else:
        # POST提交的数据,对数据进行处理
        form = TopicForm(request.POST)
        if form.is_valid():
            form.save()
            return HttpResponseRedirect(reverse('learning_logs:topics'))
    context = {'form': form}
    return render(request, 'learning_logs/new_topic.html', context)
 
def new_entry(request, topic_id):
    """在特定的主题中添加新条目"""
    topic = Topic.objects.get(id=topic_id)
 
    if request.method != 'POST':
        # 未提交数据,创建一个空表单
        form = EntryForm()
    else:
        # POST提交的数据,对数据进行处理
        form = EntryForm(data=request.POST)
        if form.is_valid():
            new_entry = form.save(commit=False)
            new_entry.topic = topic
            new_entry.save()
            return HttpResponseRedirect(reverse('learning_logs:topic',
                                                args=[topic_id]))
    context = {'topic': topic, 'form': form}
    return render(request, 'learning_logs/new_entry.html', context)
 
def edit_entry(request, entry_id):
    """编辑既有条目"""
    entry = Entry.objects.get(id=entry_id)
    topic = entry.topic
 
    if request.method != 'POST':
        # 初次请求，使用当前条目填充表单
        form = EntryForm(instance=entry)
    else:
        # POST提交的数据，对数据进行处理
        form = EntryForm(instance=entry, data=request.POST)
        if form.is_valid():
            form.save()
            return HttpResponseRedirect(reverse('learning_logs:topic',
                                                args=[topic.id]))
    context = {'entry': entry, 'topic': topic, 'form': form}
    return render(request, 'learning_logs/edit_entry.html', context)

我们首先导入了函数login_required() 。我们将login_required() 作为装饰器用于视图函数topics() ——在它前面加上符号@ 和login_required ，让Python在运行topics() 的代码前先运行login_required() 的代码。
login_required() 的代码检查用户是否已登录，仅当用户已登录时，Django才运行topics() 的代码。如果用户未登录，就重定向到登录页面。为实现这种重定向，我们需要修改settings.py，让Django知道到哪里去查找登录页面。请在项目learning_log的Django设置settings.py末尾添加如下代码:

# 我的设置
LOGIN_URL = '/users/login/'

现在，如果未登录的用户请求装饰器@login_required 的保护页面，Django将重定向到settings.py中的LOGIN_URL 指定的URL。
要测试这个设置，可注销并进入主页。然后，单击链接Topics，这将重定向到登录页面。接下来，使用你的账户登录，并再次单击主页中的Topics链接，你将看到topics页面。

2、全面限制对项目“学习笔记”的访问

Django让你能够轻松地限制对页面的访问，但你必须针对要保护哪些页面做出决定。最好先确定项目的哪些页面不需要保护，再限制对其他所有页面的访问。你可以轻松地修改过于严格的访问限制，其风险比不限制对敏感页面的访问更低。
在项目“学习笔记”中，我们将不限制对主页、注册页面和注销页面的访问，并限制对其他所有页面的访问。在下面的learning_logs/views.py中，对除index() 外的每个视图都应用了装饰器@login_required :

--snip--
@login_required
def topics(request):
    --snip--
 
@login_required
def topic(request, topic_id):
    --snip--
 
@login_required
def new_topic(request):
    --snip--
 
@login_required
def new_entry(request, topic_id):
    --snip--
 
@login_required
def edit_entry(request, entry_id):
    --snip--

如果你在未登录的情况下尝试访问这些页面，将被重定向到登录页面。另外，你还不能单击到new_topic 等页面的链接。但如果你输入URL http://localhost:8000/new_topic/，将重定向到登录页面。对于所有与私有用户数据相关的URL，都应限制对它们的访问。

3、将数据关联到用户

现在，需要将数据关联到提交它们的用户。我们只需将最高层的数据关联到用户，这样更低层的数据将自动关联到用户。例如，在项目“学习笔记”中，应用程序的最高层数据是
主题，而所有条目都与特定主题相关联。只要每个主题都归属于特定用户，我们就能确定数据库中每个条目的所有者。
下面来修改模型Topic ，在其中添加一个关联到用户的外键。这样做后，我们必须对数据库进行迁移。最后，我们必须对有些视图进行修改，使其只显示与当前登录的用户相关联的数据。

（1）修改模型Topic

对models.py的修改只涉及两行代码:

from django.db import models
from django.contrib.auth.models import User
 
class Topic(models.Model):
    """用户要学习的主题"""
    text = models.CharField(max_length=200)
    date_added = models.DateTimeField(auto_now_add=True)
    owner = models.ForeignKey(User)
 
    def __str__(self):
        """返回模型的字符串表示"""
        return self.text
 
class Entry(models.Model): --snip--

我们首先导入了django.contrib.auth 中的模型User ，然后在Topic 中添加了字段owner ，它建立到模型User 的外键关系。

(2) 确定当前有哪些用户

我们迁移数据库时，Django将对数据库进行修改，使其能够存储主题和用户之间的关联。为执行迁移，Django需要知道该将各个既有主题关联到哪个用户。最简单的办法是，将既有主题都关联到同一个用户，如超级用户。为此，我们需要知道该用户的ID。
下面来查看已创建的所有用户的ID。为此，启动一个Django shell会话，并执行如下命令:

(ll_env) [root@xxjt learning_log]# python3 manage.py shell>>> from django.contrib.auth.models import User
>>> User.objects.all()
<QuerySet [<User: happy>, <User: test1234>]>
>>>
>>> for user in User.objects.all():
...     print(user.username, user.id)
...
happy 1
test1234 2

我们在shell会话中导入了模型User 。然后，我们查看到目前为止都创建了哪些用户。我们遍历用户列表，并打印每位用户的用户名和ID。Django询问要将既有主题关联到哪个用户时，我们将指定其中的一个ID值。

3. 迁移数据库

知道用户ID后，就可以迁移数据库了。

参考资料：

1、python编程，从入门到实践