利用Java技能将Atom转换为RDF
当前位置：以往代写 > JAVA 教程 >利用Java技能将Atom转换为RDF

利用Java技能将Atom转换为RDF

2019-06-14

利用Java技能将Atom转换为RDF

利用Java技能将Atom转换为RDF

副标题#e#

RDF 包括由 W3C 拟定的各类类型。它本质上是一个元数据建模框架，该框架操作 Web 上漫衍的软件可读信息，详细要领是通过利用一些称为三元组 的 “主语-谓语-宾语”表达式识别这些信息。

常用缩略词

API：应用措施编程接口

RDF：资源描写框架

DOM：文档工具模子

IETF：互联网工程任务组

RSS：浅易新闻聚合

URI：统一资源标识符

URL：统一资源定位器

W3C：世界万维网同盟

XML：可扩展标志语言

譬喻下面这个英文表达式：“Perry the Platypus’s arch-enemy is Dr. Doofenschmirtz.”。 在这个例子中，主语是 Perry the Platypus，谓语是 archenemy，宾语是 Dr. Doofenschmirtz。在 RDF 中，这个三元组将按照一种非凡名目编码，这种名目用于识别卡通人物和他们的主要仇人。

RDF 代表 “来日诰日”，因为它是 Semantic Web（语义 Web）举动的一部门。实际上，它是该举动的重要构成部门。

Semantic Web 举动代表下一代万维网，个中的信息将通过语义识别。其理念是基于一种预界说名目显示数据，这些数据可以被软件和人类明晰识别。想想看，这种预界说名目将利用 RDF 完成。（对 RDF 的具体阐明超出了本文的范畴，请参阅 参考资料 提供的链接相识更多信息）。

Atom：接待回到昨天

这部门的标题好像对 Atom 不屑一顾，但事实上并非如此。相反，它意味着一种新呈现的技能（RDF）和一种已经存在一段时间的技能（Atom）的比拟。

Atom 是一系列基于 Web 的文档的聚及名目，它从 RSS 的固有限制开拓而来。这种聚及名目通过 XML 语言表达，所以 Atom 文档即 XML 文档。

凡是，Atom 文档通过一种称为概要阅读器（feed reader）的软件阅读，这种软件利用户可以或许查察来自一个特定站点的一些相关文档的摘要。用户可以抉择要阅读哪些文件，然后只需单击相应的链接。这种 Atom 聚及名目还答允网络打点员显示站点上的概要。

可是，Atom 没有像新呈现的 Semantic Web 勾当那样界说便于领略的语义。为此，需要利用 RDF。

两个世界的英华

这样，问题来了：“有没有一种 RDF 类型可以或许操作聚合？能不能既享受语义的长处，同时又保存高曝光度的优势？”

谜底是必定的。

请走进 “另一个” RSS。这个 RSS 不是您所想到的谁人 RSS，它暗示 RDF Site Summary（RDF 站点摘要），以语义方法界说一种聚及名目。它答允网络打点员以 RDF 名目宣布他们的文档，以便这些文档中包括的信息可以或许被 Semantic Web 所领略。

以 RDF 名目提供 feed 的长处在于：支持 Semantic Web 行为的资源将在其搜索功效中阅读、缓存和包括来自那些源的内容。跟着 Semantic Web 不绝涌现，那些回收 RDF Site Syndication（RDF 站点聚合）技能的网络打点员将发明本身置身于最新的、最先进的技能的最前沿。他们将拥有更高的曝光度，那意味着更多流量。更多流量意味着他们的告白商将给用户留下更深的印象。更深的印象意味着他们可以赚到更多钱。这必定是一种值得投资的开拓事情。

将 Atom 转换为 RDF

既然这种名目转换可以或许带来精采的经济效益，那么就让我们着手举办这项事情吧。本文将先容如何利用 Java 编程语言将 Atom 文档转换为 RDF 文档。

幸运的是，Atom 和 RDF 文档都是 XML 文档，这意味着用于读取一种文档的东西将可以或许用于读取另一种文档。

Java 编程语言

您将利用 1.6 版 Java 编程语言编写转换代码。之所以选择这种语言，是因为它著名的 “一次编写处处运行” 的成果。您可以在拥有兼容 1.6 版 Java 软件开拓东西箱（JDK）的任意平台上编译和运行本文提供的代码。

