Débuter avec Sesame

Commentez Donner une note à l'article (4)

Article lu   fois.

L'auteur

Profil ProSite personnel

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

I. Comment installer un serveur RDF Sesame ?

On a vu précédemment quelles étaient les différences entre Sesame et Jena. Voyons comment installer un serveur Sesame pour manipuler facilement des données RDF. Pas de fichiers de configuration compliqués à éditer, c'est du facile, et une fois dans l'interface d'administration Web, vous trouverez tout ce dont vous avez besoin : ajouter des fichiers RDF, faire une requête SPARQL, naviguer dans les données, etc.

Première partie : installer le serveur.

  1. Prérequis : Java doit être installé sur votre machine.
  2. Téléchargez Sesame en suivant les liens de téléchargement depuis http://www.openrdf.org (version 2.6.5 au moment de l'écriture de ces lignes) et en prenant le fichier nommé openrdf-sesame-x.y.z-sdk.zip.
  3. Téléchargez Tomcat en suivant les liens de téléchargement depuis http://tomcat.apache.org/ (version 7.0.27 au moment de l'écriture de ces lignes). Sous « Binary Distribution > Core », choisissez le format zip.
  4. Dézippez le fichier apache-tomcat-a.b.c.zip dans le répertoire de votre choix.
  5. Dézippez le fichier openrdf-sesame-x.y.z-sdk.zip dans le répertoire de votre choix.
  6. Copiez les fichiers openrdf-sesame-x.y.z/war/openrdf-sesame.war et openrdf-sesame-x.y.z/war/openrdf-workbench.war dans le répertoire apache-tomcat-a.b.c/webapps.
  7. Démarrez Tomcat à l'aide des commandes apache-tomcat-a.b.c/bin/startup.bat (ou .sh).
  8. Accédez dans votre navigateur à l'adresse http://localhost:8080/openrdf-workbench : c'est la console Web d'administration de Sesame.

Deuxième partie : paramétrer un entrepôt RDF.

  1. Dans la console d'administration, cliquez sur « New Repository » en haut à gauche.
  2. Dans le menu qui s'affiche, sélectionnez « In Memory Store », et donnez un ID et un titre à votre repository, par exemple « Test » et « Mon repository de test » ; c'est dans cet écran que vous pouvez choisir le mode de stockage du repository, dans une base, dans des fichiers, etc. Si vous avez besoin de stocker le RDF dans une base de données, c'est ici que ça doit se faire. Pour le moment, on va garder le RDF en mémoire, avec une synchronisation dans un fichier pour ne pas perdre les données en cas d'arrêt du serveur. Cliquez sur Next.
  3. Le formulaire affiche maintenant les champs « Persist Yes/No » et « Sync Delay » ; laissez « Persist » à « Yes » et entrez la valeur « 100 » pour « Sync Delay » ; cliquez sur Create.
  4. Le repository est créé et vous avez maintenant accès aux fonctions d'admin sur la gauche, notamment « Add » pour uploader des données RDF ; allez-y, vous pouvez uploader un fichier de données RDF.

Important : il faut bien comprendre que le repository Sesame est maintenant accessible comme un endpoint SPARQL. Le serveur Sesame donne de base accès aux données des repository comme des endpoints. L'URL du repository/endpoint est indiquée dans l'interface d'administration et est http://localhost:8080/openrdf-sesame/repositories/<ID_du_repository> (http://localhost:8080/openrdf-sesame/repositories/Test, si vous l'avez appelée Test). On se servira de cette URL pour accéder au repository via les API Sesame.

II. Exemple avec l'API Sesame RDF

Sesame dispose d'une API Java permettant de manipuler du RDF en mémoire, d'interroger un serveur Sesame (voir la procédure d'installation d'un serveur Sesame), ou d'interroger un endpoint SPARQL distant. Voici un « quickstart » permettant de commencer à travailler avec l'API en quelques minutes, en ajoutant les dépendances adéquates et avec un exemple de code complet. Vous pouvez également vous référer à la documentation de l'API Sesame.

II-A. JAR nécessaires

Pour utiliser l'API Sesame de manipulation de RDF dans votre programme Java, récupérer les JAR suivants :

  • depuis openrdf.org, suivez « Download > Sesame 2.x releases > here > [numéro de version de Sesame] » et téléchargez le fichier openrdf-sesame-x.y.z-onejar.jar. Attention de bien prendre le « onejar », pas le SDK ;
  • téléchargez SLF4J, dézippez-le, et extrayez slf4j-api-a.b.c.jar et slf4j-jdk14-a.b.c.jar ;
  • ajoutez à votre classpath openrdf-sesame-x.y.z-onejar.jar, slf4j-api-a.b.c.jar et slf4j-jdk14-a.b.c.jar.

Optionnellement, seulement si vous voulez vous connecter à un serveur Sesame distant ou un endpoint SPARQL (en utilisant la classe HTTPRepository), ajoutez les étapes suivantes :

  • téléchargez httpclient, en prenant le fichier commons-httpclient-3.0.zip (attention de ne pas confondre avec httpcomponents-client), et dézippez commons-httpclient-3.0.jar ;
  • téléchargez commons-logging et dézippez commons-logging-1.1.1.jar ;
  • téléchargez commons-codec et dézippez commons-codec-1.6.jar ;
  • ajoutez à votre classpath commons-httpclient-3.0.jar, commons-logging-1.1.1.jar et commons-codec-1.6.jar.

II-B. Démarrage rapide

L'exemple de code Java ci-dessous illustre l'initialisation d'un Repository, le chargement de données RDF, l'écriture de RDF dans un fichier et l'interrogation d'un serveur Sesame distant ou d'un endpoint SPARQL public. Les commentaires dans le code parlent d'eux-mêmes.

 
Sélectionnez
// I : création du Repository  

