The Django Book

Scenario 1: Reusing Data on Multiple Sites

情景1：对多个站点�用数�

As we explained in Chapter 1, the Django-powered sites LJWorld.com and Lawrence.com are operated by the same news organization: the Lawrence Journal-World newspaper in Lawrence, Kansas. LJWorld.com focuses on news, while Lawrence.com focuses on local entertainment. But sometimes editors want to publish an article on both sites.

正如我们在第一章里所讲，Django 构建的网站 LJWorld.com 和 Lawrance.com 是用由�一个新闻组织控制的：肯�斯州劳伦斯市的 劳伦斯日报世界 报纸。 LJWorld.com 主��新闻，而 Lawrence.com 关注本地娱�。然而有时，编辑�能需�把一篇文章�布到 两个 网站上。

The brain-dead way of solving the problem would be to use a separate database for each site and to require site producers to publish the same story twice: once for LJWorld.com and again for Lawrence.com. But thats inefficient for site producers, and its redundant to store multiple copies of the same story in the database.

解决此问题的死脑筋方法�能是使用�个站点分别使用��的数�库，然��求站点维护者把�一篇文章�布两次：一次为 LJWorld.com，�一次为Lawrence.com。但这对站点管�员�说是低效率的，而且为�一篇文章在数�库里�留多个副本也显得多余。

The better solution? Both sites use the same article database, and an article is associated with one or more sites via a many-to-many relationship. The Django sites framework provides the database table to which articles can be related. Its a hook for associating data with one or more sites.

更好的解决方案？两个网站用的是�一个文章数�库，并将�一篇文章与一个或多个站点用多对多关系关�起�。Django 站点框架�供数�库记载哪些文章�以被关�。它是一个把数�与一个或多个站点关�起�的钩�。

Scenario 2: Storing Your Site Name/Domain in One Place

情景2：把你的网站�称/域存储到唯一的�置

LJWorld.com and Lawrence.com both have e-mail alert functionality, which lets readers sign up to get notifications when news happens. Its pretty basic: a reader signs up on a Web form, and he immediately gets an e-mail saying, Thanks for your subscription.

LJWorld.com 和 Lawrence.com 都有邮件�醒功能，使读者注册��以在新闻�生�立�收到通知。这是一�完美的的机制：�读者�交了注册表�，然�马上就�到一�内容是“感谢您的注册�的邮件。

It would be inefficient and redundant to implement this signup-processing code twice, so the sites use the same code behind the scenes. But the Thank you for your subscription notice needs to be different for each site. By using Site objects, we can abstract the thank-you notice to use the values of the current sites name (e.g., 'LJWorld.com' ) and domain (e.g., 'www.ljworld.com' ).

把这个注册过程的代�实现两�显然是低效�多余的，因此两个站点在��使用相�的代�。但感谢注册的通知在两个网站中需���。通过使用 Site 对象，我们通过使用当�站点的 name (例如 'LJWorld.com' )和 domain (例如 'www.ljworld.com' )�以把感谢通知抽�出�。

The Django sites framework provides a place for you to store the name and domain for each site in your Django project, which means you can reuse those values in a generic way.

Django 的多站点框架为你�供了一个�置�存储 Django 项目中�个站点的 name 和 domain ，这�味�你�以用�样的方法��用这些值。

How to Use the Sites Framework

如何使用多站点框架

The sites framework is more a series of conventions than a framework. The whole thing is based on two simple concepts:

多站点框架与其说是一个框架，�如说是一系列约定。所有的一切都基于两个简�的概念：

• The Site model, found in django.contrib.sites , has domain and name fields.

• ä½�于 django.contrib.sites çš„ Site 模型有 domain å’Œ name 两个字段。

• The SITE_ID setting specifies the database ID of the Site object associated with that particular settings file.

• SITE_ID 设置指定了与特定é…�置文件相关è�”çš„ Site 对象之数æ�®åº“ ID。

How you use these two concepts is up to you, but Django uses them in a couple of ways automatically via simple conventions.

如何�用这两个概念由你决定，但 Django 是通过几个简�的约定自动使用的。

To install the sites application, follow these steps:

安装多站点应用�执行以下几个步骤：

1. Add 'django.contrib.sites' to your INSTALLED_APPS .

1. 将 'django.contrib.sites' 加入到 INSTALLED_APPS 中。