理会和建设 XML 文档的 API 是 Streaming API for XML (StAX)，这是一个精彩的界面，胜过了传统的 DOM 和 Simple API for XML (SAX) 理会方案。利用 StAX 时，XML 文档的理会是基于光标的，应用措施在运行进程中只利用 XML 中需要的内容。StAX 还答允开拓人员建设 XML 文档。

元数据

元数据本质上是关于数据的数据，它在 Semantic Web 中的浸染很是要害。它提供前面提到的三元组的识别息争释要领。

如前所述，您将对终端产物利用 RDF Site Syndication 类型。对付实现名目转换这个目标，这种类型的确堪称完美，因为它是一种遵守 Semantic Web 的聚及名目。

必需再次提起留意的是，RDF Site Syndication 名目是一种独立的类型，但它缺乏某些界说，好比日期。为了补充这个缺陷，凡是利用另一种 RDF 兼容类型，这种类型称为 Dublin Core Metadata Initiative (DCMI)。DCMI 是与 RDF 联用的最风行的 XML 语言之一。


#p#副标题#e#

编写代码

#p#分页标题#e#

根基的思路是：先读取一个现有的 Atom 概要，然后将这个概要转换为 RDF。在这种环境下，需要将 Atom 名目标 Twitter public timeline 转换为 RDF Site Syndication 名目。为此，应利用尺度 JavaBeans™ 来存储从 Atom 概要中读取的信息。您也许知道，JavaBeans 是包括一系列私有属性以及民众会见器和转变器的 Java 类。您可以利用这些类的内容来建设 RDF 文档。

一个 RDF Site Syndication 文档中包括两个重要的 “节”。一个是 <channel> 节，另一个是 <item> 节，后者大概会多次呈现。<channel> 节描写整个概要，每个 <item> 节描写这个概要中的一个文档。清单 1 显示了一个 RDF Site Syndication 文档示例。

清单 1. RDF 文档示例（节选）

<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.twitter.com">
　　　　　<title>Twitter　public　timeline</title>
　　　　　<description>Twitter　updates　from　everyone!</description>
　　　　　<link>http://twitter.com/public_timeline</link>
　　　　　<dc:date>2009-04-05T13:11:01+00:00</dc:date>
　　　　　<items>
　　　　　　　<rdf:Seq>
　　　　　　　　　　<rdf:li>http://twitter.com/TJalexander/statuses/1456808203</rdf:li>
　　　　　　　　　　<rdf:li>http://twitter.com/xElsiex/statuses/1456808201</rdf:li>
　　　　　　　　　　<rdf:li>http://twitter.com/mmama1215/statuses/1456808197</rdf:li>
　　　　　　　　　　<rdf:li>http://twitter.com/kennethmaxey/statuses/1456808196</rdf:li>
　　　　　　　　　　<rdf:li>http://twitter.com/katiestars/statuses/1456808195</rdf:li>
　　　　　　　　　　<rdf:li>http://twitter.com/Zweeal/statuses/1456808194</rdf:li>
　　　　　　　　　　<rdf:li>http://twitter.com/lilvicofficial/statuses/1456808193</rdf:li>
　　　　　　　　　　<rdf:li>http://twitter.com/PrettyNitti/statuses/1456808192</rdf:li>
　　　　　　　　　　<rdf:li>http://twitter.com/mrrobbo/statuses/1456808190</rdf:li>
　　　　　　　　　　<rdf:li>http://twitter.com/smd75jr/statuses/1456808189</rdf:li>
　　　　　　　　　　<rdf:li>http://twitter.com/BirdDiva/statuses/1456808188</rdf:li>
　　　　　　　　　　<rdf:li>http://twitter.com/nouwen/statuses/1456808185</rdf:li>
　　　　　　　　　　<rdf:li>http://twitter.com/gustavopereira/statuses/1456808184</rdf:li>
　　　　　　　　　　<rdf:li>http://twitter.com/sky_7/statuses/1456808183</rdf:li>
　　　　　　　　　　<rdf:li>http://twitter.com/fauzty/statuses/1456808182</rdf:li>
　　　　　　　　　　<rdf:li>http://twitter.com/Cheriefaery/statuses/1456808181</rdf:li>
　　　　　　　　　　<rdf:li>http://twitter.com/CarolineAttia/statuses/1456808180</rdf:li>
　　　　　　　　　　<rdf:li>http://twitter.com/ukyo_rst/statuses/1456808179</rdf:li>
　　　　　　　　　　<rdf:li>http://twitter.com/Len0r/statuses/1456808177</rdf:li>
　　　　　　　　　　<rdf:li>http://twitter.com/jhill444faceboo/statuses/1456808175</rdf:li>
　　　　　　　</rdf:Seq>
　　　　　</items>
　　</channel>
　　<item　rdf:about="http://twitter.com/TJalexander/statuses/1456808203">
　　　　　<dc:format>text/html</dc:format>
　　　　　<dc:date>2009-04-05T13:11:01+00:00</dc:date>
　　　　　<dc:source>http://www.twitter.com</dc:source>
　　　　　<dc:creator>t.j.　alexander</dc:creator>
　　　　　<dc:date>2009-04-05T13:11:01+00:00</dc:date>
　　　　　<title>TJalexander:　Photo:　somethingtobelievein:　i　don</title>
　　　　　<link>http://twitter.com/TJalexander/statuses/1456808203</link>
　　　　　<description>TJalexander:　Photo:　somethingtobelievein:　i　don</description>
　　</item>
　　<item　rdf:about="http://twitter.com/xElsiex/statuses/1456808201">
　　　　　<dc:format>text/html</dc:format>
　　　　　<dc:date>2009-04-05T13:11:01+00:00</dc:date>
　　　　　<dc:source>http://www.twitter.com</dc:source>
　　　　　<dc:creator>Elsie　Constantinides</dc:creator>
　　　　　<dc:date>2009-04-05T13:11:01+00:00</dc:date>
　　　　　<title>xElsiex:　my　hairs　gone　all　fluffy　like　:O　!!　nooooooooooooo　!!!</title>
　　　　　<link>http://twitter.com/xElsiex/statuses/1456808201</link>
　　　　　<description>xElsiex:　my　hairs　gone　all</description>
　　</item>
...