// création du Repository en mémoire.  
Repository repository = new SailRepository(new MemoryStore());    
// initialisation du Repository : cet appel est obligatoire une fois et une seule  
repository.initialize();  

// II : chargement de fichier RDF  

// le fichier RDF contenant les données à charger  
File fileToAdd = new File("/fichier/à/charger.rdf");  
// charger les données dans le Repository  
repository.getConnection().add(  
    // référence au fichier à charger  
    fileToAdd,  
    // namespace par défaut à utiliser pour les URI relatives contenues dans le RDF  
    RDF.NAMESPACE,    
    // format du fichier RDF à charger (RDF/XML, N3, TRIG, etc.)  
    // le format est déterminé dynamiquement à partir de l'extension du fichier  
    // (.rdf, .n3, .trig, etc.)  
    RDFFormat.forFileName(fileToAdd.getName())  
);  

// III : écriture de fichier RDF  

// on utilise RDFXMLWriter qui génère du RDF/XML  
repository.getConnection().export(new RDFXMLWriter(new FileOutputStream("/fichier.rdf")));  

// on peut remplacer par N3Writer pour sortir du N3  
// dans ce cas, bien mettre l'extension du fichier à .n3  
// repository.getConnection().export(new N3Writer(new FileOutputStream("/fichier.n3")));  

// IV. Connexion à un serveur Sesame ou un endpoint SPARQL distant  

// pour se connecter à un serveur Sesame : utiliser le constructeur avec 2 String  
// en donnant l'adresse du serveur et le nom du repository  
Repository sesameServer = new HTTPRepository("http://localhost:8080/openrdf-sesame","Test");  
sesameServer.initialize();  

// pour se connecter à un endpoint SPARQL public : utiliser le constructeur avec 1 String  
// en donnant l'adresse du endpoint  
Repository dbpedia = new HTTPRepository("http://dbpedia.org/sparql");  
dbpedia.initialize();

III. Exemple de requêtes SPARQL avec l'API Sesame

On a vu précédemment comment utiliser l'API Sesame depuis un programme Java, quelles dépendances étaient nécessaires et comment faire les opérations de base avec un Repository : initialiser, charger des données, écrire des données.

Voilà maintenant comment effectuer des requêtes SPARQLSELECT et CONSTRUCT sur un Repository, et traiter les résultats. Les deux types de query utilisent des objets différents : TupleQuery et TupleQueryResultSELECT pour les SELECT, GraphQuery et GraphQueryResultCONSTRUCT pour les CONSTRUCT. Les commentaires dans le code ci-dessous parlent d'eux-mêmes, et n'hésitez pas à vous reporter à la documentation des API Sesame pour d'autres exemples.

 
Sélectionnez
// création du Repository en mémoire.
Repository repository = new SailRepository(new MemoryStore());    
// initialisation du Repository : cet appel est obligatoire une fois et une seule  
repository.initialize();  

// on ouvre une connexion au repository  
// comme en JDBC, c'est à travers cette connexion que sont envoyées toute les requêtes  
RepositoryConnection connection = repository.getConnection();  

// I. exemple de Query SELECT  

// on initialise la query.  
TupleQuery selectQuery = connection.prepareTupleQuery(    
    QueryLanguage.SPARQL,  
    "SELECT ?x ?foafName WHERE { ?x <http://xmlns.com/foaf/0.1/name> ?foafName }"    
);  

// on l'exécute 
TupleQueryResult selectQueryResult = selectQuery.evaluate();  

// on itère sur les résultats  
while(selectQueryResult.hasNext()) {  
    // chaque ligne du résultat est un BindingSet  
    BindingSet aBinding = selectQueryResult.next();  

    // on print les valeurs de cette ligne  
    System.out.println("Personne "+aBinding.getValue("x")+" a pour nom "+aBinding.getValue("foafName"));  

    // si on ne connaît pas les noms de variables de la query, on peut les récupérer dynamiquement  
    for (String aBindingName : selectQueryResult.getBindingNames()) {  
        System.out.println("La valeur de "+aBindingName+" est "+aBinding.getValue(aBindingName));  
    }  
}  

// II. Exemple de Query CONSTRUCT  

// on initialise la query  
GraphQuery constructQuery = connection.prepareGraphQuery(  
    QueryLanguage.SPARQL,  
    "PREFIX foaf: <http://xmlns.com/foaf/0.1/> " +    
    "PREFIX vcard: <http://www.w3.org/2006/vcard/ns#>" +  
    "CONSTRUCT {?x vcard:n _:n . _:n vcard:given-name ?name .} WHERE { ?x foaf:name ?name }"  
);  

// on l'exécute  
GraphQueryResult constructQueryResult = constructQuery.evaluate();  

// on itère sur les résultats, qui sont des Statements RDF, pas des bindings  
while(constructQueryResult.hasNext()) {  
    Statement anRDFStatement = constructQueryResult.next();  
    // ici on se contente d'afficher le Statement  
    // typiquement on devrait en faire quelque chose : écrire dans un fichier, ou  
    // l'insérer dans un autre Repository, etc.  
    System.out.println(anRDFStatement);  
}  

// quand on n'a plus besoin de la connexion, on la ferme  
connection.close();

IV. Remerciements

Articles originaux :

De Thomas Francart que nous remercions pour son autorisation de reproduire son article sur Developpez.com. Merci à Julien Plu pour la mise en page et à ClaudeLELOUP et jacques_jean pour leur relecture orthographique.

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Copyright © 2012-2016 Thomas Francart. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.