Utilisation du moteur D2RQ avec Jena

Apache Jena est un framework Java pour construire des applications Web sémantique. Le moteur D2RQ peut être utilisé comme un composant dans de telles applications pour accéder à une vue RDF virtuelle sur les données dans les bases de données relationnelles. Commentez Donner une note à l'article (5)

Article lu   fois.

Les deux et traducteurs

Traducteur : Profil ProSite personnel

Traducteur : Profil Pro

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

I. Version de Jena

Puisque D2RQ se branche sur les composants de Jena et sur son moteur de requêtes SPARQL, ARQ, il est sensible à la version de Jena et de ARQ, qui sont utilisés. D2RQ ne fonctionnera pas normalement avec d'autres versions de Jena que celles qui sont livrées avec. Regardez le répertoire /lib/arq-X.Y dans la distribution de D2RQ pour la version utilisée.

II. Installation

  1. Télécharger D2RQ.
  2. Ajouter le fichier d2rq-X.Y.jar du répertoire /lib de D2RQ à votre CLASSPATH.
  3. Ajouter l'ensemble des fichiers JAR du répertoire /lib/arq-X.Y dans le CLASSPATH de votre application.
  4. Ajouter le JAR commons-logging-X.Y.jar et slf4j-api-X.Y.jar du répertoire /lib/logging de D2RQ dans le CLASSPATH de votre application. Si votre application ne configure pas son propre système de journalisation, ajouter les autres JAR de ce répertoire.
  5. Ajouter un pilote JDBC pour votre base de données dans le CLASSPATH de votre application. Des pilotes pour quelques bases de données populaires sont disponibles dans le répertoire /lib/db-drivers de D2RQ.

Le téléchargement de D2RQ omet quelques fichiers JAR de Jena/ARQ qui ne sont pas requis pour lancer D2RQ, mais qui peuvent l'être pour utiliser d'autres fonctionnalités de Jena/ARQ. Pour avoir tous les JAR, vous pouvez télécharger la bonne version de ARQ (comme indiqué par le nom du répertoire de D2RQ /lib/arq-X.Y) à partir du site de téléchargement de Jena.

III. Journalisation

Les journaux de D2RQ utilisent l'API Apache Commons Logging. D2RQ est envoyé avec Apache log4j, mais vous pouvez utiliser une interface de journalisation différente.

Pour activer les messages de débogage de D2RQ, fixer le niveau d'enregistrement de la journalisation de.fuberlin.wiwiss.d2rq à ALL. Une façon facile de le faire est d'ajouter les JAR de log4j du répertoire /lib/logging de D2RQ au CLASSPATH de votre application, et de créer un fichier log4j.properties quelque part dans le CLASSPATH (par exemple, dans votre dossier source) avec ce contenu :

 
Sélectionnez
log4j.rootLogger=INFO, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss} %-5p %-20c{1} :: %m%n
log4j.logger.de.fuberlin.wiwiss.d2rq=ALL

IV. Utilisation de D2RQ avec l'API Model de Jena

La classe ModelD2RQ fournit une vue Model de Jena sur les données dans la base de données associée avec D2RQ.

L'exemple suivant montre comment un ModelD2RQ est mis en place en utilisant un fichier d'associations déjà créé et comment les appels à l'API Jena sont utilisés pour extraire des informations à propos des publications et de leurs auteurs à partir du Model.

 
Sélectionnez
// Mise en place de l'objet ModelD2RQ utilisant un fichier d'associations
Model m = new ModelD2RQ("file:doc/example/mapping-iswc.ttl");

// Trouver n'importe quoi avec un iswc:InProceedings pour rdf:type 
StmtIterator paperIt = m.listStatements(null, RDF.type, ISWC.InProceedings);

// Lister les publications trouvées et afficher leur titre
while (paperIt.hasNext()) {
    Resource paper = paperIt.nextStatement().getSubject();
    System.out.println("Publication: " + paper.getProperty(DC.title).getString());

    // Liste les auteurs des publications et affiche leur nom
    StmtIterator authorIt = paper.listProperties(DC.creator);
    while (authorIt.hasNext()) {
        Resource author = authorIt.nextStatement().getResource();
        System.out.println("Auteur: " + author.getProperty(FOAF.name).getString());
    }
    System.out.println();
}
m.close();

Les classes ISWC et FOAF ont été créées avec l'outil schemagen de Jena. Les classes DC et RDF font partie de Jena.

V. Utilisation de D2RQ avec l'API Graph de Jena

Dans certaines situations, il est préférable d'utiliser l'API de bas niveau Graph de Jena à la place de l'API Model. D2RQ fournit une implémentation de l'interface Graph nommée GraphD2RQ.