#p#副标题#e#

#p#分页标题#e#

留意，清单 1 中的文档看起来与本来的 Really Simple Syndication 名目惊人地相似。这不是一个巧合，因为 RDF Site Syndication 类型背后的理念是建设一种与 RDF 兼容的聚及名目。

大大都元素是可以顾名思义的。RDF Site Syndication 和 Really Simple Syndication 之间的一个主要区别是 <items> 元素，它是 <channel> 元素的一个子元素。这个元素提供 RDF 文件中包括的所有文档链接的列表。该元素可以视为一个摘要的摘要。

思量到上述因素，好像应该建设两个 JavaBeans：一个主要 “节” 和一个 JavaBeans。清单 2 显示了 Channel 类。

清单 2. Channel 类

public　class　Channel　{

　private　String　about;
　private　String　title;
　private　String　description;
　private　String　link;
　private　String　date;
　private　List<String>　items　=　new　ArrayList<String>();

　public　String　getAbout()　{
　return　about;
　}
　public　void　setAbout(String　about)　{
　this.about　=　about;
　}
　public　String　getTitle()　{
　return　title;
　}
　public　void　setTitle(String　title)　{
　this.title　=　title;
　}
　public　String　getDescription()　{
　return　description;
　}
　public　void　setDescription(String　description)　{
　this.description　=　description;
　}
　public　String　getLink()　{
　return　link;
　}
　public　void　setLink(String　link)　{
　this.link　=　link;
　}
　public　String　getDate()　{
　return　date;
　}
　public　void　setDate(String　date)　{
　this.date　=　date;
　}
　public　List<String>　getItems()　{
　return　items;
　}
　public　void　setItems(List<String>　items)　{
　this.items　=　items;
　}
}

如上所示，Channel 类无非是一个直观的 JavaBean，它描写包括在 <channel> 节中的信息。该类中的每一个属性和 <channel> 的每一个子元素之间都有一种直接接洽。甚至有一个针对这些链接的 String 工具清单（List），这些链接是 <items> 元素的子元素。

清单 3 是另一个简朴的 JavaBeans 类，这个类代表概要中的一个文档。

清单 3. Item 类

