JSON-LD-Kontext vs. Präfixe in Jena

Question

Die JSON-LD-Spezifikation hat einen example, der einen @context-Knoten zeigt, der zum Definieren des @type eines Werts verwendet wird.

In Jena, es scheint ein @context kann durch einen von einem JsonLDWriteContextPrefixMap oder angegeben abgeleitet werden (die Einrichter für eine Java Object und einer JSON Zeichenfolge überlastet ist).

Kann dieses Beispiel in Jena mit dem Map-Ansatz erreicht werden oder benötigt es das Kontextobjekt? Gibt es ein Java Object, das übergeben werden kann, um die JsonLDWriteContext in diesem Beispiel zu erstellen, oder muss ein JSON-String analysiert werden?

Mit anderen Worten, hat Jena irgendeinen Mechanismus, um einen solchen Kontext abzuleiten, ohne dass der JSON explizit zur Verfügung gestellt wird?

{ 
    "@context": 
    { 
    "modified": 
    { 
     "@id": "http://purl.org/dc/terms/modified", 
     "@type": "http://www.w3.org/2001/XMLSchema#dateTime" 
    } 
    }, 
... 
    "@id": "http://example.com/docs/1", 
    "modified": "2010-05-29T14:17:39+02:00", 
... 
} 

Answer 1

Es ist ein detailliertes Setbeispiel bei https://github.com/apache/jena/blob/master/jena-arq/src-examples/arq/examples/riot/ExJsonLD.java

Es enthält ein Beispiel, in einem JsonLdOptions Objekt übergeben.

Answer 2

Soweit ich das beurteilen kann, muss jeder JSON-LD-Kontext, der einen typisierten Wert enthält, als String angegeben werden. Ich habe eine kleine Java-Klasse geschrieben, um die erforderliche JSON-Zeichenfolge zu generieren, indem ich einfache Präfixwerte sowie typisierte Werte einbeziehe.

import static java.util.stream.Collectors.joining; 
import static org.apache.jena.rdf.model.ResourceFactory.createResource; 
import java.util.Map; 
import java.util.TreeMap; 

public class JsonLDContext { 
    private static final String ID = "\"@id\": "; 
    private static final String TYPE = "\"@type\": "; 

    private final Map<String, String> cxt = new TreeMap<>(); 

    public JsonLDContext(){} 
    public JsonLDContext(Map<String, String> prefixes) { 
     putPrefixes(prefixes); 
    } 

    public JsonLDContext putPrefixes(Map<String, String> prefixes) { 
     prefixes.forEach(this::putPrefix); 
     return this; 
    } 

    public JsonLDContext putPrefix(String key, String value) { 
     cxt.put(key.isEmpty() ? "@vocab" : key, quote(value)); 
     return this; 
    } 

    public JsonLDContext putTypedValue(String id, String type) { 
     String key = createResource(id).getLocalName(); 
     cxt.put(key, generateJsonTypedValue(id, type)); 
     return this; 
    } 

    private static String generateJsonTypedValue(String id, String type) { 
     return '{' + ID + quote(id) + ", " + TYPE + quote(type) + '}'; 
    } 

    public String json() { 
     return cxt.entrySet().stream() 
       .map(entry -> quote(entry.getKey()) + ": " + entry.getValue()) 
       .collect(joining(", ", "{", "}")); 
    } 

    private static String quote(String s) { 
     return '"' + s + '"'; 
    } 
} 

Die obige Klasse wird wie folgt verwendet.

import org.apache.jena.query.DatasetFactory; 
import org.apache.jena.riot.JsonLDWriteContext; 
import org.apache.jena.riot.RDFDataMgr; 
import org.apache.jena.riot.RDFFormat; 
import org.apache.jena.riot.WriterDatasetRIOT; 

JsonLDWriteContext cxt = new JsonLDWriteContext(); 
cxt.setJsonLDContext(
    new JsonLDContext(/* map of prefixes */) 
     .putTypedValue("http://purl.org/dc/terms/modified", "http://www.w3.org/2001/XMLSchema#dateTime") 
     .json() 
); 
WriterDatasetRIOT writer = RDFDataMgr.createDatasetWriter(RDFFormat.JSONLD); 
writer.write(System.out, DatasetFactory.create().asDatasetGraph(), null, null, cxt);