Cómo convertir RDF a JSON bastante anidado usando java rdf4j

json-ld

Question

Tengo un archivo RDF simple y quiero convertirlo a un buen JSON anidado.

:b0 a <http://schema.org/Book> ;
<http://schema.org/name> "Semantic Web Primer (First Edition)" ;
<http://schema.org/offers> _:b1 ;
<http://schema.org/publisher> "Linked Data Tools" .
_:b1 a <http://schema.org/Offer> ;
<http://schema.org/price> "2.95" ;
<http://schema.org/priceCurrency> "USD" .

debe convertirse

{
"type" : "Book",
"name" : "Semantic Web Primer (First Edition)",
"offers" : {
"type" : "Offer",
"price" : "2.95",
"priceCurrency" : "USD"
},
"publisher" : "Linked Data Tools"
}

Answer 1

Usar enmarcado

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.StringWriter;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.eclipse.rdf4j.model.Statement;
import org.eclipse.rdf4j.rio.RDFFormat;
import org.eclipse.rdf4j.rio.RDFHandlerException;
import org.eclipse.rdf4j.rio.RDFParser;
import org.eclipse.rdf4j.rio.RDFWriter;
import org.eclipse.rdf4j.rio.Rio;
import org.eclipse.rdf4j.rio.helpers.StatementCollector;
import org.junit.Test;
import com.github.jsonldjava.core.JsonLdOptions;
import com.github.jsonldjava.core.JsonLdProcessor;
import com.github.jsonldjava.utils.JsonUtils;
import com.google.common.base.Charsets;
public class HowToConvertRdfToJson {
@Test
public void convertRdfToPrettyJson(){
try(InputStream in = Thread.currentThread().getContextClassLoader().getResourceAsStream("book.ttl")){
System.out.println(getPrettyJsonLdString(in,RDFFormat.TURTLE));
}catch(Exception e){
throw new RuntimeException(e);
}
}
/**
* @param in Input stream with rdf data
* @param format format of the rdf data
* @return a pretty JSON document as String
*/
public static String getPrettyJsonLdString(InputStream in, RDFFormat format) {
return getPrettyJsonLdString(
readRdfToString(in, format, RDFFormat.JSONLD, ""));
}
/**
* @param statements rdf statements collected
* @return a pretty JSON document as String
*/
public static String getPrettyJsonLdString(Collection<Statement> statements) {
return getPrettyJsonLdString(
graphToString(statements, RDFFormat.JSONLD));
}
private static String getPrettyJsonLdString(String rdfGraphAsJson) {
try {
//@formatter:off
return JsonUtils
.toPrettyString(
removeGraphArray(
getFramedJson(
createJsonObject(
rdfGraphAsJson))));
//@formatter:on
} catch (Exception e) {
throw new RuntimeException(e);
}
}
private static Map<String, Object> removeGraphArray(Map<String, Object> framedJson) {
List<Map<String,Object>> graph = (List<Map<String, Object>>) framedJson.get("@graph");
return graph.get(0);
}
private static Map<String, Object> getFramedJson(Object json) {
try {
return JsonLdProcessor.frame(json, getFrame(), new JsonLdOptions());
} catch (Exception e) {
throw new RuntimeException(e);
}
}
private static Map<String, Object> getFrame() {
Map<String, Object> context = new HashMap<>();
context.put("@context", "http://schema.org/");
return context;
}
private static Object createJsonObject(String ld) {
try (InputStream inputStream =
new ByteArrayInputStream(ld.getBytes(Charsets.UTF_8))) {
Object jsonObject = JsonUtils.fromInputStream(inputStream);
return jsonObject;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static Collection<Statement> readRdfToGraph(
final InputStream inputStream, final RDFFormat inf,
final String baseUrl) {
try {
final RDFParser rdfParser = Rio.createParser(inf);
final StatementCollector collector = new StatementCollector();
rdfParser.setRDFHandler(collector);
rdfParser.parse(inputStream, baseUrl);
return collector.getStatements();
} catch (final Exception e) {
throw new RuntimeException(e);
}
}
public static String readRdfToString(InputStream in, RDFFormat inf,
RDFFormat outf, String baseUrl) {
Collection<Statement> myGraph = null;
myGraph = readRdfToGraph(in, inf, baseUrl);
return graphToString(myGraph, outf);
}
public static String graphToString(Collection<Statement> myGraph,
RDFFormat outf) {
StringWriter out = new StringWriter();
RDFWriter writer = Rio.createWriter(outf, out);
try {
writer.startRDF();
for (Statement st : myGraph) {
writer.handleStatement(st);
}
writer.endRDF();
} catch (RDFHandlerException e) {
throw new RuntimeException(e);
}
return out.getBuffer().toString();
}
}

Huellas dactilares

{
"id" : "_:b0",
"type" : "Book",
"name" : "Semantic Web Primer (First Edition)",
"offers" : {
"id" : "_:b1",
"type" : "Offer",
"price" : "2.95",
"priceCurrency" : "USD"
},
"publisher" : "Linked Data Tools"
}

Con pom

<dependency>
<groupId>org.eclipse.rdf4j</groupId>
<artifactId>rdf4j-runtime</artifactId>
<version>2.2</version>
<type>pom</type>
</dependency>
<dependency>
<groupId>com.github.jsonld-java</groupId>
<artifactId>jsonld-java</artifactId>
<version>0.10.0</version>
</dependency>