public　class　Item　{

　private　String　format;
　private　String　date;
　private　String　link;
　private　String　creator;
　private　String　title;
　private　String　description;
　private　String　source;

　public　String　getSource()　{
　return　source;
　}
　public　void　setSource(String　source)　{
　this.source　=　source;
　}
　public　String　getFormat()　{
　return　format;
　}
　public　void　setFormat(String　format)　{
　this.format　=　format;
　}
　public　String　getDate()　{
　return　date;
　}
　public　void　setDate(String　date)　{
　this.date　=　date;
　}
　public　String　getLink()　{
　return　link;
　}
　public　void　setLink(String　link)　{
　this.link　=　link;
　}
　public　String　getCreator()　{
　return　creator;
　}
　public　void　setCreator(String　creator)　{
　this.creator　=　creator;
　}
　public　String　getTitle()　{
　return　title;
　}
　public　void　setTitle(String　title)　{
　this.title　=　title;
　}
　public　String　getDescription()　{
　return　description;
　}
　public　void　setDescription(String　description)　{
　this.description　=　description;
　}
}

#p#副标题#e#

如上所示，这个类包括一个项目标相关信息：title、creator（或 author）、description（摘要）和链接。

进一步深入代码之前，首先需要查抄一个 Atom 示例文档。请看 清单 4。

清单 4. 一个 Atom 示例文档（Twitter public timeline）

#p#分页标题#e#

<?xml　version="1.0"　encoding="UTF-8"?>
<feed　xml:lang="en-US"　xmlns="http://www.w3.org/2005/Atom">
　<title>Twitter　public　timeline</title>
　<id>tag:twitter.com,2007:Status</id>
　<link　type="text/html"　rel="alternate"　href="http://twitter.com/public_timeline"/>
　<updated>2009-04-06T12:20:02+00:00</updated>
　<subtitle>Twitter　updates　from　everyone!</subtitle>
　　<entry>
　　　<title>UMaineExtension:　Backyard　Poultry　course</title>
　　　<content　type="html">UMaineExtension:　Backyard　Poultry　course</content>
　　　<id>tag:twitter.com,2007:http://twitter.com/UMaineExtension/statuses/1462447470</id>
　　　<published>2009-04-06T12:20:00+00:00</published>
　　　<updated>2009-04-06T12:20:00+00:00</updated>
　　　<link　type="text/html"　rel="alternate"　href="http://twitter.com//1462447470"/>
　　　<link　type="image/jpeg"　rel="image"　href="http://UM-crest_normal.jpg"/>
　　　<author>
　　　　<name>UMaine　Extension</name>
　　　　<uri>http://www.extension.umaine.edu</uri>
　　　</author>
　　</entry>
　　<entry>
　　　<title>tmj_mem_adv:　Ecommerce　Marketing　Manager　http://tinyurl.com/cthahs</title>
　　　<content　type="html">tmj_mem_adv:　Ecommerce　Marketing　Manager</content>
　　　<id>tag:twitter.com,2007:http://twitter.com/1462447468</id>
　　　<published>2009-04-06T12:19:59+00:00</published>
　　　<updated>2009-04-06T12:19:59+00:00</updated>
　　　<link　type="text/html"　rel="alternate"
　　　　　href="http://twitter.com/statuses/1462447468"/>
　　　<link　type="image/png"　rel="image"　href="http://83603474/twitter_normal.png"/>
　　　<author>
　　　　<name>TMJ-MEM　Advert　Jobs</name>
　　　　<uri>http://www.tweetmyjobs.com</uri>
　　　</author>
　　</entry>
...

留意，<title> 元素是 <feed> 的直接子元素。而另一个元素是 <entry> 的直接子元素。此后您需要在代码中处理惩罚这个问题。

此刻模子已经完成，是时候举办实际编码，以理会 Atom 概要并建设 RDF 文件了。AtomToRdf 类用于完成这个任务。清单 5 显示了这个类本质。

清单 5. AtomToRdf 的本质

public　class　AtomToRdf　{

　.　.　.
　private　Channel　channel　=　new　Channel();
　private　List<Item>　itemList　=　new　ArrayList<Item>();

　public　static　void　main(String[]　args)　{
　AtomToRdf　atomToRdf　=　new　AtomToRdf();
　atomToRdf.go();
　}

　private　void　go()　{
　parseAtom();
　createRdf();
　}
　.　.　.
}

#p#副标题#e#

