JSON-LD

108 vues

Publié le

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

Publié dans : Technologie
0 commentaire
0 j’aime
Statistiques
Remarques
  • Soyez le premier à commenter

  • Soyez le premier à aimer ceci

Aucun téléchargement
Vues
Nombre de vues
108
Sur SlideShare
0
Issues des intégrations
0
Intégrations
1
Actions
Partages
0
Téléchargements
1
Commentaires
0
J’aime
0
Intégrations 0
Aucune incorporation

Aucune remarque pour cette diapositive

JSON-LD

  1. 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. 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. 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. 4. JSON
  5. 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. 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. 7. Les clés spéciales de JSON-LD (basiques) @context @id @value @language @type
  8. 8. Les clés spéciales de JSON-LD (avancées) @container @index @list @set @reverse @base @vocab @graph
  9. 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. 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. 11. @context, @id, @type : les bases
  12. 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. 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. 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. 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. 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. 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. 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. 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. 20. @vocab et les préfixes : raccourcir les IRIs
  21. 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. 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. 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. 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. 25. @value, @type, @language : typage et langue des valeurs
  26. 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. 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. 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. 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. 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. 31. @context avancé
  32. 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. 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. 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. 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. 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. 37. Sérialisations JSON-LD : « expended », « compacted », « flattened »
  38. 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. 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. 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. 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. 42. JSON-LD à emporter
  43. 43. • Simplicité • Compatibilité • Expressivité • Lisibilité • « Zero-Edits » (pour rendre une API JSON compatible) • Utilisable comme du RDF
  44. 44. thomas.francart@ Web de Structuration des Accès aux sparna.fr données informations connaissances

×