利用jena API查詢OWL本體

最近在學習本體和語義網。學習了OWL，也嘗試着用了一下jena API對OWL本體進行查詢。

1.本體簡介
      “本體”這個術語來自於哲學，它是研究世界上的各種實體以及他們是怎麼關聯的科學。本體是對應用領域概念化的顯示的解釋說明，爲某領域提供了一個共享通用的理解，從而無論是人還是應用系統之間都能夠有效地進行語義上的理解和通訊。studer認爲，本體是：“共享概念模型的明確的形式化規範說明”。這包括了4層含義：
概念化(conceptualization)
通過抽象出客觀世界中一些現象的相關概念而得到的模型，其表示的含義獨立於具體的環境狀態
明確(explicit)
所使用的概念及使用這些概念的約束都有明確的定義
形式化(formal)
本體應是計算機可讀的。
共享(share)
知識本體中體現的是共同認可的知識，反映的是相關領域中公認的概念集，它所針對的是團體而不是個體。本體的目標是捕獲相關的領域的知識，提供對該領域知識的共同理解，確定該陋域內共同認可的詞彙，並從不同層次的形式化模式上給出這些詞彙和詞彙之間相互關係的明確定義。2.OWL簡介
        2003 年7 月W3C 公佈了OWL Web ontology 語言的最初工作草案,2004 年2 月10 日,OWL 正式成爲W3C 推薦的標準。OWL 和DAML + OIL 非常相近,只有一些微小的變化。DAML + OIL 和OWL 的語義都基於描述邏輯(descriptionlogic ,DL) 。OWL 作爲W3C 推薦的標準本體表示語言,它的最大特點是關聯描述邏輯, 通過對概念、概念屬性及其相互間關係的描述,構成概念的複雜關係網絡,這就意味着描述邏輯推理機可以推理OWL 本體。OWL 有3個表達能力遞增的子語言:OWL Lite ,OWL DL , OWL Full[20 ] 。OWL Lite 提供了類層次的能力和簡單的約束能力,支持基數爲0 或1 的基數約束,包括6 個類別的語言構造子。OWL DL 在保持計算完整性( computational completeness ) 和可判定性(decidability) 的前提下,提供了儘可能大的表達能力,包含了OWL 的全部語言構造成分,但他們的使用受到一些限制(如一個類可以是許多類的子類,但不能是另一個類的實例) 。描述邏輯是OWL 的形式化基礎,OWL DL的主要擴充是增加了布爾邏輯運算操作。OWL Full 包含OWL 的全部語言構造成分並取消了OWL DL 的限制,在OWL Full 中一個類可以看成個體的集合,也可以看成是一個個體。由於OWL Full 取消了OWL DL 中的保證可計算的某些限制,在沒有計算保證的語法自由的RDF 上進行最大程度表達, 允許一個Ontology 在預定義的(RDF、OWL) 詞彙表上增加詞彙,從而任何推理軟件均不能支持OWL FULL 的所有特點,因此不存在完整的推理算法支持OWL Full 的全部特性。OWL 通過對概念、概念屬性及其相互間關係的描述,構成概念的複雜關係網絡。
     OWL本體的一個優點是會有能夠對其做推理的工具。這些工具提供了不特定於某個主題領域的通用支持，而如果要構建一個能對一個特定的工業界標準XML Schema做推理的系統，它往往是特定於一個領域的。構建一個可靠的和有用的推理系統不是一項簡單的工作。而創建一個本體則更爲容易處理。

3.jena簡介
   jena是惠普公司的一個項目，jena爲應用程序開發人員提供了一套java接口對本體進行操作。這樣我們就可以調用jenaAPI，構建我們自己的應用程序，實現對包括RDF，OWL本體進行創建，修改，查詢以及推理操作。
  這是一個用OWL語言開發的家族本體。

這是本體的數據文件

下面是利用jenaAPI對查詢某個人的爸爸，媽媽，兄弟，姐妹，爺爺，祖先和後代。

....

