Jena API 使用介绍

最新推荐文章于 2024-08-07 09:52:41 发布
最新推荐文章于 2024-08-07 09:52:41 发布
阅读量3.8w 收藏 74
点赞数 22
分类专栏： RDF 处理 文章标签： Jena jena RDF rdf
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/javafreely/article/details/8432522
版权

本文将对jena 的使用进行简单介绍。部分内容参考了这里 http://jena.apache.org/tutorials/rdf_api.html 。

 

1.  jena 包下载与开发环境配置

  • 首先，从 这里下载 jena 包 apache-jana-2.7.*.tar.gz。解压。
  • 打开 Eclipse，新建一个Java Project。
  • 右键点击项目->properties->Java Build Path -> libraries。将解压后 lib 目录下的 jar 文件添加到build path 中。
  • OK。现在可以在项目里使用 jena 了。

2.  jena 简单使用

我们先看下面一个例子。这是一个 people 资源。RDF 中关于人的信息用vcard 来表示比较合适。关于 RDF 中 vCard 的更多内容参考http://www.w3.org/TR/vcard-rdf/。

这个例子中，资源 http://.../JohnSmith 表示一个人。这个人的全名是 John Smith，即 vcard:FN 属性的值是 John Smith。在 Jena 中，资源用 Resource 类来表示，其属性用 Property 类来表示。而整体模型用Model 类来表示，即上图就是一个Model。一个 Model 对象可以包含多个资源。

上面所描述的资源使用 jena 编程表示如下：

import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.Resource;
import com.hp.hpl.jena.vocabulary.VCARD;

public class Introduction {
	static String personURI    = "http://somewhere/JohnSmith";
	static String fullName     = "John Smith";

	public static void main(String[] args){
		// create an empty Model
		Model model = ModelFactory.createDefaultModel();

		// create the resource
		Resource johnSmith = model.createResource(personURI);

		// add the property
		johnSmith.addProperty(VCARD.FN, fullName);
	}
}


其中， ModelFactory 类是一个Model 工厂，用于创建model 对象。我们可以使用 Model 的createResource 方法在model 中创建一个资源，并可以使用资源的 addProperty 方法添加属性。

 

3. jena 的 Statement

Model 的每个箭头都是一个陈述（Statement）。Statement 由三部分组成，分别是主语、谓语和客体。

  • 主语：图示中箭头出发的位置。代表资源。
  • 谓语：图示中的箭头。代表资源的属性。
  • 客体：图示中箭头指向的位置。代表属性的值。它可以是文本，也可以是一个资源。

下图表示一个Model：

它的每一个箭头都代表一个Statement。如资源http://.../JohnSmith 有一个vCard:FN 属性，其值是文本"John Smith ”。这个资源还有一个 vCard:N 属性，这个属性的值是另一个无名资源。该无名资源有两个属性，分别是 vCard:Given 和 vCard:Family。其值分别是文本的"John" 和 "Smith"。

我们可以用Jena API 来解析这个RDF 的Statement：

import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.Property;
import com.hp.hpl.jena.rdf.model.RDFNode;
import com.hp.hpl.jena.rdf.model.Resource;
import com.hp.hpl.jena.rdf.model.Statement;
import com.hp.hpl.jena.rdf.model.StmtIterator;
import com.hp.hpl.jena.vocabulary.VCARD;

public class StatementDemo {
	public static void main(String[] args){
		
		//Introduction
		String personURI = "http://somewhere/JohnSmith";
		String givenName = "John";
		String familyName = "Smith";
		String fullName = givenName + " " + familyName;
		Model model = ModelFactory.createDefaultModel();
		
		Resource johnSmith = model.createResource(personURI);
		johnSmith.addProperty(VCARD.FN, fullName);
		johnSmith.addProperty(VCARD.N, 
					model.createResource()
						.addProperty(VCARD.Given, givenName)
						.addProperty(VCARD.Family, familyName));
		
		//Statement
		StmtIterator iter = model.listStatements();
		
		while(iter.hasNext()){
			Statement stmt = iter.nextStatement();
			Resource subject = stmt.getSubject();
			Property predicate = stmt.getPredicate();
			RDFNode object = stmt.getObject();
			
			System.out.print(subject.toString());
			System.out.print(" "+predicate.toString());
			if(object instanceof Resource){
				System.out.print(object.toString());
			}else{
				System.out.print("\"" + object.toString() + "\"");
			}
			
			System.out.println(" .");
		}
	}
}