2. Run the command manage.py syncdb to install the django_site table into your database.

2. �行 manage.py syncdb 命令将 django_site 表安装到数�库中。

3. Add one or more Site objects, either through the Django admin site or via the Python API. Create a Site object for each site/domain that this Django project powers.

3. 通过 Django 管ç�†å�Žå�°æˆ–通过 Python API 添加一个或者多个 ‘Site’ 对象。为该 Django 项目支撑的æ¯�个站（或域）创建一个 Site 对象。

4. Define the SITE_ID setting in each of your settings files. This value should be the database ID of the Site object for the site powered by that settings file.

4. 在�个设置文件中定义一个 SITE_ID ��。该��值应当是该设置文件所支撑的站点之 Site 对象的数�库 ID 。

The Sites Frameworks Capabilities

多站点框架的功能

The sections that follow describe the various things you can do with the sites framework.

下�几节讲述的是用多站点框架能够完�的几项工作。

from django.db import models
from django.contrib.sites.models import Site

class Article(models.Model):
    headline = models.CharField(maxlength=200)
    # ...
    sites = models.ManyToManyField(Site)

from django.conf import settings

def article_detail(request, article_id):
    try:
        a = Article.objects.get(id=article_id, sites__id=settings.SITE_ID)
    except Article.DoesNotExist:
        raise Http404
    # ...

from django.db import models
from django.contrib.sites.models import Site

class Article(models.Model):
    headline = models.CharField(maxlength=200)
    # ...
    site = models.ForeignKey(Site)

from django.conf import settings

def my_view(request):
    if settings.SITE_ID == 3:
        # Do something.
    else:
        # Do something else.

from django.conf import settings
from django.contrib.sites.models import Site

def my_view(request):
    current_site = Site.objects.get(id=settings.SITE_ID)
    if current_site.domain == 'foo.com':
        # Do something
    else:
        # Do something else.

from django.contrib.sites.models import Site

def my_view(request):
    current_site = Site.objects.get_current()
    if current_site.domain == 'foo.com':
        # Do something
    else:
        # Do something else.

from django.contrib.sites.models import Site
from django.core.mail import send_mail

def register_for_newsletter(request):
    # Check form values, etc., and subscribe the user.
    # ...
    current_site = Site.objects.get_current()
    send_mail('Thanks for subscribing to %s alerts' % current_site.name,
        'Thanks for your subscription. We appreciate it.\n\n-The %s team.' % current_site.name,
        'editor@%s' % current_site.domain,
        [user_email])
    # ...

from django.core.mail import send_mail
from django.template import loader, Context

def register_for_newsletter(request):
    # Check form values, etc., and subscribe the user.
    # ...
    subject = loader.get_template('alerts/subject.txt').render(Context({}))
    message = loader.get_template('alerts/message.txt').render(Context({}))
    send_mail(subject, message, 'do-not-reply@example.com', [user_email])
    # ...

>>> from django.contrib.sites.models import Site
>>> obj = MyModel.objects.get(id=3)
>>> obj.get_absolute_url()
'/mymodel/objects/3/'
>>> Site.objects.get_current().domain
'example.com'
>>> 'http://%s%s' % (Site.objects.get_current().domain, obj.get_absolute_url())
'http://example.com/mymodel/objects/3/'

CurrentSiteManager

当�站点管�器

If Site``s play a key role in your application, consider using the helpful ``CurrentSiteManager in your model(s). Its a model manager (see Appendix B) that automatically filters its queries to include only objects associated with the current Site .

如果 站点 在你的应用中扮演很��的角色，请考虑在你的模型中使用方便的 CurrentSiteManager 。这是一个模型管�器（�附录B），它会自动过滤使其�包�与当� 站点 相关�的对象。

Use CurrentSiteManager by adding it to your model explicitly. For example:

通过显示地将 CurrentSiteManager 加入模型中以使用它。例如：

from django.db import models
from django.contrib.sites.models import Site
from django.contrib.sites.managers import CurrentSiteManager

class Photo(models.Model):
    photo = models.FileField(upload_to='/home/photos')
    photographer_name = models.CharField(maxlength=100)
    pub_date = models.DateField()
    site = models.ForeignKey(Site)
    objects = models.Manager()
    on_site = CurrentSiteManager()

