第 19 章 用户账户

Web应用程序的核心是让任何用户都能够注册账户并能够使用它，不管用户身处何方。在本章中，你将创建一些表单，让用户能够添加主题和条目，以及编辑既有的条目。你还将学习Django如何
防范对基于表单的网页发起的常见攻击，这让你无需花太多时间考虑确保应用程序安全的问题。
然后，我们将实现一个用户身份验证系统。你将创建一个注册页面，供用户创建账户，并让有些页面只能供已登录的用户访问。接下来，我们将修改一些视图函数，使得用户只能看到自己的数据。你将学习如何确保用户数据的安全。

19.1　让用户能够输入数据

建立用于创建用户账户的身份验证系统之前，我们先来添加几个页面，让用户能够输入数据。我们将让用户能够添加新主题、添加新条目以及编辑既有条目。
当前，只有超级用户能够通过管理网站输入数据。我们不想让用户与管理网站交互，因此我们将使用Django的表单创建工具来创建让用户能够输入数据的页面。

19.1.1　添加新主题

首先来让用户能够添加新主题。创建基于表单的页面的方法几乎与前面创建网页一样：定义一个URL，编写一个视图函数并编写一个模板。一个主要差别是，需要导入包含表单的模块forms.py。
1. 用于添加主题的表单
让用户输入并提交信息的页面都是表单，哪怕它看起来不像表单。用户输入信息时，我们需要进行验证，确认提供的信息是正确的数据类型，且不是恶意的信息，如中断服务器的代码。然后，我们再对这些有效信息进行处理，并将其保存到数据库的合适地方。这些工作很多都是由Django自动完成的。
在Django中，创建表单的最简单方式是使用ModelForm，它根据我们在第18章定义的模型中的信息自动创建表单。创建一个名为forms.py的文件，将其存储到models.py所在的目录中，并在其中编写你的第一个表单：
forms.py

from django import forms
from .models import Topic
class TopicForm(forms.ModelForm):❶
class Meta:
model = Topic❷
fields = ['text']❸
labels = {'text': ''}❹

我们首先导入了模块forms以及要使用的模型Topic。在❶处，我们定义了一个名为TopicForm的类，它继承了forms.ModelForm。
最简单的ModelForm版本只包含一个内嵌的Meta类，它告诉Django根据哪个模型创建表单，以及在表单中包含哪些字段。在❷处，我们根据模型Topic创建一个表单，该表单只包含字段text（见❸）。❹处的代码让Django不要为字段text生成标签。
2. URL模式new_topic
这个新网页的URL应简短而具有描述性，因此当用户要添加新主题时，我们将切换到http://localhost:8000/new_topic/。下面是网页new_topic的URL模式，我们将其添加到learning_logs/urls.py中：
urls.py

--snip--
urlpatterns = [
--snip--
# 用于添加新主题的网页
url(r'^new_topic/$', views.new_topic, name='new_topic'),
]

这个URL模式将请求交给视图函数new_topic()，接下来我们将编写这个函数。
3. 视图函数new_topic()
函数new_topic()需要处理两种情形：刚进入new_topic网页（在这种情况下，它应显示一个空表单）；对提交的表单数据进行处理，并将用户重定向到网页topics：
views.py

from django.shortcuts import render
from django.http import HttpResponseRedirect
from django.core.urlresolvers import reverse
from .models import Topic
from .forms import TopicForm
--snip--
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)

我们导入了HttpResponseRedirect类，用户提交主题后我们将使用这个类将用户重定向到网页topics。函数reverse()根据指定的
URL模型确定URL，这意味着Django将在页面被请求时生成URL。我们还
导入了刚才创建的表单TopicForm。
4. GET请求和POST请求
创建Web应用程序时，将用到的两种主要请求类型是GET请求和POST请求。对于只是从服务器读取数据的页面，使用GET请求；在用户需要通
过表单提交信息时，通常使用POST请求。处理所有表单时，我们都将
指定使用POST方法。还有一些其他类型的请求，但这个项目没有使
用。
函数new_topic()将请求对象作为参数。用户初次请求该网页时，其浏览器将发送GET请求；用户填写并提交表单时，其浏览器将发送
POST请求。根据请求的类型，我们可以确定用户请求的是空表单（GET
请求）还是要求对填写好的表单进行处理（POST请求）。
❶处的测试确定请求方法是GET还是POST。如果请求方法不是POST，请求就可能是GET，因此我们需要返回一个空表单（即便请求是其他类型的，返回一个空表单也不会有任何问题）。我们创建一个TopicForm实例（见❷），将其存储在变量form中，再通过上下文字典将这个表单发送给模板（见❼）。由于实例化TopicForm时我们没有指定任何实参，Django将创建一个可供用户填写的空表单。
如果请求方法为POST，将执行else代码块，对提交的表单数据进行处理。我们使用用户输入的数据（它们存储在request.POST中）创建一个TopicForm实例（见❸），这样对象form将包含用户提交的信息。
要将提交的信息保存到数据库，必须先通过检查确定它们是有效的（见❹）。函数is_valid()核实用户填写了所有必不可少的字段（表单字段默认都是必不可少的），且输入的数据与要求的字段类型
一致（例如，字段text少于200个字符，这是我们在第18章中的models.py中指定的）。这种自动验证避免了我们去做大量的工作。如果所有字段都有效，我们就可调用save()（见❺），将表单中的数据写入数据库。保存数据后，就可离开这个页面了。我们使用reverse()获取页面topics的URL，并将其传递给HttpResponseRedirect()（见❻），后者将用户的浏览器重定向到页面topics。在页面topics中，用户将在主题列表中看到他刚输入的主题。
5. 模板new_topic
下面来创建新模板new_topic.html，用于显示我们刚创建的表单：

