Sérialisation JENA OntModel Changements

Question

Je dois garder quelques Jena de modèles (OntModels, en particulier) synchronisées sur une prise, et je souhaitez faire un changement à la fois (pour diverses raisons -. étant que chaque déclaration ajouté ou supprimé des OntModels adapte également une base de règles de JESS). Je suis en mesure d'écouter les ajouter / supprimer des événements sur les OntModels puis créer des instances d'événements simples qui enveloppent les états ajoutés / supprimés en même temps avec un ChangeType qui indique que la déclaration a été ajouté ou supprimé, mais sérialisation la déclaration est avérée être problème.

Malheureusement, tous les documents de sérialisation JENA que j'ai trouvé concerne sérialisation un modèle entier au format XML / rdf / n3 / etc Puisque les instructions sont des Triples simplement de chaînes (à un niveau, de toute façon), il semble que cela devrait être trivial pour sérialiser les données au niveau des états. Cependant, Jena ne semble pas fournir une API pour créer des états avec des chaînes simples que « fait la bonne chose » . Des problèmes se posent avec les littéraux typés. par exemple:

Je peux créer l'instruction:

<http://someuri/myont#foo> <http://someuri/myont#weight> "50.7"^^www.w3.org/2001/XMLSchema#double

mais la version de chaîne que je peux sortir ressemble à ceci:

"http://someuri/myont#foo" "http://someuri/myont#weight" "50.7^^www.w3.org/2001/XMLSchema#double"

(notez l'absence d'un "avant ^^)

Ce ne serait pas beaucoup d'un problème, car le littéral peut encore être analysée avec une expression régulière, mais j'ai été incapable de créer une déclaration avec le bon littéral. L'approche évidente (ModelCon.createStatement (ressources, propriété, String)) génère une chaîne littérale typées avec la pleine valeur de la chaîne transmise.

Quelqu'un sait comment je peux fiable sérialisation (et désérialiser, bien sûr) Déclarations individuelles Jena?

Answer 1

Je sérialiser les changements dans le format N-Triples. Jena a intégré sérialiseur et analyseur N-Triples, mais la syntaxe N-Triples est (délibérément) très simple donc il serait facile de générer manuellement dans votre code.

Cependant, il pourrait être encore plus facile de garder un modèle mem plaine autour de tenir les changements, ont les gestionnaires d'événements écrivent des changements dans ce modèle, alors sérialisent ce modèle sur le fil selon votre programme de synchronisation. De même, à l'autre bout, je lisais les mises à jour du canal de synchronisation dans un modèle mem temporaire, puis yourOntModel.add( changesModel ) devrait ajouter dans les mises à jour très franchement.

Ian

Answer 2

Pas un domaine que je l'ai regardé en profondeur, mais je me suis souvenu Talis ont fait quelques recherches et a pu suivre panure au vocabulaire pertinent appelé "Changeset".

http://vocab.org/changeset/schema

Je suis surpris que vous aviez des questions déclarations individuelles sérialisation en utilisant JENA, mais peut-être si vous avez créé un graphique en fonction du schéma et changeset sérialisé le graphique que vous auriez plus de chance? Sinon, ajoutez l'instruction à un nouveau graphique et serialise un graphique d'un tripple.

Answer 3

Peut-être que vous devriez essayer de remplacer le paramètre de chaîne de createStatement par Model.createLiteral (String) ...

Answer 4

La solution que je fini avec est ci-dessous. Je fini par utiliser une approche reg-ex en raison des contraintes de temps (je ne voyais pas les autres suggestions sur cette question jusqu'à très récemment)

Ceci est sans doute pas la meilleure approche, mais il semble bien fonctionner (et je l'ai avec une Info brute suite de tests que l'exercice les cas d'utilisation que je dois traiter à ce stade).

La méthode createStatement(...) est dans une classe d'aide OntUtilities.

   /**
    * Serialization output method.
    * 
    * @param out
    * @throws IOException
    */
   private void writeObject(final ObjectOutputStream out) throws IOException {
     out.defaultWriteObject();
     out.writeObject(_statement.getSubject().getURI());
     out.writeObject(_statement.getPredicate().getURI());
     out.writeObject(_statement.getObject().toString());
   }

   /**
    * deserialization method.
    * 
    * @param in
    * @throws IOException
    * @throws ClassNotFoundException
    */
   private void readObject(final ObjectInputStream in) throws IOException, 
      ClassNotFoundException {
     in.defaultReadObject();

     final String subject = (String)in.readObject();
     final String predicate = (String)in.readObject();
     final String object = (String)in.readObject();

     _statement = OntUtilities.createStatement(subject, predicate, object);
   }

   /**
    * Creates a statement from a triple of strings.  These strings may be fully
    * qualified uris, or shortened "namespace" uris (eg: shai:TST)
    * 
    * @param sub The resource uri (the subject)
    * @param pred The predicate uri (the property)
    * @param ob The object uri.
    * @return A JENA Statement.
    */
   public static Statement createStatement(final String sub, final String pred,
         final String ob) {
      final Model m = ModelFactory.createDefaultModel();

      final String s = OntUtilities.nsUriToUri(sub);
      final String p = OntUtilities.nsUriToUri(pred);
      final String o = OntUtilities.nsUriToUri(ob);

      Statement stmt = null;
      try {
         // try making a uri as a syntax-verification step.
         new URI(o);
         // it was valid, so well use o as a resource:
         final Resource obj = m.createResource(o);
         stmt = m.createStatement(m.createResource(s), m.createProperty(p), obj);
      } catch (final URISyntaxException e) { 
         // o was *not* a uri.
         if (o.contains("^^")) {
            final int idx = o.lastIndexOf("^^");

            final String value = o.substring(0, idx);
            final String uri = o.substring(idx+2);

            final Literal lit = m.createTypedLiteral(value, getDataType(uri));

            stmt = m.createStatement(m.createResource(s), m.createProperty(p), lit);
         } else {
            // just use the string as-is:
            stmt = m.createStatement(m.createResource(s), m.createProperty(p), o);
         }
      }
      return stmt; 
   }