Verfahrende anonyme/leere Knoten in Jena

Question

Ich benutze die Apache Jena API, wo ein Graph auch einige anonyme/leere Knoten enthält, aufgrund von unionOf und intersectionOf. Eines dieser Beispiele ist:

<owl:Class> 
    <owl:unionOf rdf:parseType="Collection"> 
     <rdf:Description rdf:about="http://www.summyUrl.com/something#Entity1"/> 
     <rdf:Description rdf:about="http://www.summyUrl.com/something#Entity2"/> 
    </owl:unionOf> 
</owl:Class> 

Dies ist ein anonymer Knoten/Ressource. Wenn ich versuche, seine URI zu bekommen, ist es so etwas wie:

„-50a5734d: 15d839467d9: -1b8b“

Ich bin weder in der Lage auf SPARQL-Abfrage unter Verwendung eines solchen URIs (aufgrund Ausnahme zu tun Parsing solcher URIs), noch in der Lage, geeignete Jena-Methode zu finden, um damit umzugehen.

Ich bin auf der Suche nach einer Möglichkeit, solche Knoten zu explodieren und alle verschachtelten Ressourcen davon zu bekommen.

Zum Beispiel in folgendem Fall sollte es zurückgeben <http:/.../Entity1>, <http:/.../Entity2> und <http:/.../Entity3>

<owl:Class> 
    <owl:unionOf rdf:parseType="Collection"> 
     <rdf:Description rdf:about="http://www.summyUrl.com/something#Entity1"/> 
     <owl:unionOf rdf:parseType="Collection"> 
      <rdf:Description rdf:about="http://www.summyUrl.com/something#Entity2"/> 
      <rdf:Description rdf:about="http://www.summyUrl.com/something#Entity3"/> 
     </owl:unionOf> 
    </owl:unionOf> 
</owl:Class> 

1. Gibt es eine integrierte Methode von Jena es zu behandeln?

2. Wenn nicht, wie kann ich es effizient machen?

Answer 1

Ich habe versucht, es auf diese Weise zu tun und es funktionierte gut:

/** 
* Explodes <b>Anonymous resource</b> (Collection resource) in recursive way and provides 
* nested resources. Mainly considers <code>owl:unionOf</code>, <code>owl:intersactionOf</code>, <code>rdf:first</code> and <code>rdf:rest</code> 
* while traversing. 
* 
* @param resource 
* @return LinkedList<Resource> 
*/ 
private List<Resource> explodeAnonymousResource(Resource resource) 
{ 
    private static List<Property> collectionProperties = new LinkedList<Property>(Arrays.asList(OWL.unionOf,OWL.intersectionOf,RDF.first,RDF.rest)); 

    List<Resource> resources=new LinkedList<Resource>(); 
    Boolean needToTraverseNext=false; 

    if(resource.isAnon()) 
    { 
     for(Property cp:collectionProperties) 
     { 
      if(resource.hasProperty(cp) && !resource.getPropertyResourceValue(cp).equals(RDF.nil)) 
      { 
       Resource nextResource=resource.getPropertyResourceValue(cp); 
       resources.addAll(explodeAnonymousResource(nextResource)); 

       needToTraverseNext=true; 
      } 
     } 

     if(!needToTraverseNext) 
     { 
      resources.add(resource); 
     } 
    } 
    else 
    { 
     resources.add(resource); 
    } 

    return resources; 
} 

Answer 2

Mit jena-model-api:

 String s = "<rdf:RDF\n" + 
      " xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\"\n" + 
      " xmlns:dc=\"http://purl.org/dc/elements/1.1/\"\n" + 
      " xmlns:owl=\"http://www.w3.org/2002/07/owl#\"\n" + 
      " xmlns:rdfs=\"http://www.w3.org/2000/01/rdf-schema#\"\n" + 
      " xmlns:xsd=\"http://www.w3.org/2001/XMLSchema#\">\n" + 
      " <owl:Ontology/>\n" + 
      " <owl:Class>\n" + 
      " <owl:unionOf rdf:parseType=\"Collection\">\n" + 
      "  <owl:Class rdf:about=\"http://www.summyUrl.com/something#Entity1\"/>\n" + 
      "  <owl:Class>\n" + 
      "  <owl:unionOf rdf:parseType=\"Collection\">\n" + 
      "   <owl:Class rdf:about=\"http://www.summyUrl.com/something#Entity1\"/>\n" + 
      "   <owl:Class rdf:about=\"http://www.summyUrl.com/something#Entity2\"/>\n" + 
      "  </owl:unionOf>\n" + 
      "  </owl:Class>\n" + 
      " </owl:unionOf>\n" + 
      " </owl:Class>\n" + 
      "</rdf:RDF>"; 
    Model m = ModelFactory.createDefaultModel(); 
    try (InputStream in = new ByteArrayInputStream(s.getBytes(StandardCharsets.UTF_8))) { 
     m.read(in, Lang.RDFXML.getLabel()); 
    } 
    //m.write(System.out, "ttl"); 
    m.listStatements() 
      .mapWith(Statement::getObject) 
      .filterKeep(RDFNode::isURIResource) 
      .mapWith(RDFNode::asResource) 
      .filterDrop(OWL.Class::equals) 
      .filterDrop(OWL.Ontology::equals) 
      .filterDrop(RDF.nil::equals) 
      .mapWith(Resource::getURI) 
      .forEachRemaining(System.out::println); 

Der Ausgang:

http://www.summyUrl.com/something#Entity1 
http://www.summyUrl.com/something#Entity2 
http://www.summyUrl.com/something#Entity1 

Dies ist nur ein Beispiel. Es gibt eine Menge von Möglichkeiten, um alles zu behandeln