new_topic.html
{% extends "learning_logs/base.html" %}
{% block content %}
<p>Add a new topic:</p>
<form action="{% url 'learning_logs:new_topic' %}"
method='post'> ❶
{% csrf_token %} ❷
{{ form.as_p }} ❸
<button name="submit">add topic</button> ❹
</form>
{% endblock content %}

这个模板继承了base.html，因此其基本结构与项目“学习笔记”的其
他页面相同。在❶处，我们定义了一个HTML表单。实参action告诉服
务器将提交的表单数据发送到哪里，这里我们将它发回给视图函数
new_topic()。实参method让浏览器以POST请求的方式提交数据。
Django使用模板标签{% csrf_token %}（见❷）来防止攻击者利用
表单来获得对服务器未经授权的访问（这种攻击被称为跨站请求伪
造）。在❸处，我们显示表单，从中可知Django使得完成显示表单等
任务有多简单：我们只需包含模板变量{{ form.as_p }}，就可让
Django自动创建显示表单所需的全部字段。修饰符as_p让Django以段
落格式渲染所有表单元素，这是一种整洁地显示表单的简单方式。
Django不会为表单创建提交按钮，因此我们在❹处定义了一个这样的
按钮。
6. 链接到页面new_topic
接下来，我们在页面topics中添加一个到页面new_topic的链接：

topics.html
{% extends "learning_logs/base.html" %}
{% block content %}
<p>Topics</p>
<ul>
--snip--
</ul>
<a href="{% url 'learning_logs:new_topic' %}">Add a new topic:
</a>
{% endblock content %}

这个链接放在了既有主题列表的后面。图19-1显示了生成的表单。请
使用这个表单来添加几个新主题。
图19-1　用于添加新主题的页面
19.1.2　添加新条目
现在用户可以添加新主题了，但他们还想添加新条目。我们将再次定
义URL，编写视图函数和模板，并链接到添加新条目的网页。但在此之
前，我们需要在forms.py中再添加一个类。
1. 用于添加新条目的表单
我们需要创建一个与模型Entry相关联的表单，但这个表单的定制程
度比TopicForm要高些：
forms.py

from django import forms
from .models import Topic, Entry
class TopicForm(forms.ModelForm):
--snip--
class EntryForm(forms.ModelForm):
class Meta:
model = Entry
fields = ['text']
labels = {'text': ''} ❶
widgets = {'text': forms.Textarea(attrs={'cols': 80})} ❷

我们首先修改了import语句，使其除导入Topic外，还导入
Entry。新类EntryForm继承了forms.ModelForm，它包含的
Meta类指出了表单基于的模型以及要在表单中包含哪些字段。这里也
给字段'text'指定了一个空标签（见❶）。
在❷处，我们定义了属性widgets。小部件（widget）是一个HTML表
单元素，如单行文本框、多行文本区域或下拉列表。通过设置属性
widgets，可覆盖Django选择的默认小部件。通过让Django使用
forms.Textarea，我们定制了字段'text'的输入小部件，将文本
区域的宽度设置为80列，而不是默认的40列。这给用户提供了足够的
空间，可以编写有意义的条目。
2. URL模式new_entry
在用于添加新条目的页面的URL模式中，需要包含实参topic_id，因
为条目必须与特定的主题相关联。该URL模式如下，我们将它添加到了
learning_logs/urls.py中：
urls.py
--snip--
urlpatterns = [
--snip--
# 用于添加新条目的页面
url(r'^new_entry/(?P<topic_id>\d+)/$', views.new_entry,
name='new_entry'),
]
这个URL模式与形式为http://localhost:8000/new_entry/id/
的URL匹配，其中id是一个与主题ID匹配的数字。代码(?
P<topic_id>\d+)捕获一个数字值，并将其存储在变量topic_id
中。请求的URL与这个模式匹配时，Django将请求和主题ID发送给函数
new_entry()。
3. 视图函数new_entry()
视图函数new_entry()与函数new_topic()很像：
views.py

