6 - Sprachen des Semantic Web - RDF(S) Frameworks

1. Semantic Web Technologien Lehrveranstaltung Semantic Web Technologien WS 2009/10 HTWG Konstanz

2. Sprachen des Semantic Web RDF(S) Frameworks

3. Programmierungs-Frameworks für RDF(S) Seit der Einführung des Resource Description Frameworks sind bereits einige Jahre ins Land gegangen. Diverse Organisationen (Universitäten, Firmen...) haben praktische Forschung in Richtung Semantic Web betrieben

4. Viele Programmier-Frameworks sind dabei entstanden

5. Framework hier: Eher Programmbibliotheken

6. Teilweise schon in Richtung Triple-Stores

7. Oft stark erweiterbare Baukästen

8. Meist auf Java basierend Gibt es aber auch für alle anderen Sprachen Zum größten Teil Open Source Projekte

9. Sprachen des Semantic Web Sesame

10. Programmierungs-Frameworks für RDF(S) Sesame Im Februar 2000 wurde das On-To-Knowledge Forschungs-Projekts der EU ins Leben gerufen Ziel: Entwicklung von Tools und Methoden für das Semantic Web

11. Beteiligung vieler Unternehmen und Organisationen Die Firma Aduna legt in diesem Rahmen den Grundstein von Sesame

12. Als Middleware zur Speicherung und zum Abruf von RDF(S) basierter Daten und Metadaten

13. Seit dem Ende von On-To-Knowledge führt Aduna Sesame als Open-Source-Projekt weiter

14. Basiert auf Java-Technologien

15. Großer Funktionsumfang

16. http://www.openrdf.org/

17. Programmierungs-Frameworks für RDF(S) Sesame Aktuell zwei Versionsreihen (1.x und 2.x) 1.x war noch stark auf die Verwendung als Server ausgerichtet

18. 2.x (seit Ende 2007) stärker zum Einsatz als Bibliothek

19. Rückwärtskompatibilität musste aufgegeben werden

20. Sesame 2.x nutzt viele Features von Java 5 (typsichere Collections...)

21. Sesame 2.x führt Unterstützung für Kontext und Transaktionen ein

22. Programmierungs-Frameworks für RDF(S) Sesame Vollständig modularer Aufbau (Fast) Jede Komponente kann ausgetauscht, erweitert oder den persönlichen Vorlieben angepasst werden

23. Modularität wird durch Vielzahl Interface-basierter APIs erreicht

24. Programmierungs-Frameworks für RDF(S) Sesame Wichtigstes API: SAIL Storage and Inference Layer

25. Diese Schicht sorgt für die persistierung der Daten und bietet Reasoning-Dienste an

26. Durch SAIL-API wird vollständige Abstraktion erreicht

27. Für obenliegende Schichten ist es (fast) vollkommen egal, auf welche Art die Daten letztendlich gespeichert werden

28. Programmierungs-Frameworks für RDF(S) Sesame Weitere Layer Query-Layer bietet diverse Query-Engines für verschiedene Anfragesprachen (z.B.: SPARQL)

29. Repository API Zentraler Zugriffspunkt auf Sesame Repositories

30. Inhalte können abgerufen/aktualisiert werden

31. Sowohl Lokale als auch Remote Repositories ansprechbar API kümmert sich um Client-Server-Kommunikation In Version 2.x stark ausgebaut und um Kontextmechanismen (woher kommt dieses Triple) und Transaktionen erweitert Graph-API (RDF-Modell in Sesame 2.x) Programmatisches Arbeiten mit Triplen (siehe nächste Folien)

32. Programmierungs-Frameworks für RDF(S) Sesame RDF-Model von Sesame 2.x

33. Programmierungs-Frameworks für RDF(S) Sesame – Arbeiten mit dem Graph API // Erstelle einen Graph Graph myGraph = new org.openrdf.model.impl.GraphImpl( ); // Ressourcen werden mit einer ValueFactory erstellt ValueFactory myFactory = myGraph.getValueFactory( ); String namespace = “http://www.example.com/family#”; // Erstellen wir zunächst benötigte Ressourcen URI birgit = myFactory.createURI( namespace, “Birgit” ); URI hasName = myFactory.createURI( namespace, “hasName” ); Literal name = myFactory.createLiteral( “Birgit” ); // Nun können wir dieses Triple zum Graph hinzufügen myGraph.add( birgit, hasName, name ); // Aussage können auch direkt an Ressourcen angehängt werden (1.x) URI personClass = myFactory.createURI( namespace, “Person” ); URI rdfType = myFactory.createURI( org.openrdf.vocabulary.RDF.TYPE ); birgit.addProperty( rdfType, personClass );

