Sử dụng Jena để phát triển Web ngữ nghĩa

Chapter 15: Sử dụng Jena để phát triển Web ngữ nghĩa
Một phần của chương trước đã trình bày tổng quan về các framework
phát triển có sẵn. Chương này tập trung vào Jena là một ví dụ cụ thể cũng như
môi trường phát triển chính của chúng tôi.
Trong chương này, chúng tôi cung cấp một vài ví dụ, từ HelloWorld, đến
các thao tác cơ bản mà bạn có thể sẽ gặp phải đối với bất kỳ các ứng dụng trên
Semantic Web, bao gồm cả các hoạt động của mô hình RDF, xử lý đồ thị RDF
và khả năng suy luận. Mục tiêu không phải chỉ để chỉ ra cách sử dụng
framework phát triển Jena, mà còn bổ sung các classes Java vào bộ công cụ
riêng của bạn, và tái sử dụng chúng trong công tác phát triển trong tương lai của
bạn.
Lưu ý Jena là một API cho các ứng dụng Java Web ngữ nghĩa. Do đó
chương này giả định rằng bạn đã quen thuộc với ngôn ngữ lập trình Java.
15.1 Jena: A Semantic Web Framework for Java
15.1.1 What Is Jena and What Can It Do for Us?
Tại thời điểm này, chúng tôi chưa phát triển các ứng dụng trên Semantic
Web. Tuy nhiên, dựa vào những gì chúng ta đã học về Semantic Web, chúng ta
nhận ra rằng bất kỳ ứng dụng Web có ngữ nghĩa có thể xử lý các tác vụ thông
thường như sau:
• Đọc / phân tích các tài liệu RDF
• Viết / tạo các tài liệu RDF
• Định vị / tìm kiếm thông qua một đồ thị RDF
• Truy vấn một bộ dữ liệu RDF bằng SPARQL
• Suy luận sử dụng các ontology OWL
Để có thể sử dụng Jena API, bước đầu tiên là tải về các gói Jena, và bước
thứ hai là để thiết lập một môi trường phát triển Java để sử dụng các gói


Jena. Hai bước này được trình bày chi tiết trong phần này. Môi trường phát triển
Java được sử dụng là Eclipse.
15.1.2 Getting the Jena Package