from django.shortcuts import render
--snip--
from .models import Topic
from .forms import TopicForm, EntryForm
--snip--
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)

我们修改了import语句，在其中包含了刚创建的EntryForm。
new_entry()的定义包含形参topic_id，用于存储从URL中获得的
值。渲染页面以及处理表单数据时，都需要知道针对的是哪个主题，
因此我们使用topic_id来获得正确的主题（见❶）。
在❷处，我们检查请求方法是POST还是GET。如果是GET请求，将执行
if代码块：创建一个空的EntryForm实例（见❸）。如果请求方法为
POST，我们就对数据进行处理：创建一个EntryForm实例，使用
request对象中的POST数据来填充它（见❹）；再检查表单是否有
效，如果有效，就设置条目对象的属性topic，再将条目对象保存到
数据库。
调用save()时，我们传递了实参commit=False（见❺），让
Django创建一个新的条目对象，并将其存储到new_entry中，但不将
它保存到数据库中。我们将new_entry的属性topic设置为在这个函
数开头从数据库中获取的主题（见❻），然后调用save()，且不指定
任何实参。这将把条目保存到数据库，并将其与正确的主题相关联。
在❼处，我们将用户重定向到显示相关主题的页面。调用reverse()
时，需要提供两个实参：要根据它来生成URL的URL模式的名称；列表
args，其中包含要包含在URL中的所有实参。在这里，列表args只有
一个元素——topic_id。接下来，调用
HttpResponseRedirect()将用户重定向到显示新增条目所属主题
的页面，用户将在该页面的条目列表中看到新添加的条目。
4. 模板new_entry
从下面的代码可知，模板new_entry类似于模板new_topic：

new_entry.html
{% extends "learning_logs/base.html" %}
{% block content %}
<p><a href="{% url 'learning_logs:topic' topic.id %}">{{ topic
}}</a></p> ❶
<p>Add a new entry:</p>
<form action="{% url 'learning_logs:new_entry' topic.id %}"
method='post'> ❷
{% csrf_token %}
{{ form.as_p }}
<button name='submit'>add entry</button>
</form>
{% endblock content %}

我们在页面顶端显示了主题（见❶），让用户知道他是在哪个主题中
添加条目；该主题名也是一个链接，可用于返回到该主题的主页面。
表单的实参action包含URL中的topic_id值，让视图函数能够将新
条目关联到正确的主题（见❷）。除此之外，这个模板与模板
new_topic.html完全相同。
5. 链接到页面new_entry
接下来，我们需要在显示特定主题的页面中添加到页面new_entry的
链接：

topic.html
{% extends "learning_logs/base.html" %}
{% block content %}
<p>Topic: {{ topic }}</p>
<p>Entries:</p>
<p>
<a href="{% url 'learning_logs:new_entry' topic.id %}">add new
entry</a>
</p>
<ul>
--snip—
</ul>
{% endblock content %}

我们在显示条目前添加链接，因为在这种页面中，执行的最常见的操
作是添加新条目。图19-2显示了页面new_entry。现在用户可以添加
新主题，还可以在每个主题中添加任意数量的条目。请在一些既有主
题中添加一些新条目，尝试使用一下页面new_entry。
图19-2　页面new_entry

19.1.3　编辑条目

下面来创建一个页面，让用户能够编辑既有的条目。
1. URL模式edit_entry
这个页面的URL需要传递要编辑的条目的ID。修改后的
learning_logs/urls.py如下：

urls.py
--snip--
urlpatterns = [
--snip--
# 用于编辑条目的页面
url(r'^edit_entry/(?P<entry_id>\d+)/$', views.edit_entry,
name='edit_entry'),
]

在URL（如http://localhost:8000/edit_entry/1/）中传递的ID存储
在形参entry_id中。这个URL模式将预期匹配的请求发送给视图函数
edit_entry()。
2. 视图函数edit_entry()
页面edit_entry收到GET请求时，edit_entry()将返回一个表
单，让用户能够对条目进行编辑。该页面收到POST请求（条目文本经
过修订）时，它将修改后的文本保存到数据库中：
views.py

