jena 操作RDF的一个例子（参考IBM的一篇文章)

jena 操作RDF的一个例子

RDF 越来越被认为是表示和处理半结构化数据的一种极好选择。本文中，Web 开发人员 Philip McCarthy 向您展示了如何使用 Jena Semantic Web Toolkit，以便在 Java 应用程序中使用 RDF 数据模型。

“资源描述框架（Resource Description Framework，RDF）”最近成为 W3C 推荐标准，与 XML 和 SOAP 等 Web 标准并排。

创建简单的 RDF 模型

我们从基本操作开始：从头创建模型并向其添加 RDF 语句。本节，我将说明如何创建描述一组虚构家庭成员之间关系的模型，如图 1 中所示：

图 1. 虚拟家庭树

将使用来自“关系”词汇表（请参阅 参考资料 ）的属性 siblingOf 、 spouseOf 、 parentOf 和 childOf 来描述不同的关系类型。为简单起见，家庭成员用来自虚构名称空间的 URI（ http://family/ ）进行标识。词汇表 URI 通常以 Jena 代码形式使用，所以将它们声明为 Java 常量会非常有用，减少了错误输入。

Jena 的 ModelFactory 类是创建不同类型模型的首选方式。在这种情况下，您想要空的、内存模型，所以要调用的方法是 ModelFactory.createDefaultModel() 。这种方法返回 Model 实例，您将使用它创建表示家庭中每个成员的 Resource 。创建了资源后，可以编写关于这些资源的语句并添加到模型中。

在 Jena 中，语句的主题永远是 Resource ，谓词由 Property 表示，对象是另一个 Resource 或常量值。常量在 Jena 中通过 Literal 类型表示。所有这些类型共享公共接口 RDFNode 。将需要四个不同的 Property 实例表示家庭树中的关系。这些实例使用 Model.createProperty() 创建。

将语句添加到模型中的最简单方法是通过调用 Resource.addProperty() 。此方法以 Resource 作为主题在模型中创建语句。该方法使用两个参数，表示语句谓词的 Property 和语句的对象。 addProperty() 方法被过载：一个过载使用 RDFNode 作为对象，所以可以使用 Resource 或 Literal 。还有有益过载，它们使用由 Java 原语或 String 表示的常量。在示例中，语句的对象是表示其他家庭成员的 Resource 。

通过使用三元组的主题、谓词和对象调用 Model.createStatement() ，还可以直接在模型上创建语句。注意以此种方式创建 Statement 不将其添加到模型中。如果想将其添加到模型中，请使用创建的 Statement 调用 Model.add()

下面给出一些源代码：

package com.jena.ibm;
import java.util.*;
import com.hp.hpl.jena.rdf.model.*;
public class FamilyModel {
// Namespace declarations
static final String familyUri = "http://family/ ";
static final String relationshipUri = "http://family.org/relationship/ ";
// Jena model representing the family
private Model model;
public FamilyModel() {
    // Create an empty Model
    model = ModelFactory.createDefaultModel();
}
public void test()
{
   // Create the types of Property we need to describe relationships
     // in the model
   Property childOf = model.createProperty(relationshipUri,"childOf");
     Property parentOf = model.createProperty(relationshipUri,"parentOf");
     Property siblingOf = model.createProperty(relationshipUri,"siblingOf");
     Property spouseOf = model.createProperty(relationshipUri,"spouseOf");
    
     // Create resources representing the people in our model
     Resource adam = model.createResource(familyUri+"adam");
     Resource beth = model.createResource(familyUri+"beth");
     Resource chuck = model.createResource(familyUri+"chuck");
     Resource dotty = model.createResource(familyUri+"dotty");
     Resource edward = model.createResource(familyUri+"edward");
     Resource fran = model.createResource(familyUri+"fran");
     Resource greg = model.createResource(familyUri+"greg");
     Resource harriet = model.createResource(familyUri+"harriet");

     // Add properties to describing the relationships between them
     adam.addProperty(siblingOf,beth);
     adam.addProperty(spouseOf,dotty);
     adam.addProperty(parentOf,edward);
     adam.addProperty(parentOf,fran);

     beth.addProperty(siblingOf,adam);
     beth.addProperty(spouseOf,chuck);
     chuck.addProperty(spouseOf,beth);
   
     dotty.addProperty(spouseOf,adam);
     dotty.addProperty(parentOf,edward);
     dotty.addProperty(parentOf,fran);
     // Statements can also be directly created ...
     Statement statement1 = model.createStatement(edward,childOf,adam);
     Statement statement2 = model.createStatement(edward,childOf,dotty);
     Statement statement3 = model.createStatement(edward,siblingOf,fran);
     // ... then added to the model:
     model.add(statement1);
     model.add(statement2);
     model.add(statement3);
     // Arrays of Statements can also be added to a Model:
     Statement statements[] = new Statement[5];
     statements[0] = model.createStatement(fran,childOf,adam);
     statements[1] = model.createStatement(fran,childOf,dotty);
     statements[2] = model.createStatement(fran,siblingOf,edward);
     statements[3] = model.createStatement(fran,spouseOf,greg);
     statements[4] = model.createStatement(fran,parentOf,harriet);
     model.add(statements);
     // A List of Statements can also be added
     List list = new ArrayList();
     list.add(model.createStatement(greg,spouseOf,fran));
     list.add(model.createStatement(greg,parentOf,harriet));
     list.add(model.createStatement(harriet,childOf,fran));
     list.add(model.createStatement(harriet,childOf,greg));
     model.add(list);
      System.out.println("------------------");
// List everyone in the model who has a child:
     ResIterator parents = model.listSubjectsWithProperty(parentOf);
     // Because subjects of statements are Resources, the method returned a ResIterator
     while (parents.hasNext()) {
     // ResIterator has a typed nextResource() method
     Resource person = parents.nextResource();
     // Print the URI of the resource
     System.out.println(person.getURI()); }
     // Can also find all the parents by getting the objects of all "childOf" statements
     // Objects of statements could be Resources or literals, so the Iterator returned
     // contains RDFNodes
     NodeIterator moreParents = model.listObjectsOfProperty(childOf);
     while(moreParents.hasNext())
     {
     RDFNode r=moreParents.nextNode();
     if(r instanceof Resource){
        System.out.println(r);
     }
     //literal
     else System.out.println(r);
     }
     // To find all the siblings of a specific person, the model itself can be queried
     NodeIterator siblings = model.listObjectsOfProperty(edward, siblingOf);
     // But it's more elegant to ask the Resource directly
     // This method yields an iterator over Statements
     StmtIterator moreSiblings = edward.listProperties(siblingOf);
   System.out.println("------------------");
   model.listStatements(adam,spouseOf,dotty);
// Find all statements with adam as the subject and dotty as the object
model.listStatements(adam,null,dotty);
  
// Find any statements made about adam
model.listStatements(adam,null,(RDFNode)null);
// Find any statement with the siblingOf property
StmtIterator stmtIter= model.listStatements(null,siblingOf,(RDFNode)null);
while(stmtIter.hasNext())
{
   Statement stmt=stmtIter.nextStatement();
   System.out.println(stmt);
}
}
public static void main(String args[]) {
    // Create a model representing the family
    FamilyModel theFamily = new FamilyModel();
    theFamily.test();
    //System.out.println(theFamily.model);
}
}
参考：http://www.ibm.com/developerworks/cn/java/j-jena/#resources