L'exemple suivant montre comment l'API Graph est utilisée pour trouver toutes les publications qui ont été publiées en 2003.

 
Sélectionnez
// Chargement du fichier d'associations
Model mapModel = FileManager.get().loadModel("doc/example/mapping-iswc.ttl");

// Parcourt le fichier d'associations
MapParser parser = new MapParser(mapModel, "http://localhost:2020/");
Mapping mapping = parser.parse();

// Mise en place du GraphD2RQ
GraphD2RQ g = new GraphD2RQ(mapping);

// Crée un modèle find(spo)
Node subject = Node.ANY;
Node predicate = DC.date.asNode();
Node object = Node.createLiteral("2003", null, XSDDatatype.XSDgYear);
Triple pattern = new Triple(subject, predicate, object);

// Requête sur le graphe
Iterator<Triple> it = g.find(pattern);

// Affiche les résultats de la requête
while (it.hasNext()) {
    Triple t = (Triple) it.next();
    System.out.println("Published in 2003: " + t.getSubject());
};
g.close();

V-A. CachingGraphD2RQ

En supplément de GraphD2RQ, il y a un CachingGraphD2RQ qui supporte la même API et utilise un cache LRU (Least Recently Used ou « ligne de la mémoire cache la moins récemment utilisée ») pour se rappeler un certain nombre de résultats de requêtes récentes. Ceci améliorera les performances pour les requêtes répétées, mais rapportera les résultats incohérents si la base de données est mise à jour durant la durée de vie du CachingGraphD2RQ.

VI. Exécution de requêtes SPARQL sur un ModelD2RQ

D2RQ peut répondre aux requêtes SPARQL sur un modèle D2RQ. L'exemple montre comment un modèle D2RQ est mis en place, comment une requête SPARQL est exécutée et comment les résultats sont écrits dans la console.

 
Sélectionnez
ModelD2RQ m = new ModelD2RQ("file:doc/example/mapping-iswc.ttl");
String sparql = 
    "PREFIX dc: <http://purl.org/dc/elements/1.1/>" +
    "PREFIX foaf: <http://xmlns.com/foaf/0.1/>" +
    "SELECT ?paperTitle ?authorName WHERE {" +
    "     ?paper dc:title ?paperTitle . " +
    "     ?paper dc:creator ?author ." +
    "     ?author foaf:name ?authorName ." +
    "}";
Query q = QueryFactory.create(sparql); 
ResultSet rs = QueryExecutionFactory.create(q, m).execSelect();
while (rs.hasNext()) {
    QuerySolution row = rs.nextSolution();
    System.out.println("Titre: " + row.getLiteral("paperTitle").getString());
    System.out.println("Auteur: " + row.getLiteral("authorName").getString());
};
m.close();

VII. L'assembleur D2RQ

D2RQ est livré avec un assembleur Jena. Les spécifications de l'assembleur Jena sont des fichiers de configuration RDF qui décrivent comment construire un modèle Jena. Pour plus d'information sur les assembleurs Jena, consulter la page d'initiation de l'assembleur Jena.

L'exemple suivant montre une spécification d'un assembleur pour un modèle D2RQ :

 
Sélectionnez
@prefix : <#> .
@prefix ja: <http://jena.hpl.hp.com/2005/11/Assembler#> .
@prefix d2rq: <http://www.wiwiss.fu-berlin.de/suhl/bizer/D2RQ/0.1#> .

<> ja:imports d2rq: .

:myModel
    a d2rq:D2RQModel;
    d2rq:mappingFile <mapping-iswc.ttl>;
    d2rq:resourceBaseURI <http://localhost:2020/>;
    .

Les spécifications du modèle D2RQ supportent ces deux propriétés :

d2rq:mappingFile

Requis. L'URI d'un fichier d'associations D2RQ à utiliser pour la mise en place du modèle.

d2rq:resourceBaseURI

L'URI de base pour transformer les modèles d'URI relatives en URI entières. Si non spécifiée, D2RQ choisira une URI de base appropriée.


Cet exemple d'utilisation créera un modèle D2RQ à partir d'une spécification de modèle et l'écrira dans la console :

 
Sélectionnez
// Charger une spécification d'assembleur à partir d'un fichier
Model assemblerSpec = FileManager.get().loadModel("doc/example/assembler.ttl");

// Récupérer la ressource du modèle
Resource modelSpec = assemblerSpec.createResource(assemblerSpec.expandPrefix(":myModel"));

// Assemble un modèle
Model m = Assembler.general.openModel(modelSpec);

// L'écrit dans System.out
m.write(System.out);

m.close();

VIII. Documentation Javadoc de l'API

La documentation Javadoc pour la dernière version est disponible.

IX. Remerciements

Merci à Richard Cyganiak pour son aide et ses conseils durant la réalisation de cette traduction, à Thibaut Cuvelier pour ses corrections 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 Developpez.com Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.