{% raw %}

Feed聚合框架

Django带有一个高聚合的框架让创造RSS 和 Atom更容易。

创建聚合feed，你要做的仅仅是写一个简短的Python类。你想要创造多少，就能创造多少feeds。

Django 也带有一个低等级的生成feed的API。如果你想要生成一个外部的Web内容或者其他普通的方式，你可以使用它。

高等级的框架

概述

高等级的feed聚合框架由Feed类提供。新建一个feed，写一个Feed类，然后指向你的URLconf.

Feed 类

一个 Feed类就是一个提供聚合种子的Python类。一个简单的种子（例如新闻的信息种子，或者只展示博客最新消息）更多功能的种子（例如展示博客中允许展示的特定类别的条目）。

Feed类继承自django.contrib.syndication.views.Feed。它们可以在你代码中的任意一处。

Feed类需要是你URLconf中的实例。

一个简单的示例

这个简单的示例，演示了某站点的最近五条新闻的记录：

  1. from django.contrib.syndication.views import Feed
  2. from django.core.urlresolvers import reverse
  3. from policebeat.models import NewsItem
  5. class LatestEntriesFeed(Feed):
  6.     title = "Police beat site news"
  7.     link = "/sitenews/"
  8.     description = "Updates on changes and additions to police beat central."
  10.     def items(self):
  11.         return NewsItem.objects.order_by('-pub_date')[:5]
  13.     def item_title(self, item):
  14.         return item.title
  16.     def item_description(self, item):
  17.         return item.description
  19.     # item_link is only needed if NewsItem has no get_absolute_url method.
  20.     def item_link(self, item):
  21.         return reverse('news-item', args=[item.pk])

配置一个URL到这个feed，在URLconf中配置一个入口。例如:

  1. from django.conf.urls import url
  2. from myproject.feeds import LatestEntriesFeed
  4. urlpatterns = [
  5.     # ...
  6.     url(r'^latest/feed/$', LatestEntriesFeed()),
  7.     # ...
  8. ]

注意:

  • Feed类继承于django.contrib.syndication.views.Feed.
  • title, link 和 description 分别对应 RSS的 <title>, <link> 和 <description> .
  • items()就是一个返回包含feed <item>对象列表的方法.当然，这个例子返回 NewsItem对象是使用 Django的 object-relational mapper, items() 没有返回模型的实例。当然，你可以从Django模型中很容易的获取一些数据，items()可以返回任何你想要的对象。
  • 如果你要创建一个Atom feed，而不是RSS feed，你需要使用subtitle属性替代description。查看Publishing Atom and RSS feeds in tandem里面的例子。

还有一件事没做。在一个 RSS feed中, 每一个 <item> 都有一个<title>, <link> 和<description>. 我们需要告诉框架那些数据放进这些对象中。

  • 在 <title>和<description>的内容中，Django尝试着在Feed类中召集item_title()和item_description()方法。他们会传入一个自己内部的单独的参数 item。这些都是可选的; 默认的是，unicode表示的对象都被使用了
    如果你想要做一些特殊的格式化title或者description，Django templates可以帮助你。他们的路径会被Feed类中的title_template和description_template 参数做特殊处理。会通过模板内容的两个变量来返回每一条记录到模板中：