from django.shortcuts import render
--snip--
from .models import Topic, Entry
from .forms import TopicForm, EntryForm
--snip--
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)

我们首先需要导入模型Entry。在❶处，我们获取用户要修改的条目
对象，以及与该条目相关联的主题。在请求方法为GET时将执行的if
代码块中，我们使用实参instance=entry创建一个EntryForm实
例（见❷）。这个实参让Django创建一个表单，并使用既有条目对象
中的信息填充它。用户将看到既有的数据，并能够编辑它们。
处理POST请求时，我们传递实参instance=entry和
data=request.POST（见❸），让Django根据既有条目对象创建一
个表单实例，并根据request.POST中的相关数据对其进行修改。然
后，我们检查表单是否有效，如果有效，就调用save()，且不指定
任何实参（见❹）。接下来，我们重定向到显示条目所属主题的页面
（见❺），用户将在其中看到其编辑的条目的新版本。
3. 模板edit_entry
下面是模板edit_entry.html，它与模板new_entry.html类似：

edit_entry.html
{% extends "learning_logs/base.html" %}
{% block content %}
<p><a href="{% url 'learning_logs:topic' topic.id %}">{{ topic
}}</a></p>
<p>Edit entry:</p>
<form action="{% url 'learning_logs:edit_entry' entry.id %}"
method='post'> ❶
{% csrf_token %}
{{ form.as_p }}
<button name="submit">save changes</button> ❷
</form>
{% endblock content %}

在❶处，实参action将表单发回给函数edit_entry()进行处理。
在标签{% url %}中，我们将条目ID作为一个实参，让视图对象能够
修改正确的条目对象。我们将提交按钮命名为save changes，以提醒
用户：单击该按钮将保存所做的编辑，而不是创建一个新条目（见
❷）。
4. 链接到页面edit_entry
现在，在显示特定主题的页面中，需要给每个条目添加到页面
edit_entry的链接：

topic.html
--snip--
{% for entry in entries %}
<li>
<p>{{ entry.date_added|date:'M d, Y H:i' }}</p>
<p>{{ entry.text|linebreaks }}</p>
<p>
<a href="{% url 'learning_logs:edit_entry' entry.id
%}">edit entry</a>
</p>
</li>
--snip--

我们将编辑链接放在每个条目的日期和文本后面。在循环中，我们使
用模板标签{% url %}根据URL模式edit_entry和当前条目的ID属
性（entry.id）来确定URL。链接文本为"edit entry"，它出现在
页面中每个条目的后面。图19-3显示了包含这些链接时，显示特定主
题的页面是什么样的。
图19-3　每个条目都有一个用于对其进行编辑的链接
至此，“学习笔记”已具备了需要的大部分功能。用户可添加主题和
条目，还可根据需要查看任何一组条目。在下一节，我们将实现一个
用户注册系统，让任何人都可向“学习笔记”申请账户，并创建自己
的主题和条目。
动手试一试
19-1 博客：新建一个Django项目，将其命名为Blog。在这个项
目中，创建一个名为blogs的应用程序，并在其中创建一个名为
BlogPost的模型。这个模型应包含title、text和
date_added等字段。为这个项目创建一个超级用户，并使用管
理网站创建几个简短的帖子。创建一个主页，在其中按时间顺序
显示所有的帖子。
创建两个表单，其中一个用于发布新帖子，另一个用于编辑既有
的帖子。
尝试填写这些表单，确认它们能够正确地工作。

19.2　创建用户账户

在这一节，我们将建立一个用户注册和身份验证系统，让用户能够注
册账户，进而登录和注销。我们将创建一个新的应用程序，其中包含
与处理用户账户相关的所有功能。我们还将对模型Topic稍做修改，
让每个主题都归属于特定用户。
19.2.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. 将应用程序users添加到settings.py中
在settings.py中，我们需要将这个新的应用程序添加到
INSTALLED_APPS中，如下所示：
settings.py
--snip--
INSTALLED_APPS = (
--snip--
# 我的应用程序
'learning_logs',
'users',
)
--snip--
这样，Django将把应用程序users包含到项目中。
2. 包含应用程序users的URL
接下来，我们需要修改项目根目录中的urls.py，使其包含我们将为应
用程序users定义的URL：
urls.py
from django.conf.urls import include, url
from django.contrib import admin
urlpatterns = [
url(r'^admin/', include(admin.site.urls)),
url(r'^users/', include('users.urls', namespace='users')),
url(r'', include('learning_logs.urls',
namespace='learning_logs')),
]
我们添加了一行代码，以包含应用程序users中的文件urls.py。这行
代码与任何以单词users打头的URL（如
http://localhost:8000/users/login/）都匹配。我们还创建了命名
空间'users'，以便将应用程序learning_logs的URL同应用程序
users的URL区分开来。
19.2.2　登录页面
我们首先来实现登录页面的功能。为此，我们将使用Django提供的默
认登录视图，因此URL模式会稍有不同。在目录learning_log/users/
中，新建一个名为urls.py的文件，并在其中添加如下代码：
urls.py