Truy cập đường link ( để đến trang chủ Jena.
Để tải về các gói Jena, nhấp vào liên kết tải về trên trang web, và làm
theo hướng dẫn. Phiên bản sử dụng ở đây là bản 2.6.0, tuy nhiên các phiên bản
cao hơn đều có thể sử dụng được.
Sau khi tải về xong, bạn sẽ tìm thấy một tập tin zip có tên Jena-2.xx trên
ổ cứng. Giải nén tập tin này để tạo ra một thư mục gói Jena trên ổ cứng của
bạn. Lưu ý rằng Jena là một thư viện để viết các ứng dụng dựa trên RDF và tài
liệu OWL. Nó chỉ được sử dụng trong lập trình như là một tập hợp các APIs, và
không có giao diện đồ họa cho Jena. Các thành phần cốt lõi của Jena được lưu
trữ trong thư mục \lib.
Để sử dụng các thư viện Jena, cần phải thêm tất cả các file .jar liên quan
vào biến classpath.
Ví dụ đối với Windows XP, các biến classpath được chứa trong hai loại:
loại SystemVariables và loại UserVariables. Thông thường chỉ cần thay đổi giá
trị biến UserVariables là đủ.
Để làm như vậy, nhấp chuột phải vào biểu tượng My Computer, nhấp
chọn vào Properties, để hiện ra cửa sổ System Properties. Trong cửa sổ này,
click vào tab Advanced, và sau đó nhấp vào nút Environment Variables, trong
đó sẽ đưa bạn đến cửa sổ nơi bạn có thể chỉnh sửa các biến classpath chứa trong
loại UserVariables.
15.1.3 Using Jena in Your Projects
Sau khi thiết lập môi trường Jena, cần phải tích hợp các gói Jena vào các
Eclipse project để sử dụng được framework Jena.


15.1.3.1 Using Jena in Eclipse
Sự khác biệt giữa một project thuần Java và một project Java sử dụng thư
viện Jena đó là Eclipse cần biết đường dẫn để tìm các tập tin thư viện Jena để
tham chiếu đến. Khi đó, nó có thể tải các class tương ứng từ thư viện để sử dụng
trong các project.

Một cách để thực hiện điều này là để tạo ra một thư mục \lib trong project
workspace, sao chép các tập tin thư viện Jena vào thư mục \lib này và sau đó bổ
sung thư mục \lib này vào đường dẫn để build project.
Tuy nhiên, một giải pháp khác có thể được sử dụng đó là tạo thư viện
người sử dụng (user library).
Trong Eclipse, một thư viện người sử dụng một thư viện do người dùng
tự định nghĩa (một tập hợp các files jar) và có thể sử dụng cho nhiều project
khác nhau. Việc cập nhật phiên bản Jena cũng đơn giản hơn vì chỉ cần phải cập
nhật user library.
Để cấu hình một user library, mở Eclipse và chọn Window từ thanh công
cụ. Chọn Preferences. Từ cửa sổ mở ra, chọn Java ở menu bên trái, và
chọn Build Path. Khi Build Path được mở, chọn User Libraries như hình. 15.1.
Bấm New để tạo một user library mới, nhập jena làm tên thư viện, và
nhấn OK. Sau đó, nhấn vào Add JARS, trỏ đến thư mục chứa các file .jar trong
thư mục \lib. Nhấn Open, và user library đã được tạo ra.
Hình. 15.1 Thiết lập khuôn khổ Jena như một thư viện sử dụng trong
Eclipse


15.1.3.2 HelloWorld! from a Semantic Web Application
Chúng ta sẽ thực hiện ví dụ HelloWorld để khảo sát việc xây dựng một
project sử dụng framework Jena cho Semantic Web.
Ví dụ HelloWorld như sau: chúng ta sẽ tạo ra một tài liệu RDF đơn giản
đó chỉ chứa một tài liệu RDF, khai báo như sau:
subject: />property: />object: Hello World!

Khởi động Eclipse, tạo một project mới là HelloWorld, tạo một class
tên HelloWorld.java.
Nhập vào đoạn code bên dưới (Hình 15.1).
1: public class HelloWorld {

2:
3: static private String nameSpace = " />4:
5:

public static void main(String[] args) {

6:

Model model = ModelFactory.createDefaultModel();

7:
8:

Resource subject =


8a: model.createResource(nameSpace + "message");
9:

Property property =

9a: model.createProperty(nameSpace + "says");
10:

subject.addProperty(property,

10a:

"Hello World!",XSDDatatype.XSDstring);

11:
12:

model.write(System.out);

13: }
14:
15:}

Hình 15.1 HelloWorld.java

Hình. 15.2 Thiết lập framework Jena như một user library trong
Eclipse (cont.)


Hình. 15.3 Sử dụng framework Jena như một user library
Sau khi nhập đoạn code, Eclipse sẽ báo lỗi. Ví dụ, nó không nhận
ra Model, ModelFactory, Resource và Property. Rõ ràng, những định nghĩa này
đã có trong Jena, tuy nhiên Eclipse vẫn chưa nhận ra. Bây giờ chúng ta cần phải
chỉ cho Eclipse rằng các thư viện dùng chúng ta vừa tạo ra có chứa các định
nghĩa rằng nó cần; chúng ta làm điều này bằng cách thêm các user library để
build project.
Để làm điều đó, nhấp chuột phải vào HelloWorld project trong cửa sổ
Project Explorer,

chọn Properties, tìm

đến Java

Build

Path và

chọn

tab Libraries (Hình. 15.3).
Chọn Add Library để hiện cửa sổ như hình 15.4.
Chọn User Library, và nhấn Next; chọn jena và nhấn Finish để thêm user
library như trong hình. 15.5.
Nhấn OK trong cửa sổ Properties for HelloWorld để hoàn thành. Bạn có
thể thấy thư viện jena đã xuất hiện trong cửa sổ Project Explorer.


Tuy nhiên, lỗi vẫn còn hiển thị. Thực tế, Eclipse chờ chúng ta sử dụng
các khai báo import thích hợp để nó có thể tìm thấy các định nghĩa cho các
lớp Model, ModelFactory, Resource và Property như ở Hình 15.2

Hình 15.4 Sử dụng framework Jena như một user library (cont.)

Hình 15.5 Sử dụng framework Jena như một user library (bước cuối
cùng)


Hình 15.2 Import statements in our HelloWorld project
import com.hp.hpl.jena.datatypes.xsd.XSDDatatype;
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;

Bây giờ, chạy project, và bạn sẽ có thể có kết quả như trong Hình 15.3.
Hình 15.3 HelloWorld output
xmlns:j.0=" />xmlns:rdf=" >
<rdf:Description rdf:about=" />" />Hello World!
</j.0:says>
</rdf:Description>
</rdf:RDF>

Xin chúc mừng, ứng dụng Web ngữ nghĩa đầu tiên của bạn sử dụng Jena.
Đối với mô hình RDF trên, chỉ có một khai báo, và chúng ta có thể làm
cho nó trông tốt hơn bằng cách thay đổi dòng 12 trong Hình 15.1 để làm cho nó
trông như thế này:
12: model.write(System.out,"Turtle");

Chạy lại project một lần nữa. Bạn sẽ nhận được kết quả như trong Hình
15.4.
Hình 15.4 A better output from HelloWorld project
< />< />"Hello World!"^^< />

15.2 Basic RDF Model Operations
Trong phần này, chúng ta sẽ sử dụng Jena để thực hiện một số chức năng
cơ bản, đơn giản là tạo các mô hình RDF trong bộ nhớ hoặc đọc vào bộ nhớ từ
các URL hay file hệ thống.
15.2.1 Creating an RDF Model
Trong phần này, chúng tôi tạo ra một mô hình RDF từ đầu và sau đó
thêm các các khai báo cho nó. Để đơn giản, chúng ta sẽ tạo mô hình biểu diễn
FOAF, như trong Hình 15.5.
Hình 15.5 The author’s FOAF document

1: <?xml version="1.0" encoding="UTF-8"?>
2: 3:

xmlns:rdf=" />
4:

xmlns:rdfs=" />
5:

xmlns:foaf=" />
6:
7:


7a:

rdf:about=" />
8:

<foaf:name>liyang yu</foaf:name>

9:

<foaf:title>Dr</foaf:title>

10:

<foaf:givenname>liyang</foaf:givenname>

11:

<foaf:family_name>yu</foaf:family_name>

12:

<foaf:mbox rdf:resource="mailto:"/>

13:

<foaf:homepage rdf:resource=""/>

14:


14a:

rdf:resource=""/>

15:


15a:
16:

rdf:resource=" />

17:

<foaf:knows>

18:

<!-- the following is for testing purpose -->

19:

<foaf:Person>

20:


20a:

rdf:resource="mailto:"/>

21:


21a:

rdf:resource=" />
22:

</foaf:Person>

23:

</foaf:knows>

24:
25:


25a:

rdf:resource=" />
26:
27: </rdf:Description>
28: </rdf:RDF>

Và mã nguồn như trong Hình 15.6.
Hình 15.6 Create a new RDF model and add statements to it
1: import java.io.PrintWriter;
2: import com.hp.hpl.jena.rdf.model.Model;
3: import com.hp.hpl.jena.rdf.model.ModelFactory;
4: import com.hp.hpl.jena.rdf.model.Resource;
5: import com.hp.hpl.jena.sparql.vocabulary.FOAF;
6: import com.hp.hpl.jena.vocabulary.RDF;
7: import com.hp.hpl.jena.vocabulary.RDFS;
8:
9:

public class MyFOAFModel {

10:
11:
12:

public static void main(String[] args) {


13:

Model model = ModelFactory.createDefaultModel();

14:

model.setNsPrefix("rdfs",RDFS.getURI());

15:

model.setNsPrefix("foaf",FOAF.getURI());

16:
17:
17a:

Resource subject = model.createResource
(" />
18:
19:

subject.addProperty(FOAF.name,"liyang yu");

20:

subject.addProperty(FOAF.title,"Dr");

21:

subject.addProperty(FOAF.givenname,"liyang");

22:

subject.addProperty(FOAF.family_name,"yu");

23:

subject.addProperty(FOAF.mbox,

23a:
24:
24a:
25:
25a:
26:

model.createResource("mailto:"));
subject.addProperty(FOAF.homepage,
model.createResource(""));
subject.addProperty(FOAF.workplaceHomepage,
model.createResource(""));
subject.addProperty(FOAF.topic_interest,

26a:

model.createResource

26b:

(" />
27:

subject.addProperty(RDF.type,FOAF.Person);

28:
29:

Resource blankSubject = model.createResource();

30:

blankSubject.addProperty(RDF.type,FOAF.Person);

31:

blankSubject.addProperty(FOAF.mbox,

31a:

model.createResource

31b:

("mailto:"));

32:

blankSubject.addProperty(FOAF.homepage,

32a:

model.createResource

32b:

(" />

33:

subject.addProperty(FOAF.knows,blankSubject);

34:
35:

model.write(System.out);

36:

}

37:
38: }

Để tạo mô hình RDF, gọi hàm ModelFactory.createDefaultModel() (dòng
13). Hàm này trả về một instance của lớp Model, đại diện cho mô hình RDF
trống chúng ta vừa tạo. Lúc này, chúng ta có thể bắt đầu thêm các khai báo cho
mô hình này.
Để thêm khai báo vào mô hình RDF, đầu tiên cần phải tạo các khai báo
đó.
Trong Jena, các class biểu diễn như sau:
• Class Resource biểu diễn chủ ngữ khai báo
• Class Property biểu diễn vị ngữ
• Class Literal biểu diễn tân ngữ
Để tạo chủ ngữ, gọi hàm createResource() (dòng 17). Hàm truyền vào
URI như định danh.
Để tạo thuộc tính cho đối tượng, gọi hàm Resource.addProperty() (từ
dòng 19-27). Hàm này truyền vào hai tham số: tên thuộc tính và giá trị thuộc
tính.
Trong trường hợp Jena không hỗ trợ FOAF, dòng 19 có thể được viết lại
như sau:
Property nameProperty =
model.createProperty(" />subject.addProperty(nameProperty,"liyang yu");
hoặc gọn hơn như sau:


subject.addProperty
(model.createProperty(" />"liyang yu");
Như vậy chúng ta đã hoàn tất việc tạo mô hình RDF. Tiếp theo chúng ta
sẽ chạy chương trình để kiểm tra kết quả.
Cho chạy class java này, bạn sẽ nhận được các kết quả như trong Hình
15.7.
Hình 15.7 Output generated by Hình 15.6

1: 2:

xmlns:foaf=" />
3:

xmlns:rdf=" />
4:

xmlns:rdfs=" >

5: 5a:

rdf:about=" />
6:

foaf:name>liyang yu</foaf:name>

7:

<foaf:mbox rdf:resource="mailto:"/>

8:


8a:

rdf:resource=" />

9:

<foaf:family_name>yu</foaf:family_name>

10:

<foaf:knows rdf:nodeID="A0"/>

11:

<foaf:givenname>liyang</foaf:givenname>

12:

<foaf:title>Dr</foaf:title>

13:


13a:

" />
14:

<foaf:homepage rdf:resource=""/>

15:

15a:

rdf:resource=""/>

16: </rdf:Description>


17: <rdf:Description rdf:nodeID="A0">
18:


18a:
19:

rdf:resource=" />
19a:
20:

rdf:resource="mailto:"/>

20a:

rdf:resource=" />
21: </rdf:Description>
22: </rdf:RDF>

Chú ý rằng Hình 15.7 không phải là kết quả tốt nhất có thể có. Ví dụ đối
với dòng 17, node trống đã được gán cho một nodeID, do đó nó không còn thực
sự trống nữa. Ta có thể khắc phục bằng cách sử dụng tham số RDF/XMLABBR, bằng cách thay dòng 35 bằng câu lệnh:
model.write(new PrintWriter(System.out), "RDF/XML-ABBREV");
Chạy chương trình một lần nữa, và bạn sẽ thấy những kết quả như trong
Hình 15.8.
Hình 15.8 A better output generated from Hình 15.6
1: 2:

xmlns:foaf=" />
3:

xmlns:rdf=" />
4:

xmlns:rdfs=" />
5: 5a:

rdf:about=" />
6:

<foaf:name>liyang yu</foaf:name>

7:

<foaf:mbox rdf:resource="mailto:"/>

8:

<foaf:knows>

9:

<foaf:Person>

10:


10a:

rdf:resource=" />

11:


11a:

rdf:resource="mailto:"/>

12: </foaf:Person>
13: </foaf:knows>
14: <foaf:family_name>yu</foaf:family_name>
15: <foaf:givenname>liyang</foaf:givenname>
16: <foaf:title>Dr</foaf:title>
17: 17a:

rdf:resource=" />
18: <foaf:homepage rdf:resource=""/>
19: 19a:

rdf:resource=""/>

20: </foaf:Person>
21: </rdf:RDF>

15.2.2 Reading an RDF Model
So với việc tạo ra một mô hình RDF, việc đọc một tài liệu RDF đưa vào
bộ nhớ là một hoạt động thường xuyên hơn. Trước khi thao tác trên RDF, cần
phải đọc nó từ một địa chỉ URL cho trước nào đó, và lưu nó vào bộ nhớ.
Đoạn mã của hoạt động đọc như Hình 15.9, đọc tài liệu FOAF từ URL
và để hiển thị một cách chính xác, nó được lưu lại
dưới định dạng Turtle.
Hình 15.9 Reading an RDF document from a given URL
1: package test;
2:
3: import com.hp.hpl.jena.rdf.model.Model;
4: import com.hp.hpl.jena.rdf.model.ModelFactory;
5: import com.hp.hpl.jena.util.FileManager;
6:
7: public class ReadRDFModel {


8:
9:

public static final String MY_FOAF_FILE =

9a:

" />
10:
11:

public static void main( String[] args ) {

12:
13:

Model model = ModelFactory.createDefaultModel();

14:

model.read(MY_FOAF_FILE);

15:

model.write(System.out,"N3");

16:

}

17: }

Hình 15.10 cho kết quả khi chạy đoạn mã trên.
Hình 15.10 Output generated from Hình 15.9
@prefix rdfs: < .
@prefix rdf: < .
@prefix foaf: < .
< />a foaf:Person ;
foaf:family_name "yu"@en ;
foaf:givenname "liyang"@en ;
foaf:homepage <> ;
foaf:knows
[ a foaf:Person ;
foaf:homepage < ;
foaf:mbox <mailto:>
];
foaf:mbox_sha1sum
"1613a9c3ec8b18271a8fe1f79537a7b08803d896"@en ;
foaf:name "liyang yu"@en ;


foaf:title "Dr"@en ;
foaf:topic_interest
< ;
foaf:workplaceHomepage
<> .

Cũng có thể load một tài liệu RDF vào bộ nhớ từ một file hệ thống. Để
làm điều này, ta sử dụng class FileManager như Hình 15.11 .
Hình 15.11 Read an RDF document from local file system
1: package test;
2:

3: import com.hp.hpl.jena.rdf.model.Model;
4: import com.hp.hpl.jena.rdf.model.ModelFactory;
5: import com.hp.hpl.jena.util.FileManager;
6:
7: public class ReadRDFModel {
8:
9:

public static final String MY_FOAF_FILE =

9a:
10:

"c:/liyang/myWebsite/currentPage/foaf.rdf";
// public static final String MY_FOAF_FILE =

10a:

// " />
11:
12:

public static void main( String[] args ) {

13:
14:

Model model = ModelFactory.createDefaultModel();

15:

FileManager.get().readModel(model,MY_FOAF_FILE);

16:

// model.read(MY_FOAF_FILE);

17:

model.write(System.out,"N3");

18:
19: }

}


15.2.3 Understanding an RDF Model
Hình 15.12 là đoạn mã chúng ta có thể sử dụng để tìm hiểu một tài liệu
RDF.
Hình 15.12 Understanding an RDF document
1: package test;
2:
3: import java.util.Iterator;
4: import java.util.Map;
5:
6: import com.hp.hpl.jena.rdf.model.Model;
7: import com.hp.hpl.jena.rdf.model.ModelFactory;
8: import com.hp.hpl.jena.rdf.model.NodeIterator;
9: import com.hp.hpl.jena.rdf.model.ResIterator;

10: import com.hp.hpl.jena.rdf.model.Resource;
11: import com.hp.hpl.jena.vocabulary.RDF;
12:
13: public class ReadRDFModel {
14:
15:
15a:

public static final String RDF_FILE =
" />
16:
17:

public static void main( String[] args ) {

18:
19:

Model model = ModelFactory.createDefaultModel();

20:

model.read(RDF_FILE);

21:

// model.write(System.out,"N3");

22:
23:

// show all the namespaces in the model

24:

Iterator prefixNsPairs =


24a:

model.getNsPrefixMap().entrySet().iterator();

25:

while ( prefixNsPairs.hasNext() ) {

26:

Map.Entryentry = (Map.Entry)(prefixNsPairs.next());

27:

System.out.print("prefix:" + entry.getKey());

28:

System.out.println(", namespace:" + entry.getValue());

29:

}

30:
31:

// show all the classes and their instances

32:

System.out.println("the following types/classes have

32a:

been used in this RDF document(with their instances):");

33:

NodeIterator classes =

33a:

model.HìnhObjectsOfProperty(RDF.type);

34:

while ( classes.hasNext() ) {

35:

Resource typeRes = (Resource)(classes.next());

36:

System.out.println("(class/type)" + typeRes.getURI());

37:

ResIterator resources =

37a:

model.HìnhResourcesWithProperty(RDF.type,typeRes);

38:

while ( resources.hasNext() ) {

39:

Resource instanceRes = resources.nextResource();

40:

if ( instanceRes.isAnon() ) {

41:

System.out.println(" [anonymous instance] " +

41a:

instanceRes.getId());

42:

} else {

43:

System.out.println(" [instance] " +

43a:

instanceRes.getURI());

44:

}

45:

}

46:

}

47:
48:

}


49: }

Dòng 15 xác định URL của các tài liệu RDF chúng ta muốn đọc, và dòng
19 và 20 thực hiện việc đọc các tài liệu RDF vào bộ nhớ của mô hình. Dòng 2329 hiển thị tất cả các namespaces (và các prefixes) đã được sử dụng trong tài
liệu. Hàm getNsPrefixMap() (dòng 24) trả về một tập các cặp key-value; đối với
mỗi cặp, key là các prefixes và value là namespaces. Như bạn thấy, dòng 27 và
dòng 28 sẽ in các prefixes và namespaces.
Để tìm tất cả các kiểu/class được tham chiếu trong mô hình này,
hàm ListObjectsOfProperty() được sử dụng (dòng 33). Hàm này sử dụng một
thuộc tính (property) như tham số đầu vào của nó (trong trường hợp này,
property này là RDF.type):
subject rdf:type object

Sau khi thực hiện, hàm ListObjectsOfProperty() trả về một nhóm các lớp.
Để

tìm

tất

cả

các

resources

của

mỗi

lớp,

ta

sử

dụng

hàm ListResourcesWithProperty() như dòng 37. Hàm này có hai tham số truyền
vào là thuộc tính và loại đối tượng, và trong trường hợp này, RDF.type là thuộc
tính và typeRes là đối tượng. Nó sẽ tìm các trường hợp có dạng như sau:
subject rdf:type typeRes

Khi được tìm thấy, hàm sẽ trả về các resources. Dòng 38-44 sẽ hiển thị tất
cả các resources.
Lưu ý rằng một số resource có thể trống (blank). Để kiểm tra điều này, có
thể sử dụng hàm isAnon() (dòng 40). Nếu resource biểu diễn một node trống, ta
dùng getId() được gọi để lấy định danh của nó; nếu không, có thể sử dụng
hàm getURI() (dòng 43).
Chạy đoạn mã và cho ra kết quả như Hình 15.13.
Hình 15.13 Output generated from Hình 15.12 with the author’s FOAF
document


1: prefix:rdfs, namespace: />2: prefix:rdf,
2a: namespace: />3: prefix:foaf, namespace: />4: the following types/classes have been used in this RDF
4a: document (with their instances):

5: (class/type) />6: [anonymous instance] -6aa9a0b:12454881133:-8000
7: [instance] />
Như bạn có thể thấy, dòng 1-3 hiển thị các prefixes và namespaces, dòng
5 hiển thị class duy nhất (foaf: Person) được sử dụng trong tài liệu này, và dòng
6 và 7 là hai trường hợp của class đó.
Chúng ta có thể thử một số file khác có nhiều nội dung hơn tài liệu FOAF
trên. Ví dụ,
/>Bạn cần thay đổi dòng 15 của Hình 15.12 như sau:
public static final String RDF_FILE =
" />Hình 15.14 cho thấy một phần của kết quả.
Hình 15.14 Understanding Federer’s RDF document generated by
Dbpedia
prefix:dbpprop, namespace: />prefix:dbpedia-owl, namespace: />prefix:dc, namespace: />prefix:rdfs, namespace: />prefix:rdf, namespace: />prefix:foaf, namespace: />

prefix:owl, namespace: />prefix:skos, namespace: />the following types/classes have been used in this RDF document
(with their instances):
(class/type) />[instance] />(class/type) />[instance] />(class/type)
/>[instance] />(class/type) />[instance] />(class/type) />[instance] />(class/type) />[instance] />(class/type) />[instance] />
Dựa trên kết quả này, cho dù không đọc các tài liệu RDF này, chúng tôi
đã thu được khá nhiều thông tin về nó đã. Bên cạnh đó sự hiểu biết các loại
thông tin cho các nguồn tài nguyên, chúng ta cũng có thể kiểm tra các thuộc
tính xác định cho nó. Trong số tất cả các thuộc tính, sau ba là mối quan tâm đặc
biệt đến với chúng tôi:
owl:sameAs
rdfs:seeAlso
rdfs:isDefinedBy

Sử dụng các thuộc tính trên, ta có thể tìm ra tất cả các tài nguyên liên
quan đến nó, như trong Hình 15.15:
Hình 15.15 Use owl:sameAs to find links

1: package test;
2:
3: import java.util.Iterator;
4: import java.util.Map;
5:
6: import com.hp.hpl.jena.rdf.model.Model;
7: import com.hp.hpl.jena.rdf.model.ModelFactory;
8: import com.hp.hpl.jena.rdf.model.NodeIterator;
9: import com.hp.hpl.jena.rdf.model.RDFNode;
10: import com.hp.hpl.jena.rdf.model.ResIterator;
11: import com.hp.hpl.jena.rdf.model.Resource;
12: import com.hp.hpl.jena.rdf.model.Statement;
13: import com.hp.hpl.jena.rdf.model.StmtIterator;
14: import com.hp.hpl.jena.vocabulary.OWL;
15: import com.hp.hpl.jena.vocabulary.RDF;
16:
17: public class ReadRDFModel {
18:
19:
19a:

public static final String RDF_FILE =
" />
20:
21:

public static void main( String[] args ) {

22:
23:

Model model = ModelFactory.createDefaultModel();

24:

model.read(RDF_FILE);

25:

// model.write(System.out,"N3");

26:
27:
...
34:

// show all the namespaces in the model


35:

// show all the classes and their instances

...
51:
52:

// show all instances that have a owl:sameAs property

53:

System.out.println("\nfollowing instances have

53a:

owl:sameAs property:");

54:

StmtIterator statements = model.HìnhStatements

54a:

((Resource)null,OWL.sameAs,(RDFNode)null);

55:

while ( statements.hasNext() ) {

56:

Statement statement = statements.nextStatement();

57:

Resource subject = statement.getSubject();

58:

if ( subject.isAnon() ) {

59:

System.out.print(" (" + subject.getId() + ")");

60:

} else {

61:

System.out.print(" (" + subject.getURI() + ")");

62:

}

63:

System.out.print(" OWL.sameAs ");

64:

Resource object = (Resource)(statement.getObject());

65:

if ( object.isAnon() ) {

66:

System.out.print("(" + object + ")");

67:

} else if ( object.isLiteral() ) {

68:

System.out.print("(" + object.toString() + ")");

69:

} else if ( object.isResource() ) {

70:

System.out.print("(" + object.getURI() + ")");

71:

}

72:

System.out.println();

73:

}

74:
75:
76: }

}


Hàm sư dụng ở đây là HìnhStatements() như trên dòng 54. Ta truyền giá
trị null cho cả subject và object, do đó kết quả tìm được đều liên quan đến truy
vấn owl:sameAs.
Bây giờ chạy lại đoạn code, và chúng ta sẽ thấy kết quả như trong Hình
15.16.
Hình 15.16 Part of the output from Hình 15.15
the following instance(s) has/have owl:sameAs property:
( OWL.sameAs
( />( OWL.sameAs
( />
15.3 Handling Persistent RDF Models
15.3.1 From In-Memory Model to Persistent Model
Cho đến thời điểm này, chúng tôi đã được làm việc với bộ nhớ trong mô
hình. Những mô hình này được tạo ra từ đầu, hoặc là từ các tập tin phổ biến
hiện có. Các tập tin có thể được đặt trong một hệ thống tập tin địa phương, hoặc
có thể được tải về từ các URL nhất định.
Mặc dù trong bộ nhớ mô hình là khá hữu ích, họ có một số nhược
điểm. Một vài điểm:
• Các mô hình RDF có được repopulated từ đầu mỗi khi khởi chạy ứng
dụng, do đó đòi hỏi một thời gian khởi động lâu hơn.

• Bất kỳ thay đổi được thực hiện cho các mô hình trong bộ nhớ sẽ bị mất
khi ứng dụng được đóng cửa.
• Các ứng dụng dựa trên bộ nhớ trong mô hình sẽ không quy mô như
chúng tôi bắt đầu làm việc với các mô hình lớn hơn.