34. Programmierungs-Frameworks für RDF(S) Sesame - Weitere Eigenschaften Sesame liefert eine Webapplikation zur Administration des Servers in Form einer WAR-Datei Deployment in einem Servlet-Container, wie zum Beispiel Tomcat REST-Webservice Zugriff mit HTTP GET, POST, DELETE, PUT

35. Client kann bei Anfrage angeben, in welchem Format er die Antwort wünscht: RDF/XML, N-Triples, Turtle, N3, TriX, … Antworten auf komplexe Queries können im SPARQL Query Result Format in XML oder JSON Form oder als binäre RDF-Ergebnis-Tabellen erfolgen Große Community steht hinter Sesame. Sesame als Backend für Ontologie-Editor Protégé

36. Sesame als Backend für Semantic Desktop Nepomuk

37. Sesame-Jena-Integrations-Schicht basierend auf SAIL

38. Wrapper / Portierungen für PHP, Python, Perl, Ruby, C# ... ...

39. Sprachen des Semantic Web Mulgara Semantic Store

40. Programmierungs-Frameworks für RDF(S) Mulgara Semantic Store Fork des Kowari-Projektes

41. Ziel: Implementierung hochskalierbarer transaktionssicherer Triple-Store-Engine nicht basierend auf relationalen Datenbanken (siehe Sesame, Jena), sondern mit eigenem rein Java-basiertem Storage-Layer

42. Open-Source-Projekt

43. Sehr aktiv (Releases etwa alle 2 Monate)

44. Basiert auf Java-Technologien

45. Großer Funktionsumfang

46. http://www.mulgara.org

47. Programmierungs-Frameworks für RDF(S) Mulgara Semantic Store Mulgara ist mehr als ein Triple-Store: Mulgara kann per RMI angesprochen werden

48. Per SAIL als Storage für Sesame verwendbar

49. Integrierter HTTP-Server SOAP Webservice

50. SPARQL-Protokoll-Endpunkt

51. Oberfläche zum einfachen Ausführen von Anfragen Parser für diverse Query-Sprachen und RDF-Serialisierungen

52. Mächtige Integrationsschnittstelle Resolver-API

53. Eigene Anfragesprache iTQL

54. Eigenes RDF-API: JRDF (stark an Sesames Graph-API angelehnt)

55. Programmierungs-Frameworks für RDF(S) Mulgara Semantic Store Mulgara Architektur:

56. Programmierungs-Frameworks für RDF(S) Mulgara – Arbeiten mit JRDF // Erstelle einen Graph (speicherbasiert) Graph myGraph = new GraphImpl( ); // Elemente werden über eine ElementFactory erstellt GraphElementFactory myFactory = myGraph.getElementFactory( ); String namespace = “http://www.example.com/family#”; // Erstellen wir zunächst benötigte Ressourcen URIReference birgit = myFactory.createResource( new URI( namespace, “Birgit” ) ); URIReference hasName = myFactory.createResource( new URI( namespace, “hasName” ); Literal name = myFactory.createLiteral( “Birgit” ); // Das fügen wir nun zu einem Triple zusammen Triple statement = myFactory.createTriple( birgit, hasName, name ); // Das Statement kann nun zum Graph hinzugefügt werden myGraph.add( statement );

57. Programmierungs-Frameworks für RDF(S) Mulgara Semantic Store - Modelltypen in Mulgara Werden bei Erzeugung des Models übergeben

58. Standard mulgara:Model Normales Model auf eigenem (XA) Store

59. XA Store performante Implementierung basierend auf B-Bäumen

60. dreiteilig aufgebaut: Node Pool: Für jede Ressource eine eindeutige numerische ID

61. String Pool: Bildet Ids des NP auf eigentliche Daten ab

62. Statement Store: Verknüpfungen zwischen Ids des NP mulgara:ViewModel Temporärer Graph der kombinierte Sicht auf mehrere Graphen gleichzeitig bietet

