JSON-LD

JSON-LD
Thomas Francart,
Ce travail est réutilisable et modifiable librement, y compris à des fins commerciales, à condition de
citer son auteur et d’être placé sous la même licence. Pour plus d’informations, voir la licence.
Put « Linked Data » in your JSON !

JSON-LD
est une façon d'écrire
des données liées (=
du RDF) en JSON.
{
"@context": "http://json-ld.org/contexts/person.jsonld",
"@id": "http://dbpedia.org/resource/John_Lennon",
"name": "John Lennon",
"born": "1940-10-09",
"spouse": "http://dbpedia.org/resource/Cynthia_Lennon"
}

JSON-LD permet :
• de rendre compatible
des API JSON existantes
avec les données liées;
• d’inclure facilement des
données liées dans du
HTML;

Des accolades indiquent un
objet
Les chaines de caractères
sont entre guillemets
doubles
Les propriétés des objets
sont indiquées avec une
clé, deux-points, et une
valeur.
Les propriétés sont
séparées par des virgules
{un objet}
"string"
{
"clé1": valeur1,
"clé2": valeur2
}

[truc1,
truc2, truc3]
{
"nom": "Francart",
"prénoms": ["Thomas", "André", "Maurice"],
"adresse": {
"numéro": "10",
"voie": "Allée de montrichard",
"cp": "37000",
"ville": "Tours"
}
}
Un crochet indique une
liste (de chaines de
caractères ou d'objets)
Les valeurs des clés sont
soit des chaines de
caractères, soit des
objets, soit des listes.

Les clés spéciales de JSON-LD
(basiques)
@context
@id
@value
@language
@type

Les clés spéciales de JSON-LD
(avancées)
@container
@index
@list
@set
@reverse
@base
@vocab
@graph

Vite ! Un exemple
{
"@context":
{
"name": "http://schema.org/name",
"image": {
"@id": "http://schema.org/image",
"@type": "@id"
},
"homepage": {
"@id": "http://schema.org/url",
"@type": "@id"
}
},
"name": "Manu Sporny",
"homepage": "http://manu.sporny.org/",
"image": "http://manu.sporny.org/images/manu.png"
}
« name » est un raccourci pour
http://schema.org/name
« image » est un raccourci
pour schema:image et doit être
interprété comme une URI

Vite ! Un test
http://json-ld.org/playground
_:b0 <http://schema.org/image> <http://manu.sporny.org/images/manu.png> .
_:b0 <http://schema.org/name> "Manu Sporny" .
_:b0 <http://schema.org/url> <http://manu.sporny.org/> .
Du JSON-LD est interprété
comme des triplets RDF
(onglet « N-QUADS »)

@context, @id, @type :
les bases

@context
Le contexte défini un
mapping des clés JSON
vers des IRIs
{
"@context" : {
"nom" : "http://schema.org/name",
"société" : "http://schema.org/affiliation"
},
"nom" : "Thomas Francart",
"société" : "http://sparna.fr"
}

L’ @id des objets JSON
@id permet d'indiquer l'IRI
d'un objet JSON
{
"@context" : {
},
"@id" : "http://sparna.fr/qui-suis-je",
}

les IRIs avec @id
Les valeurs de la clé @id
sont converties en IRI.
On peut ainsi spécifier des valeurs
de clé IRI et non pas chaines de
caractères.
{
"@context" : {
},
"société" : { "@id" : "http://sparna.fr" }
}

les IRIs avec @id
On peut spécifier que les
valeurs d’une clé sont toujours
des IRIs en indiquant dans le
contexte "@type" : "@id"
{
"@context" : {
"name" : "http://schema.org/name",
"société" : {
"@id" : "http://schema.org/url",
"@type" : "@id"
}
},
}

les IRIs des propriétés
Les clés de valeurs en JSON-LD /
RDF sont toujours des IRIs
• soit parce qu'on les a mappé dans le contexte
• soit si la clé est déjà une IRI
{
…
"http://schema.org/affiliation" : "http://sparna.fr"
}
Toutes les clés JSON qui ne se ramènent pas à des IRIs
sont ignorées lors de l’interprétation du JSON-LD

Le @type des objets JSON
@type permet d'indiquer le
rdf:type d'un objet JSON
{
"@context" : {
"nom" : "http://schema.org/name"
},
"@type" : "http://schema.org/Person",
"nom" : "Thomas Francart"
}
Les valeurs de @type sont toujours interprétées comme des
IRIs (comme les valeurs de @id)

Imbriquer des objets
On peut (évidemment)
imbriquer des objets
{
"@context" : {
},
"société" : {
"@id" : "http://sparna.fr",
"nom" : "Sparna"
}
}

Les tableaux
Un tableau JSON permet de
spécifier plusieurs valeurs pour
la même propriété
{
"@context" : {
"profession" : "http://schema.org/jobTitle"
},
"profession" : [
"Philosophe des métadonnées",
"Machiniste dans les usines d'information"
]
}
Attention, le tableau JSON ordonné est donc interprété de
façon non-ordonnée !

@vocab et les préfixes :
raccourcir les IRIs

Raccourcir les @type
La valeur d'un @type peut
aussi être déclarée dans le
@context
{
"@context" : {
"Personne" : "http://schema.org/Person"
},
"@type" : "Personne",
}

@vocab
@vocab indique, dans le
contexte, la racine d'IRI pour
toutes les clés et les valeurs de
type qui n'auraient pas pu
être converties en IRI
{
"@context" : {
"@vocab" : "http://schema.org/"
},
"@type" : "Person",
"name" : "Thomas Francart"
}

Les préfixes
Les IRIs peuvent aussi être
écrites sous forme
"prefixe:truc", si le préfixe a
été déclaré dans le contexte
{
"@context" : {
"s" : "http://schema.org/",
"nom" : "s:name"
},
"@type" : "s:Person",
}

Les préfixes
Les préfixes permettent de
travailler avec plusieurs
vocabulaires de façon plus
simple
{
"@context" : {
"schema" : "http://schema.org/",
"foaf" : "http://xmlns.com/foaf/0.1/",
"nom" : "schema:name",
"age" : "foaf:age"
},
"@type" : "schema:Person",
"age" : "23"
}

@value, @type, @language :
typage et langue des
valeurs

@value + @type
La combinaison de @value et
@type permet de créer des
valeurs avec des datatypes :
{
"@context" : {
"xsd" : "http://www.w3.org/2001/XMLSchema#",
"naissance" : "http://schema.org/birthDate"
},
"naissance" : {
"@value" : "1980-09-22T01:23:45+02:00",
"@type" : "xsd:dateTime"
}
}

@type des valeurs dans le @context
On peut déclarer le @type
des valeurs d’une clé dans le
contexte (comme pour @id)
{
"@context" : {
"xsd" : "http://www.w3.org/2001/XMLSchema#",
"naissance" : {
"@id" : "http://schema.org/birthDate",
"@type" : "xsd:dateTime"
}
},
"naissance" : "1980-09-22T01:23:45+02:00"
}

@value + @language
La combinaison de @value et
@language permet de créer
des valeurs avec une langue
{
"@context" : {
},
"profession" : {
"@value" : "Cultivateur de métadonnées",
"@language" : "fr"
}
}

@language des valeurs dans le
@context
On peut déclarer le @language
des valeurs d’une clé dans le
contexte (comme pour @id)
{
"@context" : {
"profession" : {
"@id" : "http://schema.org/jobTitle",
"@language" : "fr"
}
},
"profession" : "Cultivateur de métadonnées"
}

@language des valeurs dans le
@context
On peut déclarer un
@language par défaut
{
"@context" : {
"@language" : "fr",
},
}

Comment spécifier le @context
Il y a 4 façons d’indiquer le
@context :
1.Inline
2.Par une URL
3.Par une entête HTTP (pour une API
JSON)
4.Au moment de parser le JSON
(dans du code)

Spécifier le @context par URL
{
"@context": "http://schema.org",
"@id": "http://dbpedia.org/resource/John_Lennon",
"name": "John Lennon",
“@type": “Person",
“jobTitle”: “Scarabée numéro 1”
}
Schema.org fournit son context JSON-LD. Pour le voir :
curl --header "Accept: application/ld+json" http://schema.org/

Spécifier le @context par entête
HTTP
GET /ordinary-json-document.json HTTP/1.1
Host: example.com
Accept: application/ld+json,application/json,*/*;q=0.1
====================================
HTTP/1.1 200 OK
...
Content-Type: application/json
Link: <http://json-ld.org/contexts/person.jsonld>;
rel="http://www.w3.org/ns/json-ld#context"; type="application/ld+json"
{
"name": "Markus Lanthaler",
"homepage": "http://www.markus-lanthaler.com/",
"image": "http://twitter.com/account/profile_image/markuslanthaler"
}
Permet de rendre des API JSON compatibles « Linked
Data » sans y toucher, en ajoutant simplement une entête
dans la réponse.

Spécifier le @context par API
API « jsonld-java » (
https://github.com/jsonld-java/jsonld-java)
Intégrée dans RDF4J
// Open a valid json(-ld) input file
InputStream inputStream = new FileInputStream("input.json");
// Read the file into an Object (The type of this object will be a List, Map, String, Boolea
// Number or null depending on the root object in the file).
Object jsonObject = JsonUtils.fromInputStream(inputStream);
// Create a context JSON map containing prefixes and definitions
Map context = new HashMap();
// Customise context... //
Create an instance of JsonLdOptions with the standard JSON-LD options
JsonLdOptions options = new JsonLdOptions();
// Customise options...
// Call whichever JSONLD function you want! (e.g. compact)
Object compact = JsonLdProcessor.compact(jsonObject, context, options);
// Print out the result (or don't, it's your call!)
System.out.println(JsonUtils.toPrettyString(compact));

Surcharger les @context
On peut spécifier plusieurs
@context. Les @context se
surchargent et le dernier
déclaré gagne.
{
"@context" : "http://schema.org",
"name" : "Thomas Francart",
"@type" : "Person",
"affiliation" : {
"@context" : {
"name" : "http://xmlns.com/foaf/0.1/"
},
"name" : "Sparna"
}
}

Sérialisations JSON-LD :
« expended »,
« compacted »,
« flattened »

« Expanded document form »
Etendre toutes les IRIs, les types et
les valeurs d’un document pour
se passer du @context
{
"@context" : {
"profession" : {
"@id": "http://schema.org/jobTitle",
"@language": "fr"
}
},
}
{
"http://schema.org/name" : "Thomas Francart",
"http://schema.org/jobTitle" : {
"@language": "fr"
}
}

« Compacted document form »
C’est l’inverse : on part d’un
document « expanded » et on
applique un context dessus.
{
"@context" : {
"profession" : {
"@language": "fr"
}
},
}
{
"http://schema.org/name" : "Thomas Francart",
"http://schema.org/jobTitle" : {
"@language": "fr"
}
}
{
"@context" : {
"profession" : {
"@language": "fr"
}
}
}

« flattened document form »
Donne un @id à tous les objets,
regroupe toutes les propriétés des
objets ensemble, et mets tous les
objets à plat
{
"@context": {
“name": "http://xmlns.com/foaf/0.1/name",
"knows": "http://xmlns.com/foaf/0.1/knows"
},
"@id": "http://sparna.fr/qui-suis-je/”
"name": “Thomas Francart",
"knows": [
{
"@id": "http://inserm.fr/jean-charlet",
"name": “Jean Charlet"
},
{
"name": “Jean Delahousse"
}
]
}
{
"@context": {
"name": "http://xmlns.com/foaf/0.1/name",
"knows": "http://xmlns.com/foaf/0.1/knows"
},
"@graph": [
{
"@id": "_:b0",
"name": “Jean Delahousse"
},
{
"@id": “http://inserm.fr/jean-charlet",
"name": “Jean Charlet"
},
{
"@id": "http://sparna.fr/qui-suis-je/",
"name": “Thomas Francart",
"knows": [
{ "@id": "http://inserm.fr/jean-charlet" },
{ "@id": "_:b0" }
]
}
]

Inclure du JSON-LD dans du HTML
On inclut le JSON-LD dans une
balise HTML <script> avec le
type « application/ld+json »
<head> (ou <body>)
…
<script type="application/ld+json">
{
"@context" : "http://schema.org",
"name" : "Thomas Francart",
"@type" : "Person",
}
</script>
…
</head>

• Simplicité
• Compatibilité
• Expressivité
• Lisibilité
• « Zero-Edits » (pour rendre une API JSON compatible)
• Utilisable comme du RDF

thomas.francart@
Web de
Structuration des
Accès aux
sparna.fr
données
informations
connaissances

JSON-LD

Contenu connexe

Tendances

Similaire à JSON-LD

Plus de Thomas Francart

JSON-LD