public class SearchFamily {
private final static String FATHER="father";
private final static String MOTHER="mother";
private final static String DAUGHTER="daughter";
private final static String SON="son";
private final static String SISTER="sister";
private final static String BROTHER="brother";
private final static String ANCESTOR="ancestor";
private final static String OFFSPRING="offSpring";
private final static String GRANDPA="grandPa";
private final static String rulePath="E:\\programming\\workspace\\OWLTest\\WebRoot\\WEB-INF\\family.rules";

private final static String pre="http://zhumzhu.com/family#";
public final static String fileSchema="E:\\programming\\workspace\\OWLTest\\WebRoot\\WEB-INF\\familySchema.xml";
public final static String fileData="E:\\programming\\workspace\\OWLTest\\WebRoot\\WEB-INF\\familyData.xml";

public static String getSearchString(String keyWords){
     StringBuffer sb=new StringBuffer("PREFIX fa: <http://zhumzhu.com/family#>" +
             " PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>" +
               " PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> "
   );
     sb.append(" SELECT ?father ?mother ?son ?daughter ?sister ?brother ?ancestor ?offSpring ?grandPa ");
     sb.append("WHERE { ");
    
     sb.append(" OPTIONAL { ");
     sb.append(keyWords+" fa:hasFather ?father ");
     sb.append(" }. ");
     sb.append(" OPTIONAL { ");
     sb.append(keyWords+" fa:hasMother ?mother ");
     sb.append(" }. ");
     sb.append(" OPTIONAL { ");
    sb.append(keyWords+" fa:hasSon ?son ");
    sb.append(" }. ");
     sb.append(" OPTIONAL { ");
    sb.append(keyWords +" fa:hasDaughter ?daughter ");
    sb.append(" }. ");
     sb.append(" OPTIONAL { ");
     sb.append(keyWords+" fa:hasSister ?sister ");
     sb.append(" }. ");
     sb.append(" OPTIONAL { ");
     sb.append(keyWords +" fa:hasBrother ?brother ");
     sb.append(" }. ");
     sb.append(" OPTIONAL { ");
     sb.append(keyWords+" fa:hasAncestor ?ancestor ");
     sb.append(" }. ");
     sb.append(" OPTIONAL { ");
    sb.append(keyWords +" fa:hasOffSpring ?offSpring ");
    sb.append(" }. ");
    sb.append(" OPTIONAL { ");
    sb.append(keyWords +" fa:hasGrandPa ?grandPa ");
    sb.append(" } ");

     sb.append(" }");
     System.out.println(sb);
   return sb.toString();
}

 

public static Map getResultsList(String keyWords,String fileSchema,String fileData,String rule){
  
  
   //Model m=getModel(fileSchema, fileData);//沒有使用家族規則
  
  
   if(rule==null) rule=rulePath;
     Model rm=getModelByRules(fileSchema, fileData, rule); //使用了家族規則  
  
   String searchString=getSearchString("fa:"+keyWords);
  
   
   Map map=getResultsList(searchString, rm);
  
  
   return map;
  
}
public static Model getModel(String fileSchema,String fileData){
         FileManager fm=FileManager.get();
      Model schema = fm.loadModel(fileSchema);
      Model data = fm.loadModel(fileData);
   
     Reasoner reasoner = ReasonerRegistry.getOWLReasoner();
     reasoner = reasoner.bindSchema(schema);
    
     InfModel m = ModelFactory.createInfModel(reasoner, data);
    
     OntModel om=ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM, m);
     return om;
}

public static Model getModelByRules(String fileSchema,String fileData,String rulePath){
   FileManager fm=FileManager.get();
      Model schema = fm.loadModel(fileSchema);
      Model data = fm.loadModel(fileData);

       //設置新的領域規則
     
     List rules = Rule.rulesFromURL(rulePath);
    
     GenericRuleReasoner rea = new GenericRuleReasoner(rules);
     rea.setOWLTranslation(true);               // not needed in RDFS case
     rea.setTransitiveClosureCaching(true);
     rea =(GenericRuleReasoner) rea.bindSchema(schema);
    
     InfModel m = ModelFactory.createInfModel(rea, data);
    
     OntModel om=ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM, m);
     return om;
}
private static Map getResultsList(String searchString,Model model){
    Query q=QueryFactory.create(searchString);

     QueryExecution qe=QueryExecutionFactory.create(q, model);
     ResultSet rs=qe.execSelect(); //執行查詢
     System.out.println("rs.getReaultVars--"+rs.getResultVars());
     QuerySolution qs;
     RDFNode father,mother,son,daughter,sister,ancestor,offSpring,brother,grandPa;
     Map<String, Set<RDFNode>> map=new HashMap<String, Set<RDFNode>>();
    
     Set<RDFNode> father_=new HashSet<RDFNode>();
     Set<RDFNode> mother_=new HashSet<RDFNode>();
     Set<RDFNode> son_=new HashSet<RDFNode>();
     Set<RDFNode> sister_=new HashSet<RDFNode>();
     Set<RDFNode> ancestor_=new HashSet<RDFNode>();
     Set<RDFNode> offSpring_=new HashSet<RDFNode>();
     Set<RDFNode> brother_=new HashSet<RDFNode>();
     Set<RDFNode> daughter_=new HashSet<RDFNode>();
     Set<RDFNode> grandPa_=new HashSet<RDFNode>();
    
    
     while(rs.hasNext()){
     qs= rs.nextSolution();
      father=qs.get(FATHER);
      mother=qs.get(MOTHER);
      son=qs.get(SON);
      daughter=qs.get(DAUGHTER);
      sister=qs.get(SISTER);
      ancestor=qs.get(ANCESTOR);
      offSpring=qs.get(OFFSPRING);
      brother=qs.get(BROTHER);
      grandPa=qs.get(GRANDPA);
     
      if(father!=null)
      father_.add(father);
      if(mother!=null)
      mother_.add(mother);
      if(son!=null)
      son_.add(son);
      if(daughter!=null)
      daughter_.add(daughter);
      if(sister!=null)
      sister_.add(sister);
      if(ancestor!=null)
      ancestor_.add(ancestor);
      if(offSpring!=null)
      offSpring_.add(offSpring);
      if(brother!=null)
      brother_.add(brother);
      if(grandPa!=null)
      grandPa_.add(grandPa);
     
   
     
   
    }
     map.put(FATHER, father_);
     map.put(MOTHER, mother_);
     map.put(SON, son_);
     map.put(SISTER, sister_);