streamalism.org

1. Oversigt

JSON-LD er et JSON-baseret RDF-format til repræsentation af sammenkædede data. Det muliggør udvidelse af eksisterende JSON-objekter med hypermedia-funktioner; med andre ord muligheden for at indeholde links på en maskinlæsbar måde.

I denne vejledning vi ser på et par Jackson-baserede muligheder for at serieisere og deserialisere JSON-LD-formatet direkte til POJO'er. Vi dækker også de grundlæggende begreber i JSON-LD, der gør det muligt for os at forstå eksemplerne.

2. Grundlæggende begreber

Første gang vi ser et JSON-LD-dokument, bemærker vi, at nogle medlemsnavne starter med @ Karakter. Dette er JSON-LD nøgleord, og deres værdier hjælper os med at forstå resten af ​​dokumentet.

For at navigere i JSON-LD's verden og for at forstå denne vejledning skal vi være opmærksomme på fire nøgleord:

• @sammenhæng er beskrivelsen af ​​JSON-objektet, der indeholder et nøgleværdikort over alt, hvad der er nødvendigt for fortolkningen af ​​dokumentet
• @vocab er en mulig nøgle i @sammenhæng der introducerer et standardordforråd til at lave @sammenhæng objekt meget kortere
• @id er nøgleordet til at identificere links enten som en ressourceegenskab til at repræsentere det direkte link til selve ressourcen eller som en @type værdi for at markere ethvert felt som et link
• @type er nøgleordet til at identificere ressourcetyper enten på ressource niveau eller i @sammenhæng; for eksempel at definere typen af ​​integrerede ressourcer

3. Serialisering i Java

Før vi fortsætter, skal vi se på vores tidligere tutorials for at opdatere vores hukommelse på Jackson ObjectMapper, Jackson-annotationer og brugerdefinerede Jackson Serializers.

Da vi allerede er fortrolige med Jackson, indser vi måske, at vi let kunne serieisere to brugerdefinerede felter i enhver POJO som @id og @type bruger @JsonProperty kommentar. Imidlertid, skriver @sammenhæng i hånden kunne være meget arbejde og også udsat for fejl.

Derfor, for at undgå denne fejltagende tilgang, lad os se nærmere på to biblioteker, som vi kunne bruge til @sammenhæng generation. Desværre er ingen af ​​dem i stand til at generere alle funktioner i JSON-LD, men vi vil også se på deres mangler senere.

4. Serialisering med Jackson-Jsonld

Jackson-Jsonld er et Jackson-modul, der muliggør annotering af POJO'er på en bekvem måde til at generere JSON-LD-dokumenter.

4.1. Maven afhængigheder

Lad os først tilføje jackson-jsonld som en afhængighed af pom.xml:

 com.io-informatics.oss jackson-jsonld 0.1.1 

4.2. Eksempel

Lad os derefter oprette vores eksempel POJO og kommentere det for @sammenhæng generation:

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

Lad os dekonstruere trinene for at forstå, hvad vi har gjort:

• Med @JsonldResource vi markerede POJO til behandling som en JSON-LD-ressource
• I @JsonldNamespace vi definerede en stenografi for det ordforråd, vi vil bruge
• Parameteren, vi specificerede i @JsonldType bliver til @type af ressourcen
• Vi brugte @JsonldLink kommentar for at tilføje links til ressourcen. Når det behandles, navn parameter vil blive brugt som et feltnavn og også tilføjet som en nøgle til @sammenhæng.href vil være feltværdien og rel vil være den kortlagte værdi i @sammenhæng
• Marken vi markerede med @JsonldId bliver til @id af ressourcen
• Parameteren, vi specificerede i @JsonldProperty bliver den værdi, der er kortlagt til feltets navn i @sammenhæng

Lad os derefter generere JSON-LD-dokumentet.

Først skal vi registrere JsonldModule i ObjectMapper. Dette modul indeholder en brugerdefineret Serializer som Jackson vil bruge til POJO'er markeret med @JsonldResource kommentar.

Derefter fortsætter vi og bruger ObjectMapper at generere JSON-LD-dokumentet:

ObjectMapper objectMapper = ny ObjectMapper (); objectMapper.registerModule (ny JsonldModule ()); Person person = ny person ("// eksempel.com/person/1234", "Eksempel navn"); String personJsonLd = objectMapper.writeValueAsString (person);

Som et resultat af dette personJsonLd variabel skal nu indeholde:

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

4.3. Overvejelser

Før vi vælger dette bibliotek til et projekt, skal vi overveje følgende:

• Bruger @vocab nøgleord er ikke muligt, så vi bliver enten nødt til at bruge @JsonldNamespace at give en stenografi til løsning af feltnavne eller skrive den fulde Internationalised Resource Identifier (IRI) ud hver gang
• Vi kan kun definere links på kompileringstidspunktet, så for at tilføje en link runtime skal vi bruge refleksion til at ændre denne parameter i kommentaren

5. Serialisering med Hydra-Jsonld

Hydra-Jsonld er et modul i Hydra-Java-biblioteket, som primært er bygget til at muliggøre bekvem oprettelse af JSON-LD-respons til Spring-applikationer. Det bruger Hydra-ordforrådet til at gøre JSON-LD-dokumenterne mere ekspressive.

Imidlertid, Hydra-Jsonld-modulet indeholder en Jackson Serializer og nogle kommentarer, som vi kan bruge til at generere JSON-LD-dokumenter uden for foråret.

5.1. Maven afhængigheder

Lad os først tilføje afhængigheden af hydra-jsonld til pom.xml:

 de.escalon.hypermedia hydra-jsonld 0.4.2 