63. Kombination von Graphen als Vereinigung / Schnittmenge

64. Schreiben nicht möglich mulgara:Lucene Volltext-Index-Modell basierend auf Suchmaschine Lucene

65. Literale als Objekt werden direkt indiziert

66. URIs als O werden als URL behandelt und abgerufen/Inhalt indiziert

67. Anfragen hierbei mit Unschärfe möglich (Groß/Klein/Wortteile...)

68. Programmierungs-Frameworks für RDF(S) Mulgara Semantic Store - Modelltypen in Mulgara mulgara:XMLSchemaModel Datentyp-Graph

69. Enthalten konzeptuelle jede wahre Aussage für einen Datentyp

70. Beispielsweise 1<2, Heiligabend ist vor Sylvester …

71. Prädikate mulgara:lt, mulgara:gt, mulgara:after, mulgara:before mulgara:TypeModel Zur Typisierung von RDF-Knoten (Resource,Literal,B-Node)

72. Ermöglicht in Anfragen, das etwa nur Literale geliefert werden mulgara:FileSystemModel Informationen über das Dateisystem Lese-/Schreibberechtigungen

73. Dateigrößen

74. Besitzer

75. Funktionieren ähnlich wie mulgara:View

76. Programmierungs-Frameworks für RDF(S) Mulgara Semantic Store – Resolver SPI Schnittstelle zur Integration externer Inhalte

77. Plugin-fähig

78. Protokollbasiert wird ein passender Resolver gewählt

79. Resolver kümmert sich um das Empfangen von Inhalten

80. Verarbeitung von Inhalten durch ContentHandler

81. ContentHandler wird anhand des Mime-Type der Daten ermittelt

82. Passender ContentHandler liefert dann die Triple Contenthandler bereits vorhanden für RDF/XML

83. Mailbox

84. MP3

85. ...

86. Programmierungs-Frameworks für RDF(S) Mulgara Semantic Store – Resolver SPI

87. Programmierungs-Frameworks für RDF(S) Mulgara Semantic Store – Topaz Project http://www.topazproject.org

88. Java-Bibliothek zur RDF-basierten Speicherung und Arbeit mit Objekten

89. Orientiert sich sehr stark an ORM-Technologien (Object-Relational-Mapping)

90. Vorbild: Hibernate Framework

91. Idee: Persistente Daten auf dem Triple-Store sollen auf klassenbasierte Objekte abgebildet werden Objektorientierte Konzepte wie Vererbung, Komposition und Assoziation werden berücksichtigt

92. Zusätzlich: OQL Object Query Language – Anfragen basierend auf Objekten anstatt auf Triplen

93. Programmierungs-Frameworks für RDF(S) Topaz – Object-Triple-Mapping Bezug zu SW-Elementen wird per Annotation hergestellt @Entity(graph=”family”, types={“ex:Person”}) public class Person { private URI id; private String name; … @Id public void setId( URI id ){ this.id = id; } public URI getId( ) { return this.id; } @Predicate(uri=”ex:hasName”) public void setName( String name ){ this.name = name; } public String getName( ){ return this.name; } ... }

94. Programmierungs-Frameworks für RDF(S) Arbeiten mit Topaz Objekten Session session = sessFactory.openSession( ); Transaction txn = session.beginTransaction( ); URI birgitUri = URI.create( family + “Birgit” ); // Objekt erstellen Person birgit = new Person( birgitUri ); birgit.setName( “Birgit” ); birgit.setWohnort( “Allensbach” ); … // Objekt in den TripleStore schreiben session.saveOrUpdate( birgit ); … // Objekt aus dem Store abrufen und auf dessen Eigenschaften zugreifen Person person2 = session.get( Person.class, familiy+”Stephan” ); System.out.println( person2.getWohnort( ) );

95. Sprachen des Semantic Web Jena

96. Programmierungs-Frameworks für RDF(S) Jena (Seit Herbst 2009: OpenJena) Zunächst von Hewlett Packard im Rahmen des Semantic Web Research Forschungsprogramm (etwa 2000) entwickelt

97. Als Open Source Software freigegeben worden

98. Mittlerweile marktführendes Framework für die Implementierung Semantik-gestützter Applikationen

99. Riesiger Funktionsumfang

100. Einfach zu erlernendes API