With this model, Photo.objects.all() will return all Photo objects in the database, but Photo.on_site.all() will return only the Photo objects associated with the current site, according to the SITE_ID setting.

通过该模型， Photo.objects.all() 将返回数�库中所有的 Photo 对象，而 Photo.on_site.all() 仅根� SITE_ID 设置返回与当�站点相关�的 Photo 对象。

In other words, these two statements are equivalent:

�言之，以下两�语�是等效的：

Photo.objects.filter(site=settings.SITE_ID)
Photo.on_site.all()

How did CurrentSiteManager know which field of Photo was the Site ? It defaults to looking for a field called site . If your model has a ForeignKey or ManyToManyField called something other than site , you need to explicitly pass that as the parameter to CurrentSiteManager . The following model, which has a field called publish_on , demonstrates this:

CurrentSiteManager 是如何知� Photo 的哪个字段是 Site 呢？缺�情况下，它会查找一个�� site 的字段。如果模型中有个 外键 或 多对多字段 �� site 之外 的�字，你必须显示地将它作为�数传递给 CurrentSiteManager 。下�的模型中有个�� publish_on 的字段，如下所示：

from django.db import models
from django.contrib.sites.models import Site
from django.contrib.sites.managers import CurrentSiteManager

class Photo(models.Model):
    photo = models.FileField(upload_to='/home/photos')
    photographer_name = models.CharField(maxlength=100)
    pub_date = models.DateField()
    publish_on = models.ForeignKey(Site)
    objects = models.Manager()
    on_site = CurrentSiteManager('publish_on')

If you attempt to use CurrentSiteManager and pass a field name that doesnt exist, Django will raise a ValueError .

如果试图使用 CurrentSiteManager 并传入一个�存在的字段�， Django 将引�一个 ValueError 异常。

Note

注�事项

Youll probably want to keep a normal (non-site-specific) Manager on your model, even if you use CurrentSiteManager . As explained in Appendix B, if you define a manager manually, then Django wont create the automatic objects = models.Manager() manager for you.

�便是已�使用了 CurrentSiteManager ，你也许还想在模型中拥有一个正常的（�站点相关）的 管�器 。正如在附录 B 中所解释的，如果你手动定义了一个管�器，那么 Django �会为你创建全自动的 objects = models.Manager() 管�器。

Also, certain parts of Django namely, the Django admin site and generic views use whichever manager is defined first in the model, so if you want your admin site to have access to all objects (not just site-specific ones), put objects = models.Manager() in your model, before you define CurrentSiteManager .

�样，Django 的特定部分——� Django 超级管�站点和通用视图——使用的管�器 首先 在模型中定义，因此如果希望超级管�站点能够访问所有对象（而�是仅仅站点特有对象），请于定义 CurrentSiteManager 之�在模型中放入 objects = models.Manager() 。

How Django Uses the Sites Framework

Django如何使用多站点框架

Although its not required that you use the sites framework, its strongly encouraged, because Django takes advantage of it in a few places. Even if your Django installation is powering only a single site, you should take a few seconds to create the site object with your domain and name , and point to its ID in your SITE_ID setting.

尽管并�是必须的，我们还是强烈建议使用多站点框架，因为 Django 在几个地方利用了它。�使�用 Django �支��个网站，你也应该花一点时间用 domain 和 name �创建站点对象，并将 SITE_ID 设置指�它的 ID 。

Heres how Django uses the sites framework:

以下讲述的是 Django 如何使用多站点框架：

• In the redirects framework (see the later section Redirects), each redirect object is associated with a particular site. When Django searches for a redirect, it takes into account the current SITE_ID .

• 在é‡�定å�‘框架中（è§�å�Žé�¢çš„é‡�定å�‘一节），æ¯�一个é‡�定å�‘对象都与一个特定站点关è�”。当 Django æ�œç´¢é‡�定å�‘的时候，它会考虑当å‰�çš„ SITE_ID 。

• In the comments framework, each comment is associated with a particular site. When a comment is posted, its site is set to the current SITE_ID , and when comments are listed via the appropriate template tag, only the comments for the current site are displayed.

• 在注册框架中，æ¯�个注释都与特定站点相关。æ¯�个注释被张贴时，其 site 被设置为当å‰�çš„ SITE_ID ，而当通过适当的模æ�¿æ ‡ç­¾åˆ—出注释时，å�ªæœ‰å½“å‰�站点的注释将会显示。

