Introduction en français aux principes de JSON-LD, pour rendre du JSON compatible RDF et Linked Data !

1. 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 !

2. 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"
}

3. 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;

4. JSON

5. 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
}

6. [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.

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

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

9. 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

10. 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 »)

11. @context, @id, @type :
les bases

12. @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"
}

13. L’ @id des objets JSON
@id permet d'indiquer l'IRI
d'un objet JSON
{
"@context" : {
"nom" : "http://schema.org/name",
"société" : "http://schema.org/affiliation"
},
"@id" : "http://sparna.fr/qui-suis-je",
"nom" : "Thomas Francart",
"société" : "http://sparna.fr"
}

14. 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" : {
"nom" : "http://schema.org/name",
"société" : "http://schema.org/affiliation"
},
"nom" : "Thomas Francart",
"société" : { "@id" : "http://sparna.fr" }
}

15. 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"
}
},
"nom" : "Thomas Francart",
"société" : "http://sparna.fr"
}

16. 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

17. Le @type des objets JSON
@type permet d'indiquer le
rdf:type d'un objet JSON
{
"@context" : {
"nom" : "http://schema.org/name"
},
"@id" : "http://sparna.fr/qui-suis-je",
"@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)

18. Imbriquer des objets
On peut (évidemment)
imbriquer des objets
{
"@context" : {
"nom" : "http://schema.org/name",
"société" : "http://schema.org/affiliation"
},
"nom" : "Thomas Francart",
"société" : {
"@id" : "http://sparna.fr",
"nom" : "Sparna"
}
}

19. Les tableaux
Un tableau JSON permet de
spécifier plusieurs valeurs pour
la même propriété
{
"@context" : {
"nom" : "http://schema.org/name",
"profession" : "http://schema.org/jobTitle"
},
"nom" : "Thomas Francart",
"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 !

20. @vocab et les préfixes :
raccourcir les IRIs

21. Raccourcir les @type
La valeur d'un @type peut
aussi être déclarée dans le
@context
{
"@context" : {
"nom" : "http://schema.org/name",
"Personne" : "http://schema.org/Person"
},
"@id" : "http://sparna.fr/qui-suis-je",
"@type" : "Personne",
"nom" : "Thomas Francart"
}

22. @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/"
},
"@id" : "http://sparna.fr/qui-suis-je",
"@type" : "Person",
"name" : "Thomas Francart"
}

23. 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"
},
"@id" : "http://sparna.fr/qui-suis-je",
"@type" : "s:Person",
"nom" : "Thomas Francart"
}

24. 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"
},
"@id" : "http://sparna.fr/qui-suis-je",
"@type" : "schema:Person",
"nom" : "Thomas Francart",
"age" : "23"
}

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

26. @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#",
"nom" : "http://schema.org/name",
"naissance" : "http://schema.org/birthDate"
},
"nom" : "Thomas Francart",
"naissance" : {
"@value" : "1980-09-22T01:23:45+02:00",
"@type" : "xsd:dateTime"
}
}

27. @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#",
"nom" : "http://schema.org/name",
"naissance" : {
"@id" : "http://schema.org/birthDate",
"@type" : "xsd:dateTime"
}
},
"nom" : "Thomas Francart",
"naissance" : "1980-09-22T01:23:45+02:00"
}

28. @value + @language
La combinaison de @value et
@language permet de créer
des valeurs avec une langue
{
"@context" : {
"nom" : "http://schema.org/name",
"profession" : "http://schema.org/jobTitle"
},
"nom" : "Thomas Francart",
"profession" : {
"@value" : "Cultivateur de métadonnées",
"@language" : "fr"
}
}

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

30. @language des valeurs dans le
@context
On peut déclarer un
@language par défaut
{
"@context" : {
"@language" : "fr",
"nom" : "http://schema.org/name",
"profession" : "http://schema.org/jobTitle"
},
"nom" : "Thomas Francart",
"profession" : "Cultivateur de métadonnées"
}

31. @context avancé

32. 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)

33. 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/

34. 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.

35. 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));

36. 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"
}
}

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

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

39. « Compacted document form »
C’est l’inverse : on part d’un
document « expanded » et on
applique un context dessus.
{
"@context" : {
"nom" : "http://schema.org/name",
"profession" : {
"@id": "http://schema.org/jobTitle",
"@language": "fr"
}
},
"nom" : "Thomas Francart",
"profession" : "Cultivateur de métadonnées"
}
{
"http://schema.org/name" : "Thomas Francart",
"http://schema.org/jobTitle" : {
"@value" : "Cultivateur de métadonnées",
"@language": "fr"
}
}
{
"@context" : {
"nom" : "http://schema.org/name",
"profession" : {
"@id": "http://schema.org/jobTitle",
"@language": "fr"
}
}
}

40. « 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" }
]
}
]

41. 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>

42. JSON-LD
à emporter

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

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