101. Hervorragend dokumentiert (für ein Open Source Projekt)

102. Große Community mit Erweiterungen

103. http://www.openjena.org http://jena.sourceforge.net

104. Programmierungs-Frameworks für RDF(S) Jena – Data Abstraction Layer DAL basiert auf JDBC (Java DB Connectivity)

105. Einheitlicher Zugriff auf relationale Datenbanken zur persistenten Speicherung von Triplen

106. Gleiche Verwendung von Schnittstellen bei persistentem und speicherbasiertem Modell

107. Direkt von Jena unterstützte DBMS: MySQL, HSQLDB, PostgreSQL, Oracle, MS SQL Weitere Implementierung (z.B: IBM DB2) von Drittanbietern

108. Programmierungs-Frameworks für RDF(S) Jena – Import / Export von Graphen Große Menge unterstützter Formate: RDF/XML (ausführlich) und RDF/XML-ABBREV (abgekürzt)

109. N3 / N-TRIPLE / TURTLE

110. … RDF Parser ARP ist eigenständiges Modul Offene Schnittstelle

111. Keine Abhängigkeiten zum Rest von Jena

112. => auch für andere Frameworks verwendbar

113. Programmierungs-Frameworks für RDF(S) Jena – Inferenz API Integration einer Vielzahl von Reasonern

114. Einige Reasoner bereits in Jena vorhanden: z.B. Zur einfachen aber effizienten Schlussfolgerung über die Properties rdfs:subPropertyOf und rdfs:subClassOf

115. Aber auch andere die schon den Umgang mit einfachen OWL-Konstrukten ermöglichen Über das API wird eine mächtige Reasoning-Engine für benutzerdefinierte Regeln zur Verfügung gestellt

116. Programmierungs-Frameworks für RDF(S) Jena – Weitere interessante Features Verfolgen von Änderungen mit ModelChangedListener Interface

117. Kann einfach implementiert und beim Model angemeldet werden

118. Listener-Pattern wie z.B: beim AWT / Swing

119. Methoden werden dann bei Veränderungen des Models aufgerufen SPARQL-Implementierung ARQ Unterstützt Standard-Anfragen SELECT, CONSTRUCT, DESCRIBE und ASK Erweitert SPARQL um Modifikations-Statements (SPARQL/Update): INSERT, DELETE … Diverse Kommandozeilen-Tools Queries von der Kommandozeile aus

120. Schemagen: Ontology-Files -> Java-Source (Konstanteninterfaces) Und noch vieles mehr ...

121. Programmierungs-Frameworks für RDF(S) Jena Beispiel – Modell erstellen und füllen // Erstellen eines leeren RDF – Modells Model model = ModelFactory.createDefaultModel( ) ; // Festlegen einiger URIs String familyUri = "http://example.com/family/"; String ontology = "http://example.com/ontology#"; // Erstellen einiger Eigenschaftstypen Property hatVorname = model. createProperty ( ontology + "hasFirstName" ); Property hatWohnort = model. createProperty ( ontology + "livesInCity" ); Property istVaterVon = model. createProperty ( ontology + "isFatherOf" ); Property istSchwesterVon =model. createProperty ( ontology+"isSisterOf" ); // Erstellen der Resource "Birgit" (http://example.com/family/Birgit) Resource birgit = model. getResource ( familyUri + "Birgit" ); birgit. addProperty ( hatVorname , "Birgit" ); birgit. addProperty ( hatWohnort , "Allensbach" ); // Erstellen der Resource "Stephan" (http://example.com/family/Stephan) Resource stephan = model. getResource ( familyUri + "Stephan" ); stephan. addProperty ( hatVorname , "Stephan" ); stephan. addProperty ( hatWohnort , "Syrgenstein" );

122. Programmierungs-Frameworks für RDF(S) // Erstellen der Resource "Hans" (http://example.com/family/Hans) Resource hans = model. createResource ( familyUri + "Hans" ); hans. addProperty ( hatVorname , "Hans" ); hans. addProperty ( hatWohnort , "Syrgenstein" ); // Aussagen, dass Birgit die Schwester von Stephan ist birgit. addProperty ( istSchwesterVon, stephan ); // Aussagen, dass Hans Vater von Birgit ist hans. addProperty ( istVaterVon, birgit ); // Aussagen kann man auch direkt so erstellen: Statement statement = model. createStatement ( hans,istVaterVon,stephan ); // Man muss das Statement dann aber separat zum Model hinzufügen model. add ( statement ); // Zur Massenverarbeitung auch mit Arrays... Statement[] statements = new Statement[1]; statements[0] = statement; model.add( statements ); // … sowie mit Listen List list = new ArrayList( ); list.add( statement ); model.add( list );