Model 类的listStatements 将返回一个 Statement 的Iterator。Statement 有的主语、谓语、客体分别用 getSubject、getPredicate、getObject 来返回。其类型分别是 Resource、Property和RDFNode。其中客体 object 类型可以是Resource 或者文本。

该程序的输出如下：

http://somewhere/JohnSmith http://www.w3.org/2001/vcard-rdf/3.0#N-1e19b4fe:13bd0803952:-7fff .
http://somewhere/JohnSmith http://www.w3.org/2001/vcard-rdf/3.0#FN"John Smith" .
-1e19b4fe:13bd0803952:-7fff http://www.w3.org/2001/vcard-rdf/3.0#Family"Smith" .
-1e19b4fe:13bd0803952:-7fff http://www.w3.org/2001/vcard-rdf/3.0#Given"John" .

这四条分别代表了四个Statement，也即上面图中的四个箭头。
需要注意的是，这里有一个资源我们没有指定资源名。

4. 输出RDF

我们看下面的例子：

import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.Resource;
import com.hp.hpl.jena.vocabulary.VCARD;


public class RDFWriting {
	public static void main(String[] args){
		
		//Introduction
		String personURI = "http://somewhere/JohnSmith";
		String givenName = "John";
		String familyName = "Smith";
		String fullName = givenName + " " + familyName;
		Model model = ModelFactory.createDefaultModel();
		
		Resource johnSmith = model.createResource(personURI);
		johnSmith.addProperty(VCARD.FN, fullName);
		johnSmith.addProperty(VCARD.N, 
					model.createResource()
						.addProperty(VCARD.Given, givenName)
						.addProperty(VCARD.Family, familyName));
		
		//Model write
		model.write(System.out);
		System.out.println();
		model.write(System.out, "RDF/XML-ABBREV");
		System.out.println();
		model.write(System.out, "N-TRIPLE");
	}
}

Model 同第三部分图示中所述一样。我们可以通过 Model 的write 方法将其model 中内容写入一个输出流。本例的输出为：

<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:vcard="http://www.w3.org/2001/vcard-rdf/3.0#" > 
  <rdf:Description rdf:about="http://somewhere/JohnSmith">
    <vcard:N rdf:nodeID="A0"/>
    <vcard:FN>John Smith</vcard:FN>
  </rdf:Description>
  <rdf:Description rdf:nodeID="A0">
    <vcard:Family>Smith</vcard:Family>
    <vcard:Given>John</vcard:Given>
  </rdf:Description>
</rdf:RDF>

<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:vcard="http://www.w3.org/2001/vcard-rdf/3.0#">
  <rdf:Description rdf:about="http://somewhere/JohnSmith">
    <vcard:N rdf:parseType="Resource">
      <vcard:Family>Smith</vcard:Family>
      <vcard:Given>John</vcard:Given>
    </vcard:N>
    <vcard:FN>John Smith</vcard:FN>
  </rdf:Description>
</rdf:RDF>

<http://somewhere/JohnSmith> <http://www.w3.org/2001/vcard-rdf/3.0#N> _:AX2dX498ae941X3aX13bd08e9fe5X3aXX2dX7fff .
<http://somewhere/JohnSmith> <http://www.w3.org/2001/vcard-rdf/3.0#FN> "John Smith" .
_:AX2dX498ae941X3aX13bd08e9fe5X3aXX2dX7fff <http://www.w3.org/2001/vcard-rdf/3.0#Family> "Smith" .
_:AX2dX498ae941X3aX13bd08e9fe5X3aXX2dX7fff <http://www.w3.org/2001/vcard-rdf/3.0#Given> "John" .