5.2. Eksempel

For det andet, lad os kommentere vores POJO for @sammenhæng generation.

Hydra-Jsonld genererer automatisk en standard @sammenhæng uden behov for kommentarer. Hvis vi er tilfredse med standardindstillingerne, behøver vi kun tilføje @id for at få et gyldigt JSON-LD-dokument.

Standardordforrådet er ordforrådet schema.org, @type Java klasse navn og POJO's offentlige egenskaber vil alle blive inkluderet i det resulterende JSON-LD-dokument.

I dette eksempel lad os tilsidesætte disse standarder med brugerdefinerede værdier:

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

Lad os igen se nærmere på de involverede trin:

• Sammenlignet med Jackson-Jsonld-eksemplet udelod vi kender til felt fra vores POJO på grund af begrænsningerne i Hydra-Jsonld uden for foråret
• Vi indstiller vores foretrukne ordforråd med @Vocab kommentar
• Ved hjælp af @Udsætte kommentar på klassen, vi indstiller en anden ressource @type
• Vi brugte det samme @Udsætte kommentar på en ejendom for at indstille kortlægningen til en brugerdefineret værdi i @sammenhæng
• For at generere @id fra en ejendom brugte vi @JsonProperty kommentar fra Jackson

Lad os derefter konfigurere en forekomst af en Jackson Modul at vi kan registrere os i ObjectMapper. Vi tilføjer JacksonHydraSerializer som en BeanSerializerModifier så det kan anvendes på alle POJO'er, der er i serie:

SimpleModule getJacksonHydraSerializerModule () {returner nyt 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 JacksonHizerialer; Serializer; Serializer; }); }}; }

Lad os så registrere Modul i ObjectMapper og brug det. Vi bør også indstille ObjectMapper at kun inkludere ikke-nul værdier at fremstille et gyldigt JSON-LD-dokument:

ObjectMapper objectMapper = ny ObjectMapper (); objectMapper.registerModule (getJacksonHydraSerializerModule ()); objectMapper.setSerializationInclusion (JsonInclude.Include.NON_NULL); Person person = ny person ("// eksempel.com/person/1234", "Eksempel navn"); String personJsonLd = objectMapper.writeValueAsString (person);

Nu, den personJsonLd variabel skal indeholde:

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

5.3. Overvejelser

Selvom det er teknisk muligt at bruge Hydra-Jsonld uden for Spring Framework, blev det oprindeligt designet til brug med Spring-HATEOAS. Som et resultat er der ingen måde at generere links med kommentarer, som vi så i Jackson-Jsonld. På den anden side genereres de automatisk til nogle forårsspecifikke klasser.

Før vi vælger dette bibliotek til et projekt, skal vi overveje følgende:

• Brug af det med Spring Framework muliggør yderligere funktioner
• Der er ingen nem måde at generere links på, hvis vi ikke bruger Spring Framework
• Vi kan ikke deaktivere brugen af @vocab, vi kan kun tilsidesætte det

6. Deserialisering med Jsonld-Java og Jackson

Jsonld-Java er Java-implementeringen af ​​JSON-LD 1.0-specifikationen og API'en, som desværre ikke er den nyeste version.

For en implementering af 1.1-specifikationsversionen, se på Titanium JSON-LD-biblioteket.

For at deserialisere et JSON-LD-dokument, lad os omdanne det med en JSON-LD API-funktion, kaldet komprimering, til et format, som vi kan kortlægge til en POJO med ObjectMapper.

6.1. Maven afhængigheder

Lad os først tilføje afhængigheden af jsonld-java:

 com.github.jsonld-java jsonld-java 0.13.0 

6.2. Eksempel

Lad os arbejde med dette JSON-LD-dokument som vores input:

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

Af enkelheds skyld antager vi, at vi har indholdet af dokumentet i en Snor variabel kaldet inputJsonLd.

Lad os først komprimere det og konvertere det tilbage til en Snor:

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

• Vi kan analysere og skrive JSON-LD-objektet med metoder fra JsonUtils, som er en del af Jsonld-Java-biblioteket
• Når du bruger kompakt metode, som en anden parameter kan vi bruge en tom Kort. På denne måde producerer komprimeringsalgoritmen et simpelt JSON-objekt, hvor nøglerne løses til deres IRI-former

Det kompakt indhold variabel skal indeholde:

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

For det andet, lad os skræddersy vores POJO med Jackson-kommentarer til at passe til en sådan dokumentstruktur:

@JsonIgnoreProperties (ignoreUnknown = true) offentlig klasse Person {@JsonProperty ("@ id") privat streng-id; @JsonProperty ("// schema.org/name") privat strengnavn; @JsonProperty ("// schema.org/knows") privat link ved; // konstruktører, getters, settere offentlig statisk klasse Link {@JsonProperty ("@ id") privat String id; // konstruktører, getters, setters}}

Og endelig, lad os kortlægge JSON-LD til POJO:

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

7. Konklusion

I denne artikel kiggede vi på to Jackson-baserede biblioteker til serialisering af en POJO til et JSON-LD-dokument og en måde at deserialisere en JSON-LD til en POJO.

Som vi har fremhævet, har begge serialiseringsbiblioteker mangler, som vi bør overveje, før vi bruger dem. Hvis vi har brug for flere funktioner i JSON-LD, end disse biblioteker kan tilbyde, kan vi nærme os at oprette vores dokument via et RDF-bibliotek med JSON-LD-outputformat.

Som sædvanlig kan kildekoden findes på GitHub.