streamalism.org

1. Oversikt

JSON-LD er et JSON-basert RDF-format for å representere koblede data. Det gjør det mulig å utvide eksisterende JSON-objekter med hypermedia-muligheter; med andre ord muligheten til å inneholde lenker på en maskinlesbar måte.

I denne veiledningen, vi ser på et par Jackson-baserte alternativer for å serieisere og deserialisere JSON-LD-formatet direkte til POJOer. Vi vil også dekke de grunnleggende konseptene til JSON-LD som gjør det mulig for oss å forstå eksemplene.

2. Grunnleggende konsepter

Første gang vi ser et JSON-LD-dokument, merker vi at noen medlemsnavn begynner med @ karakter. Dette er JSON-LD-nøkkelord, og verdiene deres hjelper oss til å forstå resten av dokumentet.

For å navigere i JSON-LD-verdenen og for å forstå denne veiledningen, må vi være oppmerksom på fire nøkkelord:

• @kontekst er beskrivelsen av JSON-objektet som inneholder et nøkkelverdikart over alt som trengs for tolkningen av dokumentet
• @vocab er en mulig nøkkel i @kontekst som introduserer et standard ordforråd for å lage @kontekst gjenstand mye kortere
• @id er nøkkelordet for å identifisere lenker enten som en ressursegenskap som representerer den direkte lenken til selve ressursen eller som en @type verdi for å markere et felt som en lenke
• @type er nøkkelordet for å identifisere ressurstyper enten på ressursnivå eller i @kontekst; for eksempel å definere typen innebygde ressurser

3. Serialisering i Java

Før vi fortsetter, bør vi ta en titt på de tidligere veiledningene våre for å oppdatere minnet vårt om Jackson ObjectMapper, Jackson-merknader og tilpassede Jackson Serializers.

Fordi vi allerede er kjent med Jackson, kan vi innse at vi enkelt kan serieisere to tilpassede felt i hvilken som helst POJO som @id og @type bruker @JsonProperty kommentar. Derimot, skrive @kontekst for hånd kan være mye arbeid og også utsatt for feil.

Derfor, for å unngå denne feilutsatte tilnærmingen, la oss se nærmere på to biblioteker som vi kan bruke til @kontekst generasjon. Dessverre er ingen av dem i stand til å generere alle funksjonene i JSON-LD, men vi vil også se på manglene senere.

4. Serialisering med Jackson-Jsonld

Jackson-Jsonld er en Jackson-modul som gjør det mulig å kommentere POJOer på en praktisk måte for å generere JSON-LD-dokumenter.

4.1. Maven avhengigheter

La oss først legge til jackson-jsonld som en avhengighet av pom.xml:

 com.io-informatics.oss jackson-jsonld 0.1.1 

4.2. Eksempel

Så la oss lage vårt eksempel POJO og kommentere det for @kontekst generasjon:

@JsonldResource @JsonldNamespace (name = "s", uri = "//schema.org/") @JsonldType ("s: Person") @JsonldLink (rel = "s: vet", name = "vet", href = "//eksempel.com/person/2345") Person i offentlig klasse {@JsonldId privat streng-id; @JsonldProperty ("s: name") privat strengnavn; // constructor, getters, setters}

La oss dekonstruere trinnene for å forstå hva vi har gjort:

• Med @JsonldResource vi merket POJO for behandling som en JSON-LD-ressurs
• I @JsonldNamespace vi definerte en stenografi for ordforrådet vi vil bruke
• Parameteren vi spesifiserte i @JsonldType vil bli @type av ressursen
• Vi brukte @JsonldLink kommentar for å legge til lenker til ressursen. Når den behandles, Navn parameter vil bli brukt som et feltnavn og også lagt til som en nøkkel til @kontekst.href vil være feltverdien og rel vil være den tilordnede verdien i @kontekst
• Feltet vi markerte med @JsonldId vil bli den @id av ressursen
• Parameteren vi spesifiserte i @JsonldProperty blir verdien som er kartlagt til feltnavnet i @kontekst

Deretter, la oss generere JSON-LD-dokumentet.

Først bør vi registrere JsonldModule i ObjectMapper. Denne modulen inneholder en egendefinert Serializer som Jackson vil bruke til POJOer merket med @JsonldResource kommentar.

Så fortsetter vi og bruker ObjectMapper å generere JSON-LD-dokumentet:

ObjectMapper objectMapper = ny ObjectMapper (); objectMapper.registerModule (ny JsonldModule ()); Personperson = ny person ("// example.com/person/1234", "Eksempelnavn"); String personJsonLd = objectMapper.writeValueAsString (person);

Som et resultat ble den personJsonLd variabel skal nå inneholde:

{"@type": "s: Person", "@context": {"s": "//schema.org/", "name": "s: name", "vet": {"@id" : "s: vet", "@type": "@id"}}, "navn": "Eksempelnavn", "@id": "//eksempel.com/person/1234", "vet": " //eksempel.com/person/2345 "}

4.3. Hensyn

Før vi velger dette biblioteket for et prosjekt, bør vi vurdere følgende:

• Bruker @vocab nøkkelord er ikke mulig, så vi må enten bruke @JsonldNamespace å gi en stenografi for å løse feltnavn eller skrive ut den fullstendige Internationalized Resource Identifier (IRI) hver gang
• Vi kan bare definere lenker på kompileringstidspunktet, så for å legge til en kjøretid, må vi bruke refleksjon for å endre den parameteren i kommentaren.

5. Serialisering med Hydra-Jsonld

Hydra-Jsonld er en modul i Hydra-Java-biblioteket, som primært er bygget for å muliggjøre praktisk JSON-LD-responsoppretting for Spring-applikasjoner. Den bruker Hydra Vocabulary for å gjøre JSON-LD-dokumentene mer ekspressive.

derimot, Hydra-Jsonld-modulen inneholder en Jackson Serializer og noen kommentarer som vi kan bruke til å generere JSON-LD-dokumenter utenfor Spring Framework.

5.1. Maven avhengigheter

La oss først legge til avhengigheten for hydra-jsonld til pom.xml:

 de.escalon.hypermedia hydra-jsonld 0.4.2 

5.2. Eksempel

For det andre, la oss kommentere vår POJO for @kontekst generasjon.

Hydra-Jsonld genererer automatisk en standard @kontekst uten behov for merknader. Hvis vi er fornøyde med standardene, trenger vi bare å legge til @id for å få et gyldig JSON-LD-dokument.

Standardordforrådet vil være ordforrådet schema.org, @type Java klasse navn, og de offentlige eiendommene til POJO vil alle bli inkludert i det resulterende JSON-LD-dokumentet.

I dette eksemplet, la oss overstyre disse standardene med tilpassede verdier:

@Vocab ("// example.com/vocab/") @Expose ("person") offentlig klasse person {privat streng-id; privat strengnavn; // constructor @JsonProperty ("@ id") offentlig streng getId () {retur id; } @Expose ("fullName") public String getName () {return name; }}

Igjen, la oss se nærmere på trinnene som er involvert:

• Sammenlignet med Jackson-Jsonld-eksemplet utelukket vi vet felt fra vår POJO på grunn av begrensningene til Hydra-Jsonld utenfor vårrammen
• Vi setter vårt foretrukne ordforråd med @Vocab kommentar
• Ved å bruke @Avdekke kommentar på klassen, vi setter en annen ressurs @type
• Vi brukte det samme @Avdekke merknad på en eiendom for å sette kartleggingen til en tilpasset verdi i @kontekst
• For å generere @id fra en eiendom, brukte vi @JsonProperty kommentar fra Jackson

Deretter la oss konfigurere en forekomst av en Jackson Modul at vi kan registrere oss i ObjectMapper. Vi legger til JacksonHydraSerializer som en BeanSerializerModifier slik at den kan brukes på alle POJOer som blir seriellisert:

SimpleModule getJacksonHydraSerializerModule () {returner nytt SimpleModule () {@ Override public void setupModule (SetupContext context) {super.setupModule (context); context.addBeanSerializerModifier (new BeanSerializerModifier () {@Override public JsonSerializer modifySerializer (SerializationConfig config, BeanDescription beanDesc, JsonSerializer serializer) {if (serializer instanceof BeanSerializerBase) {return new JacksonHizeralizer; Serializer; Serializer; }); }}; }

Så la oss registrere Modul i ObjectMapper og bruk den. Vi bør også sette ObjectMapper å bare inkludere ikke-null verdier å produsere et gyldig JSON-LD-dokument:

ObjectMapper objectMapper = ny ObjectMapper (); objectMapper.registerModule (getJacksonHydraSerializerModule ()); objectMapper.setSerializationInclusion (JsonInclude.Include.NON_NULL); Personperson = ny person ("// example.com/person/1234", "Eksempelnavn"); String personJsonLd = objectMapper.writeValueAsString (person);

Nå, den personJsonLd variabel skal inneholde:

{"@context": {"@vocab": "//eksempel.com/vocab/", "name": "fullName"}, "@type": "person", "name": "Eksempelnavn", "@id": "//eksempel.com/person/1234"}

5.3. Hensyn

Selv om det er teknisk mulig å bruke Hydra-Jsonld utenfor Spring Framework, ble det opprinnelig designet for bruk med Spring-HATEOAS. Som et resultat er det ingen måte å generere lenker med merknader som vi så i Jackson-Jsonld. På den annen side genereres de automatisk for noen vårspesifikke klasser.

Før vi velger dette biblioteket for et prosjekt, bør vi vurdere følgende:

• Hvis du bruker den med vårrammeverket, blir det mulig med flere funksjoner
• Det er ingen enkel måte å generere lenker på hvis vi ikke bruker Spring Framework
• Vi kan ikke deaktivere bruken av @vocab, vi kan bare overstyre det

6. Deserialisering med Jsonld-Java og Jackson

Jsonld-Java er Java-implementeringen av JSON-LD 1.0-spesifikasjonen og API, som dessverre ikke er den siste versjonen.

For en implementering av 1.1-spesifikasjonsversjonen, ta en titt på Titanium JSON-LD-biblioteket.

For å deserialisere et JSON-LD-dokument, la oss transformere det med en JSON-LD API-funksjon, kalt komprimering, til et format som vi kan kartlegge til en POJO med ObjectMapper.

6.1. Maven avhengigheter

La oss først legge til avhengigheten for jsonld-java:

 com.github.jsonld-java jsonld-java 0.13.0 

6.2. Eksempel

La oss jobbe med dette JSON-LD-dokumentet som vår innspill:

{"@context": {"@vocab": "//schema.org/", "vet": {"@type": "@id"}}, "@type": "Person", "@id ":" //eksempel.com/person/1234 "," navn ":" Eksempelnavn "," vet ":" //eksempel.com/person/2345 "}

La oss for enkelhets skyld anta at vi har innholdet i dokumentet i a String variabel kalt inngangJsonLd.

La oss først komprimere den og konvertere den tilbake til en String:

Objekt jsonObject = JsonUtils.fromString (inputJsonLd); Objekt kompakt = JsonLdProcessor.compact (jsonObject, ny HashMap (), ny JsonLdOptions ()); Streng compactContent = JsonUtils.toString (kompakt);

• Vi kan analysere og skrive JSON-LD-objektet med metoder fra JsonUtils, som er en del av Jsonld-Java-biblioteket
• Når du bruker kompakt metode, som en annen parameter kan vi bruke en tom Kart. På denne måten vil komprimeringsalgoritmen produsere et enkelt JSON-objekt der nøklene løses til deres IRI-former

De kompakt Innhold variabel skal inneholde:

{"@id": "//eksempel.com/person/1234", "@type": "//schema.org/Person", "//schema.org/knows": {"@id": " //eksempel.com/person/2345 "}," //schema.org/name ":" Eksempelnavn "}

For det andre, la oss skreddersy vår POJO med Jackson-merknader slik at de passer til en slik dokumentstruktur:

@JsonIgnoreProperties (ignoreUnknown = true) Person i offentlig klasse {@JsonProperty ("@ id") privat streng-id; @JsonProperty ("// schema.org/name") privat strengnavn; @JsonProperty ("// schema.org/knows") privat link vet; // constructors, getters, setters public static class Link {@JsonProperty ("@ id") private String id; // konstruktører, getters, setters}}

Og til slutt, la oss kartlegge JSON-LD til POJO:

ObjectMapper objectMapper = ny ObjectMapper (); Personperson = objectMapper.readValue (compactContent, Person.class);

7. Konklusjon

I denne artikkelen så vi på to Jackson-baserte biblioteker for serialisering av en POJO til et JSON-LD-dokument, og en måte å deserialisere en JSON-LD til en POJO.

Som vi har fremhevet, har begge serialiseringsbibliotekene mangler som vi bør vurdere før vi bruker dem. Hvis vi trenger å bruke flere funksjoner i JSON-LD enn disse bibliotekene kan tilby, kan vi nærme oss å lage dokumentet vårt via et RDF-bibliotek med JSON-LD-utdataformat.

Som vanlig kan kildekoden bli funnet på GitHub.