可以看出，model.write(OutputStream)，model.write(OutputStream, ”RDF/XML-ABBREV")，model.write(OutputStream, "N-TRIPLE") 分别输出了不同格式的内容。

  • model.write(OutputStream) : 也可以用model.write(OutputStream, null) 代替。默认的输出格式。
  • model.write(OutputStream, "RDF/XML-ABBREV"): 使用XML 缩略语法输出RDF。
  • model.write(OutputStream, "N-TRIPLE"): 输出n 元组的格式。

5. 输入RDF

我们有如下一个rdf 文件

resources.rdf:

<rdf:RDF
  xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'
  xmlns:vcard='http://www.w3.org/2001/vcard-rdf/3.0#'
 >
  <rdf:Description rdf:nodeID="A0">
    <vcard:Family>Smith</vcard:Family>
    <vcard:Given>John</vcard:Given>
  </rdf:Description>
  <rdf:Description rdf:about='http://somewhere/JohnSmith/'>
    <vcard:FN>John Smith</vcard:FN>
    <vcard:N rdf:nodeID="A0"/>
  </rdf:Description>
  <rdf:Description rdf:about='http://somewhere/SarahJones/'>
    <vcard:FN>Sarah Jones</vcard:FN>
    <vcard:N rdf:nodeID="A1"/>
  </rdf:Description>
  <rdf:Description rdf:about='http://somewhere/MattJones/'>
    <vcard:FN>Matt Jones</vcard:FN>
    <vcard:N rdf:nodeID="A2"/>
  </rdf:Description>
  <rdf:Description rdf:nodeID="A3">
    <vcard:Family>Smith</vcard:Family>
    <vcard:Given>Rebecca</vcard:Given>
  </rdf:Description>
  <rdf:Description rdf:nodeID="A1">
    <vcard:Family>Jones</vcard:Family>
    <vcard:Given>Sarah</vcard:Given>
  </rdf:Description>
  <rdf:Description rdf:nodeID="A2">
    <vcard:Family>Jones</vcard:Family>
    <vcard:Given>Matthew</vcard:Given>
  </rdf:Description>
  <rdf:Description rdf:about='http://somewhere/RebeccaSmith/'>
    <vcard:FN>Becky Smith</vcard:FN>
    <vcard:N rdf:nodeID="A3"/>
  </rdf:Description>
</rdf:RDF>


它包含有四个People 资源。下面的程序将读取该rdf 文件并再将内容输出：

import java.io.InputStream;

import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.util.FileManager;

public class RDFReading {
	public static String inputFileName = "resources.rdf";
	
	public static void main(String[] args){
		Model model = ModelFactory.createDefaultModel();

		// 使用 FileManager 查找文件
		InputStream in = FileManager.get().open( inputFileName );
		if (in == null) {
			throw new IllegalArgumentException(
	                                 "File: " + inputFileName + " not found");
		}

		// 读取RDF/XML 文件
		model.read(in, null);

		model.write(System.out);
	}
}


Model 的read 方法可以读取RDF 输入到model 中。第二个参数可以指定格式。

6. 设置Namespace 前缀

我们看下面这个例子：

import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.Property;
import com.hp.hpl.jena.rdf.model.Resource;


public class NSPrefix {
	public static void main(String[] args){
		Model m = ModelFactory.createDefaultModel();
		String nsA = "http://somewhere/else#";
		String nsB = "http://nowhere/else#";
		
		//创建Resource 和 Property
		Resource root = m.createResource( nsA + "root" );
		Property P = m.createProperty( nsA + "P" );
		Property Q = m.createProperty( nsB + "Q" );
		Resource x = m.createResource( nsA + "x" );
		Resource y = m.createResource( nsA + "y" );
		Resource z = m.createResource( nsA + "z" );
		
		//层叠增加三个Statement
		m.add( root, P, x ).add( root, P, y ).add( y, Q, z );
		System.out.println( "# -- no special prefixes defined" );
		m.write( System.out );
		System.out.println( "# -- nsA defined" );
		
		//设置Namespace nsA 的前缀为“nsA”
		m.setNsPrefix( "nsA", nsA );
		m.write( System.out );
		System.out.println( "# -- nsA and cat defined" );
		
		//设置Namespace nsB 的前缀为“cat”
		m.setNsPrefix( "cat", nsB );
		m.write( System.out );
	}
}


该程序首先调用 Model 的createProperty 和createResource 生成属性和资源。然后调用Model.add 想model 中增加3个Statement。add 的三个参数分别是三元组的主语、谓语和客体。想Model 中增加内容实际上就是增加三元组。

Model 的 setNsPrefix 函数用于设置名字空间前缀。该程序的输出如下：

# -- no special prefixes defined
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:j.0="http://nowhere/else#"
    xmlns:j.1="http://somewhere/else#" > 
  <rdf:Description rdf:about="http://somewhere/else#y">
    <j.0:Q rdf:resource="http://somewhere/else#z"/>
  </rdf:Description>
  <rdf:Description rdf:about="http://somewhere/else#root">
    <j.1:P rdf:resource="http://somewhere/else#y"/>
    <j.1:P rdf:resource="http://somewhere/else#x"/>
  </rdf:Description>
</rdf:RDF>
# -- nsA defined
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:j.0="http://nowhere/else#"
    xmlns:nsA="http://somewhere/else#" > 
  <rdf:Description rdf:about="http://somewhere/else#y">
    <j.0:Q rdf:resource="http://somewhere/else#z"/>
  </rdf:Description>
  <rdf:Description rdf:about="http://somewhere/else#root">
    <nsA:P rdf:resource="http://somewhere/else#y"/>
    <nsA:P rdf:resource="http://somewhere/else#x"/>
  </rdf:Description>
</rdf:RDF>
# -- nsA and cat defined
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:cat="http://nowhere/else#"
    xmlns:nsA="http://somewhere/else#" > 
  <rdf:Description rdf:about="http://somewhere/else#y">
    <cat:Q rdf:resource="http://somewhere/else#z"/>
  </rdf:Description>
  <rdf:Description rdf:about="http://somewhere/else#root">
    <nsA:P rdf:resource="http://somewhere/else#y"/>
    <nsA:P rdf:resource="http://somewhere/else#x"/>
  </rdf:Description>
</rdf:RDF>

如果我们没有为RDF 指定namespace 前缀，则jena 会自动为其生成名为 j.0, j.1 的名字空间。

7. jena 的 Model 访问

上面介绍了jena 用来创建、读、写 RDF Model，本部分将主要用来访问RDF Model 的信息，对Model 的内容进行操作。

看下面一个例子：

import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.Resource;
import com.hp.hpl.jena.rdf.model.StmtIterator;
import com.hp.hpl.jena.vocabulary.VCARD;

public class ModelAccess {
	public static void main(String[] args){
		String personURI = "http://somewhere/JohnSmith";
		String givenName = "John";
		String familyName = "Smith";
		String fullName = givenName + " " + familyName;
		Model model = ModelFactory.createDefaultModel();
		
		Resource johnSmith = model.createResource(personURI);
		johnSmith.addProperty(VCARD.FN, fullName);
		johnSmith.addProperty(VCARD.N, 
					model.createResource()
						.addProperty(VCARD.Given, givenName)
						.addProperty(VCARD.Family, familyName));
		
		// 从 Model 获取资源
		Resource vcard = model.getResource(personURI);
		
		/*
		// 获取N 属性的值（用属性的 getObject()方法）
		Resource name = (Resource) vcard.getProperty(VCARD.N)
		                                .getObject();
		*/
		
		// 如果知道属性的值是资源，可以使用属性的getResource 方法
		Resource name = vcard.getProperty(VCARD.N)
		                     .getResource();
		
		// 属性的值若是 literal，则使用 getString 方法
		fullName = vcard.getProperty(VCARD.FN)
		                        .getString();
		
		// 增加两个 NICKNAME 属性
		vcard.addProperty(VCARD.NICKNAME, "Smithy")
		     .addProperty(VCARD.NICKNAME, "Adman");
		
		System.out.println("The nicknames of \""
		                      + fullName + "\" are:");
		
		// 列出两个NICKNAME 属性，使用资源的 listProperties 方法
		StmtIterator iter = vcard.listProperties(VCARD.NICKNAME);
		while (iter.hasNext()) {
		    System.out.println("    " + iter.nextStatement()
		                                    .getObject()
		                                    .toString());
		}
	}
}

本例子中主要使用了以下内容

  • Model 的 getResource 方法：该方法根据参数返回一个资源对象。
  • Resource 的 getProperty 方法：根据参数返回一个属性对象。
  • Property 的 getObject 方法：返回属性值。使用时根据实际类型是 Resource 还是 literal 进行强制转换。
  • Property 的 getResource 方法：返回属性值的资源。如果属性值不是Resource，则报错。
  • Property 的 getString 方法：返回属性值的文本内容。如果属性值不是文本，则报错。
  • Resource 的 listProperties 方法：列出所找到符合条件的属性。

8. 对 Model 的查询

Jena 和核心 API 仅支持有限的查询操作。我们这里进行简单介绍。

  • Model.listStatements(): 列出Model 所有的Statements。
  • Model.listSubjects(): 列出所有具有属性的资源。
  • Model.listSubjectsWithProperty(Property p, RDFNode o): 列出所有具有属性p 且其值为 o 的资源。

上面所述的几种查询都是对 Model.listStatements(Selector s) 进行了一些包装得到的。如

  • Selector selector = new SimpleSelector(subject, predicate, object). 这个选择器选择所有主语符合 subject、谓语符合 predicate、客体符合 object 的Statement。

下面分别使用两种方式查询具有 fullName 的资源。

1. 使用 Model.listSubjectsWithProperty 查询：

import java.io.InputStream;

import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.ResIterator;
import com.hp.hpl.jena.util.FileManager;
import com.hp.hpl.jena.vocabulary.VCARD;

public class RDFQuery {
	public static String inputFileName = "resources.rdf";
	
	public static void main(String[] args){
		Model model = ModelFactory.createDefaultModel();

		InputStream in = FileManager.get().open( inputFileName );
		if (in == null) {
			throw new IllegalArgumentException(
	                                 "File: " + inputFileName + " not found");
		}

		model.read(in, null);

		//使用 listResourcesWithProperty
		ResIterator iter = model.listResourcesWithProperty(VCARD.FN);
		if(iter.hasNext()){
			System.out.println("The database contains vcard for:");
			while(iter.hasNext()){
				System.out.println(" "+iter.nextResource().getProperty(VCARD.FN).getString());
			}
		}else{
			System.out.println("No vcards were found in the database");
		}
	}
}

 

2. 使用 Selector 查询：

import java.io.InputStream;

import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.RDFNode;
import com.hp.hpl.jena.rdf.model.SimpleSelector;
import com.hp.hpl.jena.rdf.model.StmtIterator;
import com.hp.hpl.jena.util.FileManager;
import com.hp.hpl.jena.vocabulary.VCARD;

public class RDFQuery1 {
	public static String inputFileName = "resources.rdf";
	
	public static void main(String[] args){
		Model model = ModelFactory.createDefaultModel();

		InputStream in = FileManager.get().open( inputFileName );
		if (in == null) {
			throw new IllegalArgumentException(
	                                 "File: " + inputFileName + " not found");
		}

		model.read(in, null);

		//使用 Selector
		StmtIterator iter = model.listStatements(new SimpleSelector(null, VCARD.FN, (RDFNode)null));
		if(iter.hasNext()){
			System.out.println("The database contains vcard for:");
			while(iter.hasNext()){
				System.out.println(" "+iter.nextStatement().getString());
			}
		}else{
			System.out.println("No vcards were found in the database");
		}
	}
}

本例中使用resources.rdf 资源。上面两例的输出均为：

The database contains vcard for:
 Becky Smith
 Matt Jones
 Sarah Jones
 John Smith

9. 对Model 的增删操作

我们知道，对数据库的操作主要包括增、删、改、查等。对RDF 我们同样可以实现这几种操作。查询操作我们已经介绍过，本节将介绍RDF Model 的增删操作。我们可以对一个RDF 增加或者删除 Statement。由于 RDF Model完全是由 Statements 构成的，因此我们可以据此实现资源和属性等的增删。改动操作可以通过删除后再添加来实现。

看下面这个例子：

import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.RDFNode;
import com.hp.hpl.jena.rdf.model.Resource;
import com.hp.hpl.jena.vocabulary.VCARD;


public class AddDelete {
	public static void main(String[] args){
		String personURI = "http://somewhere/JohnSmith";
		String givenName = "John";
		String familyName = "Smith";
		String fullName = givenName + " " + familyName;
		Model model = ModelFactory.createDefaultModel();
		
		Resource johnSmith = model.createResource(personURI);
		johnSmith.addProperty(VCARD.FN, fullName);
		johnSmith.addProperty(VCARD.N, 
					model.createResource()
						.addProperty(VCARD.Given, givenName)
						.addProperty(VCARD.Family, familyName));

		System.out.println("原始内容：");
		model.write(System.out);
		// 删除 Statement 		
		model.remove(model.listStatements(null, VCARD.N, (RDFNode)null));
		model.removeAll(null, VCARD.Given, (RDFNode)null);
		model.removeAll(null, VCARD.Family, (RDFNode)null);
		
		System.out.println("\n删除后的内容：");
		model.write(System.out);
		
		//增加 Statement
		model.add(johnSmith, VCARD.N, model.createResource()
				.addProperty(VCARD.Given, givenName)
				.addProperty(VCARD.Family, familyName));
		System.out.println("\n重新增加后的内容：");
		model.write(System.out);
	}
}

在此例中，我们首先生成一个Model ，然后使用 Model.remove 方法删除几个statement 条目，然后使用Model.add 又增加了回来。

Model.remove 方法可以实现statement 的删除操作，Model.add 可以实现statement 的增加。

除了直接使用 Model 的方法外，对Model 中的Resource（资源）或Property（属性，实际上也继承自Resource）进行增删操作也可以达到更改 Model 的目的。

10 .Model 的合并操作

Model 的合并主要分为 交、并、补三种操作。

如下图所示：

          

这两个图分别代表一个Model。它们的名字相同，且具有相同的属性 vcard:FN ，值为John Smith。因此，我们对这两个Model 进行“并”（union）操作。所得到的Model 的图形表示如下：

其中重复的 vcard:FN 值只出现一个。

这三种操作的方法分别为：

  • Model.intersection(Model model): 交操作。创建一个新Model ，新Model 中包含之前两个Model 中都有的部分。
  • Model.union(Model model): 并操作。创建一个新Model，新 Model 中包含之前两个Model 中某一个具有的部分。
  • Model.difference(Model model): 补操作。创建一个新Model，新Model 中包含本Model 中有单在参数所示 Model 中没有的部分。

11. 总结

本文对核心 Jena API 进行了比较全面的介绍。Jena API 是处理RDF 的一个Java 框架。RDF 是用来进行资源描述的。

本文中的所有例子都经过本人调试运行正常。

需要了解 Jena 的更多内容，请参考 http://jena.apache.org/index.html 。

需要了解 RDF 的更多内容，请参考 http://www.w3.org/RDF/ 。另外http://www.w3school.com.cn/rdf/index.asp 是一个简明介绍。

Jena API的使用以及实例
wingofdeath的博客
03-24 1271
本文将对jena API进行简单介绍，鉴于Jena已经更新到3.2版本，有些设置已经无法使用，对此进行了一定程度的修改，以方便新手的使用。部分内容参考了这里http://www.iandickinson.me.uk/articles/jena-eclipse-helloworld/。1.Jena包下载以及环境配置首先，下载最新版本的Jena包，目前更新到3.2版本，下载地址，解压；（1）打开Ecli
Jena API使用手册
04-04
纯粹的Jena API介绍资料，结合中文解说+code例子+实验结果
Apache Jena 使用教程
最新发布
gitblog_00509的博客
08-07 924
Apache Jena 使用教程 项目地址:https://gitcode.com/gh_mirrors/je/jena 项目介绍 Apache Jena 是一个开源的 Java 框架，用于构建基于 RDF 和 SPARQL 的语义网应用。它提供了丰富的 API 和工具，支持 RDF 数据的管理、查询和推理。Jena 的核心功能包括 RDF 数据的存储、查询（通过 SPARQL）、推理（支持 OW...
Jena TDB 环境搭建以及几个工具的使用
Think Different
03-14 400
简单的说，TDB是Jena提供的两个subsystem之一，另外一个叫做SDB。TDB使用triple store的形式对RDF数据提供持久性存储（persistent store）, SDB则支持使用传统的关系数据库存储RDF数据。详细介绍可以参考Apache Jena页面http://jena.staging.apache.org/jena/index.html   在这个页面http:/...
关于jena的API说明
longfei8812的专栏
12-25 1266
 本文来自：万能的天空http://hi.baidu.com/wanneng/blog/item/7442af18c26bc00435fa41cd.htmlJena文档《An Introduction to RDF and the Jena RDF API》的译文RDF和Jena RDF API入门____________________________________
jena API 项目以及相关依赖
04-20
Onto_JDBC_test：OWL文件存入Mysql数据库的测试类； MySQL2Onto：从Mysql数据库读取转Onto的测试类
Jena使用介绍
03-15
本文是通过实例介绍了Java推理引擎Jena的使用方法。
JenaApi.docx
03-07
本文档主要介绍了Jena的Ontology API，用于处理本体信息。 首先，预备知识部分强调了对RDF和Jena的基本理解是必要的。RDF是一种数据模型，用于描述网络中的资源和它们之间的关系，而Jena是一个用Java实现的工具包，...
jena+API查询OWL本体（重要）.rar_OWL API_jena_jena api_jena owl api_本体 ow
07-13
这是一个jena api解析owl文件的简单案例。
OWL Jena.zip_OWL API_OWL Jena API_jena_owl
09-20
6. **示例应用**：在文档《An Introduction to RDF and the Jena RDF API》中，可能包含了使用Jena OWL API创建、读取和操作OWL本体的简单示例，这些示例有助于初学者快速上手。 通过学习和使用OWL API和Jena OWL ...
Jena使用实例
04-01
Jena的使用实例，对新手来说非常有用哦
jena基本使用案例
03-09
想学习jena 就看此资源，jean入门的朋友看看，里面是一个jena与本体应用的联系操作实例，对jena初学者有很大帮助，希望可以帮到大家。
Jena-API.rar_jena api_jena protege_owl_protege jena_本体
09-23
ena对应用程序就像Protege 对我们，我们使用Protege操作 ...API，相当于对Jena的包装，据说使用起来更方便，这个API就是Protege 的OWL Plugin所使用的，相信作者经过OWL Plugin的开发以后，说这些话 是有一定依据的。
jena基本使用
hongyiluoguihua的专栏
11-27 2849
1. 什么是jena（摘自http://imarine.blog.163.com/blog/static/51380183200812774739130/ ）     　Jena由 HP Labs（http://www.hpl.hp.com）开发的Java开发工具包, 用于Semantic Web(语义网)中的应用程序开发；Jana是开源的，在下载的文档中有Jena的完整代码。Jena框架主
Jena使用总结
爱米酱的博客
08-14 4094
今天我在使用Jena的过程中出现了一些问题，现在我将我出现的问题进行如下总结： 1.要使用Jena,需要分别下载apache-jena和apache-jena-fuseki,因为fuseki和其他的功能模块不在同一个文件中。 还要在环境变量中配置JENA_HOME和path. 2.我们需要创建一个tdb目录，用于存放tdb数据。我们可以进入Jena的bat目录，使用命令将我们的RDF数据以T...
mysql api 读取与设置_Jena API使用详解（关注将本体持久化到MySQL后的操作及解决中文乱码等问题）...
weixin_35769289的博客
02-01 174
关于Jena的简介在很多博客中都能看到，例如对Jena的简单理解和一个例子，使用Jena将本体存入MySQL，Jena进阶等。在入门的时候，看这些文章总是很疑惑，对于存入数据库后的操作一无所知。因此，在做毕设之余，把使用到的一些方法记录下来，供将来查阅。将本体持久化到数据库首先，还是不能免俗，说说如何将本体持久化到数据库的方法。总体的操作流程是将本体从owl文件中读出，建立一个数据库的连接，将Mo...
jena 初步使用
极e象
05-11 847
原文 本文简单介绍Jena（Jena 2.4），使用Protégé 3.1（不是最新版本）创建一个简单的生物（Creature）本体，然后参照Jena文档中的一个例子对本体进行简单的处理，输出本体中的Class、Property等信息。 本文内容安排如下： Ø         介绍Jena Ø         运行Jena Ø         Jena Ontology A
jena使用 java_【jena】 jena基本使用
weixin_42503069的博客
02-27 1427
1. 什么是jena(摘自http://imarine.blog.163.com/blog/static/51380183200812774739130/)Jena由HP Labs(http://www.hpl.hp.com)开发的Java开发工具包, 用于Semantic Web(语义网)中的应用程序开发；Jana是开源的，在下载的文档中有Jena的完整代码。Jena框架主要包括:a)...
Jena对本体、RDF三元组的API操作记录
凉茶冰
05-12 1244
通过JenaAPI实现对本体文件、RDF三元组.nt文件导入到TDB中，并且支持通过api的方式新增、删除、查询三元组数据。
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值