123. Programmierungs-Frameworks für RDF(S) Jena Beispiel – Modell untersuchen // Gib mit alle Elemente die Vater von jemandem sind // da Subjekte immer Ressourcen sind, bekommen wir einen ResIterator ResIterator parents = model.listSubjectsWithProperty( istVaterVon ); while (parents.hasNext()) { Resource person = parents.nextResource(); // Gib die URI der Ressource aus System.out.println(person.getURI()); } // Gib mir alle Elemente, von denen jemand Vater ist // Da Objekte Literale oder Ressourcen sein können, bekommen wir einen // Node Iterator zurück NodeIterator children = model.listObjectsOfProperty( istVaterVon ); // Gib mir alle Elemente von denen Birgit Schwester ist NodeIterator siblings = model.listObjectsOfProperty( birgit, istSchwesterVon ); // Oder frag Birgit selbst (In dem Fall bekommen wir einen StmtIterator) StmtIterator moreSiblings = birgit.listProperties( istSchwesterVon );

124. Programmierungs-Frameworks für RDF(S) Jena Beispiel – Modell untersuchen 2 // Finden eines bestimmten Statements (Ist eine Aussage vorhanden) model.listStatements( birgit, istSchwesterVon, stephan ); // Gib mir alle Statements mit birgit als Subjekt, Stephan als Objekt model.listStatements( birgit, null, stephan ); // Gib mir alle Statements über Stephan model.listStatements( birgit, null, stephan ); // Gib mir alle Statements mit der istVaterVon Eigenschaft model.listStatements( null, istVaterVon, null );

125. Programmierungs-Frameworks für RDF(S) Jena Beispiel – Modelle persistieren mit Model.write() // Einfache Ausgabe des Models nach System.out in RDF/XML-Form model.write( System.out ); // Anstelle von System.out können auch andere Output-Streams stehen File file = new File( filename ); FileOutputStream fos = new FileOutputStream( file ); model.write( fos ); // Ausgabe mit abgekürzter RDF/XML Syntax model.write( fos, “RDF/XML-ABBREV” ); // Ausgabe im N-Triple-Format mit Basis-URL für relative URIs model.write( fos, “N-TRIPLE”, “http://www.example.org/” ); // Vordefinierte Formate: RDF/XML, RDF/XML-ABBREV, N-TRIPLE, TURTLE, N3

126. Programmierungs-Frameworks für RDF(S) Jena Beispiel – Modelle lesen mit Model.read( ) // Zunächst müssen wir ein Model erstellen Model model = ModelFactory.createDefaultModel( ); // FileManager verwenden um eine Eingabedatei zu finden InputStream is = FileManager.get().open( inputFileName ); // es sollte überprüft werden ob is != null ist // Nun können wir problemlos lesen (ohne Behandlung relativer URIs) model.read( is, null ); // Optional kann wieder ein RDF-Format angegeben werden model.read( is, null, “N3” ); // Vordefinierte Formate: RDF/XML, RDF/XML-ABBREV, N-TRIPLE, TURTLE, N3 // RDF/XML-ABBREV ist hier gleichbedeutend mit RDF/XML // null bedeuted wieder RDF/XML

127. Programmierungs-Frameworks für RDF(S) Jena Beispiel – Modelle verschmelzen // Zunächst erstellen wir uns 3 Modelle Model model1 = ModelFactory.createDefaultModel( ); Model model2 = ModelFactory.createDefaultModel( ); Model model3 = ModelFactory.createDefaultModel( ); // Lesen wir die Informationen aus 2 Dateien model1.read( new InputStreamReader( fileName1 ), “” ); model2.read( new InputStreamReader( fileName2 ), “” ); // Nun können wir die zwei Modelle einfach vereinen model3 = model1.union( model2 ); // Und das verschmolzene Modell wieder ausgeben model.write( System.out, “RDF/XML-ABBREV” );