假如一切都这样简朴就好了！实际环境是 main() 要领只是在一个实例化的 AtomToRdf 类上执行了一个私有要领 go()。这是一种跳出静态上下文的要领。go() 要领反过来执行两个相当顾名思义的要领：parseAtom() 和 createRdf()。第一个要领是阅读器，第二个要领是写入器。

为确保从 Atom 概要中读取的信息可以或许用于 AtomToRdf 工具中的所有要领，必需声明两个局部可用的工具变量，如 清单 5 所示。一个是 Channel 类的一个实例（称为 channel）。另一个是包括一个或多个 Item 工具的 List 工具（称为 itemList）。

清单 6 显示了 parseAtom() 要领的开始部门。该要领利用 StAX 来理会 Atom 概要。这段代码首先实例化一个新的 XMLInputFactory 工具，然后打开一个包括 Atom 名目标 Twitter public timeline 的 InputStream 工具。这个 StAX InputFactory 从 InputStream 建设一个 XMLEventReader 工具。在 “拖动—理会” Atom 概要的进程中，StAX 用这个工具来识别 事件。事件的一些例子好比文档启动、元素启动和元素竣事。

清单 6. 开始理会 Atom

　private　void　parseAtom()　{
　　　　try　{
　　　　　　XMLInputFactory　inputFactory　=　XMLInputFactory.newInstance();
　　　　　　InputStream　in　=　new　URL("http://twitter.com/statuses/public_timeline.atom")　
　　.openStream();

　　　　　　XMLEventReader　eventReader　=　inputFactory.createXMLEventReader(in);

　　　　　　boolean　inEntry　=　false;
　　　　　　Item　currentItem　=　null;

　　　　　　while　(eventReader.hasNext())　{
...

#p#分页标题#e#

要处理惩罚这两个 <title> 元素，这个 isEntry Boolean 用于区分它们。假如 Boolean 为 True，理会器查抄 <title> 元素，该元素是 <entry> 的一个子元素。

变量 currentItem 用于存储输出文件中的每个 <item> 节中将包括的信息。每次理会器碰着输入文件中的另一个 <entry> 元素时，一个新的 currentItem 工具将被实例化。每次理会器碰着 <entry> 元素的末了时，现有的 currentItem 工具添加到 Item 工具列表（itemList）。

最后，清单 6 开始理会器轮回。本质上，那条 while 语句的意思是 “只要理会器碰着 任何事件，它将反复执行大括号（{}）内里的代码。”

急需办理的问题是：将碰着哪种事件？如那里理惩罚这些事件？请看 清单 7。

清单 7. 理会 Title 元素

if　(event.isStartElement())　{
　　StartElement　startElement　=　event.asStartElement();

　　if　(event.asStartElement().getName().getLocalPart().equals("title"))　{
　　　　　event　=　eventReader.nextEvent();
　　　　　String　title　=　event.asCharacters().getData();

　　　　　if　(!inEntry)　{
　　　　　channel.setTitle(title);
　　　　　}　else　{
　　　　　currentItem.setTitle(title);
　　　　　}

　　　　　continue;
　　}
...

当这段代码碰着一个事件时，它首先查抄这个事件是不是一个新元素的初步。假如是，则一个 StartElement 工具被实例化。然后查抄这个元素的名字。假如这个元素的名字是 title，这段代码将把该元素的实际内容放到字符串变量 title 中。

还记得 isEntry 变量吗？这个变量将在这里利用，因为 — 您大概还记得 — 定名为 title 的元素呈此刻 Atom 概要的两个位置。假如 isEntry 配置为 True，代码知道查抄一个文档的标题，而不是整个概要的标题。对付前一种环境，将配置 currentItem 工具的 title 属性；对付后一种环境，将配置 channel 工具的 title 属性。

最后，continue 语句是一条尺度的 Java 语句，它的意思是 “只要到此就继承轮回”。换句话说，今世码处理惩罚完这个事件后，将开始寻找更多事件。

假如您查察整个代码，您将发明有很多代码块与 清单 7 中的代码雷同。区别在于每个代码块查抄 Atom 概要中的一个差异元素，然后在正确的工具上配置适当的实例变量。

轮回竣事时，代码将拥有一个完全填充的 Channel 工具和一个完全填充的 Item 工具列表。这些工具将被读取，个中的信息将用于建设 RDF 文件。

在查抄代码以建设 RDF 文档之前，首先必需领略已在 AtomToRdf 中界说的一些常量（见 清单 8）。

清单 8. 在 AtomToRdf 中界说的常量

private　static　final　String　DUBLIN_CORE_PREFIX　=　"dc";
private　static　final　String　DUBLIN_CORE_URI　=　"http://purl.org/dc/elements/1.1/";
private　static　final　String　RDF_PREFIX　=　"rdf";
private　static　final　String　RDF_URI　=　"http://www.w3.org/1999/02/22-rdf-syntax-ns#";
private　static　final　String　RSS_URI　　=　"http://purl.org/rss/1.0/";　

#p#副标题#e#

为何需要这些常量呢？让我们转头看看 清单 1 中的 RDF 示例文档。您将看到 RDF 输出需要名称空间，在许多环境下，这些名称空间是反复的。这些常量可以或许使您更轻松地引用那些名称空间和它们对应的 URI。清单 9 中的代码开始输出。

清单 9. 开始输出

　　private　void　createRdf()　{
　　try　{

　XMLOutputFactory　xmlof　=　XMLOutputFactory.newInstance();
　　　XMLStreamWriter　xmlw　=　xmlof.createXMLStreamWriter
　　(new　FileOutputStream　("c:/twitter.rdf"));
　　　xmlw.writeStartElement(RDF_PREFIX,　"RDF",　RDF_URI);
　　　xmlw.writeNamespace(RDF_PREFIX,　RDF_URI);
　　　xmlw.writeNamespace("",RSS_URI);
　　　xmlw.writeNamespace(DUBLIN_CORE_PREFIX,　DUBLIN_CORE_URI);
　　　xmlw.writeCharacters("\n");
　　　xmlw.writeCharacters("　　");

　　　writeChannel(xmlw);
　　　writeItems(xmlw);

　　　xmlw.writeCharacters("\n");
　　　xmlw.writeEndElement();
　　　xmlw.writeEndDocument();
　　　xmlw.close();
　　　}　catch　(Exception　e)　{
　　　e.printStackTrace();
　　　}
　　}

#p#分页标题#e#

再次利用了 StAX API。区别在于这一次它用于生成输出而不是读取输入。这段代码首先实例化一个新的 XMLOutputFactory 工具，然后从一个 FileOutputStream 工具建设一个 XMLStreamWriter，该工具指向 c:/twitter.rdf（输出文件的名称和位置）。您大概需要按照本身的情况变动文件位置。

这段代码开始写出这些元素。它首先从根元素开始，并对根元素利用前缀 rdf 和它对应的 URI。下面三行界说与根元素关联的各类名称空间和相应的前缀。留意，RSS_URI 常量代表默认前缀，因此一个空字符串用作前缀。

接下来两行的目标是名目化，使输出更适合人类阅读。您将在整个输出代码中看到大量这种环境。

下面两行挪用单独的要领，它们用作输出例程的 “重要部门”。第一种要领写出 <channel> 节，第二种要领写出每个 <item> 节。

下面几行封锁根元素和文档自己。最后，XMLStreamWriter 工具封锁。

您大概留意到 清单 10 中的一种模式。首先，建设一个带有得当 about 属性的父元素（凡是定名为 channel）。留意，about 属性需要 rdf 名称空间。about 属性的值只是一个 URL，它指向 RDF Site Syndication 中包括的信息。为此，我利用了 Twitter 的 URL。

清单 10. writeChannel() 要领

　　private　void　writeChannel(XMLStreamWriter　xmlw)　throws　Exception　{
　xmlw.writeStartElement("channel");
　xmlw.writeAttribute(RDF_PREFIX,　RDF_URI,　"about",
　　"http://www.twitter.com");
　xmlw.writeCharacters("\n");
　xmlw.writeCharacters("　　　　　");
　xmlw.writeStartElement("title");
　xmlw.writeCharacters(channel.getTitle());
　xmlw.writeEndElement();
　xmlw.writeCharacters("\n");
　xmlw.writeCharacters("　　　　　");
　xmlw.writeStartElement("description");
　xmlw.writeCharacters(channel.getDescription());
　xmlw.writeEndElement();
　xmlw.writeCharacters("\n");
　xmlw.writeCharacters("　　　　　");
...

这是您第二次在输出中看到 about 属性。相识它为什么在哪里很重要，其原因是 about 属性界说 “主语-谓语-宾语” 三元组中的主语。在这个例子中主语是一个 URL（这种环境很普遍）。每个子元素（好比 <title>）代表一个谓语。每个元素的内容是宾语。

在两个名目化行之后，建设 <title> 元素并利用从 Atom 概要收集的标题填充，然后建设 <description> 元素等。

纵然 清单 10 中只提供了两个元素，您大概照旧留意到了一种模式呈现。首先建设一个元素，然后利用来自 Channel 工具的内容填充这个元素，然后元素竣事。这个进程将对包括在 Channel 工具中的所有数据反复。

#p#副标题#e#

为了使工作更直观，Channel 工具中的属性名称与 <channel> 节中的元素名称沟通，这使在代码和输出之间举办正确映射越发容易。

在 清单 11 中，writeItems() 要领有一些差异，因为它不是写一个节，而是许多节。它对 Atom 概要中的每个 <entry> 元素写一个节。指向该要领开始处的 for 轮回确保这一点得以实现。

清单 11. writeItems() 要领

　　private　void　writeItems(XMLStreamWriter　xmlw)　throws　Exception　{
　　　xmlw.writeCharacters("\n");
　　　xmlw.writeCharacters("　　");

　for　(Item　item　:　itemList)　{
　xmlw.writeStartElement("item");
　xmlw.writeAttribute(RDF_PREFIX,　RDF_URI,
　　"about",　item.getLink());
　xmlw.writeCharacters("\n");
　xmlw.writeCharacters("　　　　　");

　xmlw.writeStartElement(DUBLIN_CORE_PREFIX,"format",
　　DUBLIN_CORE_URI);
　xmlw.writeCharacters(item.getFormat());
　xmlw.writeEndElement();
　xmlw.writeCharacters("\n");
　xmlw.writeCharacters("　　　　　");
...

对付 itemList 中的每个 Item 工具，将建设一个新的 <item> 元素。同样，一个特定于名称空间的 about 属性指向该文档的链接。在这个例子中，这个链接指向 Twitter 上的一个特定用户的一篇文章。

#p#分页标题#e#

颠末一些名目化之后，建设了一个称为 format 的子元素。这个 format 元素描写文档中的输格外式。在这里，这个元素是 text/html 名目。留意，这里利用了 Dublin Core 元数据而不是 RDF Site Syndication 尺度或 RDF 尺度指定的元数据。那是因为这两种尺度都不支持界说文档名目。

在以上代码块中，呈现了一种模式。对付 Item 类中的每个属性，一个新元素被建设并关联到一个与该属性名对应的元素。

总之，这就是那段代码，此刻让我们来看看它实际上是否像所说的那样有效。

测试代码

将包括本文的这个压缩文件 — AtomToRdf.zip — 解压到您选择的一个测试目次。您将看到已经大抵先容过的三个文件：Item.java、Channel.java 和 AtomToRdf.java。

利用您最钟爱的集成开拓情况（IDE）或进入一个呼吁提示，然后利用与 1.6 版兼容的 Java 编译器编译那些类。然后不带呼吁行参数执行 AtomToRdf.class。

假如您没有变动提供的代码的内容，您的 C 盘根目次下将建设一个文件：twitter.rdf。该文件的名目将与 清单 1 中的名目沟通。

如何知道这是不是一个有效的 RDF 文件呢？只需用一个验证器检讨一下。幸运的是，W3C 上的一些好同伴为您建设了一个校验器，它位于：http://www.w3.org/RDF/Validator。会见这个 URL，然后将 twitter.rdf 的内容粘贴到文本区域。单击 Parse RDF。您将看到一个窗口，窗口顶部显示 “Your RDF document validated successfully.”。恭喜您，您乐成了！

竣事语

跟着 Semantic Web 成为技能革命的前沿技能，站点宣布与 Semantic Web 尺度兼容的文档变得很重要。RDF 就是这些尺度之一。

利用 RDF Site Syndication，网络打点员可以或许生成与 Atom 概要雷同的、兼容 RDF 的文档。这将提供聚合和语义双厚长处。

利用 Java 编程语言和 StAX API，可以轻松理会一个 Atom 概要并将其转换为一个 RDF 文档，然后可以用这个 RDF 文档来提供特定于语义的概要。

本文随文源码下载

    关键字：

在线提交作业