a complex example Feed.``get_context_data**kwargs `Feed``get_context_data```` from mysite.models import Article from django.contrib.syndication.views import Feed

class ArticlesFeed(Feed): title = “My articles” description_template = “feeds/articles.html”

  1. def items(self):
  2.     return Article.objects.order_by('-pub_date')[:5]
  4. def get_context_data(self, **kwargs):
  5.     context = super(ArticlesFeed, self).get_context_data(**kwargs)
  6.     context['foo'] = 'bar'
  7.     return context

Something about {{ foo }}: {{ obj.description }}

  2. `items()`
  3.    - `item`：当前项目。出于向后兼容性原因，此上下文变量的名称为`{％ obj ％}`。
  4.    - `obj`：`get_object()`返回的对象。默认情况下，这不会暴露给模板，以避免与`{％ obj ％}` ，但您可以在实现`get_context_data()`时使用它。
  5.    - `site`：如上所述的当前网站。
  6.    - `request`：当前请求。
  8. `get_context_data()`[_generic views_](_topics_class-based-views_generic-display.html#adding-extra-context)`super()`
  9. - 
  10. 要指定`<link>`的内容，您有两个选项。对于`items()`中的每个项目，Django首先尝试调用[`Feed`](486c9fc7a88c3b5c025c2cd87c3cd225)类上的`item_link()`方法。以类似于标题和描述的方式，它传递单个参数`item`。如果该方法不存在，Django尝试对该对象执行`get_absolute_url()`方法。`get_absolute_url()`和`item_link()`应将项目的网址作为普通的Python字符串返回。与`get_absolute_url()`一样，`item_link()`的结果将直接包含在URL中，因此您负责对所有必要的URL进行引用并将其转换为ASCII方法本身。
  13. <a name="a64ed0f0"></a>
  14. ### 一个复杂的例子
  16. 该框架还通过参数支持更复杂的feed。
  18. 例如，网站可以为城市中的每个警察节拍提供最近的犯罪的RSS源。为每个警察节拍创建一个单独的[`Feed`](486c9fc7a88c3b5c025c2cd87c3cd225)课；这将违反[_DRY principle_](_misc_design-philosophies.html#dry)并且将数据耦合到编程逻辑。相反，联合框架可让您访问从[_URLconf_](_topics_http_urls.html)传递的参数，以便Feed可以根据Feed的网址中的信息输出项目。
  20. 警察打击饲料可以通过这样的URL访问：
  22. - `/beats/613/rss/` - 返回613的最近犯罪。
  23. - `/beats/1424/rss/` - 返回1424年最近的犯罪。
  25. 这些可以与[_URLconf_](_topics_http_urls.html)行匹配，例如：

url(r’^beats/(?P[0-9]+)/rss/$’, BeatFeed()),

  2. 与视图类似，URL中的参数与请求对象一起传递到`get_object()`方法。
  4. 以下是这些特定于节拍的Feed的代码：

from django.contrib.syndication.views import FeedDoesNotExist from django.shortcuts import get_object_or_404

class BeatFeed(Feed): description_template = ‘feeds/beat_description.html’

  1. def get_object(self, request, beat_id):
  2.     return get_object_or_404(Beat, pk=beat_id)
  4. def title(self, obj):
  5.     return "Police beat central: Crimes for beat %s" % obj.beat
  7. def link(self, obj):
  8.     return obj.get_absolute_url()
  10. def description(self, obj):
  11.     return "Crimes recently reported in police beat %s" % obj.beat
  13. def items(self, obj):
  14.     return Crime.objects.filter(beat=obj).order_by('-crime_date')[:30]
  2. To generate the feed’s `&lt;title&gt;`, `&lt;link&gt;` and `&lt;description&gt;`, Django uses the `title()`, `link()` and `description()` methods. 在前面的示例中，它们是简单的字符串类属性，但是本示例说明它们可以是字符串_或_方法。对于`title`，`link`和`description`中的每一个，Django都遵循此算法：
  4. - 首先，它尝试调用传递`obj`参数的方法，其中`obj`是由`get_object()`返回的对象。
  5. - 如果没有，它试图调用没有参数的方法。
  6. - 如果没有，它使用类属性。
  8. 还要注意，`items()`也遵循相同的算法 - 首先，它尝试`items(obj)`，然后`items()` `items`类属性（它应该是一个列表）。
  10. 我们正在使用模板作为项目描述。它可以很简单：

{{ obj.description }}

  2. 但是，您可以根据需要自由添加格式。
  4. 下面的`ExampleFeed`类提供了有关[`Feed`](486c9fc7a88c3b5c025c2cd87c3cd225)类的方法和属性的完整文档。
  6. <a name="4eb8e2be"></a>
  7. ### 指定Feed的类型
  9. 默认情况下，此框架中生成的Feed使用RSS 2.0。
  11. 要更改此属性，请向您的[`Feed`](486c9fc7a88c3b5c025c2cd87c3cd225)类添加`feed_type`属性，如下所示：

from django.utils.feedgenerator import Atom1Feed

class MyFeed(Feed): feed_type = Atom1Feed

  2. 请注意，您将`feed_type`设置为类对象，而不是实例。
  4. 目前可用的Feed类型有：
  6. - [`django.utils.feedgenerator.Rss201rev2Feed`](703ccc64475acd54a8019d9cdb44e9c5)（RSS 2.01。默认。）
  7. - [`django.utils.feedgenerator.RssUserland091Feed`](7d4c5e298fd0c76cec8e5156076e7ce9)（RSS 0.91.）
  8. - [`django.utils.feedgenerator.Atom1Feed`](4af197e6c5697ca3074305565d6513c4)（Atom 1.0.）
  10. <a name="c9a6ee90"></a>
  11. ### 附件
  13. 要指定机柜（例如用于创建Podcast Feed的机柜），请使用`item_enclosure_url`，`item_enclosure_length`和`item_enclosure_mime_type`挂钩。有关用法示例，请参见下面的`ExampleFeed`类。
  15. <a name="295bb704"></a>
  16. ### 语言
  18. 由联合框架创建的Feed会自动包含适当的`&lt;language&gt;`标记（RSS 2.0）或`xml:lang`属性（Atom）。这直接来自您的[`LANGUAGE_CODE`]()设置。
  20. <a name="b3b91f77"></a>
  21. ### 网址
  23. `link`方法/属性可以返回绝对路径（例如`"/blog/"`）或具有完全限定域和协议的URL（例如`"http://www.example.com/blog/"`）。如果`link`未返回域，则整合框架将根据您的[`SITE_ID setting`]()。
  25. Atom Feed需要定义Feed的当前位置的`＆lt； link rel =“self”＆gt；`。
  27. <a name="fd8feafc"></a>
  28. ### 串联发布Atom和RSS Feed
  30. 有些开发人员喜欢提供Atom _和_ RSS版本的Feed。使用Django很容易：只需创建[`Feed`](486c9fc7a88c3b5c025c2cd87c3cd225)类的子类，并将`feed_type`设置为不同的类型即可。然后更新您的URLconf以添加额外的版本。
  32. 这里有一个完整的例子：

from django.contrib.syndication.views import Feed from policebeat.models import NewsItem from django.utils.feedgenerator import Atom1Feed

class RssSiteNewsFeed(Feed): title = “Police beat site news” link = “/sitenews/“ description = “Updates on changes and additions to police beat central.”

  1. def items(self):
  2.     return NewsItem.objects.order_by('-pub_date')[:5]

class AtomSiteNewsFeed(RssSiteNewsFeed): feed_type = Atom1Feed subtitle = RssSiteNewsFeed.description

  2. 注意
  4. 在此示例中，RSS提要使用`description`，而Atom提要使用`subtitle`。这是因为Atom Feed不提供Feed级“说明”，但他们提供“字幕”。
  6. 如果您在[`Feed`](486c9fc7a88c3b5c025c2cd87c3cd225)类中提供`description`，Django将_不会_自动将其放入`subtitle`字幕和描述不一定是同一件事。而应定义`subtitle`属性。
  8. 在上面的示例中，我们只需将Atom Feed的`subtitle`设置为RSS Feed的`description`，因为它已经很短。
  10. 和附带的URLconf：

from django.conf.urls import url from myproject.feeds import RssSiteNewsFeed, AtomSiteNewsFeed

urlpatterns = [

  1. # ...
  2. url(r'^sitenews/rss/$', RssSiteNewsFeed()),
  3. url(r'^sitenews/atom/$', AtomSiteNewsFeed()),
  4. # ...

]

  2. <a name="9d7ebafc"></a>
  3. ### Feed类引用
  5. _class_ `views.``Feed`
  7. 此示例说明[`Feed`](486c9fc7a88c3b5c025c2cd87c3cd225)类的所有可能的属性和方法：

from django.contrib.syndication.views import Feed from django.utils import feedgenerator

class ExampleFeed(Feed):

  1. # FEED TYPE -- Optional. This should be a class that subclasses
  2. # django.utils.feedgenerator.SyndicationFeed. This designates
  3. # which type of feed this should be: RSS 2.0, Atom 1.0, etc. If
  4. # you don't specify feed_type, your feed will be RSS 2.0\. This
  5. # should be a class, not an instance of the class.
  7. feed_type = feedgenerator.Rss201rev2Feed
  9. # TEMPLATE NAMES -- Optional. These should be strings
  10. # representing names of Django templates that the system should
  11. # use in rendering the title and description of your feed items.
  12. # Both are optional. If a template is not specified, the
  13. # item_title() or item_description() methods are used instead.
  15. title_template = None
  16. description_template = None
  18. # TITLE -- One of the following three is required. The framework
  19. # looks for them in this order.
  21. def title(self, obj):
  22.     """

Takes the object returned by get_object() and returns the feed’s title as a normal Python string. “””

  1. def title(self):
  2.     """

Returns the feed’s title as a normal Python string. “””

  1. title = 'foo' # Hard-coded title.
  3. # LINK -- One of the following three is required. The framework
  4. # looks for them in this order.
  6. def link(self, obj):
  7.     """

Takes the object returned by get_object() and returns the URL

of the HTML version of the feed as a normal Python string.

“””

  1. def link(self):
  2.     """

Returns the URL of the HTML version of the feed as a normal Python string. “””

  1. link = '/blog/' # Hard-coded URL.
  3. # FEED_URL -- One of the following three is optional. The framework
  4. # looks for them in this order.
  6. def feed_url(self, obj):
  7.     """

Takes the object returned by get_object() and returns the feed’s

own URL as a normal Python string.

“””

  1. def feed_url(self):
  2.     """

Returns the feed’s own URL as a normal Python string. “””

  1. feed_url = '/blog/rss/' # Hard-coded URL.
  3. # GUID -- One of the following three is optional. The framework looks
  4. # for them in this order. This property is only used for Atom feeds
  5. # (where it is the feed-level ID element). If not provided, the feed
  6. # link is used as the ID.
  8. def feed_guid(self, obj):
  9.     """

Takes the object returned by get_object() and returns the globally unique ID for the feed as a normal Python string. “””

  1. def feed_guid(self):
  2.     """

Returns the feed’s globally unique ID as a normal Python string. “””

  1. feed_guid = '/foo/bar/1234' # Hard-coded guid.
  3. # DESCRIPTION -- One of the following three is required. The framework
  4. # looks for them in this order.
  6. def description(self, obj):
  7.     """

Takes the object returned by get_object() and returns the feed’s description as a normal Python string. “””

  1. def description(self):
  2.     """

Returns the feed’s description as a normal Python string. “””

  1. description = 'Foo bar baz.' # Hard-coded description.
  3. # AUTHOR NAME --One of the following three is optional. The framework
  4. # looks for them in this order.
  6. def author_name(self, obj):
  7.     """

Takes the object returned by get_object() and returns the feed’s author’s name as a normal Python string. “””

  1. def author_name(self):
  2.     """

Returns the feed’s author’s name as a normal Python string. “””

  1. author_name = 'Sally Smith' # Hard-coded author name.
  3. # AUTHOR EMAIL --One of the following three is optional. The framework
  4. # looks for them in this order.
  6. def author_email(self, obj):
  7.     """

Takes the object returned by get_object() and returns the feed’s author’s email as a normal Python string. “””

  1. def author_email(self):
  2.     """

Returns the feed’s author’s email as a normal Python string. “””

  1. author_email = 'test@example.com' # Hard-coded author email.
  3. # AUTHOR LINK --One of the following three is optional. The framework
  4. # looks for them in this order. In each case, the URL should include
  5. # the "http://" and domain name.
  7. def author_link(self, obj):
  8.     """

Takes the object returned by get_object() and returns the feed’s author’s URL as a normal Python string. “””

  1. def author_link(self):
  2.     """

Returns the feed’s author’s URL as a normal Python string. “””

  1. author_link = 'http://www.example.com/' # Hard-coded author URL.
  3. # CATEGORIES -- One of the following three is optional. The framework
  4. # looks for them in this order. In each case, the method/attribute
  5. # should return an iterable object that returns strings.
  7. def categories(self, obj):
  8.     """

Takes the object returned by get_object() and returns the feed’s categories as iterable over strings. “””

  1. def categories(self):
  2.     """

Returns the feed’s categories as iterable over strings. “””

  1. categories = ("python", "django") # Hard-coded list of categories.
  3. # COPYRIGHT NOTICE -- One of the following three is optional. The
  4. # framework looks for them in this order.
  6. def feed_copyright(self, obj):
  7.     """

Takes the object returned by get_object() and returns the feed’s copyright notice as a normal Python string. “””

  1. def feed_copyright(self):
  2.     """

Returns the feed’s copyright notice as a normal Python string. “””

  1. feed_copyright = 'Copyright (c) 2007, Sally Smith' # Hard-coded copyright notice.
  3. # TTL -- One of the following three is optional. The framework looks
  4. # for them in this order. Ignored for Atom feeds.
  6. def ttl(self, obj):
  7.     """

Takes the object returned by get_object() and returns the feed’s TTL (Time To Live) as a normal Python string. “””

  1. def ttl(self):
  2.     """

Returns the feed’s TTL as a normal Python string. “””

  1. ttl = 600 # Hard-coded Time To Live.
  3. # ITEMS -- One of the following three is required. The framework looks
  4. # for them in this order.
  6. def items(self, obj):
  7.     """

Takes the object returned by get_object() and returns a list of items to publish in this feed. “””

  1. def items(self):
  2.     """

Returns a list of items to publish in this feed. “””

  1. items = ('Item 1', 'Item 2') # Hard-coded items.
  3. # GET_OBJECT -- This is required for feeds that publish different data
  4. # for different URL parameters. (See "A complex example" above.)
  6. def get_object(self, request, *args, **kwargs):
  7.     """

Takes the current request and the arguments from the URL, and returns an object represented by this feed. Raises django.core.exceptions.ObjectDoesNotExist on error. “””

  1. # ITEM TITLE AND DESCRIPTION -- If title_template or
  2. # description_template are not defined, these are used instead. Both are
  3. # optional, by default they will use the unicode representation of the
  4. # item.
  6. def item_title(self, item):
  7.     """

Takes an item, as returned by items(), and returns the item’s title as a normal Python string. “””

  1. def item_title(self):
  2.     """

Returns the title for every item in the feed. “””

  1. item_title = 'Breaking News: Nothing Happening' # Hard-coded title.
  3. def item_description(self, item):
  4.     """

Takes an item, as returned by items(), and returns the item’s description as a normal Python string. “””

  1. def item_description(self):
  2.     """

Returns the description for every item in the feed. “””

  1. item_description = 'A description of the item.' # Hard-coded description.
  3. def get_context_data(self, **kwargs):
  4.     """

Returns a dictionary to use as extra context if either description_template or item_template are used.

Default implementation preserves the old behavior of using {‘obj’: item, ‘site’: current_site} as the context. “””

  1. # ITEM LINK -- One of these three is required. The framework looks for
  2. # them in this order.
  4. # First, the framework tries the two methods below, in
  5. # order. Failing that, it falls back to the get_absolute_url()
  6. # method on each item returned by items().
  8. def item_link(self, item):
  9.     """

Takes an item, as returned by items(), and returns the item’s URL. “””

  1. def item_link(self):
  2.     """

Returns the URL for every item in the feed. “””

  1. # ITEM_GUID -- The following method is optional. If not provided, the
  2. # item's link is used by default.
  4. def item_guid(self, obj):
  5.     """

Takes an item, as return by items(), and returns the item’s ID. “””

  1. # ITEM_GUID_IS_PERMALINK -- The following method is optional. If
  2. # provided, it sets the 'isPermaLink' attribute of an item's
  3. # GUID element. This method is used only when 'item_guid' is
  4. # specified.
  6. def item_guid_is_permalink(self, obj):
  7.     """

Takes an item, as returned by items(), and returns a boolean. “””

  1. item_guid_is_permalink = False  # Hard coded value
  3. # ITEM AUTHOR NAME -- One of the following three is optional. The
  4. # framework looks for them in this order.
  6. def item_author_name(self, item):
  7.     """

Takes an item, as returned by items(), and returns the item’s author’s name as a normal Python string. “””

  1. def item_author_name(self):
  2.     """

Returns the author name for every item in the feed. “””

  1. item_author_name = 'Sally Smith' # Hard-coded author name.
  3. # ITEM AUTHOR EMAIL --One of the following three is optional. The
  4. # framework looks for them in this order.
  5. #
  6. # If you specify this, you must specify item_author_name.
  8. def item_author_email(self, obj):
  9.     """

Takes an item, as returned by items(), and returns the item’s author’s email as a normal Python string. “””

  1. def item_author_email(self):
  2.     """

Returns the author email for every item in the feed. “””

  1. item_author_email = 'test@example.com' # Hard-coded author email.
  3. # ITEM AUTHOR LINK -- One of the following three is optional. The
  4. # framework looks for them in this order. In each case, the URL should
  5. # include the "http://" and domain name.
  6. #
  7. # If you specify this, you must specify item_author_name.
  9. def item_author_link(self, obj):
  10.     """

Takes an item, as returned by items(), and returns the item’s author’s URL as a normal Python string. “””

  1. def item_author_link(self):
  2.     """

Returns the author URL for every item in the feed. “””

  1. item_author_link = 'http://www.example.com/' # Hard-coded author URL.
  3. # ITEM ENCLOSURE URL -- One of these three is required if you're
  4. # publishing enclosures. The framework looks for them in this order.
  6. def item_enclosure_url(self, item):
  7.     """

Takes an item, as returned by items(), and returns the item’s enclosure URL. “””

  1. def item_enclosure_url(self):
  2.     """

Returns the enclosure URL for every item in the feed. “””

  1. item_enclosure_url = "/foo/bar.mp3" # Hard-coded enclosure link.
  3. # ITEM ENCLOSURE LENGTH -- One of these three is required if you're
  4. # publishing enclosures. The framework looks for them in this order.
  5. # In each case, the returned value should be either an integer, or a
  6. # string representation of the integer, in bytes.
  8. def item_enclosure_length(self, item):
  9.     """

Takes an item, as returned by items(), and returns the item’s enclosure length. “””

  1. def item_enclosure_length(self):
  2.     """

Returns the enclosure length for every item in the feed. “””

  1. item_enclosure_length = 32000 # Hard-coded enclosure length.
  3. # ITEM ENCLOSURE MIME TYPE -- One of these three is required if you're
  4. # publishing enclosures. The framework looks for them in this order.
  6. def item_enclosure_mime_type(self, item):
  7.     """

Takes an item, as returned by items(), and returns the item’s enclosure MIME type. “””

  1. def item_enclosure_mime_type(self):
  2.     """

Returns the enclosure MIME type for every item in the feed. “””

  1. item_enclosure_mime_type = "audio/mpeg" # Hard-coded enclosure MIME type.
  3. # ITEM PUBDATE -- It's optional to use one of these three. This is a
  4. # hook that specifies how to get the pubdate for a given item.
  5. # In each case, the method/attribute should return a Python
  6. # datetime.datetime object.
  8. def item_pubdate(self, item):
  9.     """

Takes an item, as returned by items(), and returns the item’s pubdate. “””

  1. def item_pubdate(self):
  2.     """

Returns the pubdate for every item in the feed. “””

  1. item_pubdate = datetime.datetime(2005, 5, 3) # Hard-coded pubdate.
  3. # ITEM UPDATED -- It's optional to use one of these three. This is a
  4. # hook that specifies how to get the updateddate for a given item.
  5. # In each case, the method/attribute should return a Python
  6. # datetime.datetime object.
  8. def item_updateddate(self, item):
  9.     """

Takes an item, as returned by items(), and returns the item’s updateddate. “””

  1. def item_updateddate(self):
  2.     """

Returns the updateddated for every item in the feed. “””

  1. item_updateddate = datetime.datetime(2005, 5, 3) # Hard-coded updateddate.
  3. # ITEM CATEGORIES -- It's optional to use one of these three. This is
  4. # a hook that specifies how to get the list of categories for a given
  5. # item. In each case, the method/attribute should return an iterable
  6. # object that returns strings.
  8. def item_categories(self, item):
  9.     """

Takes an item, as returned by items(), and returns the item’s categories. “””

  1. def item_categories(self):
  2.     """

Returns the categories for every item in the feed. “””

  1. item_categories = ("python", "django") # Hard-coded categories.
  3. # ITEM COPYRIGHT NOTICE (only applicable to Atom feeds) -- One of the
  4. # following three is optional. The framework looks for them in this
  5. # order.
  7. def item_copyright(self, obj):
  8.     """

Takes an item, as returned by items(), and returns the item’s copyright notice as a normal Python string. “””

  1. def item_copyright(self):
  2.     """

Returns the copyright notice for every item in the feed. “””

  1. item_copyright = 'Copyright (c) 2007, Sally Smith' # Hard-coded copyright notice.
  2. <a name="9dcff8e8"></a>
  3. ## 低级框架
  5. 在后台，高级RSS框架使用较低级别的框架来生成订阅源的XML。此框架存在于单个模块中：[django / utils / feedgenerator.py](https://github.com/django/django/blob/master/django/utils/feedgenerator.py)。
  7. 您自己使用此框架，用于生成较低级别的Feed。您还可以创建自定义Feed生成器子类，以与`feed_type` `Feed`选项一起使用。
  9. <a name="98904659"></a>
  10. ### 联合供稿 classes
  12. [`feedgenerator`](5de86f2f06a3b35278ced82c525d9226)模块包含基类：
  14. - [django.utils.feedgenerator.SyndicationFeed](205d1ae84380c366b45853120b596631)
  16. 和几个子类：
  18. - [django.utils.feedgenerator.RssUserland091Feed](7d4c5e298fd0c76cec8e5156076e7ce9)
  19. - [django.utils.feedgenerator.Rss201rev2Feed](703ccc64475acd54a8019d9cdb44e9c5)
  20. - [django.utils.feedgenerator.Atom1Feed](4af197e6c5697ca3074305565d6513c4)
  22. 这三个类中的每一个都知道如何将某种类型的feed呈现为XML。他们共享这个接口：
  24. [`SyndicationFeed.__init__()`](a0a8daa392ea13a6545cef1c24f4fd8c)
  26. 使用给定的元数据字典初始化Feed，该元数据字典应用于整个Feed。必需的关键字参数为：
  28. - `title`
  29. - `link`
  30. - `description`
  32. 还有一堆其他可选关键字：
  34. - `language`
  35. - `author_email`
  36. - `author_name`
  37. - `author_link`
  38. - `subtitle`
  39. - `categories`
  40. - `feed_url`
  41. - `feed_copyright`
  42. - `feed_guid`
  43. - `ttl`
  45. 您传递给`__init__`的任何其他关键字参数将存储在`self.feed`中以与[自定义Feed生成器](_#custom-feed-generators)配合使用。
  47. 所有参数都应该是Unicode对象，除了`categories`，它应该是Unicode对象序列。
  49. [`SyndicationFeed.add_item()`](82e4b5d911d1483ca3008384f7bef69b)
  51. 向具有给定参数的Feed中添加项目。
  53. 必需的关键字参数为：
  55. - `title`
  56. - `link`
  57. - `description`
  59. 可选的关键字参数为：
  61. - `author_email`
  62. - `author_name`
  63. - `author_link`
  64. - `pubdate`
  65. - `comments`
  66. - `unique_id`
  67. - `enclosure`
  68. - `categories`
  69. - `item_copyright`
  70. - `ttl`
  71. - `updateddate`
  73. 将为[自定义Feed生成器](_#custom-feed-generators)存储额外的关键字参数。
  75. 所有参数，如果给定，应该是Unicode对象，除了：
  77. - `pubdate`应为Python [`datetime`](https://docs.python.org/3/library/datetime.html#datetime.datetime)对象。
  78. - `updateddate`应为Python [`datetime`](https://docs.python.org/3/library/datetime.html#datetime.datetime)对象。
  79. - `enclosure`应为[`django.utils.feedgenerator.Enclosure`](ec868fae877c3b1f0de22227d1d3f80a)的实例。
  80. - `categories`应为Unicode对象序列。
  82. New in Django 1.7:
  84. 已添加可选的`updateddate`参数。
  86. [`SyndicationFeed.write()`](27bd7b7ea86d7c55061c39701c1bbb12)
  88. Outputs the feed in the given encoding to outfile, which is a file-like object.
  90. [`SyndicationFeed.writeString()`](1bafeda259a0d4ce906502a1798608a1)
  92. Returns the feed as a string in the given encoding.
  94. 例如，要创建Atom 1.0订阅源并将其打印到标准输出：

from django.utils import feedgenerator from datetime import datetime f = feedgenerator.Atom1Feed( … title=”My Weblog”, … link=”http://www.example.com/“, … description=”In which I write about what I ate today.”, … language=”en”, … author_name=”Myself”, … feed_url=”http://example.com/atom.xml“) f.add_item(title=”Hot dog today”, … link=”http://www.example.com/entries/1/“, … pubdate=datetime.now(), … description=”

Today I had a Vienna Beef hot dog. It was pink, plump and perfect.

“) print(f.writeString(‘UTF-8’)) <?xml version=”1.0” encoding=”UTF-8”?>

… ```