"""为应用程序users定义URL模式"""
from django.conf.urls import url
from django.contrib.auth.views import login ❶
from . import views
urlpatterns = [
# 登录页面
url(r'^login/$', login, {'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/中：

login.html
{% 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. 链接到登录页面
下面在base.html中添加到登录页面的链接，让所有页面都包含它。用
户已登录时，我们不想显示这个链接，因此将它嵌套在一个

{% if
%}标签中：
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 }}. ❷
{% 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。。在这个主页的页眉中，显示了一条个性化问候语，其
中包含你的用户名。
图19-4　登录页面
19.2.3　注销
现在需要提供一个让用户注销的途径。我们不创建用于注销的页面，
而让用户只需单击一个链接就能注销并返回到主页。为此，我们将为
注销链接定义一个URL模式，编写一个视图函数，并在base.html中添
加一个注销链接。
1. 注销URL
下面的代码为注销定义了URL模式，该模式与URL
http://locallwst:8000/users/logout/匹配。修改后的
users/urls.py如下：

urls.py
--snip--
urlpatterns = [
# 登录页面
--snip--
# 注销
url(r'^logout/$', views.logout_view, name='logout'),
]

这个URL模式将请求发送给函数logout_view()。这样给这个函数命
名，旨在将其与我们将在其中调用的函数logout()区分开来（请确
保你修改的是users/urls.py，而不是learning_log/ urls.py）。
2. 视图函数logout_view()
函数logout_view()很简单：只是导入Django函数logout()，并
调用它，再重定向到主页。请打开users/views.py，并输入下面的代
码：

views.py
from django.http import HttpResponseRedirect
from django.core.urlresolvers 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. 链接到注销视图
现在我们需要添加一个注销链接。我们在base.html中添加这种链接，
让每个页面都包含它；我们将它放在标签{% if
user.is_authenticated %}中，使得仅当用户登录后才能看到
它：

base.html
--snip—
{% 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 %}
--snip--

图19-5显示了用户登录后看到的主页。这里的重点是创建能够正确工
作的网站，因此几乎没有设置任何样式。确定所需的功能都能正确运
行后，我们将设置这个网站的样式，使其看起来更专业。
图19-5　包含个性化问候语和注销链接的主页

19.2.4　注册页面

下面来创建一个让新用户能够注册的页面。我们将使用Django提供的
表单UserCreationForm，但编写自己的视图函数和模板。
1. 注册页面的URL模式
下面的代码定义了注册页面的URL模式，它也包含在users/urls.py
中：

urls.py
--snip--
urlpatterns = [
# 登录页面
--snip--
# 注册页面
url(r'^register/$', views.register, name='register'),
]

这个模式与URL http://localhost:8000/users/register/匹配，并将
请求发送给我们即将编写的函数register()。
2. 视图函数register()
在注册页面首次被请求时，视图函数register()需要显示一个空的
注册表单，并在用户提交填写好的注册表单时对其进行处理。如果注
册成功，这个函数还需让用户自动登录。请在users/views.py中添加
如下代码：

views.py
from django.shortcuts import render
from django.http import HttpResponseRedirect
from django.core.urlresolvers import reverse
from django.contrib.auth import login, logout, authenticate
from django.contrib.auth.forms import UserCreationForm
def logout_view(request):
--snip--
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所在的目录中：
register.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. 链接到注册页面
接下来，我们添加这样的代码，即在用户没有登录时显示到注册页面
的链接：
base.html
--snip--
{% 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 %}
--snip--
现在，已登录的用户看到的是个性化的问候语和注销链接，而未登录
的用户看到的是注册链接和登录链接。请尝试使用注册页面创建几个
用户名各不相同的用户账户。
在下一节，我们将对一些页面进行限制，仅让已登录的用户访问它
们，我们还将确保每个主题都属于特定用户。
注意　这里的注册系统允许用户创建任意数量的账户。有些系统
要求用户确认其身份：发送一封确认邮件，用户回复后其账户才
生效。通过这样做，系统生成的垃圾账户将比这里使用的简单系
统少。然而，学习创建应用程序时，完全可以像这里所做的那
样，使用简单的用户注册系统。
　
动手试一试
19-2 博客账户：在你为完成练习19-1而开发的项目Blog中，添
加一个用户身份验证和注册系统。让已登录的用户在屏幕上看到
其用户名，并让未注册的用户看到一个到注册页面的链接。

19.3　让用户拥有自己的数据

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

19.3.1　使用@login_required限制访问
Django提供了装饰器@login_required，让你能够轻松地实现这样
的目标：对于某些页面，只允许已登录的用户访问它们。装饰器
（decorator）是放在函数定义前面的指令，Python在函数运行前，根
据它来修改函数代码的行为。下面来看一个示例。
1. 限制对topics页面的访问
每个主题都归特定用户所有，因此应只允许已登录的用户请求
topics页面。为此，在learning_logs/views.py中添加如下代码：
views.py
--snip--
from django.core.urlresolvers import reverse
from django.contrib.auth.decorators import login_required
from .models import Topic, Entry
--snip--
@login_required
def topics(request):
"""显示所有的主题"""
--snip--
我们首先导入了函数login_required()。我们将
login_required()作为装饰器用于视图函数topics()——在它前
面加上符号@和login_required，让Python在运行topics()的代
码前先运行login_required()的代码。
login_required()的代码检查用户是否已登录，仅当用户已登录
时，Django才运行topics()的代码。如果用户未登录，就重定向到
登录页面。
为实现这种重定向，我们需要修改settings.py，让Django知道到哪里
去查找登录页面。请在settings.py末尾添加如下代码：
settings.py
"""
项目learning_log的Django设置
--snip--
# 我的设置
LOGIN_URL = '/users/login/'
现在，如果未登录的用户请求装饰器@login_required的保护页
面，Django将重定向到settings.py中的LOGIN_URL指定的URL。
要测试这个设置，可注销并进入主页。然后，单击链接Topics，这将
重定向到登录页面。接下来，使用你的账户登录，并再次单击主页中
的Topics链接，你将看到topics页面。
2. 全面限制对项目“学习笔记”的访问
Django让你能够轻松地限制对页面的访问，但你必须针对要保护哪些
页面做出决定。最好先确定项目的哪些页面不需要保护，再限制对其
他所有页面的访问。你可以轻松地修改过于严格的访问限制，其风险
比不限制对敏感页面的访问更低。
在项目“学习笔记”中，我们将不限制对主页、注册页面和注销页面
的访问，并限制对其他所有页面的访问。
在下面的learning_logs/views.py中，对除index()外的每个视图都
应用了装饰器@login_required：
views.py
--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，都应限制对它们的访问。

19.3.2　将数据关联到用户

现在，需要将数据关联到提交它们的用户。我们只需将最高层的数据
关联到用户，这样更低层的数据将自动关联到用户。例如，在项目
“学习笔记”中，应用程序的最高层数据是主题，而所有条目都与特
定主题相关联。只要每个主题都归属于特定用户，我们就能确定数据
库中每个条目的所有者。
下面来修改模型Topic，在其中添加一个关联到用户的外键。这样做
后，我们必须对数据库进行迁移。最后，我们必须对有些视图进行修
改，使其只显示与当前登录的用户相关联的数据。
1. 修改模型Topic
对models.py的修改只涉及两行代码：
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会
话，并执行如下命令：
(venv)learning_log$ python manage.py shell
>>> from django.contrib.auth.models import User ❶
>>> User.objects.all() ❷
[, , ]
>>> for user in User.objects.all(): ❸
... print(user.username, user.id)
...
ll_admin 1
eric 2
willie 3
>>>
在❶处，我们在shell会话中导入了模型User。然后，我们查看到目
前为止都创建了哪些用户（见❷）。输出中列出了三个用户：
ll_admin、eric和willie。
在❸处，我们遍历用户列表，并打印每位用户的用户名和ID。Django
询问要将既有主题关联到哪个用户时，我们将指定其中的一个ID值。
3. 迁移数据库
知道用户ID后，就可以迁移数据库了。
(venv)learning_log$ python manage.py makemigrations learning_logs
❶
You are trying to add a non-nullable field 'owner' to topic
without a default; ❷
we can't do that (the database needs something to populate
existing rows).
Please select a fix: ❸
1) Provide a one-off default now (will be set on all existing
rows)
2) Quit, and let me add a default in models.py
Select an option: 1 ❹
Please enter the default value now, as valid Python ❺
The datetime and django.utils.timezone modules are available, so
you can do e.g. timezone.now()
>>> 1 ❻
Migrations for 'learning_logs':
0003_topic_owner.py:
- Add field owner to topic
我们首先执行了命令makemigrations（见❶）。在❷处的输出中，
Django指出我们试图给既有模型Topic添加一个必不可少（不可为
空）的字段，而该字段没有默认值。在❸处，Django给我们提供了两
种选择：要么现在提供默认值，要么退出并在models.py中添加默认
值。在❹处，我们选择了第一个选项，因此Django让我们输入默认值
（见❺）。
为将所有既有主题都关联到管理用户ll_admin，我输入了用户ID值
1（见❻）。并非必须使用超级用户，而可使用已创建的任何用户的
ID。接下来，Django使用这个值来迁移数据库，并生成了迁移文件
0003_topic_owner.py，它在模型Topic中添加字段owner。
现在可以执行迁移了。为此，在活动的虚拟环境中执行下面的命令：
(venv)learning_log$ python manage.py migrate
Operations to perform:
Synchronize unmigrated apps: messages, staticfiles
Apply all migrations: learning_logs, contenttypes, sessions,
admin, auth
--snip--
Running migrations:
Rendering model states... DONE
Applying learning_logs.0003_topic_owner... OK ❶
(venv)learning_log$
Django应用新的迁移，结果一切顺利（见❶）。
为验证迁移符合预期，可在shell会话中像下面这样做：
>>> from learning_logs.models import Topic ❶
>>> for topic in Topic.objects.all(): ❷
... print(topic, topic.owner)
...
Chess ll_admin
Rock Climbing ll_admin
>>>
我们从learning_logs.models中导入Topic（见❶），再遍历所
有的既有主题，并打印每个主题及其所属的用户（见❷）。正如你看
到的，现在每个主题都属于用户ll_admin。
注意　你可以重置数据库而不是迁移它，但如果这样做，既有的
数据都将丢失。一种不错的做法是，学习如何在迁移数据库的同
时确保用户数据的完整性。如果你确实想要一个全新的数据库，
可执行命令python manage.py flush，这将重建数据库的结
构。如果你这样做，就必须重新创建超级用户，且原来的所有数
据都将丢失。

19.3.3　只允许用户访问自己的主题

当前，不管你以哪个用户的身份登录，都能够看到所有的主题。我们
来改变这种情况，只向用户显示属于自己的主题。
在views.py中，对函数topics()做如下修改：
views.py
--snip--
@login_required
def topics(request):
"""显示所有的主题"""
topics =
Topic.objects.filter(owner=request.user).order_by('date_added')
context = {'topics': topics}
return render(request, 'learning_logs/topics.html', context)
--snip--
用户登录后，request对象将有一个user属性，这个属性存储了有
关该用户的信息。代码
Topic.objects.filter(owner=request.user)让Django只从
数据库中获取owner属性为当前用户的Topic对象。由于我们没有修
改主题的显示方式，因此无需对页面topics的模板做任何修改。
要查看结果，以所有既有主题关联到的用户的身份登录，并访问
topics页面，你将看到所有的主题。然后，注销并以另一个用户的身
份登录，topics页面将不会列出任何主题。

19.3.4　保护用户的主题

我们还没有限制对显示单个主题的页面的访问，因此任何已登录的用
户都可输入类似于http://localhost:8000/topics/1/的URL，来访问
显示相应主题的页面。
你自己试一试就明白了。以拥有所有主题的用户的身份登录，访问特
定的主题，并复制该页面的URL，或将其中的ID记录下来。然后，注销
并以另一个用户的身份登录，再输入显示前述主题的页面的URL。虽然
你是以另一个用户登录的，但依然能够查看该主题中的条目。
为修复这种问题，我们在视图函数topic()获取请求的条目前执行检
查：
views.py
from django.shortcuts import render
from django.http import HttpResponseRedirect, Http404 ❶
from django.core.urlresolvers import reverse
--snip--
@login_required
def topic(request, topic_id):
"""显示单个主题及其所有的条目"""
topic = Topic.objects.get(id=topic_id)
# 确认请求的主题属于当前用户
if topic.owner != request.user: ❷
raise Http404
entries = topic.entry_set.order_by('-date_added')
context = {'topic': topic, 'entries': entries}
return render(request, 'learning_logs/topic.html', context)
--snip--
服务器上没有请求的资源时，标准的做法是返回404响应。在这里，我
们导入了异常Http404（见❶），并在用户请求它不能查看的主题时
引发这个异常。收到主题请求后，我们在渲染网页前检查该主题是否
属于当前登录的用户。如果请求的主题不归当前用户所有，我们就引
发Http404异常（见❷），让Django返回一个404错误页面。
现在，如果你试图查看其他用户的主题条目，将看到Django发送的消
息Page Not Found。在第20章，我们将对这个项目进行配置，让用户
看到更合适的错误页面。

19.3.5　保护页面edit_entry
页面edit_entry的URL为
http://localhost:8000/edit_entry/entry_id/，其中
entry_id是一个数字。下面来保护这个页面，禁止用户通过输入类
似于前面的URL来访问其他用户的条目：
views.py
--snip--
@login_required
def edit_entry(request, entry_id):
"""编辑既有条目"""
entry = Entry.objects.get(id=entry_id)
topic = entry.topic
if topic.owner != request.user:
raise Http404
if request.method != 'POST':
# 初次请求，使用当前条目的内容填充表单
--snip--
我们获取指定的条目以及与之相关联的主题，然后检查主题的所有者
是否是当前登录的用户，如果不是，就引发Http404异常。

19.3.6　将新主题关联到当前用户
当前，用于添加新主题的页面存在问题，因此它没有将新主题关联到
特定用户。如果你尝试添加新主题，将看到错误消息
IntegrityError，指出learning_logs_topic.user_id不能
为NULL。Django的意思是说，创建新主题时，你必须指定其owner字
段的值。
由于我们可以通过request对象获悉当前用户，因此存在一个修复这
种问题的简单方案。请添加下面的代码，将新主题关联到当前用户：
views.py
--snip--
@login_required
def new_topic(request):
"""添加新主题"""
if request.method != 'POST':
# 没有提交的数据,创建一个空表单
form = TopicForm()
else:
# POST提交的数据,对数据进行处理
form = TopicForm(request.POST)
if form.is_valid():
new_topic = form.save(commit=False) ❶
new_topic.owner = request.user ❷
new_topic.save() ❸
return
HttpResponseRedirect(reverse('learning_logs:topics'))
context = {'form': form}
return render(request, 'learning_logs/new_topic.html',
context)
--snip--
我们首先调用form.save()，并传递实参commit=False，这是因
为我们先修改新主题，再将其保存到数据库中（见❶）。接下来，将
新主题的owner属性设置为当前用户（见❷）。最后，对刚定义的主
题实例调用save()（见❸）。现在主题包含所有必不可少的数据，将
被成功地保存。
现在，这个项目允许任何用户注册，而每个用户想添加多少新主题都
可以。每个用户都只能访问自己的数据，无论是查看数据、输入新数
据还是修改旧数据时都如此。
动手试一试
19-3 重构：在views.py中，我们在两个地方核实主题关联到的
用户为当前登录的用户。请将执行这种检查的代码放在一个名为
check_topic_owner()的函数中，并在恰当的地方调用这个函
数。
19-4 保护页面new_entry：一个用户可在另一个用户的学习笔
记中添加条目，方法是输入这样的URL，即其中包含输入另一个用
户的主题的ID。为防范这种攻击，请在保存新条目前，核实它所
属的主题归当前用户所有。
19-5 受保护的博客：在你创建的项目Blog中，确保每篇博文都
与特定用户相关联。确保任何用户都可访问所有的博文，但只有
已登录的用户能够发表博文以及编辑既有博文。在让用户能够编
辑其博文的视图中，在处理表单前确认用户编辑的是他自己发表
的博文。

19.4　小结

在本章中，你学习了如何使用表单来让用户添加新主题、添加新条目
和编辑既有条目。接下来，你学习了如何实现用户账户。你让老用户
能够登录和注销，并学习了如何使用Django提供的表单
UserCreationForm让用户能够创建新账户。
建立简单的用户身份验证和注册系统后，你通过使用装饰器
@login_required禁止未登录的用户访问特定页面。然后，你通过
使用外键将数据关联到特定用户，还学习了如何执行要求指定默认数
据的数据库迁移。
最后，你学习了如何修改视图函数，让用户只能看到属于他的数据。
你使用方法filter()来获取合适的数据，并学习了如何将请求的数
据的所有者同当前登录的用户进行比较。
该让哪些数据可随便访问，该对哪些数据进行保护呢？这可能并非总
是那么显而易见，但通过不断地练习就能掌握这种技能。在本章中，
我们就该如何保护用户数据所做的决策表明，与人合作开发项目是个
不错的主意：有人对项目进行检查的话，更容易发现其薄弱环节。
至此，我们创建了一个功能齐备的项目，它运行在本地计算机上。在
本书的最后一章，我们将设置这个项目的样式，使其更漂亮；我们还
将把它部署到一台服务器上，让任何人都可通过互联网注册并创建账
户。