一、什么是RSS?
也许大家是第一次听到RSS这个概念,那什么是RSSRich Site Summary或者RDF Site Summary呢?RSS是站点用来和其他站点之间共享内容的一种简易方式(也叫聚合内容),通常被用于新闻和其他按顺序排列的网站,RSS使用XML作为彼此共享内容的标准方式。
它代表什么:Really Simple Syndication (或RDF Site Summary,RDF站点摘要)
例如Blog。一段项目的介绍可能包含新闻的全部介绍等。或者仅仅是额外的内容或者简短的介绍。这些项目的链接通常都能链接到全部的内容。网络用户可以在客户端借助于支持RSS的新闻聚合工具软件,在不打开网站内容页面的情况下阅读支持RSS输出的网站内容。
它有什么用处:让别人容易的发现你已经更新了你的站点,让人们很容易的追踪他们阅读的所有weblogs。
说得更加简单一点,RSS就是一种用来分发和汇集网页内容的XML格式!如果你还是不太明白,没有关系,RSS是什么其实基本就不重要,重要的是RSS可以做什么,下面我们就来了解一下,RSS能给我们带来什么?
小知识
BLOG:BLOG是Web Log的简称。在国内,人们通常称它为博客。它是一种作者与读者以日记风格进行交互的中介。在软件社区,人们以博客形式来共享观念与思想变得越来越流行,人们开始以博客的形式互相学习,博客已经成了一个技术交流的场所!如:http://blogs.msdn.com 就是MSDN上的一个blogging。而在国内博客中国也已经越来越有名。http://www.blogchina.com。
XML:XML是Extensible Markup Language的简写,一种扩展性标识语言。
二、RSS可以干什么?
1.订阅BLOG(BLOG上,你可以订阅你工作中所需的技术文章;也可以订阅与你有共同爱好的作者的日志,总之,BLOG上你对什么感兴趣你就可以订什么)
2.订阅新闻(无论是奇闻怪事、明星消息、体坛风云,只要你想知道的,都可以订阅)
你再也不用一个网站一个网站,一个网页一个网页去逛了。只要这将你需要的内容订阅在一个RSS阅读器中,这些内容就会自动出现你的阅读器里,你也不必为了一个急切想知道的消息而不断的刷新网页,因为一旦有了更新,RSS阅读器就会自己通知你!
三、RSS阅读器
目前,RSS阅读器基本可以分为两类。
第一类大多数阅读器是运行在计算机桌面上的单机应用程序,通过所订阅网站和博客(blog)中的新闻供应,可自动、定时地更新新闻标题。在该类阅读器中,有Awasu、FeedDemon和RSSReader这三款流行的单机版阅读器都提供免费试用版和付费高级版,另外,新华网在不久前也推出了一款RSS阅读器,它不仅是完全是中文界面,而且目前还是完全的免费软件!(后面我们就将以这款软件为例,为大家介绍怎样来使用RSS阅读器)
第二类新闻阅读器通常是内嵌于已在计算机中运行的应用程序中。例如,NewsGator内嵌在微软的Outlook中,所订阅的新闻标题位于Outlook的收件箱文件夹中。另外,Pluck内嵌在Internet Explorer浏览器中!
四、认识RSS
以下内容是为了让大家更加了解RSS,如果你对其不感兴趣,完全可以不看,它不会对你使用RSS阅读产生多大的影响。
1.Feed(提要)
博客以RSS文档形式为其内容提供一个提要,该RSS文档可以通过众所周知的URL获得。RSS文档是一个XML文件,它包含大量离散的新闻项,如某个博客中的入口项。由于RSS是XML格式文件,所以它很容易被其它程序所使用。
RSS聚合器是一个读取RSS文档并显示新闻项的程序。大多数聚合器只要输入RSS的URL,使得预定提要成为可能。
RSS使阅读博客便得容易。大多数经常阅读博客的开发人员都使用某种类型的聚合器来帮助他们有效地筛选提要内容。聚合器使得阅读博客的感觉就象是在阅读电子邮件,因为它们突出新闻项并将新闻项进行缓冲处理以便离线阅读。
还有一些在线RSS聚合器将RSS提要捆绑到某个单独的网站。其优点是易于设置并且可以从任何计算机存取你的提要内容。当然,其缺点也是显而易见的,那就是在阅读时必须始终保持连接。
RSS是博客成为一种强大的新型信息交流形式之根本所在。在网志出现之前,大多数开发人员为了要查找到需要的内容,通常要花大量时间来筛选掉那些令人讨厌的无关的信息。
博客通过让读者选择所要阅读的提要,将控制权交给读者,从而有效地构建自己的个性化内容流。
2.RSS版本
RSS的版本有很多个,0.90、0.91、0.92、0.93、0.94、1.0 和 2.0。要理解它们需要了解一些有关它们的历史背景。最初Netscape创建了RSS的最初版本0.90,起初的名字是“RDF Site Summary”或者“Rich Site Summary”(规范中说前者是正式名称)。Netscape创建RSS0.90用于其Web门户,这个时候,其他人看到了RSS的使用潜力。Userland Software是第一个开始将 RSS 用于其网志商业产品者之一。
版本 0.90 在很大程度上基于 W3C 的 Resource Description Framework (RDF)。许多人都认为 RDF 过于复杂,因此都建议出一个免费的简化版本 0.91。这个任务恰好就给了 Userland Software。Userland Software 便继续发展 RSS 的简化版本,随后出台的版本包括:0.92、0.93 和 0.94。为了强调其所做的简化工作,他们将 RSS 的全称定为“Really Simple Syndication”。
正当Userland Software继续专注于其简化工作时,另外一组开发人员在复兴最初的RDF版本(0.90),因为RSS号称自己更灵活。他们最终发布了一个RSS 1.0的版本,其正式名称还是“RDF Site Summary”。由于使用RDF,这个版本完全不同于 Userland Software所控制的版本。Userland Software当然不太愿意看到RSS 1.0似乎要取代其0.94版本的事实,于是出了一个新版本,并将版本号一下子跳到了2.0。
这就是今天的这种局面,形成了两个主要的竞争版本:一个基于RDF1.0,而另一个则是由Userland Software所开发的2.0,由于它们两个都共用相同的名字。就成为一种可怕的混乱,因为版本号导致人们误认为2.0是1.0的改进版本,而实际上它们是两个目标完全不同的规范。现在,另一组开发人员已经下狠心着手解决这种混乱问题,通过定义新的摘要(syndication)规范来与 RSS名字的随意性决裂。这个解决方案称为 Atom(原子)项目。
3.Atom(原子)
Atom是一个项目的名字,主要是开发一个新的博客摘要格式以解决目前RSS存在的问题(混乱的版本号,不是一个真正的开放标准,表示方法的不一致,定义贫乏等等)。Atom 希望提供一个清晰的版本以解决每个人的需要,其设计完全不依赖于供货商,任何人都可以对之进行自由扩展,完整详细说明。
除了定义新的摘要格式之外,Atom还希望定义一个标准的档案文件格式和一个标准的博客编辑API(Atom API)。
其实RSS1.0和2.0格式所包含的核心信息是相同的,只是其结构不一样罢了,这里我们不再继续深入的讨论这个问题,有兴趣的朋友可以去博客中国里了解相关知识!
4.blogroll
blogroll是博客页面提要的集合,大多数博客在其个人页面上都提供blogroll。这就允许读者连接到其他趣味和写作风格相投的人的网页上。Blogroll方便了网络上的沟通。通过使用Outline Processor Markup Language(OPML),人们可以用XML 格式文件交换blogroll。
大多数网志引擎都自己管理blogroll,每当读者请求blogroll时都自己产生相应的XML格式。同样,大多数聚合器(RSS阅读器)都能导入blogroll并自动预定所包含的摘要
--------------------------------------------------------------------------------
原文:http://www.xml.com/lpt/a/2002/12/18/dive-into-xml.html
What is RSS?
By Mark Pilgrim
RSS is a format for syndicating news and the content of news-like sites, including major news sites like Wired, news-oriented community sites like Slashdot, and personal weblogs. But it's not just for news. Pretty much anything that can be broken down into discrete items can be syndicated via RSS: the "recent changes" page of a wiki, a changelog of CVS checkins, even the revision history of a book. Once information about each item is in RSS format, an RSS-aware program can check the feed for changes and react to the changes in an appropriate way.
RSS-aware programs called news aggregators are popular in the weblogging community. Many weblogs make content available in RSS. A news aggregator can help you keep up with all your favorite weblogs by checking their RSS feeds and displaying new items from each of them.
A brief history
But coders beware. The name "RSS" is an umbrella term for a format that spans several different versions of at least two different (but parallel) formats. The original RSS, version 0.90, was designed by Netscape as a format for building portals of headlines to mainstream news sites. It was deemed overly complex for its goals; a simpler version, 0.91, was proposed and subsequently dropped when Netscape lost interest in the portal-making business. But 0.91 was picked up by another vendor, UserLand Software, which intended to use it as the basis of its weblogging products and other web-based writing software.
In the meantime, a third, non-commercial group split off and designed a new format based on what they perceived as the original guiding principles of RSS 0.90 (before it got simplified into 0.91). This format, which is based on RDF, is called RSS 1.0. But UserLand was not involved in designing this new format, and, as an advocate of simplifying 0.90, it was not happy when RSS 1.0 was announced. Instead of accepting RSS 1.0, UserLand continued to evolve the 0.9x branch, through versions 0.92, 0.93, 0.94, and finally 2.0.
What a mess.
So which one do I use?
That's 7 -- count 'em, 7! -- different formats, all called "RSS". As a coder of RSS-aware programs, you'll need to be liberal enough to handle all the variations. But as a content producer who wants to make your content available via syndication, which format should you choose?
Version | Owner | Pros | Status | Recommendation |
---|---|---|---|---|
0.90 | Netscape | Obsoleted by 1.0 | Don't use | |
0.91 | UserLand | Drop dead simple | Officially obsoleted by 2.0, but still quite popular | Use for basic syndication. Easy migration path to 2.0 if you need more flexibility |
0.92, 0.93, 0.94 | UserLand | Allows richer metadata than 0.91 | Obsoleted by 2.0 | Use 2.0 instead |
1.0 | RSS-DEV Working Group | RDF-based, extensibility via modules, not controlled by a single vendor | Stable core, active module development | Use for RDF-based applications or if you need advanced RDF-specific modules |
2.0 | UserLand | Extensibility via modules, easy migration path from 0.9x branch | Stable core, active module development | Use for general-purpose, metadata-rich syndication |
What does RSS look like?
Imagine you want to write a program that reads RSS feeds, so that you can publish headlines on your site, build your own portal or homegrown news aggregator, or whatever. What does an RSS feed look like? That depends on which version of RSS you're talking about. Here's a sample RSS 0.91 feed (adapted from XML.com's RSS feed):
<rss version="0.91">
<channel>
<title>XML.com</title>
<link>http://www.xml.com/</link>
<description>XML.com features a rich mix of information and services for the XML community.</description>
<language>en-us</language>
<item>
<title>Normalizing XML, Part 2</title>
<link>http://www.xml.com/pub/a/2002/12/04/normalizing.html</link>
<description>In this second and final look at applying relational normalization techniques to W3C XML Schema data modeling, Will Provost discusses when not to normalize, the scope of uniqueness and the fourth and fifth normal forms.</description>
</item>
<item>
<title>The .NET Schema Object Model</title>
<link>http://www.xml.com/pub/a/2002/12/04/som.html</link>
<description>Priya Lakshminarayanan describes in detail the use of the .NET Schema Object Model for programmatic manipulation of W3C XML Schemas.</description>
</item>
<item>
<title>SVG's Past and Promising Future</title>
<link>http://www.xml.com/pub/a/2002/12/04/svg.html</link>
<description>In this month's SVG column, Antoine Quint looks back at SVG's journey through 2002 and looks forward to 2003.</description>
</item>
</channel>
</rss>
Simple, right? A feed comprises a channel, which has a title, link, description, and (optional) language, followed by a series of items, each of which have a title, link, and description.
Now look at the RSS 1.0 version of the same information:
<rdf:RDF
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns="http://purl.org/rss/1.0/"
xmlns:dc="http://purl.org/dc/elements/1.1/"
>
<channel rdf:about="http://www.xml.com/cs/xml/query/q/19">
<title>XML.com</title>
<link>http://www.xml.com/</link>
<description>XML.com features a rich mix of information and services for the XML community.</description>
<language>en-us</language>
<items>
<rdf:Seq>
<rdf:li rdf:resource="http://www.xml.com/pub/a/2002/12/04/normalizing.html"/>
<rdf:li rdf:resource="http://www.xml.com/pub/a/2002/12/04/som.html"/>
<rdf:li rdf:resource="http://www.xml.com/pub/a/2002/12/04/svg.html"/>
</rdf:Seq>
</items>
</channel>
<item rdf:about="http://www.xml.com/pub/a/2002/12/04/normalizing.html">
<title>Normalizing XML, Part 2</title>
<link>http://www.xml.com/pub/a/2002/12/04/normalizing.html</link>
<description>In this second and final look at applying relational normalization techniques to W3C XML Schema data modeling, Will Provost discusses when not to normalize, the scope of uniqueness and the fourth and fifth normal forms.</description>
<dc:creator>Will Provost</dc:creator>
<dc:date>2002-12-04</dc:date>
</item>
<item rdf:about="http://www.xml.com/pub/a/2002/12/04/som.html">
<title>The .NET Schema Object Model</title>
<link>http://www.xml.com/pub/a/2002/12/04/som.html</link>
<description>Priya Lakshminarayanan describes in detail the use of the .NET Schema Object Model for programmatic manipulation of W3C XML Schemas.</description>
<dc:creator>Priya Lakshminarayanan</dc:creator>
<dc:date>2002-12-04</dc:date>
</item>
<item rdf:about="http://www.xml.com/pub/a/2002/12/04/svg.html">
<title>SVG's Past and Promising Future</title>
<link>http://www.xml.com/pub/a/2002/12/04/svg.html</link>
<description>In this month's SVG column, Antoine Quint looks back at SVG's journey through 2002 and looks forward to 2003.</description>
<dc:creator>Antoine Quint</dc:creator>
<dc:date>2002-12-04</dc:date>
</item>
</rdf:RDF>
Quite a bit more verbose. People familiar with RDF will recognize this as an XML serialization of an RDF document; the rest of the world will at least recognize that we're syndicating essentially the same information. In fact, we're including a bit more information: item-level authors and publishing dates, which RSS 0.91 does not support.
|
by Mark Pilgrim
Despite being RDF/XML, RSS 1.0 is structurally similar to previous versions of RSS -- similar enough that we can simply treat it as XML and write a single function to extract information out of either an RSS 0.91 or RSS 1.0 feed. However, there are some significant differences that our code will need to be aware of:
-
The root element is
rdf:RDF
instead ofrss
. We'll either need to handle both explicitly or just ignore the name of the root element altogether and blindly look for useful information inside it. -
RSS 1.0 uses namespaces extensively. The RSS 1.0 namespace is
http://purl.org/rss/1.0/
, and it's defined as the default namespace. The feed also useshttp://www.w3.org/1999/02/22-rdf-syntax-ns#
for the RDF-specific elements (which we'll simply be ignoring for our purposes) andhttp://purl.org/dc/elements/1.1/
(Dublin Core) for the additional metadata of article authors and publishing dates.We can go in one of two ways here: if we don't have a namespace-aware XML parser, we can blindly assume that the feed uses the standard prefixes and default namespace and look for
item
elements anddc:creator
elements within them. This will actually work in a large number of real-world cases; most RSS feeds use the default namespace and the same prefixes for common modules like Dublin Core. This is a horrible hack, though. There's no guarantee that a feed won't use a different prefix for a namespace (which would be perfectly valid XML and RDF). If or when it does, we'll miss it.If we have a namespace-aware XML parser at our disposal, we can construct a more elegant solution that handles both RSS 0.91 and 1.0 feeds. We can look for items in no namespace; if that fails, we can look for items in the RSS 1.0 namespace. (Not shown, but RSS 0.90 feeds also use a namespace, but not the same one as RSS 1.0. So what we really need is a list of namespaces to search.)
-
Less obvious but still important, the
item
elements are outside thechannel
element. (In RSS 0.91, theitem
elements were inside thechannel
. In RSS 0.90, they were outside; in RSS 2.0, they're inside. Whee.) So we can't be picky about where we look for items. -
Finally, you'll notice there is an extra
items
element within thechannel
. It's only useful to RDF parsers, and we're going to ignore it and assume that the order of the items within the RSS feed is given by their order of theitem
elements.
But what about RSS 2.0? Luckily, once we've written code to handle RSS 0.91 and 1.0, RSS 2.0 is a piece of cake. Here's the RSS 2.0 version of the same feed:
<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/">
<channel>
<title>XML.com</title>
<link>http://www.xml.com/</link>
<description>XML.com features a rich mix of information and services for the XML community.</description>
<language>en-us</language>
<item>
<title>Normalizing XML, Part 2</title>
<link>http://www.xml.com/pub/a/2002/12/04/normalizing.html</link>
<description>In this second and final look at applying relational normalization techniques to W3C XML Schema data modeling, Will Provost discusses when not to normalize, the scope of uniqueness and the fourth and fifth normal forms.</description>
<dc:creator>Will Provost</dc:creator>
<dc:date>2002-12-04</dc:date>
</item>
<item>
<title>The .NET Schema Object Model</title>
<link>http://www.xml.com/pub/a/2002/12/04/som.html</link>
<description>Priya Lakshminarayanan describes in detail the use of the .NET Schema Object Model for programmatic manipulation of W3C XML Schemas.</description>
<dc:creator>Priya Lakshminarayanan</dc:creator>
<dc:date>2002-12-04</dc:date>
</item>
<item>
<title>SVG's Past and Promising Future</title>
<link>http://www.xml.com/pub/a/2002/12/04/svg.html</link>
<description>In this month's SVG column, Antoine Quint looks back at SVG's journey through 2002 and looks forward to 2003.</description>
<dc:creator>Antoine Quint</dc:creator>
<dc:date>2002-12-04</dc:date>
</item>
</channel>
</rss>
As this example shows, RSS 2.0 uses namespaces like RSS 1.0, but it's not RDF. Like RSS 0.91, there is no default namespace and items are back inside the channel
. If our code is liberal enough to handle the differences between RSS 0.91 and 1.0, RSS 2.0 should not present any additional wrinkles.
How can I read RSS?
Now let's get down to actually reading these sample RSS feeds from Python. The first thing we'll need to do is download some RSS feeds. This is simple in Python; most distributions come with both a URL retrieval library and an XML parser. (Note to Mac OS X 10.2 users: your copy of Python does not come with an XML parser; you will need to install PyXML first.)
from xml.dom import minidom
import urllib
def load(rssURL):
return minidom.parse(urllib.urlopen(rssURL))
This takes the URL of an RSS feed and returns a parsed representation of the DOM, as native Python objects.
The next bit is the tricky part. To compensate for the differences in RSS formats, we'll need a function that searches for specific elements in any number of namespaces. Python's XML library includes a getElementsByTagNameNS
which takes a namespace and a tag name, so we'll use that to make our code general enough to handle RSS 0.9x/2.0 (which has no default namespace), RSS 1.0 and even RSS 0.90. This function will find all elements with a given name, anywhere within a node. That's a good thing; it means that we can search for item
elements within the root node and always find them, whether they are inside or outside the channel
element.
DEFAULT_NAMESPACES = \
(None, # RSS 0.91, 0.92, 0.93, 0.94, 2.0
'http://purl.org/rss/1.0/', # RSS 1.0
'http://my.netscape.com/rdf/simple/0.9/' # RSS 0.90
)
def getElementsByTagName(node, tagName, possibleNamespaces=DEFAULT_NAMESPACES):
for namespace in possibleNamespaces:
children = node.getElementsByTagNameNS(namespace, tagName)
if len(children): return children
return []
Finally, we need two utility functions to make our lives easier. First, our getElementsByTagName
function will return a list of elements, but most of the time we know there's only going to be one. An item
only has one title
, one link
, one description
, and so on. We'll define a first
function that returns the first element of a given name (again, searching across several different namespaces). Second, Python's XML libraries are great at parsing an XML document into nodes, but not that helpful at putting the data back together again. We'll define a textOf
function that returns the entire text of a particular XML element.
def first(node, tagName, possibleNamespaces=DEFAULT_NAMESPACES):
children = getElementsByTagName(node, tagName, possibleNamespaces)
return len(children) and children[0] or None
def textOf(node):
return node and "".join([child.data for child in node.childNodes]) or ""
That's it. The actual parsing is easy. We'll take a URL on the command line, download it, parse it, get the list of items, and then get some useful information from each item:
DUBLIN_CORE = ('http://purl.org/dc/elements/1.1/',)
if __name__ == '__main__':
import sys
rssDocument = load(sys.argv[1])
for item in getElementsByTagName(rssDocument, 'item'):
print 'title:', textOf(first(item, 'title'))
print 'link:', textOf(first(item, 'link'))
print 'description:', textOf(first(item, 'description'))
print 'date:', textOf(first(item, 'date', DUBLIN_CORE))
print 'author:', textOf(first(item, 'creator', DUBLIN_CORE))
Running it with our sample RSS 0.91 feed prints only title, link, and description (since the feed didn't include any other information on dates or authors):
$ python rss1.py http://www.xml.com/2002/12/18/examples/rss091.xml.txt
title: Normalizing XML, Part 2
link: http://www.xml.com/pub/a/2002/12/04/normalizing.html
description: In this second and final look at applying relational normalization techniques to W3C XML Schema data modeling, Will Provost discusses when not to normalize, the scope of uniqueness and the fourth and fifth normal forms.
date:
author:
title: The .NET Schema Object Model
link: http://www.xml.com/pub/a/2002/12/04/som.html
description: Priya Lakshminarayanan describes in detail the use of the .NET Schema Object Model for programmatic manipulation of W3C XML Schemas.
date:
author:
title: SVG's Past and Promising Future
link: http://www.xml.com/pub/a/2002/12/04/svg.html
description: In this month's SVG column, Antoine Quint looks back at SVG's journey through 2002 and looks forward to 2003.
date:
author:
For both the sample RSS 1.0 feed and sample RSS 2.0 feed, we also get dates and authors for each item
. We reuse our custom getElementsByTagName
function, but pass in the Dublin Core namespace and appropriate tag name. We could reuse this same function to extract information from any of the basic RSS modules. (There are a few advanced modules specific to RSS 1.0 that would require a full RDF parser, but they are not widely deployed in public RSS feeds.)
Here's the output against our sample RSS 1.0 feed:
$ python rss1.py http://www.xml.com/2002/12/18/examples/rss10.xml.txt
title: Normalizing XML, Part 2
link: http://www.xml.com/pub/a/2002/12/04/normalizing.html
description: In this second and final look at applying relational normalization techniques to W3C XML Schema data modeling, Will Provost discusses when not to normalize, the scope of uniqueness and the fourth and fifth normal forms.
date: 2002-12-04
author: Will Provost
title: The .NET Schema Object Model
link: http://www.xml.com/pub/a/2002/12/04/som.html
description: Priya Lakshminarayanan describes in detail the use of the .NET Schema Object Model for programmatic manipulation of W3C XML Schemas.
date: 2002-12-04
author: Priya Lakshminarayanan
title: SVG's Past and Promising Future
link: http://www.xml.com/pub/a/2002/12/04/svg.html
description: In this month's SVG column, Antoine Quint looks back at SVG's journey through 2002 and looks forward to 2003.
date: 2002-12-04
author: Antoine Quint
Running against our sample RSS 2.0 feed produces the same results.
This technique will handle about 90% of the RSS feeds out there; the rest are ill-formed in a variety of interesting ways, mostly caused by non-XML-aware publishing tools building feeds out of templates and not respecting basic XML well-formedness rules. Next month we'll tackle the thorny problem of how to handle RSS feeds that are almost, but not quite, well-formed XML.
Related resources
|