自定义Feed生成器

如果您需要生成自定义Feed格式，您有几个选项。

如果Feed格式是完全自定义的，您需要将SyndicationFeed作为子类，并完全替换write()和writeString()方法。

但是，如果Feed格式是RSS或Atom分拆（即GeoRSS，Apple的iTunes podcast格式等），则您有了更好的选择。这些类型的Feed通常会向底层格式添加额外的元素和/或属性，并且有一组方法可以SyndicationFeed调用以获取这些额外的属性。因此，您可以对相应的Feed生成器类（Atom1Feed或Rss201rev2Feed）进行子类化，并扩展这些回调。他们是：

SyndicationFeed.root_attributes(self, )

Return a dict of attributes to add to the root feed element (feed/channel).

SyndicationFeed.add_root_elements(self, handler)

Callback to add elements inside the root feed element (feed/channel). handler is an XMLGenerator from Python’s built-in SAX library; you’ll call methods on it to add to the XML document in process.

SyndicationFeed.item_attributes(self, item)

Return a dict of attributes to add to each item (item/entry) element. The argument, item, is a dictionary of all the data passed to SyndicationFeed.add_item().

SyndicationFeed.add_item_elements(self, handler, item)

Callback to add elements to each item (item/entry) element. handler and item are as above.

警告

如果您覆盖任何这些方法，请务必调用超类方法，因为它们为每种Feed格式添加了必需的元素。

例如，您可能开始实现iTunes RSS Feed生成器，如：

  1. class iTunesFeed(Rss201rev2Feed):
  2.     def root_attributes(self):
  3.         attrs = super(iTunesFeed, self).root_attributes()
  4.         attrs['xmlns:itunes'] = 'http://www.itunes.com/dtds/podcast-1.0.dtd'
  5.         return attrs
  7.     def add_root_elements(self, handler):
  8.         super(iTunesFeed, self).add_root_elements(handler)
  9.         handler.addQuickElement('itunes:explicit', 'clean')

显然，对于一个完整的自定义feed类，还有很多工作要做，但上面的例子应该展示基本的想法。

{% endraw %}