• In the flatpages framework (see the later section Flatpages), each flatpage is associated with a particular site. When a flatpage is created, you specify its site , and the flatpage middleware checks the current SITE_ID in retrieving flatpages to display.

• 在 flatpages 框架中 (å�‚è§�å�Žé�¢çš„ Flatpages 一节），æ¯�个 flatpage 都与特定的站点相关è�”。创建 flatpage 时，你都将指定它的 site ，而 flatpage 中间件在获å�– flatpage 以显示它的过程中，将查看当å‰�çš„ SITE_ID 。

• In the syndication framework (see Chapter 11), the templates for title and description automatically have access to a variable {{ site }} , which is the Site object representing the current site. Also, the hook for providing item URLs will use the domain from the current Site object if you dont specify a fully qualified domain.

• 在 syndication 框架中（å�‚阅第 11 章）， title å’Œ description 的模æ�¿è‡ªåŠ¨è®¿é—®å�˜é‡� {{ site }} ，它就是代表当å‰�ç�€æ¡¨çš„ Site 对象。而且，如果你ä¸�指出一个完全å�ˆæ ¼çš„domainçš„è¯�，æ��供目录URLSçš„é’©å­�将会使用当å‰�“Siteâ€�对象的domain。

• In the authentication framework (see Chapter 12), the django.contrib.auth.views.login view passes the current Site name to the template as {{ site_name }} .

• 在身份验è¯�框架（å�‚è§�第 12 章）中， django.contrib.auth.views.login 视图将当å‰� Site å��称作为 {{ site_name }} 传递给模æ�¿ã€‚

Using Flatpages

使用简�页�

To install the flatpages application, follow these steps:

安装简�页�应用程�必须按照下�的步骤：

1. Add 'django.contrib.flatpages' to your INSTALLED_APPS . django.contrib.flatpages depends on django.contrib.sites , so make sure the both packages are in INSTALLED_APPS .

1. 添加 'django.contrib.flatpages' 到 INSTALLED_APPS 设置。 django.contrib.flatpages �赖于 django.contrib.sites , 所以确�这两个开�包都包括在 INSTALLED_APPS 设置中。

2. Add 'django.contrib.flatpages.middleware.FlatpageFallbackMiddleware' to your MIDDLEWARE_CLASSES setting.

2. 将 'django.contrib.flatpages.middleware.FlatpageFallbackMiddleware' 添加到 MIDDLEWARE_CLASSES 设置中。

3. Run the command manage.py syncdb to install the two required tables into your database.

3. �行 manage.py syncdb 命令在数�库中创建必需的两个表。

The flatpages application creates two tables in your database: django_flatpage and django_flatpage_sites . django_flatpage simply maps a URL to a title and bunch of text content. django_flatpage_sites is a many-to-many table that associates a flatpage with one or more sites.

简�页�应用程�在数�库中创建两个表： django_flatpage 和 django_flatpage_sites 。 django_flatpage �是将 URL 映射到标题和一段文本内容。 django_flatpage_sites 是一个多对多表，用于关��个简�页�以�一个或多个站点。

The application comes with a single FlatPage model, defined in django/contrib/flatpages/models.py . It looks like this:

该应用所带�的 FlatPage 模型在 django/contrib/flatpages/models.py 进行定义，如下所示：

from django.db import models
from django.contrib.sites.models import Site

class FlatPage(models.Model):
    url = models.CharField(maxlength=100)
    title = models.CharField(maxlength=200)
    content = models.TextField()
    enable_comments = models.BooleanField()
    template_name = models.CharField(maxlength=70, blank=True)
    registration_required = models.BooleanField()
    sites = models.ManyToManyField(Site)

Lets examine these fields one at a time:

让我们�项看看这些字段的�义：

• url : The URL at which this flatpage lives, excluding the domain name but including the leading slash (e.g., /about/contact/ ).

• url : 该简å�•é¡µé�¢æ‰€å¤„çš„ URL，ä¸�包括域å��，但是包å�«å‰�导斜æ�  (例如 /about/contact/ )。

• title : The title of the flatpage. The framework doesnt do anything special with this. Its your responsibility to display it in your template.

• title : 简å�•é¡µé�¢çš„标题。框架ä¸�对它作任何特殊处ç�†ã€‚由你通过模æ�¿æ�¥æ˜¾ç¤ºå®ƒã€‚

• content : The content of the flatpage (i.e., the HTML of the page). The framework doesnt do anything special with this. Its your responsibility to display it in the template.

• content : 简å�•é¡µé�¢çš„内容 (å�³ HTML 页é�¢)。框架ä¸�会对它作任何特别处ç�†ã€‚由你负责使用模æ�¿æ�¥æ˜¾ç¤ºã€‚

• enable_comments : Whether to enable comments on this flatpage. The framework doesnt do anything special with this. You can check this value in your template and display a comment form if needed.

• enable_comments : 是å�¦å…�许该简å�•é¡µé�¢ä½¿ç”¨è¯„论。框架ä¸�对此å�šä»»ä½•ç‰¹åˆ«å¤„ç�†ã€‚ä½ å�¯åœ¨æ¨¡æ�¿ä¸­æ£€æŸ¥è¯¥å€¼å¹¶æ ¹æ�®éœ€è¦�显示评论窗体。

• template_name : The name of the template to use for rendering this flatpage. This is optional; if its not given or if this template doesnt exist, the framework will fall back to the template flatpages/default.html .

• template_name : 用æ�¥è§£æž�该简å�•é¡µé�¢çš„模æ�¿å��称。这是一个å�¯é€‰é¡¹ï¼›å¦‚果未指定模æ�¿æˆ–该模æ�¿ä¸�存在，系统会退而使用默认模æ�¿ flatpages/default.html 。

• registration_required : Whether registration is required for viewing this flatpage. This integrates with Djangos authentication/user framework, which is explained further in Chapter 12.

• registration_required : 是å�¦æ³¨å†Œç”¨æˆ·æ‰�能查看此简å�•é¡µé�¢ã€‚该设置项集æˆ�了 Djangos 验è¯�/用户框架，该框架于第å��二章详述。

• sites : The sites that this flatpage lives on. This integrates with Djangos sites framework, which is explained in the Sites section of this chapter.

• sites : 该简å�•é¡µé�¢æ”¾ç½®çš„站点。该项设置集æˆ�了 Django 多站点框架，该框架在本章的《多站点》一节中有所é˜�述。

You can create flatpages through either the Django admin interface or the Django database API. For more information on this, see the section Adding, Changing, and Deleting Flatpages.

你�以通过 Django 超级管�界�或者 Django 数�库 API �创建简�页�。�了解更多内容，请查阅《添加�修改和删除简�页�》一节。

Once youve created flatpages, FlatpageFallbackMiddleware does all of the work. Each time any Django application raises a 404 error, this middleware checks the flatpages database for the requested URL as a last resort. Specifically, it checks for a flatpage with the given URL with a site ID that corresponds to the SITE_ID setting.

一旦简�页�创建完�， FlatpageFallbackMiddleware 将完�（剩下）所有的工作。�当 Django 引� 404 错误，作为终�手段，该中间件将根�所请求的 URL 检查平页�数�库。确切地说，它将使用所指定的 URL以� SITE_ID 设置对应的站点 ID 查找一个简�页�。

If it finds a match, it loads the flatpages template or flatpages/default.html if the flatpage has not specified a custom template. It passes that template a single context variable, flatpage , which is the flatpage object. It uses RequestContext in rendering the template.

如果找到一个匹�项，它将载入该简�页�的模�（如果没有指定的�，将使用默认模� flatpages/default.html ）。�时，它把一个简�的上下文��—— flatpage （一个简�页�对象）传递给模�。在模�解�过程中，它实际用的是 RequestContext 。

If FlatpageFallbackMiddleware doesnt find a match, the request continues to be processed as usual.

如果 FlatpageFallbackMiddleware 没有找到匹�项，该请求继续如常处�。

Note

注�

This middleware only gets activated for 404 (page not found) errors not for 500 (server error) or other error responses. Also note that the order of MIDDLEWARE_CLASSES matters. Generally, you can put FlatpageFallbackMiddleware at or near the end of the list, because its a last resort.

该中间件仅在�生 404 （页�未找到）错误时被激活，而�会在 500 （�务器错误）或其他错误�应时被激活。还�注�的是必须考虑 MIDDLEWARE_CLASSES 的顺�问题。通常，你�以把 FlatpageFallbackMiddleware 放在列表最�，因为它是一�终�手段。

Adding, Changing, and Deleting Flatpages

添加�修改和删除简�页�

You can add, change and delete flatpages in two ways:

�以用两�方�增加��更或删除简�页�：

>>> from django.contrib.flatpages.models import FlatPage
>>> from django.contrib.sites.models import Site
>>> fp = FlatPage(
...     url='/about/',
...     title='About',
...     content='<p>About this site...</p>',
...     enable_comments=False,
...     template_name='',
...     registration_required=False,
... )
>>> fp.save()
>>> fp.sites.add(Site.objects.get(id=1))
>>> FlatPage.objects.get(url='/about/')
<FlatPage: /about/ -- About>

Using Flatpage Templates

使用简�页�模�

By default, flatpages are rendered via the template flatpages/default.html , but you can override that for a particular flatpage with the template_name field on the FlatPage object.

缺�情况下，系统使用模� flatpages/default.html �解�简�页�，但你也�以通过设定 FlatPage 对象的 template_name 字段�覆盖特定简�页�的模�。

Creating the flatpages/default.html template is your responsibility. In your template directory, just create a flatpages directory containing a default.html file.

你必须自己创建 flatpages/default.html 模�。�需�在模�目录创建一个 flatpages 目录，并把 default.html 文件置于其中。

Flatpage templates are passed a single context variable, flatpage , which is the flatpage object.

简�页�模��接�有一个上下文��—— flatpage ，也就是该简�页�对象。

Heres a sample flatpages/default.html template:

以下是一个 flatpages/default.html 模�范例:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"
    "http://www.w3.org/TR/REC-html40/loose.dtd">
<html>
<head>
<title>{{ flatpage.title }}</title>
</head>
<body>
{{ flatpage.content }}
</body>
</html>

Using the Redirects Framework

使用�定�框架

To install the redirects application, follow these steps:

安装�定�应用程�必须�循以下步骤：

1. Add 'django.contrib.redirects' to your INSTALLED_APPS .

1. 将 'django.contrib.redirects' 添加到 INSTALLED_APPS 设置中。

2. Add 'django.contrib.redirects.middleware.RedirectFallbackMiddleware' to your MIDDLEWARE_CLASSES setting.

2. 将 'django.contrib.redirects.middleware.RedirectFallbackMiddleware' 添加到 MIDDLEWARE_CLASSES 设置中。

3. Run the command manage.py syncdb to install the single required table into your database.

3. �行 manage.py syncdb 命令将所需的表安装到数�库中。

manage.py syncdb creates a django_redirect table in your database. This is a simple lookup table with site_id , old_path , and new_path fields.

manage.py syncdb 在数�库中创建了一个 django_redirect 表。这是一个简�的查询表，�有 site_id � old_path 和 new_path 三个字段。

You can create redirects through either the Django admin interface or the Django database API. For more, see the section Adding, Changing, and Deleting Redirects.

你�以通过 Django 超级管�界�或者 Django 数�库 API �创建�定�。�了解更多信�，请�阅《增加��更和删除�定�》一节。

Once youve created redirects, the RedirectFallbackMiddleware class does all of the work. Each time any Django application raises a 404 error, this middleware checks the redirects database for the requested URL as a last resort. Specifically, it checks for a redirect with the given old_path with a site ID that corresponds to the SITE_ID setting. (See the earlier section Sites for more information on SITE_ID and the sites framework.) Then it follows these steps:

一旦创建了�定�， RedirectFallbackMiddleware 类将完�所有的工作。�当 Django 应用引�一个 404 错误，作为终�手段，该中间件将为所请求的 URL 在�定�数�库中进行查找。确切地说，它将使用给定的 old_path 以� SITE_ID 设置对应的站点 ID 查找�定�设置。（查阅��的《多站点》一节�了解关于 SITE_ID 和多站点框架的更多细节） 然�，它将执行以下两个步骤：

• If it finds a match, and new_path is not empty, it redirects to new_path .

• 如果找到了匹é…�项，并且 new_path é�žç©ºï¼Œå®ƒå°†é‡�定å�‘到 new_path 。

• If it finds a match, and new_path is empty, it sends a 410 (Gone) HTTP header and an empty (contentless) response.

• 如果找到了匹é…�项，但 new_path 为空，它将å�‘é€�一个 410 (Gone) HTTP 头信æ�¯ä»¥å�Šä¸€ä¸ªç©ºï¼ˆæ— å†…容）å“�应。

• If it doesnt find a match, the request continues to be processed as usual.

• 如果未找到匹é…�项，该请求将如常处ç�†ã€‚

The middleware only gets activated for 404 errors not for 500 errors or responses of any other status code.

该中间件仅为 404 错误激活，而�会为 500 错误或其他任何状��的�应所激活。

Note that the order of MIDDLEWARE_CLASSES matters. Generally, you can put RedirectFallbackMiddleware toward the end of the list, because its a last resort.

注�必须考虑 MIDDLEWARE_CLASSES 的顺�。通常，你�以将 RedirectFallbackMiddleware 放置在列表的最�，因为它是一�终�手段。

Note

注�

If youre using both the redirect and flatpage fallback middleware, consider which one (redirect or flatpage) youd like checked first. We suggest flatpages before redirects (thus putting the flatpage middleware before the redirect middleware), but you might feel differently.

如果�时使用�定�和简�页�回退中间件， 必须考虑先检查其中的哪一个（�定�或简�页�）。我们建议将简�页�放在�定�之�（因此将简�页�中间件放置在�定�中间件之�），但你�能有��想法。

Adding, Changing, and Deleting Redirects

增加��更和删除�定�

You can add, change and delete redirects in two ways:

你�以两�方�增加��更和删除�定�：

>>> from django.contrib.redirects.models import Redirect
>>> from django.contrib.sites.models import Site
>>> red = Redirect(
...     site=Site.objects.get(id=1),
...     old_path='/music/',
...     new_path='/sections/arts/music/',
... )
>>> red.save()
>>> Redirect.objects.get(old_path='/music/')
<Redirect: /music/ ---> /sections/arts/music/>

A Simple CSRF Example

一个简�的 CSRF 例�

Suppose youre logged in to a webmail account at example.com . This webmail site has a Log Out button that points to the URL example.com/logout that is, the only action you need to take in order to log out is to visit the page example.com/logout .

�定你已�登录到 example.com 的网页邮件账�。该网页邮件站点上有一个登出按钮指�了 URL example.com/logout ，���说，�登出的�，需��的唯一动作就是访问 URL ： example.com/logout 。

A malicious site can coerce you to visit the URL example.com/logout by including that URL as a hidden <iframe> on its own (malicious) page. Thus, if youre logged in to the example.com webmail account and visit the malicious page that has an <iframe> to example.com/logout , the act of visiting the malicious page will log you out from example.com .

通过在（��）网页上用��一个指� URL example.com/logout 的 <iframe> ,��网站�以强迫你访问该 URL 。因此，如果你登录 example.com 的网页邮件账�之�，访问了带有指� example.com/logout 之 <iframe> 的��站点，访问该��页�的动作将使你登出 example.com 。

Clearly, being logged out of a webmail site against your will is not a terrifying breach of security, but this same type of exploit can happen to any site that trusts users, such as an online banking site or an e-commerce site.

诚然，对你而言登出一个网页邮件站点并�会构�多大的安全破�，但�样的攻击�能�生在 任何 信任用户的站点之上，比如在线银行网站或者电�商务网站。

A More Complex CSRF Example

�微��一点的CSRF例�

In the previous example, example.com was partially at fault because it allowed a state change (i.e., logging the user out) to be requested via the HTTP GET method. Its much better practice to require an HTTP POST for any request that changes state on the server. But even Web sites that require POST for state-changing actions are vulnerable to CSRF.

在上一个例�中， example.com 应该负部分责任，因为它�许通过 HTTP GET 方法进行状��更（�登入和登出）。如果对�务器的状��更�求使用 HTTP POST 方法，情况就好得多了。但是，�便是强制�求使用 POST 方法进行状��更�作也易�到 CSRF 攻击。

Suppose example.com has upgraded its Log Out functionality so that its a <form> button that is requested via POST to the URL example.com/logout . Furthermore, the logout <form> includes this hidden field:

�设 example.com 对登出功能进行了�级，登出 <form> 按钮是通过一个指� URL example.com/logout 的 POST 动作完�，�时在 <form> 中加入了以下��的字段：

<input type="hidden" name="confirm" value="true" />

This ensures that a simple POST to the URL example.com/logout wont log a user out; in order for a user to log out, the user must request example.com/logout via POST and send the confirm POST variable with a value of 'true' .

这就确�了用简�的 POST 到 example.com/logout �会让用户登出；�让用户登出，用户必须通过 POST � example.com/logout ��请求 并且 ��一个值为 'true' 的 POST ��。

Well, despite the extra security, this arrangement can still be exploited by CSRF the malicious page just needs to do a little more work. Attackers can create an entire form targeting your site, hide it in an invisible <iframe> , and then use JavaScript to submit that form automatically.

尽管增加了�外的安全机制，这�设计�然会�到 CSRF 的攻击——��页�仅需一点点改进而已。攻击者�以针对你的站点设计整个表�，并将其�身于一个���的 <iframe> 中，然�使用 Javascript 自动�交该表�。

Preventing CSRF

防止 CSRF

How, then, can your site protect itself from this exploit? The first step is to make sure all GET requests are free of side effects. That way, if a malicious site includes one of your pages as an <iframe> , it wont have a negative effect.

那么，是��以让站点��这�攻击呢？第一步，首先确�所有 GET 方法没有副作用。这样以�，如果�个��站点将你的页�包�为 <iframe> ，它将�会产生负�效果。

That leaves POST requests. The second step is to give each POST <form> a hidden field whose value is secret and is generated from the users session ID. Then, when processing the form on the server side, check for that secret field and raise an error if it doesnt validate.

该技术没有考虑 POST 请求。第二步就是给所有 POST 的 <form> 一个 ��字段，它的值是�密的并根�用户进程的 ID 生�。这样，从�务器端访问表�时，�以检查该�密的字段，���时�以引�一个错误。

This is exactly what Djangos CSRF prevention layer does, as explained in the sections that follow.

这正是 Django CSRF 防护层完�的工作，正如下�的�节所介�的。

apnumber

apnumber

For numbers 1 through 9, this filter returns the number spelled out. Otherwise, it returns the numeral. This follows Associated Press style.

对于 1 到 9 的数字，该过滤器返回了数字的拼写形�。�则，它将返回数字。这�循的是美�社风格。

Examples:

举例：

• 1 becomes one.

• 1 å�˜æˆ� one 。

• 2 becomes two.

• 2 å�˜æˆ� two 。

• 10 becomes 10.

• 10 å�˜æˆ� 10 。

You can pass in either an integer or a string representation of an integer.

你�以传入一个整数或者表示整数的字符串。

intcomma

intcomma

This filter converts an integer to a string containing commas every three digits.

该过滤器将整数转�为�三个数字用一个逗�分隔的字符串。

Examples:

例如：

• 4500 becomes 4,500.

• 4500 å�˜æˆ� 4,500 。

• 45000 becomes 45,000.

• 45000 å�˜æˆ� 45,000 。

• 450000 becomes 450,000.

• 450000 å�˜æˆ� 450,000 。

• 4500000 becomes 4,500,000.

• 4500000 å�˜æˆ� 4,500,000 。

You can pass in either an integer or a string representation of an integer.

你�以传入整数或者表示整数的字符串。

intword

intword

This filter converts a large integer to a friendly text representation. It works best for numbers over 1 million.

该过滤器将一个很大的整数转���好的文本表示方�。它对于超过一百万的数字最好用。

Examples:

例如：

• 1000000 becomes 1.0 million.

• 1000000 å�˜æˆ� 1.0 million 。

• 1200000 becomes 1.2 million.

• 1200000 å�˜æˆ� 1.2 million 。

• 1200000000 becomes 1.2 billion.

• 1200000000 å�˜æˆ� 1.2 billion 。

Values up to 1 quadrillion (1,000,000,000,000,000) are supported.

最大支��超过一�的五次方（1,000,000,000,000,000）。

You can pass in either an integer or a string representation of an integer.

你�以传入整数或者表示整数的字符串。

ordinal

ordinal

This filter converts an integer to its ordinal as a string.

该过滤器将整数转�为�数�的字符串形�。

Examples:

例如：

• 1 becomes 1st.

• 1 å�˜æˆ� 1st 。

• 2 becomes 2nd.

• 2 å�˜æˆ� 2nd 。

• 3 becomes 3rd.

• 3 å�˜æˆ� 3rd 。

You can pass in either an integer or a string representation of an integer.

你�以传入整数或�表示整数的字符串。