128. Programmierungs-Frameworks für RDF(S) Jena Beispiel – Arbeiten mit RDF-Containern // Erstellung eines Bag Bag steiners = model.createBag( ); // Iterator für hatWohnort-Statements, bei denen Ort mit “stein” endet StmtIterator iter = model.listStatements( new SimpleSelector( null, hatWohnort, (RDFNode) null ){ public boolean selects( Statement s ) { return s.getObject().toString().endsWith( “stein” ); } } ); // holen wir uns alle Subjekte des Iterators und fügen sie der Bag hinzu while( iter.hasNext( ) ){ steiners.add( iter.nextStatement( ).getSubject( ) ); } // Die Ausgabe sieht in etwa folgendermaßen aus: // … // <rdf:Description rdf:nodeID=”A3”> // <rdf:type rdf:resource=” http://www.w3.org/1999/02/22-rdf-syntax-ns#Bag ” /> // <rdf:_1 rdf:resource=” http://www.example.com/family/Stephan ” /> // <rdf:_2 rdf:resource=”http://www.example.com/family/Hans” /> // … // </rdf:Description>

129. Programmierungs-Frameworks für RDF(S) Jena Beispiel – Arbeiten mit Persistenz // DB Parameter einstellen String M_DB_URL = “jdbc:mysql://localhost/jenatest”; String M_DB_USER = “testuser”; String M_DB_PASS = “testpass”; String M_DB = “MySQL”; String M_DBDRIVER_CLASS = “com.mysql.jdbc.Driver”; // DB Treiber Klasse laden Class.forName( M_DBDRIVER_CLASS ); // Connection zur Datenbank erstellen IDBConnection connection = new DBConnection( M_DB_URL, M_DB_USER, M_DB_PASS, M_DB ); // ModelMaker für die Connection erstellen ModelMaker maker = ModelFactory.createModelRDBMaker( connection ); // Standard Model erstellen ... Model defModel = maker.createDefaultModel(); // ... oder existierendes Modell öffnen Model existingModel = maker.openModel(); // alles weitere wie bisher – Jena kümmert sich um die Persistenz

130. Programmierungs-Frameworks für RDF(S) Jena Beispiel – Arbeiten mit Persistenz

131. Benannte Modelle: // benanntes Modell erstellen Model namedModel = maker.createModel( “MyNamedModel” ); // existierendes benanntes Modell öffnen Model previousNamedModel = maker.openModel( “MyStoredNamedModel” ); // Prüfen ob Model auf Datenbank existiert ModelRDB model; if( !connection.containsModel( modelName ) ) model = ModelRDB.createModel( connection, modelName ); else model = ModelRDB.open( connection, modelName );

132. Programmierungs-Frameworks für RDF(S) Jena - Ist auf den Rechnern im Pool F033 installiert Zum Programmieren müssen einfach die nötigen JAR-Files aus dem lib Unterverzeichnis von Jena eingebunden werden: jena.jar

133. log4j-*.jar

134. slf4j-*.jar

135. slf4j-log4j*-*.jar

136. xercesImpl.jar Unter Eclipse: Project Properties

137. Java Build-Path

138. Libraries

139. Add External JARs Happy Hacking !

140. Programmierungs-Frameworks für RDF(S) Noch Fragen ?

141. Programmierungs-Frameworks für RDF(S) Literatur: Buch “Semantic Web Grundlagen”, Springer Verlag 2008 Pascal Hitzler, Markus Krötzsch, Sebastian Rudolph, York Sure ISBN: 978-3-540-33993-9

142. Sesame Dokumentation http://www.openrdf.org/documentation.jsp

143. Mulgara Tutorial / Dokumentation http://docs.mulgara.org/ http://www.mulgara.org/trac/wiki

144. Jena RDF-API Tutorial http://openjena.org/tutorial/RDF_API/index.html

145. Umfangreiches Tutorial von IBM zu Jena: http://www.ibm.com/developerworks/xml/library/j-jena/

146. JENA API-Docs http://jena.sourceforge.net/javadoc/index.html

6 - Sprachen des Semantic Web - RDF(S) Frameworks

Weitere ähnliche Inhalte

Mehr von Steffen Schloenvoigt (14)

6 - Sprachen des Semantic Web - RDF(S) Frameworks