Ontology理論研究和應用建模
目錄html
此爲幾年前剛開始學本體時查到的資料，目前感受仍是有參考做用java
做者未知
《Ontology研究綜述》、w3c Ontology研究組文檔以及Jena編程應用總結web其中代碼僅供參考。Jena已爲Apache項目，版本已更新spring
1 關於Ontology
1.1 Ontology的定義
Ontology最先是一個哲學的範疇，後來隨着人工智能的發展，被人工智能界給予了新的定義。而後最初人們對Ontology的理解並不完善，這些定義也出在不斷的發展變化中，比較有表明性的定義列表以下：shell
| 範疇 | 提出時間/提出人 | 定義 |
|---|---|---|
| 哲學 | 客觀存在的一個系統的解釋和說明，客觀現實的一個抽象本質 | |
| 計算機 | 1991/Neches等 | 給出構成相關領域詞彙的基本術語和關係，以及利用這些術語和關係構成的規定這些詞彙外延的規則的定義 |
| 1993/Gruber | 概念模型的明確的規範說明 | |
| 1997/Borst | 共享概念模型的形式化規範說明 | |
| 1998/Studer | 共享概念模型的明確的形式化規範說明 |
關於最後一個定義的說明體現了Ontology的四層含義：數據庫
- 概念模型（cerptualization）
經過抽象出客觀世界中一些現象（Phenomenon）的相關概念而獲得的模型，其表示的含義獨立於具體的環境狀態express
- 明確（explicit）
所使用的概念及使用這些概念的約束都有明確的定義編程
- 形式化（formal）
Ontology是計算機可讀的。api
- 共享（share）
Ontology中體現的是共同承認的知識，反映的是相關領域中公認的概念集，它所針對的是團體而不是個體。服務器
Ontology的目標是捕獲相關的領域的知識，提供對該領域知識的共同理解，肯定該領域內共同承認的詞彙，並從不一樣層次的形式化模式上給出這些詞彙（術語）和詞彙之間相互關係的明肯定義。
1.2 Ontology的建模元語
Perez等人用分類法組織了Ontology，概括出5個基本的建模元語（Modeling Primitives）：
類（classes）或概念（concepts）指任何事務，如工做描述、功能、行爲、策略和推理過程。從語義上講，它表示的是對象的集合，其定義通常採用框架（frame）結構，包括概念的名稱，與其餘概念之間的關係的集合，以及用天然語言對概念的描述。
關係（relations）在領域中概念之間的交互做用，形式上定義爲n維笛卡兒積的子集：R:C1×C2×…×Cn。如子類關係（subclass-of）。在語義上關係對應於對象元組的集合。
函數（functions）一類特殊的關係。該關係的前n－1個元素能夠惟一決定第n個元素。形式化的定義爲F:C1×C2×…×Cn-1→Cn。如Mother-of就是一個函數，mother-of(x,y)表示y是x的母親。
公理（axioms）表明永真斷言，如概念乙屬於概念甲的範圍。
實例（instances）表明元素。從語義上講實例表示的就是對象。
另外，從語義上講，基本的關係共有4種：
| 關係名 | 關係描述 |
|---|---|
| part-of | 表達概念之間部分與總體的關係。 |
| kind-of | 表達概念之間的繼承關係，相似於面向對象中的父類與子類之間的關係。 |
| instance-of | 表達概念的實例與概念之間的關係，相似於面向對象中的對象和類之間的關係。 |
| attribute-of | 表達某個概念是另外一個概念的屬性。如「價格」是桌子的一個屬性。 |
在實際建模過程當中，概念之間的關係不限於上面列出的4種基本關係，能夠根據領域的具體狀況定義相應的關係。
1.3 Ontology和語義網絡
Ontology和語義網絡的聯繫和區別列表以下：
- 聯繫：它們都是知識表示的形式，都可以經過帶標記的有向圖來表示，適合於邏輯推理。
- 區別
| 比較方面 | Ontology | 語義網絡 |
|---|---|---|
| 描述的對象和範圍 | 是對共享概念模型的規範說明，即其概念在某個特定領域是公認的，是面向特定領域的概念模型。 | 從數學上講是一種帶有標記的有向圖，最初用於表示命題信息，現普遍用於專家系統表示知識。其節點表示物理實體、概念或狀態，邊用於表示關係，可是對節點和邊都沒有特殊規定，因此描述的範圍比Ontology廣。 |
| 表示的深度上 | 有5個要素「元語，類，關係，函數，公理和實例」，它經過這5個要素來嚴格、正確地刻畫所描述的對象。 | 深度上不如Ontology，對建模沒有特殊要求。 |
| 建模條件 | 創建必須有專家的參與，相對更加嚴格和困難，這也是Ontology目前的主要缺點之一。 | 沒必要有專家的參與。 |
【例子】：語義網絡中能夠表達「個人汽車是紅色的」，而Ontology則適合表達如「團體組織的內部構成」等總體內容。
1.4 Ontology的描述語言
目前在具體應用中Ontology的表示方式主要有4類：
- 非形式化語言
- 半非形式化語言
- 半形式化語言
- 形式化語言
能夠用天然語言來描述Ontology，也能夠用框架、語義網絡或邏輯語言來描述。
目前廣泛使用的方法列表以下：
| 名稱 | 描述 | 特色 |
|---|---|---|
| Ontolingua | 一種基於KIF（knowledge interchange format）的提供統一的規範格式來構建Ontology的語言。 | ü 爲構造和維護Ontology提供了統一的、計算機可讀的方式；ü 由其構造的Ontology能夠方便地轉換到各類知識表示和推理系統（Prolog、CORBA的IDL、CLIPS、LOOM、Epikit、Algernon和KIF），從而將Ontology的維護與使用它的目標系統隔開；ü 主要用於Ontology服務器。 |
| CycL | Cyc系統的描述語言，一種體系龐大而很是靈活的知識描述語言。 | ü 在一階謂詞演算的基礎上擴充了等價推理、缺省推理等功能；ü 具有一些二階謂詞演算的能力；ü 其語言環境中配有功能很強的可進行推理的推理機。 |
| Loom | Ontosaurus的描述語言，一種基於一階謂詞邏輯的高級編程語言，屬於描述邏輯體系。後來發展爲PowrLoom語言（採用先後鏈規則（backward and forward chainer）做爲推理機制）。 | ü 提供表達能力強、聲明性的規範說明語言；ü 提供強大的演繹推理能力；ü 提供多種編程風格和知識庫服務。 |
1.5 已有的Ontology及其分類
目前普遍使用的Ontology列表以下：
| 名稱 | 描述 |
|---|---|
| Wordnet | 基於心理語言規則的英文詞典，以synsets（在特定的上下文環境中可互換的同義詞的集合）爲單位組織信息。 |
| Framenet | 英文詞典，採用稱爲Frame Semantics的描述框架，提供很強的語義分析能力，目前發展爲FramenetII。 |
| GUM | 面向天然語言處理，支持多語種處理，包括基本概念及獨立於各類具體語言的概念組織方式。 |
| SENSUS | 面向天然語言處理，爲機器翻譯提供概念結構，包括7萬多概念。 |
| Mikrokmos | 面向天然語言處理，支持多語種處理，採用一種語言中間的中間語言TMR表示知識。 |
Guarino提出以詳細程度和領域依賴度兩個維度對Ontology進行劃分。具體說明以下：
| 維度 | 說明 | 分類級別 |
|---|---|---|
| 詳細程度 | 描述或刻畫建模對象的程度 | 高的稱做參考（Reference）Ontologies |
| 低的稱做共享（share）Ontologies | ||
| 領域依賴程度 | － | 頂級（top-level）Ontologies描述的是最廣泛的概念及概念之間的關係，如空間、時間、事件、行爲等，與具體的應用無關，其餘Ontologies均爲其特例。 |
| 領域（domain）Ontologies描述的是特定領域中的概念和概念之間的關係。 | ||
| 任務（task）Ontologies描述的是特定任務或行爲中的概念及概念之間的關係。 | ||
| 應用（application）Ontologies描述的是依賴於特定領域和任務的概念和概念之間的關係。 |
1999年Perez和Benjamins概括出了10種Ontologies：
- 知識表示Ontologies
- 普通Ontologies
- 頂級Ontologies
- 元（核心）Ontologies
- 領域Ontologies
- 語言Ontologies
- 任務Ontologies
- 領域－任務Ontologies
- 方法Ontologies
- 應用Ontologies
但它們之間有交叉，層次不夠清晰。
1.6 構造Ontology的規則
出於對各自問題域和具體工程的考慮，構造Ontology的過程各不相同。目前沒有一個標準的Ontology的構造方法。最有影響的是Gruber在1995年提出的5條規則：
- 明確性和客觀性：Ontology應該用天然語言對所定義的術語給出明確、客觀的語義定義。
- 徹底性：所給出的定義是完整的，徹底能表達所描述的術語的含義。
- 一致性：由術語得出的推論與術語自己的含義是相容的，不會產生矛盾。
- 最大單調可擴展性：向Ontology中添加通用或專用的術語時，不須要修改已有的內容。
- 最小承諾：對待建模對象給出儘量少的約束。
目前你們公認在構造特定領域的Ontology的過程當中須要領域專家的參與。
2 Ontology的研究和應用
Ontology的研究和應用主要包括如下3方面：
- 理論上的研究，主要研究概念及其分類，Ontology上的代數；
- 信息系統中的應用，主要包括處理信息組織、信息檢索和異構信息系統互操做問題；
- Ontology做爲一種能在知識層提供知識共享和重用的工具在語義Web中的應用。
2.1 Ontology的理論研究
Ontology的理論研究包括概念和概念分類、Ontology上的代數。最有表明性的是Guarino等人對概念的分類所作的深刻和細緻的研究，他們從通常的意義上分析了什麼是概念、概念的特性、概念之間的關係以及概念的分類，提出了一套用於指導概念分類的可行理論。基於這個理論，他又提出了Ontology驅動的建模方法，在理論上爲建模提供了一個通用的模式。
Guarino認爲概念之間的差異不只體如今概念的定義上，同時也體如今概念的某些特性上。從這些特性出發，概括出概念的元特性（最基本的特性），從而用公式給出元特性的嚴格的形式定義。在此基礎上，他們又討論了元特性之間的關係和約束，最終把研究結果做爲概念分類的基本理論工具並提出一套完成的概念分類體系結構。
Guarino的理論能夠概括以下：
概念分類理論的基礎是概念的元特性。以概念的元特性爲出發點，按照必定的規則，把具備相同元特性組合的概念歸爲一類，進而給出通常意義上的概念分類體系。概念的基本元特性包括：持久特性、非持久特性、反持久特性、半持久特性、載體標識特性、支持標識特性、外部依賴特性等。
如下是對各類特性的說明：
| 名稱 | 描述 | 舉例 |
|---|---|---|
| 持久特性 | 嚴格定義爲： 。表明某個概念，表明x是的一個實例，表示其後的斷言永遠爲真。 |
Person具備持久性，而Student不具備持久性。 |
| 非持久特性 | 對某個概念而言，存在某些實例不會永遠屬於該概念。 | Student具備非持久性。 |
| 反持久特性 | 對概念的任何一個實例，這個實例不會永遠屬於該概念。 | Youth具備反持久性。 |
| 半持久特性 | 非持久性和反持久性的差集。 | —— |
| 載體標識特性 | —— | 如Student具備載體標識特性，由於學生之間的區別不是靠學生，而是做爲人來區分的。 |
| 支持標識特性 | 每一個實例相互之間是能夠區分的。 | Person具備支持標識特性，人和人之間可由標識（人的指紋）來區分。 |
| 外部依賴特性 | 一個概念對另一個概念的某種依賴關係。概念A對概念B的外在依賴關係表現爲概念A中的任何一個實例a必蘊涵屬於概念B的實例b，而b不是a的一部分。 | Parent外在依賴於Child，某人的父母蘊涵他（她）有小孩，而他的小孩固然不是他身體的一部分。 |
2.2 Ontology在信息系統中的應用
目前信息檢索技術的分類和對他們的描述列舉以下：
| 分類 | 特色 | 缺點 |
|---|---|---|
| 全文（Text retrieval） | 把用戶的查詢請求和全文中的每個詞進行比較，不考慮查詢請求和文件語義上的匹配。 | 雖然能夠保證查全率，可是查準率大大下降。 |
| 數據（Data retrieval） | 查詢要求和信息系統中的數據都遵循必定的格式，具備必定的結構，容許對特定字段檢索。須要有標識字段的方法。 | 性能取決於所使用的字段標識方法和用戶對方法的理解，具備很大的侷限性，支持語義匹配的能力較差。 |
| 知識（Knowledge retrieval） | 基於知識的、語義上的匹配，在查準率和查全率上有更好的保證。是信息檢索的重點，特別是面向Web信息的知識檢索的重點。 | —— |
Ontology具備良好的概念層次結構和對邏輯推理的支持，在知識檢索中有普遍應用。基於Ontology的信息檢索的基本思想有：
- 在領域專家的幫助下，創建相關領域的Ontology；
- 收集信息源中的數據，並參照已創建的Ontology把收集來的數據按規定格式存儲在元數據庫（RDB，KDB等）中；
- 對用戶檢索界面獲取的查詢請求，查詢轉換器按照Ontology把查詢請求轉換成規定的格式，在Ontology的幫助下從元數據庫中匹配出符合條件的數據集合；
- 檢索的結果通過定製處理返回給用戶。
關於Ontology的表達，主要分爲兩種狀況進行處理：
- 檢索系統如不須要太強的推理能力，Ontology可用概念圖的形式表示並存儲，數據能夠保存在通常的關係數據庫中，採用圖匹配技術完成檢索；
- 如要求較強的推理能力，通常須要一種描述語言（Loom等）表示Ontology，數據保存在知識庫中，採用描述語言的邏輯推理能力完成檢索。
目前Ontology用於信息檢索的項目列舉以下：
| 項目名稱 | 說明 |
|---|---|
| (Onto)2Agent | 爲了幫助用戶檢索所須要的WWW上已有的Ontology，主要採用參照Ontology，即以WWW上已有的Ontology爲對象創建起來的Ontology，保存各種Ontology的元數據。 |
| Ontobroker | 面向WWW上的網頁資源，目的是幫助用戶檢索所需的網頁，這些網頁含有用戶關心的內容。 |
| SKC | 解決信息系統語義異構的問題，實現異構的自治系統間的互操做。但願經過在Ontology上的一個代數系統來實現Ontology之間的互操做，從而實現異構系統之間的互操做。 |
2.3 Ontology和語義Web
提升Web信息檢索的質量包括兩方面的內容：
- 如何在現有的資源上面設計更好的檢索技術；
- 如何爲Web上的資源附加上計算機能夠理解的內容，便於計算機處理，即給出一種計算機可以理解的表示資源的手段。
基於後一種考慮，Berners-Lee在2000－12－18的XML2000的會議上提出了語義Web。語義Web的目標是使得Web上的信息具備計算機能夠理解的語義，知足智能軟件代理（Agent）對WWW上異構和分佈信息的有效訪問和檢索。下面是Berners-Lee爲將來Web發展提出的基於語義的體系結構－語義Web體系結構
|
層數 | 名稱 | 描述 |
|---|---|---|---|
| 第一層 | UNICODE和URI | 整個語義網絡的基礎，Unicode處理資源的編碼，URI負責標識資源。 | |
| 第二層 | XML＋NS＋xmlschema | 用於表示數據的內容和結構。 | |
| 第三層 | RDF＋rdfschema | 用於描述Web上的資源及其類型。 | |
| 第四層 | Ontology vocabulary | 用於描述各類資源之間的聯繫。 | |
| 第五層 | Logic | 在下面四層的基礎上進行的邏輯推理操做。 | |
| 第六層 | Proof | ||
| 第七層 | Trust |
* 核心層，用於表示Web信息的語義。
XML和RDF都能爲所表述的資源提供必定的語義。可是XML中的標籤（tags）和RDF中的屬性（properties）集都沒有任何限制。一個例子是：XML能夠用「<Author>TOM</Author>」表示TOM是教師。而「<rdf:Description about=http://www.w3.org/Home/Lassila><s:Creator>Ora Lassila</s:Creator></rdf:Description> 」這個RDF片段描述了Web頁的建立者問題。而上面的Author和Creator徹底能夠用Writer來代替。另外一個例子是：某醫院和某大學的Web頁上都有<Doctor>，可是不知道它表明醫生仍是博士。綜上，XML和RDF在處理語義上存在的問題是：
- 同一律念有多種詞彙表示（多詞同義）；
- 同一個詞彙有多種概念（含義）（一詞多義）。
Ontology經過對概念的嚴格定義和概念之間的關係來肯定概念精確含義，表示共同承認的、可共享的知識，從而解決上面的問題。所以在語義Web中，Ontology具備很是重要的地位，是解決語義層次上Web信息共享和交換的基礎。
爲了便於Web上應用程序使用方便，須要有一個通用的標準語言來表示Ontology，就像XML做爲標準的數據交換語言同樣。目前正在開發中的語言有：SHOE、OML、XOL、Riboweb、RDFS和OIL。下面將就w3c提出的OWL（Web Ontology Language）作進一步的分析。
目前語義Web是一個新興的研究方向，Ontology在其中的應用剛剛起步。
3 Web Ontology Language (OWL)概述
3.1 OWL簡介
OWL（Web Ontology Language）適用於這樣的應用，在這些應用中，不只僅須要提供給用戶可讀的文檔內容，並且但願處理文檔內容信息。OWL可以被用於清晰地表達詞彙表中的詞條（term）的含義以及這些詞條之間的關係。而這種對詞條和它們之間的關係的表達就稱做Ontology。OWL相對XML、RDF和RDFSchema擁有更多的機制來表達語義，從而OWL超越了XML、RDF和RDFSchema僅僅可以表達網上機器可讀的文檔內容的能力。
3.2 OWL在語義網中的地位
語義網是對將來網絡的一個設想，在這樣的網絡中，信息都被賦予了明確的含義，機器可以自動地處理和集成網上可用的信息。語義網使用XML來定義定製的標籤格式以及用RDF的靈活性來表達數據，下一步須要的就是一種Ontology的網絡語言（好比OWL）來描述網絡文檔中的術語的明確含義和它們之間的關係。
OWL是w3c推薦的語義網絡「棧」中的一部分，這個「棧」被表達以下：
| 名稱 | 描述 |
|---|---|
| XML | 結構化文檔的表層語法，對文檔沒有任何語義約束。 |
| XML Schema | 定義XML文檔的結構約束的語言。 |
| RDF | 對象（或者資源）以及它們之間關係的數據模型，爲數據模型提供了簡單的語義，這些數據模型可以用XML語法進行表達。 |
| RDF Schema | 描述RDF資源的的屬性和類型的詞彙表，提供了對這些屬性和類型的廣泛層次的語義。 |
| OWL | 添加了更多的用於描述屬性和類型的詞彙，例如類型之間的不相交性（disjointness），基數（cardinality），等價性，屬性的更豐富的類型，屬性特徵（例如對稱性，symmetry），以及枚舉類型（enumerated classes）。 |
下圖給出了w3c的Ontology語言棧描述：
W3C2002年7月31日透露了發行OWL Web 本體論語言（OWL Web Ontology Language） 工做草案的細節，其目的是爲了更好地開發語義網（Semantic Web）。
W3C 發言人Ian Jacobs說，開發語義網的目的是可以在互聯網上進行更結構化的智能處理，例如，當一我的肯定要參加某個城市的會議後，就能夠自動查找有關航班和酒店的信息。
W3C稱，W3C Web 本體論工做小組正在對OWL Web本體論語言進行設計，OWL是本體論Web 語言（Ontology Web Language）的字母縮寫。設計的最終目的是爲了提供一種能夠用於各類應用的語言，這些應用須要理解內容，從而代替只是採用人類易讀的形式來表達內容。做爲語義網的一部分，XML、RDF和RDF-S支持經過提供針對術語描述的詞彙表，共同推動了機器的可靠性。
W3C發行的三種工做草案名爲《特點大綱》（Web Ontology Language (OWL) Guide Version 1_0）、《抽象句法》（OWL Web Ontology Language 1_0 Abstract Syntax）和《語言參考》。
W3C本週還發行了其Web 服務架構使用方案集合的工做草案，目的是爲下一代的Web服務提供使用案例和方案。
W3C Web服務架構工做小組特別發行的方案包括諸如旅行社使用案例和相似電子數據交換的採購等情形。Jacobs說：「W3C官員正在制定有關Web服務架構範圍的文件。」
3.3 OWL的三個子語言——OWL Lite、OWL DL、OWL Full
3.3.1 子語言描述
OWL的三個子語言描述列表以下：
| 子語言 | 描述 | 例子 |
|---|---|---|
| OWL Lite | 用於提供給那些只須要一個分類層次和簡單的屬性約束的用戶。 | 支持基數（cardinality），只容許基數爲0或1。 |
| OWL DL | 支持那些須要在推理系統上進行最大程度表達的用戶，這裏的推理系統可以保證計算徹底性（computational completeness，即全部地結論都可以保證被計算出來）和可決定性（decidability，即全部的計算都在有限的時間內完成）。它包括了OWL語言的全部約束，可是能夠被僅僅置於特定的約束下。 | 當一個類能夠是多個類的一個子類時，它被約束不能是另一個類的實例。 |
| OWL Full | 支持那些須要在沒有計算保證的語法自由的RDF上進行最大程度表達的用戶。它容許在一個Ontology在預約義的（RDF、OWL）詞彙表上增長詞彙，從而任何推理軟件均不能支持OWL FULL的全部feature。 | 一個類能夠被同時表達爲許多個體的一個集合以及這個集合中的一個個體。 |
3.3.2 子語言間以及子語言和RDF的關係
這三種子語言之間的關係是：
- 每一個合法的OWL Lite都是一個合法的OWL DL；
每一個合法的OWL DL都是一個合法的OWL Full；
每一個有效的OWL Lite結論都是一個有效的OWL DL結論；
每一個有效的OWL DL結論都是一個有效的OWL Full結論。
用戶在選擇使用哪一種語言時的主要考慮是：
選擇OWL Lite仍是OWL DL主要取決於用戶須要整個語言在多大程度上給出了約束的可表達性；
選擇OWL DL仍是OWL Full主要取決於用戶在多大程度上須要RDF的元模型機制（如定義類型的類型以及爲類型賦予屬性）；
在使用OWL Full而不是OWL DL時，推理的支持不可預測，由於目前尚未徹底的OWL Full的實現。
這三種子語言與RDF的關係是：
OWL Full能夠當作是RDF的擴展；
OWL Lite和OWL Full能夠當作是一個約束化的RDF的擴展；
- 全部的OWL文檔（Lite，DL，Full）都是一個RDF文檔；
- 全部的RDF文檔都是一個OWL Full文檔；
只有一些RDF文檔是一個合法的OWL Lite和OWL DL文檔。
3.4 OWL語言大綱
【說明】：如下用斜體標出的爲OWL中的詞條（term），rdf:和rdfs:前綴表示這些詞條已經在RDF和RDF Schema中出現。
3.4.1 OWL Lite語言大綱
| 分類 | 詞條 |
|---|---|
| RDF Schema Features | · Class · rdf:Property · rdfs:subClassOf · rdfs:subPropertyOf · rdfs:domain · rdfs:range · Individual |
| (In)Equality | · equivalentClass · equivalentProperty · sameIndividualAs · differentFrom · allDifferent |
| Property Characteristics | · inverseOf · TransitiveProperty · SymmetricProperty · FunctionalProperty · InverseFunctionalProperty |
| Property Type Restrictions | · allValuesFrom · someValuesFrom |
| Restricted Cardinality | · minCardinality (only 0 or 1) · maxCardinality (only 0 or 1) · cardinality (only 0 or 1) |
| Header Information | · imports · versionInfo · priorVersion · backwardCompatibleWith · incompatibleWith |
| Class Intersection | · intersectionOf |
| Datatypes |
3.4.2 OWL DL和OWL Full大綱
下面給出了在OWL Lite基礎上添加的OWL DL和OWL Full語言架構
| 分類 | 詞條 |
|---|---|
| Class Axioms | · oneOf · disjointWith · equivalentClass (applied to class expressions) · rdfs:subClassOf (applied to class expressions) |
| Boolean Combinations of Class Expressions | · unionOf · intersectionOf · complementOf |
| Arbitrary Cardinality | · minCardinality · maxCardinality · cardinality |
| Filler Information | · hasValue |
3.5 OWL Lite語言描述
和OWL DL和OWL Full相比，OWL Lite只是使用了OWL語言的一些feature，而且作了限制。
Class只能根據命名了的superclass（它不能是任意的邏輯表達式）進行定義，並且只能使用特定類型的class restriction。
類之間的Equivalence以及子類關係只能在命名了的class上作聲明，不能應用於任意的類型表達式。
OWL Lite只容許屬性限制應用於命名類型。
OWL Lite對cardinality的概念也有限制——它的取值範圍只能是0和1。
如下列出了OWL Lite大綱中各種feature的描述。
3.5.1 OWL Lite RDF Schema Features
| 名稱 | 描述 | 實例 |
|---|---|---|
| Class | 定義了一組共享了某些相同屬性的individual。Class可以經過subClassOf定義出一個特定的類層次。有一個內置的公共類Thing，它是全部individual的Class，也是全部Class的superclass。 | Deborah 和Frank都是Person這個Class的成員。 |
| rdfs:subClassOf | 類層次能夠經過給出諸如一個類是另外一個或多個類的子類這樣的聲明來建立。 | Person能夠被定義爲是Mammal的一個subclass，這樣咱們就可以推斷：若是X是一個Person，那麼X必定也是一個Mammal。 |
| Rdfs:Property | 表達了individual之間的關係。 | 例如hasChild，hasRelative,，hasSibling,和hasAge都是Property的例子。前三個例子用於表達Person之間的關係，最後一個把一個Person和一個Datatype Integer關聯起來。 |
| rdfs:subPropertyOf | 屬性層次能夠經過給出諸如一個屬性是另外一個或多個屬性的子屬性這樣的聲明來建立。 | hasSibling是hasRelative的子屬性。經過這一點咱們就能夠推理出：若是X和Y經過hasSibling進行了關聯，那麼它們必定也經過hasRelative進行了關聯。 |
| rdfs:domain | 一個property的domain是可以應用該property的individual的集合。若是property P把class X和class Y關聯起來，P的domain是class Z，那麼X必定是Z的一個實例。Domain是一個全局約束，由於它就property而言，可是當它與一個特定的class關聯時也不僅是就property而言。 | Property hasChild能夠被說擁有domain Mammal，從這一點咱們就可以推理出若是Frank hasChild Anna，那麼Frank必定是一個Mammal。 |
| rdfs:range | 一個property的range是該property所必須有的值的individual的集合。若是proerty P將class X和class Y關聯，P的range是class Z，那麼Y必定是Z的一個實例。 | Property hasChild能夠被說擁有range Mammal，從這一點咱們就可以推理出若是Louise hasChild Deborah，那麼Deborah必定是一個Mammal。 |
| Individual | Class的實例，property能夠被用來把一個individual和另外一個individual關聯起來。 | 一個名叫Deborah的individual能夠被描述爲是Person這個class的實例，而property hasEmployer能夠把individual Deborah和individual StanfordUniversity關聯起來。 |
3.5.2 OWL Lite Equality 和Inequality
| 名稱 | 描述 | 實例 |
|---|---|---|
| equivalentClass | 兩個類能夠被聲明爲相同，即它們擁有不一樣的名字可是卻擁有相同的individual的集合。它被用來建立同義類。 | Car能夠被說成是Automobile的equivalentClass。從這一點咱們能推理獲得任何Car的實例都是Automobile的實例，反之也同樣。 |
| equivalentProperty | 兩個類也能夠被聲明爲相同。它能夠被用來建立同義屬性。 | HasLeader能夠被說成是hasHead的equivalentProperty。從這一點咱們可以推理獲得：若是X經過HasLeader與Y關聯，那麼X也經過hasHead與Y關聯。咱們也可以推理獲得：HasLeader是hasHead的子屬性，同時hasHead也是HasLeader的子屬性。 |
| sameIndividualAs | 兩個individual也能夠被聲明爲相同。它能夠被用來建立一系列指向同一個individual的名字。 | Deborah被說成與DeborahMcGuinness是同一個individual。 |
| differentFrom | 一個individual可被聲明爲與其餘一些individual不一樣，這在使用如OWL（RDF）等語言時表達individual有並且只有一個名字時很是重要。 | l Frank可被說成與Deborah以及Jim是不一樣的individual，這樣當Frank和Deborah都被說成是一個functional（最多隻有一個值）的property的值時，就會出現矛盾；l 沒有特別指出的話，咱們不能推理說Deborah和Frank指的是不一樣的individual。 |
| allDifferent | 在一個allDifferent聲明中，咱們能夠指出必定數量的individual兩兩不一樣。這在表達一個不一樣對象的集合而建模者側重於強調這些對象的惟一的名字時尤爲有用。 | 能夠在一個allDifferent聲明中說明Frank、Deborah、Jim兩兩不一樣。 |
3.5.3 OWL Lite Property Characteristics
| 名稱 | 描述 | 實例 |
|---|---|---|
| inverseOf | 一個屬性能夠被聲明爲另外一個屬性的翻轉屬性。若是P1被聲明爲P2的翻轉屬性，那麼若是X經過P1關聯到Y，那麼Y經過P1關聯到X。 | 若是hasChild是hasParent的翻轉屬性，Deborah hasParent Louise，那麼咱們就可以推理出Louise hasChild Deborah。**** |
| TransitiveProperty | 屬性能夠被聲明爲傳遞的。若是(x,y)是傳遞屬性P的一個實例，(y,z)也是傳遞屬性P的一個實例，那麼(x,z)是傳遞屬性P的一個實例。OWL Lite給出了關於傳遞屬性的一個邊界條件：傳遞屬性和它的superproperty不能有maxCardinality爲1的限制，不然OWL Lite和OWL DL都將成爲不肯定語言。 | 若是ancestor被聲明爲傳遞的，(Sara,Louise)是它的一個實例，(Louise,Deborah)也是他的一個實例，那咱們就可以推理出(Sara,Deborah)是他的一個實例。 |
| SymmetricProperty | 屬性能夠被聲明爲是對稱的。若是(x,y)是對稱屬性P的一個實例，那麼(y,x)也是它的一個實例。被聲明爲對稱的屬性不能有任意的domain和range。 | Friend能夠被說成是一個對稱屬性，若是Frank 是 Deborah的Friend，那咱們能夠推斷出Deborah 是Frank的Friend。 |
| FunctionalProperty | 屬性能夠被聲明爲只有一個值。即一個individual若是被聲明爲FunctionalProperty，那麼對於這樣的一個實例它最多隻有一個值。這能夠被方便的用來講明一個屬性的cardinality最小爲0，最大爲1。 | l Frank可被說成與Deborah以及Jim是不一樣的individual，這樣當Frank和Deborah都被說成是一個functional（最多隻有一個值）的property的值時，就會出現矛盾；l 沒有特別指出的話，咱們不能推理說Deborah和Frank指的是不一樣的individual。 |
| InverseFunctionalProperty | 若是一個屬性被聲明爲inverse functional，則意味着它的翻轉屬性是functional的，也就是說該屬性的翻轉屬性的每一個individual最多隻有一個值。 | HasUSSocialSecurityNumber（SecurityNumber是美國居民的惟一標識符）能夠被聲明爲inverse functional。該屬性的翻轉屬性isTheSocialSecurityNumberFor在社會保險號這個class中任何一個individual至多隻有一個值。由此咱們能夠推斷出任何兩個Person的實例都不能有相同的SecurityNumber。還能夠推斷出：若是兩個Person的實例有相同的SecurityNumber，那麼他們必定是表示同一個individual。 |
3.5.4 OWL Lite Property Type Restriction
該約束針對某個屬性，屬於局部約束。
| 名稱 | 描述 | 實例 |
|---|---|---|
| allValuesFrom | 該約束將一個屬性的取值和一個class相關。也就是說，若是一個class的實例經過這個屬性和另一個individual相關，那麼後一個individual則可以被認爲是改約束類的一個實例。 | Class Person有一個屬性hasOffspring，該屬性被約束在allValuesFrom上取值爲Person類。這就是說若是Person的一個實例Louise經過屬性hasOffspring和另外一個individual Deborah相關，從這一點咱們能推斷出 Deborah是Person的一個實例。這種約束容許hasOffspring屬性被其餘class使用，例如被class Cat使用，從而作出相應的約束。 |
| someValuesFrom | 和上面相似，該約束也將一個屬性的取值和一個class相關。只不過此時要求該屬性的取值至少有一個是該class類型的。 | Class SemanticWebPaper在property hasKeyword上的someValuesFrom 約束值SemanticWebTopic說明hasKeyword存在某個取值應該是class SemanticWebTopic的一個實例。可是咱們不能就此推斷說hasKeyword的全部取值都是SemanticWebTopic的實例。 |
3.5.5 OWL Lite Restricted Cardinality
同上，該約束也是局部約束，並且OWL Lite在Cardinality上的局部約束只容許Cardinality的取值爲0和1（這不一樣於其餘兩類OWL容許任意數目的Cardinality）。
| 名稱 | 描述 | 實例 |
|---|---|---|
| minCardinality | Cardinality是依據一個特定的class在一個property上作的聲明。若是就一個class而言某個property的minCardinality爲1，則該class的任何一個實例都經過該property至少和一個individual相關。這也是一種用來表達某property必須在某class的任何一個實例中有一個值的辦法。在OWL Lite中，minCardinality的值只能爲0或者1。0表示的意思是對於某個class而言這個proerty是可選的。 | l Class Person在property hasOffspring並無minCardinality約束，由於不是全部的Person都有Offspring的。l Class Parent則在property hasOffspring上有minCardinality爲1。l Class Person在property hasOffspring上的minCardinality值能夠爲0。根據上面的前兩條信息咱們能夠推斷出，若是Louise是一個Person，咱們並不能獲得任何有關他後代的信息；可是一旦發現他是一個Parent，則Louise經過property hasOffspring至少和一個individual相關。可是咱們不能獲得他最多和幾個individual相關。 |
| maxCardinality | 若是就一個class而言某個property的maxCardinality爲1，則該class的任何一個實例都經過該property至多和一個individual相關。MaxCardinality值爲1的約束property有時也叫作functional或者unique property。經過它咱們不能獲得有關minCardinality的任何信息，可是這對於咱們表達某些class在某些property上沒有值是很重要的。 | l Class UnitedStatesCitizens上的property hasRegisteredVotingState的MaxCardinality值爲1（由於一個公民只能在一個州投票）。l Class UnmarriedPerson實例不能經過property hasSpouse和任何individual相關，這時只要把hasSpouse的maxCardinality設爲0就能夠了。 |
| cardinality | 它用於方便表達在一個class上的property同時擁有約束minCardinality 0 和 maxCardinality 0 或者 minCardinality 1 和 maxCardinality 1。 | Class person在property hasBirthMother上只有一個值，能夠設定該property的Cardinality。 |
3.5.6 OWL Lite Class Intersection
| 名稱 | 描述 | 實例 |
|---|---|---|
| intersectionOf: | OWL Lite容許在class和約束之間存在交集。 | Class EmployedPerson能夠被定義爲intersectionOf class Person和EmployedThings（後者能夠被定義爲擁有hasEmployer屬性並在該屬性上的minCardinality爲1）。 |
3.5.7 Datatypes
OWL 使用了RDF的datatype schema，然後者又參考了XML Schema的datatype。這些datatype可以經過URI被識別。每當有一個datatype的實例出現時，必須有一個RDF屬性rdf:datatype，它的值爲URI引用的XML Schema datatype。
3.5.8 OWL Lite Header Information
OWL支持ontology引用、包含以及元信息描述。上面提到的三個層次的OWL都包含了用於指定導入的ontology、ontology版本信息和前版本信息、可向後兼容的ontology信息以及不兼容的ontology信息等一系列信息的方法。
3.6 增量語言OWL DL和OWL Full描述
儘管OWL DL添加了一些約束，它和OWL Lite實際上共享了詞彙表。總的來說，OWL DL引入了類型分割（一個class不能是一個property或者一個individual，一個property也不能是一個class或者individual）；它要求property或者是ObjectProperties，或者是DatatypeProperties。後者RDF literal、XML Datatype以及class實例之間的關係。前者是兩個class實例之間的關係。下面繼續列出了OWL DL和OWL Full的擴展詞彙
| 名稱 | 描述 | 實例 |
|---|---|---|
| One of（枚舉類型） | Class能夠經過枚舉構成該class的individual來描述。 | Class daysOfTheWeek能夠簡單地經過枚舉Sunday、Monday、Tuesday、Wednesday,、Thursday、Friday、 Saturday這7個individual來表達。咱們能夠由此推斷出任何擁有allValuesFrom約束於daysOfTheWeek的property的maxcardinality爲7。 |
| HasValue（屬性值） | 一個property能夠被要求擁有一個特定的individual做爲它的值。 | Class dutchCitizens的實例能夠在property nationality上以theNetherlands最爲它的值。 |
| disjointWith | OWL Full容許在class定義不相交性。 | Man和Woman能夠被定義爲是不相交的，這樣咱們就可以推斷出若是已知A爲Man，那麼A必定不是Woman。 |
| unionOf, complementOf, intersectionOf（布爾鏈接） | OWL Full容許class之間任意的布爾鏈接。 | l 經過unionOf，咱們可以聲明或者是USCitizens或者是DutchCitizens的事物；l 經過complementOf，咱們可以聲明children不是SeniorCitizens。 |
| minCardinality, maxCardinality, cardinality（全cradinality） | OWL Full容許取值爲任意非負整數的cardinality。 | Class DINKs（Dual Income）在property hasIncome上的mincardinality約束爲2 |
| complex classes | 因爲OWL Full引入了上面的詞條，實際上它已經支持了複雜類。它還包括了一個底層class名爲Nothing，它沒有任何實例。OWL容許class被用做實例（另兩種不能夠）。 |
4 OWL文檔結構舉例
4.1 命名空間
這是使用OWL的一系列詞條的前提，咱們必須準確說明正在使用的特定的詞彙表。一個Ontology的標準的初始模塊是包含在rdf:RDF標籤中的一系列命名空間（namespace）的聲明。這些聲明用以準確解釋文檔中的標識符，從而使得Ontology的其餘部分具備可讀性。如下是一個典型的命名空間聲明的例子：
<rdf:RDF
xmlns ="http://www.example.org/wine#"
xmlns:vin ="http://www.example.org/wine#"
xmlns:food="http://www.example.org/food#"
xmlns:owl ="http://www.w3.org/2002/07/owl#"
xmlns:rdf ="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
xmlns:xsd ="http://www.w3.org/2000/10/XMLSchema#"
xmlns:dte ="http://www.example.org/wine-dt#">
| 命名標識符 | 描述 |
|---|---|
| xmlns ="http://www.example.org/wine#" | 說明了缺省的命名空間，也就是當文檔中出現沒有前綴的標籤時所引用的命名空間。 |
| xmlns:vin ="http://www.example.org/wine#" | 說明了和當前的Ontology相關的具備前綴vin的命名空間。 |
| xmlns:food="http://www.example.org/food#" | 指出了支持表達本Ontology的food這一Ontology的命名空間，它們之前綴food出現。 |
| xmlns:owl ="http://www.w3.org/2002/07/owl#" | 說明了出現owl前綴的詞條應該尋找的命名空間。這是一般的OWL聲明，用以在文檔中加入OWL詞彙表。 |
| xmlns:rdf ="http://www.w3.org/1999/02/22-rdf-syntax-ns#" | 說明了在文檔中出現的以rdf爲前綴的詞條的命名空間，這是爲了引入RDF定義的詞彙。 |
| xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" | 說明了在文檔中出現的以rdfs爲前綴的詞條的命名空間，這是爲了引入RDF Schema定義的詞彙。 |
| xmlns:xsd ="http://www.w3.org/2000/10/XMLSchema#" | 說明了在文檔中出現的以xsd爲前綴的詞條的命名空間，這是爲了引入XML Schema定義的詞彙。 |
| xmlns:dte ="http://www.example.org/wine-dt#" > | 說明了在文檔中出現的以dte爲前綴的詞條的命名空間，這是爲了引入包含XML Schema Datatype定義的詞彙。 |
咱們也能夠在Ontology定義以前在文檔類型定義DocType一節中經過定義一些實體來給出命名空間的說明。例如：
<!DOCTYPE owl [
<!ENTITY vin "http://www.example.org/wine#" >
<!ENTITY food "http://www.example.org/food#" > ]>
另外，命名空間只是對標籤的說明，對屬性沒有約束。可是在OWL文檔中咱們又常常要用到和命名空間相關的詞條，這時就必須寫清楚整個URI。例如http://www.example.org/owl/wine#merlot。可是若是有了相似上面的實體定義，咱們也能夠簡寫成「&vin;merlot」。
4.2 Ontology頭
完成了命名空間的定義，咱們必須如下面的斷言來開始一個OWL Ontology：
<owl:Ontology rdf:about="http://www.example.org/wine">
接下來能夠以一些標籤標明註釋、版本控制、以及對其餘Ontology的引入等信息。例如：
<owl:Ontology rdf:about="http://www.example.org/wine">
<rdfs:comment>An example OWL ontology</rdfs:comment>
<owl:versionInfo>
$Id: Overview.html,v 1.2 2002/11/08 16:42:25 connolly Exp $
</owl:versionInfo>
<owl:imports rdf:resource="http://www.w3.org/TR/2002/WD-owl-guide-20021104/food.owl"/>
| 標籤 | 說明 |
|---|---|
|
|
給出了本Ontology的主要功能。 |
|
|
標準標籤，給出了供版本控制系統掛鉤用的信息，OWL自己並無什麼結構上的約束。 |
|
|
提供了引入機制，只給出了一個參數rdf:resource。 |
其中引入另一個Ontology將會將它的整個定義的集合加入到知識庫中來。須要注意的是，這個標籤只是說明了引入一個Ontology的意圖，但不老是成功的。在語義網上對網上資源的訪問不老是成功的，這須要依照工具實現的狀況而定。
最後，給出相應的Ontology頭的結束標籤：
</owl:Ontology>
4.3 基本定義
4.3.1 簡單的Classe和Individual
全部用戶定義的class都缺省是owl:Thing的subclass。而領域相關的根class的定義只要給出一個命名的類聲明就能夠了。例如在制酒業的三個根class定義以下：
<owl:Class rdf:ID="Winery"/> <owl:Class rdf:ID="Region"/> <owl:Class rdf:ID="ConsumableThing"/>
這時咱們只是用ID爲類起了名字，並無指定有關類的其餘任何信息，例如該類的成員等等。rdf:ID屬性相似於XML中的ID屬性，這樣咱們可以經過相似「documentURI#Region」在其餘的Ontology中引用region這一class。也能夠採用相似「rdf:about="#x」的方法引用。
Class的基本的分類構造器是subclassof。例如：
<owl:Class rdf:ID="PotableLiquid"> <rdfs:subClassOf rdf:resource="#ConsumableThing" /> ... </owl:Class>
這裏咱們定義了PotableLiquid是ConsumableThing的subclass。
類定義除了包括命名和引用之外，還包括限制。上面的subclassof就是一個限制。下面給出了Wine這個class的簡單定義：
<owl:Class rdf:ID="Wine"> <rdfs:subClassOf rdf:resource="#PotableLiquid"/> <rdfs:label xml:lang="en">wine</rdfs:label> <rdfs:label xml:lang="fr">vin</rdfs:label> ... </owl:Class>
rdfs:label標籤給出了人們可讀的類名。屬性lang表示支持多語言表達。
一個Individual能夠經過聲明它是某個類的成員得以表達。例如：
<Region rdf:ID="CentralCoastRegion" />
下面的表達是等價的：
<owl:Thing rdf:ID="CentralCoastRegion" /> <owl:Thing rdf:about="#CentralCoastRegion"> <rdf:type rdf:resource="#Region"/> </owl:Thing>
type這個RDF詞條將一個Individual和一個class的成員綁定起來。
下面的例子給出了一個grape分類，並用一個individual表達了Cabernet Sauvignon品種的grape：
<owl:Class rdf:ID="Grape"> <owl:Class rdf:ID="WineGrape"> <rdfs:subClassOf rdf:resource="#Grape"/> </owl:Class> <WineGrape rdf:ID="CabernetSauvignonGrape" />
4.3.2 簡單的Property
property能夠被用來講明class的共同特徵以及某些individual的專有特徵。一個property是一個二元關係。有兩類property：
datatype property：class元素和XML datatype之間的關係；
object property：兩個類元素之間的關係。
能夠經過指定property的domain和range以及定義subproperty來約束一個property。下面是一個例子：
<owl:ObjectProperty rdf:ID="madeFromGrape"> <rdfs:domain rdf:resource="#Wine"/> <rdfs:range rdf:resource="#WineGrape"/> </owl:ObjectProperty>
經過上面的定義property madeFromGrape給出了class Wine的元素和WineGrape的元素之間的關係。下面的例子給出了property的層次定義：
<owl:ObjectProperty rdf:ID="WineDescriptor" /> <owl:Class rdf:ID="WineColor"> <rdfs:subClassOf rdf:resource="#WineDescriptor" /> ... </owl:Class> <owl:ObjectProperty rdf:ID="hasWineDescriptor"> <rdfs:domain rdf:resource="#Wine" /> <rdfs:range rdf:resource="#WineDescriptor" /> </owl:ObjectProperty> <owl:ObjectProperty rdf:ID="hasColor"> <rdfs:subPropertyOf rdf:resource="#hasWineDescriptor" /> <rdfs:range rdf:resource="#WineColor" /> </owl:ObjectProperty>
下面是locatedIn property的定義：
<owl:ObjectProperty rdf:ID="locatedIn"> ... <rdfs:domain rdf:resource="http://www.w3.org/2002/07/owl#Thing" /> <rdfs:range rdf:resource="#Region" /> </owl:ObjectProperty>
該定義容許locatedIn的domain爲任何一個thing。
下面是Vintage這個class的定義：
<owl:Class rdf:ID="Vintage">
<rdfs:subClassOf rdf:resource="http://www.w3.org/2002/07/owl#Thing"/>
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#vintageOf"/>
<owl:minCardinality>1</owl:minCardinality>
</owl:Restriction>
</rdfs:subClassOf>
</Class>
property vintageOf 將Vintage關聯到wine。
Datatype利用XML Schema datatype定義的簡單類型完成定義。若是咱們想把vintage的年限約束到1700之後，咱們須要在其餘文件中建立幾個XML Schema datatype定義：
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.example.org/wine-dt.xsd">
<xsd:simpleType name="year">
<!-- year is an XMLS datatype based on integer -->
<xsd:restriction base="xsd:decimal"/>
</xsd:simpleType>
<xsd:simpleType name="wineYear">
<!-- wineYear is an XMLS datatype based on year -->
<!-- with the added restriction that values must be GEQ 1700 -->
<xsd:restriction base="year">
<xsd:minInclusive value="1700"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:schema>
然後咱們再給出WineYear這個class的定義：
<owl:Class rdf:ID="WineYear" /> <owl:DataTypeProperty rdf:ID="yearValue"> <rdfs:domain rdf:resource="#WineYear" /> <rdfs:range rdf:resource="&dt;wineYear"/> </owl:DataTypeProperty>
關於individual的property定義，一個例子以下：
<CaliforniaRegion rdf:ID="SantaCruzMountainsRegion" /> <Winery rdf:ID="SantaCruzMountainVineyard" /> <CabernetSauvignon rdf:ID="SantaCruzMountainVineyardCabernetSauvignon" > <locatedIn rdf:resource="#SantaCruzMountainsRegion"/> <hasMaker rdf:resource="#SantaCruzMountainVineyard" /> </CabernetSauvignon>
下面建立了一個WineYear的實例並將它和一個特殊的datatype dte:wineYear關聯起來：
<WineYear rdf:ID="Year1998"> <yearValue rdf:datatype="&dte;wineYear">1998</yearValue> </WineYear>
4.3.3 Property特徵
下面給出了用於擴展定義property的各種特徵。
- TransitiveProperty
被標記爲Transitive的property P知足下面的公理：
P(x,y) and P(y,z) -> P(x,z)
例如：
<owl:ObjectProperty rdf:ID="locatedIn"> <rdf:type rdf:resource="&owl;TransitiveProperty" /> <rdfs:domain rdf:resource="&owl;Thing" /> <rdfs:range rdf:resource="#Region" /> </owl:ObjectProperty> <Region rdf:ID="SantaCruzMountainsRegion"> <locatedIn rdf:resource="#CaliforniaRegion" /> </Region> <Region rdf:ID="CaliforniaRegion"> <locatedIn rdf:resource="#UsRegion" /> </Region>
其中locatedIn就是Transitive的。
- SymmetricProperty
被標記爲symmetric的property P知足下面的公理：
P(x,y) iff P(y,x)
例如：
<owl:ObjectProperty rdf:ID="adjacentRegion"> <rdf:type rdf:resource="&owl;SymmetricProperty" /> <rdfs:domain rdf:resource="#Region" /> <rdfs:range rdf:resource="#Region" /> </owl:ObjectProperty> <Region rdf:ID="MendocinoRegion"> <locatedIn rdf:resource="#CaliforniaRegion" /> <adjacentRegion rdf:resource="#SonomaRegion" /> </Region>
adjacentRegion就是symmetric的。
- Functional Property
被標記爲functional的property P知足下面的公理：
P(x,y) and P(x,z) -> y = z
例如：
<owl:Class rdf:ID="WineYear" /> <owl:ObjectProperty rdf:ID="hasVintageYear"> <rdf:type rdf:resource="&owl;FunctionalProperty" /> <rdfs:domain rdf:resource="#Vintage" /> <rdfs:range rdf:resource="#WineYear" /> </owl:ObjectProperty>
hasVintageYear就是functional的，由於每種wine只有一個VintageYear。
- inverseOf
一個property P1被標記爲inverseof 一個property P2，知足下面的公理：
P1(x,y) iff P2(y,x)
例如：
<owl:ObjectProperty rdf:ID="hasMaker"> <rdf:type rdf:resource="&owl;FunctionalProperty" /> </owl:ObjectProperty> <owl:ObjectProperty rdf:ID="producesWine"> <owl:inverseOf rdf:resource="#hasMaker" /> </owl:ObjectProperty>
- InverseFunctionalProperty
一個被標記爲InverseFunctional的property P知足下面的公理：
P(y,x) and P(z,x) -> y = z
例如：
<owl:ObjectProperty rdf:ID="hasMaker" /> <owl:ObjectProperty rdf:ID="producesWine"> <rdf:type rdf:resource="&owl;InverseFunctionalProperty" /> <owl:inverseOf rdf:resource="#hasMaker" /> </owl:ObjectProperty>
producesWine就是InverseFunctional的。
4.3.4 Property 約束
還能夠進一步經過約束來規定property的range在某些範圍內。
- allValuesFrom, someValuesFrom
上面已經給出的property都是全局的屬性約束。而這兩個約束相對包含它們的類定義而言是局部的。例如：
<owl:Class rdf:ID="Wine">
<rdfs:subClassOf rdf:resource="&food;PotableLiquid" />
...
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasMaker" />
<owl:allValuesFrom rdf:resource="#Winery" />
</owl:Restriction>
</rdfs:subClassOf>
...
</owl:Class>
其中在hasMaker這個property上的allValuesFrom約束只是對wine這個class有意義。上面的allValuesFrom能夠被替換爲someValuesFrom，約束範圍也是相似的。
- Cardinality
咱們能夠經過Cardinality直接指定於一個class相關的class的數目，例如：
<owl:Class rdf:ID="Vintage">
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasVintageYear"/>
<owl:cardinality>1</owl:cardinality>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>
在OWL Lite中只能指定Cardinality爲0或者1，而在OWL Full中，可使用owl:maxCardinality來指定一個上界。
- hasValue [OWL DL]
hasValue容許咱們定義基於特定property的值存在的class。一個individual要成爲一個類的成員，它在這個property上的取值必須知足hasValue的規定。例如：
<owl:Class rdf:ID="Burgundy">
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasSugar" />
<owl:hasValue rdf:resource="#Dry" />
</owl:Restriction>
</rdfs:subClassOf>
...
</owl:Class>
4.4 Ontology映射
咱們須要在Ontology上定義映射關係來重用已有的Ontology的class和property。
- sameClassAs, samePropertyAs
下面是重用類的一個例子：
<owl:Class rdf:ID="Wine"> <owl:sameClassAs rdf:resource="&vin;Wine"/> </owl:Class>
下面是重用一個類並在其基礎上進行約束的例子：
<owl:Class rdf:ID="TexasThings">
<owl:sameClassAs>
<owl:Restriction>
<owl:onProperty rdf:resource="#locatedIn" />
<owl:allValuesFrom rdf:resource="#TexasRegion" />
</owl:Restriction>
</owl:sameClassAs>
</owl:Class>
- sameIndividualAs
它的定義和class相似，說明了兩個individual是同一的，例如：
- differentIndividualFrom
該定義與sameIndividualAs的效果正好相反
4.5 複雜的Class【OWL DL】
OWL經過下面的機制給出了定義類表達式的基本方法，從而可以經過嵌套定義給出一個複雜的class。
4.5.1 集合操做符
- Intersection [OWL DL]
下面給出了操做符intersectionOf的用法：
<owl:Class rdf:ID="WhiteWine">
<owl:intersectionOf rdf:parseType="Collection">
<owl:Class rdf:about="#Wine" />
<owl:Restriction>
<owl:onProperty rdf:resource="#hasColor" />
<owl:hasValue rdf:resource="#White" />
</owl:Restriction>
</owl:intersectionOf>
</owl:Class>
注意類操做符是封閉的。
下面是一個經過兩次嵌套定義的例子：
<owl:Class rdf:about="#Burgundy">
<owl:intersectionOf rdf:parseType="Collection">
<owl:Class rdf:about="#Wine" />
<owl:Restriction>
<owl:onProperty rdf:resource="#locatedIn" />
<owl:hasValue rdf:resource="#BourgogneRegion" />
</owl:Restriction>
</owl:intersectionOf>
</owl:Class>
<owl:Class rdf:ID="WhiteBurgundy">
<owl:intersectionOf rdf:parseType="Collection">
<owl:Class rdf:about="#Burgundy" />
<owl:Class rdf:about="#WhiteWine" />
</owl:intersectionOf>
</owl:Class>
- Union [OWL DL]
下面是一個使用UnionOf的例子：
<owl:Class rdf:ID="Fruit">
<owl:unionOf rdf:parseType="Collection">
<owl:Class rdf:about="#SweetFruit" />
<owl:Class rdf:about="#NonSweetFruit" />
</owl:unionOf>
</owl:Class>
能夠將它和下面的定義做比較：
<owl:Class rdf:ID="Fruit"> <rdfs:subClassOf rdf:resource="#SweetFruit" /> <rdfs:subClassOf rdf:resource="#NonSweetFruit" /> </owl:Class>
- Complement [OWL DL]
下面是一個使用complementOf的例子：
<owl:Class rdf:ID="ConsumableThing" />
<owl:Class rdf:ID="NonConsumableThing">
<owl:complementOf rdf:resource="#ConsumableThing" />
</owl:Class>
下面是一個混和使用了各類集合操做符的例子：
<owl:Class rdf:ID="NonFrenchWine">
<owl:intersectionOf rdf:parseType="Collection">
<owl:Class rdf:about="#Wine"/>
<owl:Class>
<owl:complementOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#locatedIn" />
<owl:hasValue rdf:resource="#FrenchRegion" />
</owl:Restriction>
</owl:complementOf>
</owl:Class>
</owl:intersectionOf>
</owl:Class>
4.5.2 枚舉Class
- oneOf [OWL DL]
OWL經過one of操做符給出了枚舉一個class的成員的基本方法，例以下面的例子定義了WineColor這個class擁有3個成員：
<owl:Class rdf:ID="WineColor">
<rdfs:subClassOf rdf:resource="#WineDescriptor"/>
<owl:oneOf rdf:parseType="Collection">
<owl:Thing rdf:about="#White"/>
<owl:Thing rdf:about="#Rose"/>
<owl:Thing rdf:about="#Red"/>
</owl:oneOf>
</owl:Class>
咱們也能夠經過直接指定每一個成員的類型進行定義：
<owl:Class rdf:ID="WineColor">
<rdfs:subClassOf rdf:resource="#WineDescriptor"/>
<owl:oneOf> rdf:parseType="Collection">
<WineColor rdf:about="#White" />
<WineColor rdf:about="#Rose" />
<WineColor rdf:about="#Red" />
</owl:oneOf>
</owl:Class>
4.5.3 不交的Class
- disjointWith [OWL DL]
它用於表達一個individual是一個class的成員，同時不能是另一個class的成員。
例如：
<owl:Class rdf:ID="Pasta"> <rdfs:subClassOf rdf:resource="#EdibleThing"/> <owl:disjointWith rdf:resource="#Meat"/> <owl:disjointWith rdf:resource="#Fowl"/> <owl:disjointWith rdf:resource="#Seafood"/> <owl:disjointWith rdf:resource="#Dessert"/> <owl:disjointWith rdf:resource="#Fruit"/> </owl:Class>
定義一個class是幾個不交的subclass的union的例子以下：
<owl:Class rdf:ID="SweetFruit"> <rdfs:subClassOf rdf:resource="#EdibleThing" /> </owl:Class>
<owl:Class rdf:ID="NonSweetFruit"> <rdfs:subClassOf rdf:resource="#EdibleThing" /> <owl:disjointWith rdf:resource="#SweetFruit" /> </owl:Class>
<owl:Class rdf:ID="Fruit"> <owl:unionOf rdf:parseType="Collection"> <owl:Class rdf:about="#SweetFruit" /> <owl:Class rdf:about="#NonSweetFruit" /> </owl:unionOf> </owl:Class>
定義的規模隨着不相交類的數目（n）的增加是n2級的。
5 一個完整的制酒行業的Ontology的OWL建模
這個例子是w3c的Guus Schrieber開發的關於制酒行業的更爲精細的Ontology。
5.1 相關背景
對於制酒業而言，「產品地域」（production area）是一個很是重要的feature。根據生產地域的穀類的大小酒的類型存在很大的變化，從一個國家到一個特定的葡萄園。咱們能夠給出四種不一樣的產品地域：
國家（country），例如France，Italy
區域（region），例如Bordeaux，Medoc，Tuscany
城鎮（town），例如Margaux， Montalcino， Montepulciano
葡萄園（vineyard），例如Chateau Margaux，Avignonesi
並且咱們必須爲不一樣產品地域之間的關係建模：
區域是國家的一部分：Tuscany在Italy
區域有子區域：Medoc是Bordeaux的子區域
城鎮在某區域中：Montalcino在Tuscany
葡萄園在城鎮中：Chateau Margaux在Margaux，Avignonesi在Montepulciano
5.2 建模決策
咱們決定去掉「town」，將它們都看做region。這樣作簡化了模型，而且這附和實際中town做爲一個產品地域在城鎮周邊，比城鎮面積稍大或稍小的事實。
5.3 模型
5.3.1 Class
<owl:Class rdf:ID="&vin;ProductionArea"/ > <owl:Class rdf:ID="&vin;Country:"> <rdfs:subClassOf rdf:resource="&vin;ProductionArea"/> </owl:Class> <owl:Class rdf:ID="&vin;Region:"> <rdfs:subClassOf rdf:resource="&vin;ProductionArea"/> </owl:Class> <owl:Class rdf:ID="&vin;Vineyard:"> <rdfs:subClassOf rdf:resource="&vin;ProductionArea"/> </owl:Class>
用三元組能夠表示爲：
vin:ProductionArea rdf:type rdfs:Class. vin:Country rdfs:subClassOf vin:ProductionArea. vin:Region rdfs:subClassOf vin:ProductionArea. vin:Vineyard rdfs:subClassOf vin:ProductionArea.
5.3.2 Property
<owl:ObjectProperty rdf:ID="&vin;hasSubArea"> <rdf:type rdf:resource="&owl;TransitiveProperty" /> </owl:ObjectProperty> <owl:ObjectProperty rdf:ID="&vin;subAreaOf"> <owl:inverseOf rdf:resource="&vin;hasSubArea"/> </owl:ObjectProperty> <owl:ObjectProperty rdf:ID="&vin;hasRegion"> <rdfs:subPropertyOf rdf:resource="&vin;hasSubArea"/> <owl:allValuesFrom rdf:resource="&vin;Region"/> </owl:ObjectProperty> <owl:ObjectProperty rdf:ID="&vin;regionOf"> <owl:inverseOf rdf:resource="&vin;hasRegion"/> <owl:allValuesFrom rdf:resource="&vin;Country"/> <owl:cardinality>1</owl:cardinality> </owl:ObjectProperty> <owl:ObjectProperty rdf:ID="&vin;hasSubRegion"> <rdfs:subPropertyOf rdf:resource="&vin;hasSubArea"/> <owl:allValuesFrom rdf:resource="&vin;Region"/> </owl:ObjectProperty> <owl:ObjectProperty rdf:ID="&vin;subRegionOf"> <owl:inverseOf rdf:resource="&vin;hasSubRegion"/> <owl:allValuesFrom rdf:resource="&vin;Region"/> <owl:cardinality>1</owl:cardinality> </owl:ObjectProperty> <owl:ObjectProperty rdf:ID="&vin;hasVineyard"> <rdfs:subPropertyOf rdf:resource="&vin;hasSubArea"/> <owl:allValuesFrom rdf:resource="&vin;Vinyard"/> </owl:ObjectProperty> <owl:ObjectProperty rdf:ID="&vin;vineyardRegion"> <owl:inverseOf rdf:resource="&vin;hasVineyard"/> <owl:allValuesFrom rdf:resource="&vin;Region"/> <owl:cardinality>1</owl:cardinality> </owl:ObjectProperty>
用三元組表示爲：
vin:hasSubArea rdf:type rdfs:Property. vin:hasSubArea rdf:type owl:TransitiveProperty. vin:subAreaOf owl:inverseOf vin:hasSubArea. vin:hasRegion rdfs:subPropertyOf vin:hasSubArea. vin:hasRegion owl:allValuesFrom vin:Region. vin:regionOf owl:inverseOf vin:hasRegion. vin:regionOf owl:allValuesFrom vin:Country. vin:regionOf owl:cardinality 1. vin:hasSubRegion rdfs:subPropertyOf vin:hasSubArea. vin:hasSubRegion owl:allValuesFrom vin:Region. vin:subRegionOf owl:inverseOf vin:hasSubRegion. vin:subRegionOf owl:allValuesFrom vin:Region. vin:subRegionOf owl:cardinality 1. vin:hasVineyard rdfs:subPropertyOf vin:hasSubArea. vin:hasVineyard owl:allValuesFrom vin:Vineyard. vin:vineyardRegion owl:inverseOf vin:hasVineyard.. vin:vineyardRegion owl:allValuesFrom vin:Region. vin:vineyardRegion owl:cardinality 1.
5.3.3 UML註釋
6 緊急聯動的一個簡單建模
6.1 UML模型（應急聯動機構）
6.2 Ontology模型
<?xml version="1.0" encoding="GB2312"?>
<rdf:RDF
xmlns ="http://gis.pku.edu.cn/應急聯動機構#"
xmlns: 應急聯動機構="http://www.example.org/應急聯動機構#"
xmlns:owl ="http://www.w3.org/2002/07/owl#"
xmlns:rdf ="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
xmlns:xsd =http://www.w3.org/2000/10/XMLSchema#>
<owl:Ontology rdf:about=" http://gis.pku.edu.cn/應急聯動機構">
<rdfs:comment>中國城市應急聯動機構的Ontology</rdfs:comment>
<owl:versionInfo>
$Id: test.html,v 1.0 2003/03/20 22:22:00 Lxp $
</owl:versionInfo>
</owl:Ontology>
<owl:Class rdf:ID="&應急聯動機構;聯動單位"/ >
<owl:Class rdf:ID="&應急聯動機構;消防局:">
<rdfs:subClassOf rdf:resource="&應急聯動機構;聯動單位"/>
</owl:Class>
<owl:Class rdf:ID="&應急聯動機構;聯動單位調度中心"/ >
<owl:Class rdf:ID="&應急聯動機構;處置力量分支"/ >
<owl:Class rdf:ID="&應急聯動機構;消防指揮調度中心:">
<rdfs:subClassOf rdf:resource="&應急聯動機構;聯動單位調度中心"/>
</owl:Class>
<owl:Class rdf:ID="&應急聯動機構;消防支隊:">
<rdfs:subClassOf rdf:resource="&應急聯動機構;處置力量分支"/>
</owl:Class>
<owl:Class rdf:ID="&應急聯動機構;處置力量部門"/ >
<owl:Class rdf:ID="&應急聯動機構;消防中隊:">
<rdfs:subClassOf rdf:resource="&應急聯動機構; 處置力量部門"/>
</owl:Class>
<owl:Class rdf:ID="&應急聯動機構;消防車"/ >
<owl:ObjectProperty rdf:ID="&應急聯動機構;包含中心">
<rdf:type rdf:resource="&owl;FunctionalProperty" />
</owl:ObjectProperty>
<owl:ObjectProperty rdf:ID="&應急聯動機構;包含分支">
</owl:ObjectProperty>
<owl:ObjectProperty rdf:ID="&應急聯動機構;包含聯動調度中心">
<rdfs:subPropertyOf rdf:resource="&應急聯動機構;包含中心"/>
<rdfs:domain rdf:resource="&應急聯動機構;聯動單位" />
<rdfs:range rdf:resource="&應急聯動機構;聯動單位調度中心" />
</owl:ObjectProperty>
<owl:ObjectProperty rdf:ID="&應急聯動機構;包含力量分支">
<rdfs:subPropertyOf rdf:resource="&應急聯動機構;包含分支"/>
<rdfs:domain rdf:resource="&應急聯動機構;聯動單位" />
<rdfs:range rdf:resource="&應急聯動機構;處置力量分支" />
</owl:ObjectProperty>
<owl:ObjectProperty rdf:ID="&應急聯動機構;包含力量部門">
<rdfs:subPropertyOf rdf:resource="&應急聯動機構;包含分支"/>
<owl:allValuesFrom rdf:resource="&應急聯動機構;處置力量部門"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:ID="&應急聯動機構;包含消防調度中心">
<rdfs:subPropertyOf rdf:resource="&應急聯動機構;包含中心"/>
<rdfs:domain rdf:resource="&應急聯動機構;消防局" />
<rdfs:range rdf:resource="&應急聯動機構;消防指揮調度中心" />
</owl:ObjectProperty>
<owl:ObjectProperty rdf:ID="&應急聯動機構;包含消防支隊">
<rdfs:subPropertyOf rdf:resource="&應急聯動機構;包含分支"/>
<rdfs:domain rdf:resource="&應急聯動機構;消防局" />
<rdfs:range rdf:resource="&應急聯動機構;消防支隊" />
</owl:ObjectProperty>
<owl:ObjectProperty rdf:ID="&應急聯動機構;包含中隊">
<rdfs:subPropertyOf rdf:resource="&應急聯動機構;包含分支"/>
<owl:allValuesFrom rdf:resource="&應急聯動機構;消防中隊"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:ID="&應急聯動機構;包含車">
<rdfs:subPropertyOf rdf:resource="&應急聯動機構;包含分支"/>
<rdfs:domain rdf:resource="&應急聯動機構;消防中隊" />
<rdfs:range rdf:resource="&應急聯動機構;消防車" />
</owl:ObjectProperty>
</rdf:RDF>
7 一個比較複雜的應急聯動的建模
略
8 Jena—語義網建模的Java API
8.1 簡介——幾個RDF建模的實例
【例一】： 給出下面的RDF有向圖：
其中，橢圓中的URI給出了一個resource，有向邊給出了該resource的一個property：FN（Full Name）。vcard是一個命名空間的前綴。該property的值在方框中給出，是一個literral類型的「John Smith」。
Jena一組可以用來建立和操縱諸如此種類型的有向圖的Java API。Jena用對象類來表示圖、resource、property和literal，用於表達後三者的接口分別叫作Resource、Property和Literal，而圖被表示爲一個model。用於建立上面的圖的代碼以下：
// some definitions static String personURI = "http://somewhere/JohnSmith"; static String fullName = "John Smith"; // create an empty graph Model model = new ModelMem(); // create the resource Resource johnSmith = model.createResource(personURI); // add the property johnSmith.addProperty(VCARD.FN, fullName);
ModelMem是實現了接口Model的類。Jena還包括了其餘用於實現Model的類，它們能夠被存儲在Berklay的DB數據庫以及關係數據庫中。VCARD是一個常數類，裏面定義了全部VCARD Schema的常數。Jena還提供了其餘常數類，如RDF、RDF Schema、Dublin Core 和DAML。其中，建立resource和添加property的兩條語句能夠被壓縮爲下面的一句：
Resource johnSmith = model.createResource(personURI).addProperty(VCARD.FN, fullName);
【例二】：下面給出了在例一的基礎上獲得的一個相對複雜的有向圖：
與上面不一樣的是，vcard:N屬性以一個resource做爲它的值，而該resource沒有名字，稱做一個空結點（blank Node）。
下面是Jena的建立代碼：
// some definitions
String personURI = "http://somewhere/JohnSmith";
String givenName = "John";
String familyName = "Smith";
String fullName = givenName + " " + familyName;
// create an empty graph
Model model = new ModelMem();
// create the resource
// and add the properties cascading style
Resource johnSmith = model.createResource(personURI)
.addProperty(VCARD.FN, fullName)
.addProperty(VCARD.N,
model.createResource()
.addProperty(VCARD.Given, givenName)
.addProperty(VCARD.Family, familyName));
8.2 Jena與整個建模流程
8.2.1 陳述（statement）
如上面的兩個例子所示，RDF有向圖中的每條邊就是一個陳述，它確定了resource的一個事實。一個陳述包含三個部分：
subject，即有向邊離開的resource；主語
predicate，即帶標記的有向邊；謂詞
object，有向邊指向的resource或者literal。賓語
因此陳述又叫作三元組。一個RDF有向圖包含了一系列的陳述（statement），他是陳述的集合，因此重複的陳述能夠被加進一個圖中。Jena的model接口提供了一個listStatements()方法用於獲得一個在這個集合上的迭代器，它的返回類型爲Statement。Statement接口提供了用於訪問該陳述的subject、predicate和object的方法。一個例子以下：
// list the statements in the graph
StmtIterator iter = model.listStatements();
// print out the predicate, subject and object of each statement
while (iter.hasNext()) {
Statement stmt = iter.next(); // get next statement
Resource subject = stmt.getSubject(); // get the subject
Property predicate = stmt.getPredicate(); // get the predicate
RDFNode object = stmt.getObject(); // get the object
System.out.print(subject.toString());
System.out.print(" " + predicate.toString() + " ");
if (object instanceof Resource) {
System.out.print(object.toString());
} else {
// object is a literal
System.out.print(" \"" + object.toString() + "\");
}
System.out.println(" .");
}
因爲object能夠爲一個resource或者一個literal，因此getObject() 方法返回一個類型爲RDFNode的對象，該類是resource和literal的公共超類。
8.2.2 書寫RDF
Jena提供了用XML格式讀寫RDF的方法，這就使得咱們可以將一個RDF model存爲一個文件並在之後將它讀出來。
下面的代碼片段給出瞭如何將一個model存入文件的方法：
// now write the model in XML form to a file model.write(new PrintWriter(System.out));
即調用model的write方法經過一個PrintWriter寫入文件中。
對於上面的例子，調用這樣的輸入語句可能獲得下面的輸出結果：
<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:FN>John Smith</vcard:FN>
<vcard:N rdf:resource='#A0'/>
</rdf:Description>
<rdf:Description rdf:about='#A0'>
<vcard:Given>John</vcard:Given>
<vcard:Family>Smith</vcard:Family>
</rdf:Description>
</rdf:RDF>
不過該表達並不徹底與咱們上面給出的例子相符。在XML表達中不能描述一個空的節點，在原圖中的空結點被賦予了一個URI。
Jena還提供了擴展接口用於支持可插入的新的writer來序列化RDF。上面使用的是標準的「dumb」writer，Jena還支持一個更爲成熟的RDF/XML writer：
model.write(new PrintWriter(System.out), "RDF/XML-ABBREV");// now write the model in XML form to a file
這個writer也叫作PrettyWriter，它可以使用RDF/XML feature的縮寫語法更爲緊湊的將一張圖輸出到文件。它同時也支持空結點。可是對於很大的圖則不太適用，由於這樣作的性能不能接收。要想輸出很大的文件而且維持空結點，則使用N-Triples格式：
// now write the model in XML form to a file model.write(new PrintWriter(System.out), "N-TRIPLE");
8.2.3 讀取RDF
下面的代碼給出了用於讀取一個RDF文件而且將它另外寫回的方法：
// create an empty model
Model model = new ModelMem();
// use the class loader to find the input file
InputStream in = Tutorial05.class
.getClassLoader()
.getResourceAsStream(inputFileName);
if (in == null) {
throw new IllegalArgumentException(
"File: " + inputFileName + " not found");
}
// read the RDF/XML file
model.read(new InputStreamReader(in), "");
// write it to standard out
model.write(new PrintWriter(System.out));
其中，read方法的第二個參數應該是相對的URI，由於這裏沒有引用相對URI，因此能夠爲空。
8.2.4 關於Jena的RDF包
最新版本已再也不使用使用
com.hp.hpl.mesa命名空間
l 語義網應用開發人員使用Jena時的最重要的包是com.hp.hpl.mesa.rdf.jena.model。這個包包含了用於表達model、resource、property、literal、statements以及其餘RDF的關鍵的接口；
l com.hp.hpl.mesa.rdf.jena.tutorial包包含了與Jena一同發佈的指南中所使用的例子的源代碼；
l com.hp.hpl.mesa.rdf.jena.mem包包含了用於將整個模型狀態裝入內存的Jena API的實現。凡是建立基於內存的模型（最典型的是建立ModelMem類的實例）的實現都在本包中；
l com.hp.hpl.mesa.rdf.jena.common包包含了對於諸多實現通用的實現類。例如，它定義了類ResourceImpl, PropertyImpl, LiteralImpl。開發者通常不要直接使用這裏的方法，例如不直接使用ResourceImpl，而使用createResource方法。這是爲了保證在實現發生優化後不須要進行類型轉換；
l com.hp.hpl.jena.rdf爲RDF包。
8.2.5 在RDF有向圖中的導航
給出一個resource的URL，可使用Model.getResource(String uri)方法從圖中獲得該資源所對應的對象。若是對應的resource存在，則返回該resource的對象，不然將建立一個新的對象。例如：
Resource vcard = model.getResource(johnSmithURI);// retrieve the John Smith vcard resource from the model
Resource接口定義了一系列方法用於訪問一個Resource的Property。Resource.getProperty(Property p)方法用於訪問一個resource的一個property。同以往的Java API不一樣的是該方法返回的是整個Statement對象，而後經過該對象的訪問方法來獲得Property的值。例如想獲得vcard:N這個property的值所對應的resource，代碼以下：
Resource name = (Resource) vcard.getProperty(VCARD.N).getObject();// retrieve the value of the N property
因爲property的值可能爲resource或者literal，而咱們已經知道上面獲得的值爲resource，因此進行了強制類型轉換。Jena也提供了特定類型的訪問方法，從而不須要在編譯時進行類型轉換。因此上面的代碼也能夠寫成：
Resource name = vcard.getProperty(VCARD.N).getResource();// retrieve the value of the FN property
相似，若是property的值爲literal，則能夠寫成：
String fullName = vcard.getProperty(VCARD.FN) .getString();// retrieve the given name property
上面的property VCARD.FN只有一個，但RDF容許一個resource有重複的property。例如Adam可能有多於一個的nickname：
// add two nick name properties to vcard
vcard.addProperty(VCARD.NICKNAME, "Smithy")
.addProperty(VCARD.NICKNAME, "Adman");
當調用getProperty方法時，Jena並無定義要返回哪個property，因此vcard.getProperty(VCARD.NICKNAME)的結果是不肯定的。Jena只是返回其中任意一個，但並不保證連續兩條調用都有可能返回同一個值。
這樣，當proeprty連續出現時，可使用Resource.listProperties(Property p)方法來獲得一個迭代器從而列舉出它們。例以下面的代碼可以列舉出上面添加的nickname：
// set up the output
System.out.println("The nicknames of \""+ fullName + "\" are:");
// list the nicknames
StmtIterator iter = vcard.listProperties(VCARD.NICKNAME);
while (iter.hasNext()) {
System.out.println(" " + iter.next().getObject().toString());
}
該代碼的輸出結果是：
The nicknames of "John Smith" are:
Smithy
Adman
8.2.6 關於圖的查詢
Jena核心只是提供了有限的查詢元語。另外對RDF還有更爲強大的RDQL查詢語言。
Model.listStatements()方法用於列舉一個model中的全部statement，多是最爲原始的對一個model的查詢。該查詢不適於在很大的圖上面作查詢。Model.listSubjects()方法相似，只是返回在全部有property的resource上的迭代器。Model.listSubjectsWithProperty(Property p, RDFNode o)則返回全部在property p上有值o的resource的迭代器。例如：
// retrieve all resource of type Vcard. ResIterator iter = model.listSubjectsWithProperty(RDF.type, VCARD.Vcard);
若是咱們使用的vcard schema並無爲vcard定義一個類型，那咱們能夠假定只有類型爲vcard的resource有property vcard:FN，並且在咱們的數據中，全部這樣的resource都有一個這樣的property，那咱們能夠這樣進行查詢：
// list vcards
ResIterator iter = model.listSubjectsWithProperty(VCARD.FN);
while (iter.hasNext()) {
Resource r = iter.next();
...
}
全部上面的查詢都基於這樣一個查詢元語：model.listStatements(Selector s)。該方法返回創建在通過s選擇獲得的statement上的迭代器。Selector被定義爲可擴展的，目前只有一個實現：com.hp.hpl.mesa.rdf.jena.common包中的SelectorImpl類。SelectorImpl構造函數有三個參數：
Selector selector = new SelectorImpl(subject, predicate, object)
顯然它返回匹配參數給出的三元組的statement。若是在這三個參數的位置上任意一個爲null，則認爲匹配全部。因此
Selector selector = new SelectorImpl(null, null, null);
返回一張圖中的全部statement。
Selector selector = new SelectorImpl(null, VCARD.FN, null);
返回知足predicate爲VCARD.FN的statement而不論其餘兩個參數的值爲何。如下的代碼列出了數據庫中全部vcard的full name：
// select all the resources with a VCARD.FN property
ResIterator iter = model.listSubjectsWithProperty(VCARD.FN);
if (iter.hasNext()) {
System.out.println("The database contains vcards for:");
while (iter.hasNext()) {
System.out.println(" " + iter.next()
.getProperty(VCARD.FN)
.getString());
}
} else {
System.out.println("No vcards were found in the database");
}
輸出結果能夠是：
The database contains vcards for: Sarah Jones John Smith Matt Jones Becky Smith
下面的例子是採用SelectorImpl來實現查詢的例子：
// select all the resources with a VCARD.FN property
// whose value ends with "Smith"
StmtIterator iter = model.listStatements(
new SelectorImpl(null, VCARD.FN, (RDFNode) null) {
public boolean selects(Statement s) {
try {
return s.getString()
.endsWith("Smith");
} catch (RDFException e) {
throw new RDFError(e);
}
}
});
以上的代碼使用了Java的內置代理方法定義技術。其中select方法確保full name以「Smith」結束，而該過濾只是對subject起做用。
如下的兩段代碼可被認爲是有着相同的功能：
//【1】
// do all filtering in the selects method
StmtIterator iter = model.listStatements(
new SelectorImpl(null, null, (RDFNode) null) {
public boolean selects(Statement s) {
try {
return (subject == null || s.getSubject().equals(subject))
&& (predicate == null || s.getPredicate().equals(predicate))
&& (object == null || s.getObject().equals(object))
} catch (RDFException e) {
throw new RDFError(e);
}
}
});
//【2】
StmtIterator iter =
model.listStatements(new SelectorImpl(subject, predicate, object)
前者列出圖中全部的statement然後依次測試之，然後者容許使用應用實現自己維護的索引來提升性能。
8.2.7 對圖的操做
Jena提供了3種針對圖這一總體進行的操做——即典型的集合操做：並（union）、叫（intersection）和差（different）。
對兩張圖取並就是對兩張圖所包含的statement取並，這是爲了支持RDF所給出的一個關鍵操做，它使得不一樣數據源的數據可以被合併。給出下面的兩張圖：
它們能夠被合併爲：
上面的操做的代碼是：
// read the RDF/XML files model1.read(new InputStreamReader(in1), ""); model2.read(new InputStreamReader(in2), ""); // merge the graphs Model model = model1.union(model2); // print the graph as RDF/XML model.write(new PrintWriter(System.out), "RDF/XML-ABBREV");
生成的RDF爲：
<?xml version='1.0'?>
<rdf:RDF
xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'
xmlns:RDFNsId1='http://www.w3.org/2001/vcard-rdf/3.0#'>
<rdf:Description rdf:about='http://somewhere/JohnSmith/'>
<RDFNsId1:N
RDFNsId1:Given='John'
RDFNsId1:Family='Smith'/>
<RDFNsId1:FN>John Smith</RDFNsId1:FN>
<RDFNsId1:EMAIL
rdf:value='John@somewhere.com'
rdf:type='http://www.w3.org/2001/vcard-rdf/3.0#internet'/>
</rdf:Description>
</rdf:RDF>
交和差操做與此相似。
8.2.8 相關異常
目前Jena的異常機制不很受歡迎，它將在未來獲得改進。因爲Jena被設計成具備很高的靈活性而且支持不一樣的存儲系統，因此存儲管理器能夠在任什麼時候候給出一個非預期的錯誤。因此幾乎全部的Jena方法在結尾都要註明要拋出RDFException異常。經驗證實這不是一個好方法，當拋出異常時，一般這些異常都應該被忽略，檢查出這些異常沒有任何好處。
8.2.9 容器（Containers）
RDF給出了表達事物集合的特殊類型的resource。這些resource叫作容器。容器的成員或者是resource，或者是literal。共有3類容器：
- BAG是一個無序的容器；
- ALT是一個用於表達選擇的無序的容器；
- SEQ是一個有序的集合。
下圖是一個含有BAG的RDF有向圖的示意：
注意BAG的成員標號rdf:_1和rdf:_2的順序並不重要，它們能夠被交換。而ALT的成員標號除了第一個是重要的（它是缺省的選擇）外，也是順序無關的。
Jena提供了明確的類接口和類實現用於表達容器，例如：
// create a bag
Bag smiths = model.createBag();
// select all the resources with a VCARD.FN property
// whose value ends with "Smith"
StmtIterator iter = model.listStatements(
new SelectorImpl(null, VCARD.FN, (RDFNode) null) {
public boolean selects(Statement s) {
try {
return s.getString()
.endsWith("Smith");
} catch (RDFException e) {
throw new RDFError(e);
}
}
});
// add the Smith's to the bag
while (iter.hasNext()) {
smiths.add(iter.next().getSubject());
}
由它獲得的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='#A3'>
<rdf:type rdf:resource='http://www.w3.org/1999/02/22-rdf-syntax-ns#Bag'/>
<rdf:_1 rdf:resource='http://somewhere/JohnSmith/'/>
<rdf:_2 rdf:resource='http://somewhere/RebeccaSmith/'/>
</rdf:Description>
</rdf:RDF>
容器接口提供了一個迭代器用於列舉它的成員：
// print out the members of the bag
NodeIterator iter2 = smiths.iterator();
if (iter2.hasNext()) {
System.out.println("The bag contains:");
while (iter2.hasNext()) {
System.out.println(" " +
(Resource) iter2.next())
.getProperty(VCARD.FN)
.getString());
}
} else {
System.out.println("The bag is empty");
}
上面的輸出爲：
The bag contains: John Smith Becky Smith
Jena類提供的用於操縱容器的方法包括：添加新成員、插入成員到容器的成員中部、刪除成員等。
8.2.10 有關Literal和DataType的細節
RDF的literal不是簡單的string。它能夠包含一個語種標籤來講明該literal的語種。語種標籤爲English的Literal「chat」和語種標籤爲「French」的Literal 「chat」被認爲是不一樣的literal。
進一步說，一共有兩類literal：一種是普通的string，一種是一個定義良好的XML片段。例以下面的代碼：
// create the resource
Resource r = model.createResource();
// add the property
r.addProperty(RDFS.label, model.createLiteral("chat", "en"))
.addProperty(RDFS.label, model.createLiteral("chat", "fr"))
.addProperty(RDFS.label, model.createLiteral("<em>chat</em>", true));
// write out the graph
model.write(new PrintWriter(System.out));
它產生的RDF爲：
<rdf:RDF
xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'
xmlns:rdfs='http://www.w3.org/2000/01/rdf-schema#'>
<rdf:Description rdf:about='#A0'>
<rdfs:label xml:lang='en'>chat</rdfs:label>
<rdfs:label xml:lang='fr'>chat</rdfs:label>
<rdfs:label xml:lang='en' rdf:parseType='Literal'><em>chat</em></rdfs:label>
</rdf:Description>
</rdf:RDF>
兩個literal能夠被看做相等的條件是：或者都是簡單的literal，或者都是XML literal。並且要麼都沒有語種標籤，要麼有的話標籤相同。
- 1. 搜索算法知多少？理論研究+應用資料集
- 2. 演化博弈理論與應用研究綜述[轉]
- 3. 機器人基礎研究和應用研究的內容
- 4. 研究生數學建模
- 5. Redis和Mongodb應用場景研究
- 6. View的canVerticalScroll函數研究和應用
- 7. 幣氪研報- Ontology(ONT)
- 8. mGBDT論文研究
- 9. 四旋翼飛行器的原理研究和建模
- 10. RabbitMQ研究與應用
- 更多相關文章...
- • CAP理論是什麼？ - NoSQL教程
- • Maven Web 應用 - Maven教程
- • 適用於PHP初學者的學習線路和建議
- • TiDB 在摩拜單車在線數據業務的應用和實踐
-
每一个你不满意的现在，都有一个你没有努力的曾经。