{% 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方法的实现。例如:

    1. from mysite.models import Article
    2. from django.contrib.syndication.views import Feed
    4. class ArticlesFeed(Feed):
    5.     title = "My articles"
    6.     description_template = "feeds/articles.html"
    8.     def items(self):
    9.         return Article.objects.order_by('-pub_date')[:5]
    11.     def get_context_data(self, **kwargs):
    12.         context = super(ArticlesFeed, self).get_context_data(**kwargs)
    13.         context['foo'] = 'bar'
    14.         return context

    和模板：

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

    此方法将由items()返回的列表中的每个项目调用一次，并使用以下关键字参数：

    • item：当前项目。出于向后兼容性原因，此上下文变量的名称为{％ obj ％}。
    • obj：get_object()返回的对象。默认情况下，这不会暴露给模板，以避免与{％ obj ％} ，但您可以在实现get_context_data()时使用它。
    • site：如上所述的当前网站。
    • request：当前请求。

    get_context_data()的行为模仿了generic views的行为 - 你应该调用super()从父类中检索上下文数据，添加您的数据并返回修改后的字典。

  • 要指定<link>的内容，您有两个选项。对于items()中的每个项目，Django首先尝试调用Feed类上的item_link()方法。以类似于标题和描述的方式，它传递单个参数item。如果该方法不存在，Django尝试对该对象执行get_absolute_url()方法。get_absolute_url()和item_link()应将项目的网址作为普通的Python字符串返回。与get_absolute_url()一样，item_link()的结果将直接包含在URL中，因此您负责对所有必要的URL进行引用并将其转换为ASCII方法本身。

一个复杂的例子

该框架还通过参数支持更复杂的feed。

例如，网站可以为城市中的每个警察节拍提供最近的犯罪的RSS源。为每个警察节拍创建一个单独的Feed课；这将违反DRY principle并且将数据耦合到编程逻辑。相反，联合框架可让您访问从URLconf传递的参数，以便Feed可以根据Feed的网址中的信息输出项目。

警察打击饲料可以通过这样的URL访问：

  • /beats/613/rss/ - 返回613的最近犯罪。
  • /beats/1424/rss/ - 返回1424年最近的犯罪。

这些可以与URLconf行匹配，例如：

  1. url(r'^beats/(?P<beat_id>[0-9]+)/rss/$', BeatFeed()),

与视图类似，URL中的参数与请求对象一起传递到get_object()方法。

以下是这些特定于节拍的Feed的代码：

  1. from django.contrib.syndication.views import FeedDoesNotExist
  2. from django.shortcuts import get_object_or_404
  4. class BeatFeed(Feed):
  5.     description_template = 'feeds/beat_description.html'
  7.     def get_object(self, request, beat_id):
  8.         return get_object_or_404(Beat, pk=beat_id)
  10.     def title(self, obj):
  11.         return "Police beat central: Crimes for beat %s" % obj.beat
  13.     def link(self, obj):
  14.         return obj.get_absolute_url()
  16.     def description(self, obj):
  17.         return "Crimes recently reported in police beat %s" % obj.beat
  19.     def items(self, obj):
  20.         return Crime.objects.filter(beat=obj).order_by('-crime_date')[:30]

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都遵循此算法：

  • 首先，它尝试调用传递obj参数的方法，其中obj是由get_object()返回的对象。
  • 如果没有，它试图调用没有参数的方法。
  • 如果没有，它使用类属性。

还要注意，items()也遵循相同的算法 - 首先，它尝试items(obj)，然后items() items类属性（它应该是一个列表）。

我们正在使用模板作为项目描述。它可以很简单：

  1. {{ obj.description }}

但是，您可以根据需要自由添加格式。

下面的ExampleFeed类提供了有关Feed类的方法和属性的完整文档。

指定Feed的类型

默认情况下，此框架中生成的Feed使用RSS 2.0。

要更改此属性，请向您的Feed类添加feed_type属性，如下所示：

  1. from django.utils.feedgenerator import Atom1Feed
  3. class MyFeed(Feed):
  4.     feed_type = Atom1Feed

请注意，您将feed_type设置为类对象，而不是实例。

目前可用的Feed类型有：

附件

要指定机柜（例如用于创建Podcast Feed的机柜），请使用item_enclosure_url，item_enclosure_length和item_enclosure_mime_type挂钩。有关用法示例，请参见下面的ExampleFeed类。

语言

由联合框架创建的Feed会自动包含适当的&lt;language&gt;标记（RSS 2.0）或xml:lang属性（Atom）。这直接来自您的LANGUAGE_CODE设置。

网址

link方法/属性可以返回绝对路径（例如"/blog/"）或具有完全限定域和协议的URL（例如"http://www.example.com/blog/"）。如果link未返回域，则整合框架将根据您的SITE_ID setting。

Atom Feed需要定义Feed的当前位置的＆lt； link rel =“self”＆gt；。

串联发布Atom和RSS Feed

有些开发人员喜欢提供Atom 和 RSS版本的Feed。使用Django很容易：只需创建Feed类的子类，并将feed_type设置为不同的类型即可。然后更新您的URLconf以添加额外的版本。

这里有一个完整的例子：

  1. from django.contrib.syndication.views import Feed
  2. from policebeat.models import NewsItem
  3. from django.utils.feedgenerator import Atom1Feed
  5. class RssSiteNewsFeed(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. class AtomSiteNewsFeed(RssSiteNewsFeed):
  14.     feed_type = Atom1Feed
  15.     subtitle = RssSiteNewsFeed.description

注意

在此示例中，RSS提要使用description，而Atom提要使用subtitle。这是因为Atom Feed不提供Feed级“说明”，但他们提供“字幕”。

如果您在Feed类中提供description，Django将不会自动将其放入subtitle字幕和描述不一定是同一件事。而应定义subtitle属性。

在上面的示例中，我们只需将Atom Feed的subtitle设置为RSS Feed的description，因为它已经很短。

和附带的URLconf：

  1. from django.conf.urls import url
  2. from myproject.feeds import RssSiteNewsFeed, AtomSiteNewsFeed
  4. urlpatterns = [
  5.     # ...
  6.     url(r'^sitenews/rss/$', RssSiteNewsFeed()),
  7.     url(r'^sitenews/atom/$', AtomSiteNewsFeed()),
  8.     # ...
  9. ]

Feed类引用

class views.``Feed

此示例说明Feed类的所有可能的属性和方法：

  1. from django.contrib.syndication.views import Feed
  2. from django.utils import feedgenerator
  4. class ExampleFeed(Feed):
  6.     # FEED TYPE -- Optional. This should be a class that subclasses
  7.     # django.utils.feedgenerator.SyndicationFeed. This designates
  8.     # which type of feed this should be: RSS 2.0, Atom 1.0, etc. If
  9.     # you don't specify feed_type, your feed will be RSS 2.0\. This
  10.     # should be a class, not an instance of the class.
  12.     feed_type = feedgenerator.Rss201rev2Feed
  14.     # TEMPLATE NAMES -- Optional. These should be strings
  15.     # representing names of Django templates that the system should
  16.     # use in rendering the title and description of your feed items.
  17.     # Both are optional. If a template is not specified, the
  18.     # item_title() or item_description() methods are used instead.
  20.     title_template = None
  21.     description_template = None
  23.     # TITLE -- One of the following three is required. The framework
  24.     # looks for them in this order.
  26.     def title(self, obj):
  27.         """
  28.  Takes the object returned by get_object() and returns the
  29.  feed's title as a normal Python string.
  30.  """
  32.     def title(self):
  33.         """
  34.  Returns the feed's title as a normal Python string.
  35.  """
  37.     title = 'foo' # Hard-coded title.
  39.     # LINK -- One of the following three is required. The framework
  40.     # looks for them in this order.
  42.     def link(self, obj):
  43.         """
  44.  # Takes the object returned by get_object() and returns the URL
  45.  # of the HTML version of the feed as a normal Python string.
  46.  """
  48.     def link(self):
  49.         """
  50.  Returns the URL of the HTML version of the feed as a normal Python
  51.  string.
  52.  """
  54.     link = '/blog/' # Hard-coded URL.
  56.     # FEED_URL -- One of the following three is optional. The framework
  57.     # looks for them in this order.
  59.     def feed_url(self, obj):
  60.         """
  61.  # Takes the object returned by get_object() and returns the feed's
  62.  # own URL as a normal Python string.
  63.  """
  65.     def feed_url(self):
  66.         """
  67.  Returns the feed's own URL as a normal Python string.
  68.  """
  70.     feed_url = '/blog/rss/' # Hard-coded URL.
  72.     # GUID -- One of the following three is optional. The framework looks
  73.     # for them in this order. This property is only used for Atom feeds
  74.     # (where it is the feed-level ID element). If not provided, the feed
  75.     # link is used as the ID.
  77.     def feed_guid(self, obj):
  78.         """
  79.  Takes the object returned by get_object() and returns the globally
  80.  unique ID for the feed as a normal Python string.
  81.  """
  83.     def feed_guid(self):
  84.         """
  85.  Returns the feed's globally unique ID as a normal Python string.
  86.  """
  88.     feed_guid = '/foo/bar/1234' # Hard-coded guid.
  90.     # DESCRIPTION -- One of the following three is required. The framework
  91.     # looks for them in this order.
  93.     def description(self, obj):
  94.         """
  95.  Takes the object returned by get_object() and returns the feed's
  96.  description as a normal Python string.
  97.  """
  99.     def description(self):
  100.         """
  101.  Returns the feed's description as a normal Python string.
  102.  """
  104.     description = 'Foo bar baz.' # Hard-coded description.
  106.     # AUTHOR NAME --One of the following three is optional. The framework
  107.     # looks for them in this order.
  109.     def author_name(self, obj):
  110.         """
  111.  Takes the object returned by get_object() and returns the feed's
  112.  author's name as a normal Python string.
  113.  """
  115.     def author_name(self):
  116.         """
  117.  Returns the feed's author's name as a normal Python string.
  118.  """
  120.     author_name = 'Sally Smith' # Hard-coded author name.
  122.     # AUTHOR EMAIL --One of the following three is optional. The framework
  123.     # looks for them in this order.
  125.     def author_email(self, obj):
  126.         """
  127.  Takes the object returned by get_object() and returns the feed's
  128.  author's email as a normal Python string.
  129.  """
  131.     def author_email(self):
  132.         """
  133.  Returns the feed's author's email as a normal Python string.
  134.  """
  136.     author_email = 'test@example.com' # Hard-coded author email.
  138.     # AUTHOR LINK --One of the following three is optional. The framework
  139.     # looks for them in this order. In each case, the URL should include
  140.     # the "http://" and domain name.
  142.     def author_link(self, obj):
  143.         """
  144.  Takes the object returned by get_object() and returns the feed's
  145.  author's URL as a normal Python string.
  146.  """
  148.     def author_link(self):
  149.         """
  150.  Returns the feed's author's URL as a normal Python string.
  151.  """
  153.     author_link = 'http://www.example.com/' # Hard-coded author URL.
  155.     # CATEGORIES -- One of the following three is optional. The framework
  156.     # looks for them in this order. In each case, the method/attribute
  157.     # should return an iterable object that returns strings.
  159.     def categories(self, obj):
  160.         """
  161.  Takes the object returned by get_object() and returns the feed's
  162.  categories as iterable over strings.
  163.  """
  165.     def categories(self):
  166.         """
  167.  Returns the feed's categories as iterable over strings.
  168.  """
  170.     categories = ("python", "django") # Hard-coded list of categories.
  172.     # COPYRIGHT NOTICE -- One of the following three is optional. The
  173.     # framework looks for them in this order.
  175.     def feed_copyright(self, obj):
  176.         """
  177.  Takes the object returned by get_object() and returns the feed's
  178.  copyright notice as a normal Python string.
  179.  """
  181.     def feed_copyright(self):
  182.         """
  183.  Returns the feed's copyright notice as a normal Python string.
  184.  """
  186.     feed_copyright = 'Copyright (c) 2007, Sally Smith' # Hard-coded copyright notice.
  188.     # TTL -- One of the following three is optional. The framework looks
  189.     # for them in this order. Ignored for Atom feeds.
  191.     def ttl(self, obj):
  192.         """
  193.  Takes the object returned by get_object() and returns the feed's
  194.  TTL (Time To Live) as a normal Python string.
  195.  """
  197.     def ttl(self):
  198.         """
  199.  Returns the feed's TTL as a normal Python string.
  200.  """
  202.     ttl = 600 # Hard-coded Time To Live.
  204.     # ITEMS -- One of the following three is required. The framework looks
  205.     # for them in this order.
  207.     def items(self, obj):
  208.         """
  209.  Takes the object returned by get_object() and returns a list of
  210.  items to publish in this feed.
  211.  """
  213.     def items(self):
  214.         """
  215.  Returns a list of items to publish in this feed.
  216.  """
  218.     items = ('Item 1', 'Item 2') # Hard-coded items.
  220.     # GET_OBJECT -- This is required for feeds that publish different data
  221.     # for different URL parameters. (See "A complex example" above.)
  223.     def get_object(self, request, *args, **kwargs):
  224.         """
  225.  Takes the current request and the arguments from the URL, and
  226.  returns an object represented by this feed. Raises
  227.  django.core.exceptions.ObjectDoesNotExist on error.
  228.  """
  230.     # ITEM TITLE AND DESCRIPTION -- If title_template or
  231.     # description_template are not defined, these are used instead. Both are
  232.     # optional, by default they will use the unicode representation of the
  233.     # item.
  235.     def item_title(self, item):
  236.         """
  237.  Takes an item, as returned by items(), and returns the item's
  238.  title as a normal Python string.
  239.  """
  241.     def item_title(self):
  242.         """
  243.  Returns the title for every item in the feed.
  244.  """
  246.     item_title = 'Breaking News: Nothing Happening' # Hard-coded title.
  248.     def item_description(self, item):
  249.         """
  250.  Takes an item, as returned by items(), and returns the item's
  251.  description as a normal Python string.
  252.  """
  254.     def item_description(self):
  255.         """
  256.  Returns the description for every item in the feed.
  257.  """
  259.     item_description = 'A description of the item.' # Hard-coded description.
  261.     def get_context_data(self, **kwargs):
  262.         """
  263.  Returns a dictionary to use as extra context if either
  264.  description_template or item_template are used.
  266.  Default implementation preserves the old behavior
  267.  of using {'obj': item, 'site': current_site} as the context.
  268.  """
  270.     # ITEM LINK -- One of these three is required. The framework looks for
  271.     # them in this order.
  273.     # First, the framework tries the two methods below, in
  274.     # order. Failing that, it falls back to the get_absolute_url()
  275.     # method on each item returned by items().
  277.     def item_link(self, item):
  278.         """
  279.  Takes an item, as returned by items(), and returns the item's URL.
  280.  """
  282.     def item_link(self):
  283.         """
  284.  Returns the URL for every item in the feed.
  285.  """
  287.     # ITEM_GUID -- The following method is optional. If not provided, the
  288.     # item's link is used by default.
  290.     def item_guid(self, obj):
  291.         """
  292.  Takes an item, as return by items(), and returns the item's ID.
  293.  """
  295.     # ITEM_GUID_IS_PERMALINK -- The following method is optional. If
  296.     # provided, it sets the 'isPermaLink' attribute of an item's
  297.     # GUID element. This method is used only when 'item_guid' is
  298.     # specified.
  300.     def item_guid_is_permalink(self, obj):
  301.         """
  302.  Takes an item, as returned by items(), and returns a boolean.
  303.  """
  305.     item_guid_is_permalink = False  # Hard coded value
  307.     # ITEM AUTHOR NAME -- One of the following three is optional. The
  308.     # framework looks for them in this order.
  310.     def item_author_name(self, item):
  311.         """
  312.  Takes an item, as returned by items(), and returns the item's
  313.  author's name as a normal Python string.
  314.  """
  316.     def item_author_name(self):
  317.         """
  318.  Returns the author name for every item in the feed.
  319.  """
  321.     item_author_name = 'Sally Smith' # Hard-coded author name.
  323.     # ITEM AUTHOR EMAIL --One of the following three is optional. The
  324.     # framework looks for them in this order.
  325.     #
  326.     # If you specify this, you must specify item_author_name.
  328.     def item_author_email(self, obj):
  329.         """
  330.  Takes an item, as returned by items(), and returns the item's
  331.  author's email as a normal Python string.
  332.  """
  334.     def item_author_email(self):
  335.         """
  336.  Returns the author email for every item in the feed.
  337.  """
  339.     item_author_email = 'test@example.com' # Hard-coded author email.
  341.     # ITEM AUTHOR LINK -- One of the following three is optional. The
  342.     # framework looks for them in this order. In each case, the URL should
  343.     # include the "http://" and domain name.
  344.     #
  345.     # If you specify this, you must specify item_author_name.
  347.     def item_author_link(self, obj):
  348.         """
  349.  Takes an item, as returned by items(), and returns the item's
  350.  author's URL as a normal Python string.
  351.  """
  353.     def item_author_link(self):
  354.         """
  355.  Returns the author URL for every item in the feed.
  356.  """
  358.     item_author_link = 'http://www.example.com/' # Hard-coded author URL.
  360.     # ITEM ENCLOSURE URL -- One of these three is required if you're
  361.     # publishing enclosures. The framework looks for them in this order.
  363.     def item_enclosure_url(self, item):
  364.         """
  365.  Takes an item, as returned by items(), and returns the item's
  366.  enclosure URL.
  367.  """
  369.     def item_enclosure_url(self):
  370.         """
  371.  Returns the enclosure URL for every item in the feed.
  372.  """
  374.     item_enclosure_url = "/foo/bar.mp3" # Hard-coded enclosure link.
  376.     # ITEM ENCLOSURE LENGTH -- One of these three is required if you're
  377.     # publishing enclosures. The framework looks for them in this order.
  378.     # In each case, the returned value should be either an integer, or a
  379.     # string representation of the integer, in bytes.
  381.     def item_enclosure_length(self, item):
  382.         """
  383.  Takes an item, as returned by items(), and returns the item's
  384.  enclosure length.
  385.  """
  387.     def item_enclosure_length(self):
  388.         """
  389.  Returns the enclosure length for every item in the feed.
  390.  """
  392.     item_enclosure_length = 32000 # Hard-coded enclosure length.
  394.     # ITEM ENCLOSURE MIME TYPE -- One of these three is required if you're
  395.     # publishing enclosures. The framework looks for them in this order.
  397.     def item_enclosure_mime_type(self, item):
  398.         """
  399.  Takes an item, as returned by items(), and returns the item's
  400.  enclosure MIME type.
  401.  """
  403.     def item_enclosure_mime_type(self):
  404.         """
  405.  Returns the enclosure MIME type for every item in the feed.
  406.  """
  408.     item_enclosure_mime_type = "audio/mpeg" # Hard-coded enclosure MIME type.
  410.     # ITEM PUBDATE -- It's optional to use one of these three. This is a
  411.     # hook that specifies how to get the pubdate for a given item.
  412.     # In each case, the method/attribute should return a Python
  413.     # datetime.datetime object.
  415.     def item_pubdate(self, item):
  416.         """
  417.  Takes an item, as returned by items(), and returns the item's
  418.  pubdate.
  419.  """
  421.     def item_pubdate(self):
  422.         """
  423.  Returns the pubdate for every item in the feed.
  424.  """
  426.     item_pubdate = datetime.datetime(2005, 5, 3) # Hard-coded pubdate.
  428.     # ITEM UPDATED -- It's optional to use one of these three. This is a
  429.     # hook that specifies how to get the updateddate for a given item.
  430.     # In each case, the method/attribute should return a Python
  431.     # datetime.datetime object.
  433.     def item_updateddate(self, item):
  434.         """
  435.  Takes an item, as returned by items(), and returns the item's
  436.  updateddate.
  437.  """
  439.     def item_updateddate(self):
  440.         """
  441.  Returns the updateddated for every item in the feed.
  442.  """
  444.     item_updateddate = datetime.datetime(2005, 5, 3) # Hard-coded updateddate.
  446.     # ITEM CATEGORIES -- It's optional to use one of these three. This is
  447.     # a hook that specifies how to get the list of categories for a given
  448.     # item. In each case, the method/attribute should return an iterable
  449.     # object that returns strings.
  451.     def item_categories(self, item):
  452.         """
  453.  Takes an item, as returned by items(), and returns the item's
  454.  categories.
  455.  """
  457.     def item_categories(self):
  458.         """
  459.  Returns the categories for every item in the feed.
  460.  """
  462.     item_categories = ("python", "django") # Hard-coded categories.
  464.     # ITEM COPYRIGHT NOTICE (only applicable to Atom feeds) -- One of the
  465.     # following three is optional. The framework looks for them in this
  466.     # order.
  468.     def item_copyright(self, obj):
  469.         """
  470.  Takes an item, as returned by items(), and returns the item's
  471.  copyright notice as a normal Python string.
  472.  """
  474.     def item_copyright(self):
  475.         """
  476.  Returns the copyright notice for every item in the feed.
  477.  """
  479.     item_copyright = 'Copyright (c) 2007, Sally Smith' # Hard-coded copyright notice.

低级框架

在后台，高级RSS框架使用较低级别的框架来生成订阅源的XML。此框架存在于单个模块中：django / utils / feedgenerator.py。

您自己使用此框架，用于生成较低级别的Feed。您还可以创建自定义Feed生成器子类，以与feed_type Feed选项一起使用。

联合供稿 classes

feedgenerator模块包含基类：

和几个子类：

这三个类中的每一个都知道如何将某种类型的feed呈现为XML。他们共享这个接口：

SyndicationFeed.__init__()

使用给定的元数据字典初始化Feed，该元数据字典应用于整个Feed。必需的关键字参数为：

  • title
  • link
  • description

还有一堆其他可选关键字：

  • language
  • author_email
  • author_name
  • author_link
  • subtitle
  • categories
  • feed_url
  • feed_copyright
  • feed_guid
  • ttl

您传递给__init__的任何其他关键字参数将存储在self.feed中以与自定义Feed生成器配合使用。

所有参数都应该是Unicode对象，除了categories，它应该是Unicode对象序列。

SyndicationFeed.add_item()

向具有给定参数的Feed中添加项目。

必需的关键字参数为：

  • title
  • link
  • description

可选的关键字参数为：

  • author_email
  • author_name
  • author_link
  • pubdate
  • comments
  • unique_id
  • enclosure
  • categories
  • item_copyright
  • ttl
  • updateddate

将为自定义Feed生成器存储额外的关键字参数。

所有参数，如果给定，应该是Unicode对象，除了：

New in Django 1.7:

已添加可选的updateddate参数。

SyndicationFeed.write()

Outputs the feed in the given encoding to outfile, which is a file-like object.

SyndicationFeed.writeString()

Returns the feed as a string in the given encoding.

例如，要创建Atom 1.0订阅源并将其打印到标准输出：

  1. >>> from django.utils import feedgenerator
  2. >>> from datetime import datetime
  3. >>> f = feedgenerator.Atom1Feed(
  4. ...     title="My Weblog",
  5. ...     link="http://www.example.com/",
  6. ...     description="In which I write about what I ate today.",
  7. ...     language="en",
  8. ...     author_name="Myself",
  9. ...     feed_url="http://example.com/atom.xml")
  10. >>> f.add_item(title="Hot dog today",
  11. ...     link="http://www.example.com/entries/1/",
  12. ...     pubdate=datetime.now(),
  13. ...     description="<p>Today I had a Vienna Beef hot dog. It was pink, plump and perfect.</p>")
  14. >>> print(f.writeString('UTF-8'))
  15. <?xml version="1.0" encoding="UTF-8"?>
  16. <feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en">
  17. ...
  18. </feed>

自定义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 %}