Bygg en API med Spark Java Framework

1. Introduksjon

I denne artikkelen vil vi ha en rask introduksjon til Spark framework. Spark framework er et raskt rammeverk for utvikling av nettet inspirert av Sinatra-rammeverket for Ruby og er bygget rundt Java 8 Lambda Expression-filosofi, noe som gjør det mindre ordentlig enn de fleste applikasjoner skrevet i andre Java-rammer.

Det er et godt valg hvis du vil ha en Node.js som erfaring når du utvikler et web-API eller mikrotjenester i Java. Med Spark kan du ha en REST API klar til å servere JSON i mindre enn ti kodelinjer.

Vi får en rask start med et “Hello World” -eksempel, etterfulgt av et enkelt REST API.

2. Maven-avhengigheter

2.1. Spark Framework

Inkluder følgende Maven-avhengighet i din pom.xml:

 com.sparkjava gnistkjerne 2.5.4 

Du finner den nyeste versjonen av Spark på Maven Central.

2.2. Gson-biblioteket

På forskjellige steder i eksemplet vil vi bruke Gson-biblioteket for JSON-operasjoner. For å inkludere Gson i prosjektet ditt, inkluder denne avhengigheten i din pom.xml:

 com.google.code.gson gson 2.8.0 

Du finner den nyeste versjonen av Gson på Maven Central.

3. Komme i gang med Spark Framework

La oss ta en titt på de grunnleggende byggesteinene i et Spark-program og demonstrere en rask nettjeneste.

3.1. Ruter

Webtjenester i Spark Java er bygd på ruter og deres håndterere. Ruter er viktige elementer i Spark. I henhold til dokumentasjonen består hver rute av tre enkle brikker - a verb, a sti, og en Ring tilbake.

  1. De verb er en metode som tilsvarer en HTTP-metode. Verbmetoder inkluderer: få, post, put, delete, head, trace, connect, og alternativer
  2. De sti (også kalt rutemønster) bestemmer hvilken URI (r) ruten skal lytte til og gi et svar på
  3. De Ring tilbake er en behandlerfunksjon som påkalles for et gitt verb og bane for å generere og returnere et svar på den tilsvarende HTTP-forespørselen. En tilbakeringing tar et forespørselobjekt og svarobjekt som argumenter

Her viser vi den grunnleggende strukturen for en rute som bruker verb:

få ("/ din-rute-sti /", (forespørsel, svar) -> {// din tilbakeringingskode});

3.2. Hello World API

La oss lage en enkel webtjeneste som har to ruter for GET-forespørsler og returnerer "Hello" -meldinger som svar. Disse rutene bruker metode, som er en statisk import fra klassen gnist. gnist:

importer statisk gnist.Spark. *; offentlig klasse HelloWorldService {public static void main (String [] args) {get ("/ hallo", (req, res) -> "Hello, world"); get ("/ hallo /: navn", (req, res) -> {return "Hello," + req.params (": name");}); }}

Det første argumentet til metoden er stien for ruten. Den første ruten inneholder en statisk sti som kun representerer en enkelt URI ("/Hallo").

Stien til den andre ruten (“/ Hallo /: navn”) inneholder en plassholder for "Navn" parameter, som angitt ved å foran parameteren med et kolon (“:”). Denne ruten vil bli påkalt som svar på GET-forespørsler til URI-er som “/ Hallo / Joe” og “/ Hallo / Mary”.

Det andre argumentet til metoden er et lambdauttrykk som gir en funksjonell programmeringssmak til dette rammeverket.

Lambdauttrykket har forespørsel og respons som argumenter og hjelper til med å returnere svaret. Vi vil sette kontrollerlogikken vår i lambda-uttrykket for REST API-rutene, som vi skal se senere i denne opplæringen.

3.3. Testing av Hello World API

Etter å ha kjørt klassen HelloWorldService som en vanlig Java-klasse, vil du kunne få tilgang til tjenesten på standardporten til 4567 ved hjelp av rutene som er definert med metoden ovenfor.

La oss se på forespørselen og svaret for den første ruten:

Be om:

FÅ // localhost: 4567 / hei

Respons:

Hei Verden

La oss teste den andre ruten, forbi Navn parameter i sin bane:

Be om:

FÅ // localhost: 4567 / hallo / baeldung

Respons:

Hei, baeldung

Se hvordan plasseringen av teksten “Baeldung” i URI ble brukt til å matche rutemønsteret “/ Hallo /: navn” - forårsaker at den andre ruteens funksjon for tilbakeringingsbehandling behandles

4. Designe en RESTful Service

I denne delen vil vi designe en enkel REST-nettjeneste for følgende Bruker enhet:

offentlig klasse bruker {privat streng-id; privat streng fornavn; privat streng etternavn; privat streng e-post; // konstruktører, getters og setters}

4.1. Ruter

La oss liste opp rutene som utgjør API-en vår:

  • GET / brukere - få liste over alle brukere
  • GET / brukere /: id - få bruker med gitt ID
  • POST / brukere /: id - legg til en bruker
  • PUT / brukere /: id - rediger en bestemt bruker
  • ALTERNATIVER / brukere /: id - sjekk om en bruker eksisterer med gitt ID
  • SLETT / brukere /: id - slett en bestemt bruker

4.2. Brukertjenesten

Nedenfor er UserService grensesnitt som erklærer CRUD-operasjoner for Bruker enhet:

offentlig grensesnitt UserService {public void addUser (brukerbruker); offentlig samling GetUsers (); offentlig bruker getUser (streng-id); offentlig brukerredigeringBruker (brukerbruker) kaster UserException; offentlig ugyldig deleteUser (streng-id); offentlig boolsk brukerExist (streng-id); }

For demonstrasjonsformål tilbyr vi en Kart implementering av dette UserService grensesnitt i GitHub-koden for å simulere utholdenhet. Du kan levere din egen implementering med databasen og utholdenhetslaget du ønsker.

4.3. JSON-responsstrukturen

Nedenfor er JSON-strukturen til svarene som brukes i vår REST-tjeneste:

{status: melding: data:}

De status feltverdien kan være enten SUKSESS eller FEIL. De data feltet vil inneholde JSON-representasjonen av returdataene, for eksempel en Bruker eller samling av Brukere.

Når det ikke blir returnert data, eller hvis status er FEIL, vil vi fylle ut beskjed felt for å formidle en årsak til feilen eller mangelen på returdata.

La oss representere ovennevnte JSON-struktur ved hjelp av en Java-klasse:

offentlig klasse StandardResponse {privat StatusResponse status; privat strengmelding; private JsonElement-data; public StandardResponse (StatusResponse status) {// ...} public StandardResponse (StatusResponse status, String message) {// ...} public StandardResponse (StatusResponse status, JsonElement data) {// ...} // getters and setters }

hvor Statussvar er en enum definert som nedenfor:

offentlig enum StatusResponse {SUCCESS ("Suksess"), FEIL ("Feil"); privat strengstatus; // konstruktører, getters}

5. Implementering av RESTful Services

La oss nå implementere rutene og håndtererne for REST API.

5.1. Opprette kontrollere

Følgende Java-klasse inneholder rutene for API-en vår, inkludert verbene og banene og en oversikt over håndtererne for hver rute:

offentlig klasse SparkRestExample {public static void main (String [] args) {post ("/ users", (forespørsel, svar) -> {// ...}); get ("/ brukere", (forespørsel, svar) -> {// ...}); get ("/ brukere /: id", (forespørsel, svar) -> {// ...}); put ("/ brukere /: id", (forespørsel, svar) -> {// ...}); delete ("/ brukere /: id", (forespørsel, svar) -> {// ...}); alternativer ("/ brukere /: id", (forespørsel, svar) -> {// ...}); }}

Vi vil vise full implementering av hver rutebehandler i de følgende underavsnittene.

5.2. Legg til bruker

Nedenfor er post metoden svarhåndterer som vil legge til Bruker:

post ("/ brukere", (forespørsel, svar) -> {respons.type ("applikasjon / json"); brukerbruker = ny Gson (). fraJson (forespørsel.kropp (), bruker.klasse); brukerService.addUser (bruker); returner nye Gson () .toJson (nye StandardResponse (StatusResponse.SUCCESS));});

Merk: I dette eksemplet er JSON-representasjonen av Bruker objektet sendes som den rå kroppen til en POST-forespørsel.

La oss teste ruten:

Be om:

POST // localhost: 4567 / brukere {"id": "1012", "email": "[email protected]", "firstName": "Mac", "lastName": "Mason1"}

Respons:

{"status": "SUKSESS"}

5.3. Få alle brukere

Nedenfor er metoden svarbehandler som returnerer alle brukere fra UserService:

få ("/ brukere", (forespørsel, svar) -> {respons.type ("applikasjon / json"); returnere ny Gson (). til Json (ny StandardResponse (StatusResponse.SUCCESS, ny Gson () .toJsonTree (userService) getUsers ())));});

La oss nå teste ruten:

Be om:

GET // localhost: 4567 / brukere

Respons:

{"status": "SUCCESS", "data": [{"id": "1014", "firstName": "John", "lastName": "Miller", "email": "[email protected]"} , {"id": "1012", "firstName": "Mac", "lastName": "Mason1", "email": "[email protected]"}}

5.4. Få bruker etter ID

Nedenfor er metodesvarbehandler som returnerer a Bruker med det gitte id:

get ("/ users /: id", (request, response) -> {response.type ("application / json"); returner ny Gson (). toJson (ny StandardResponse (StatusResponse.SUCCESS, nye Gson () .toJsonTree (userService.getUser (request.params (": id")))));});

La oss nå teste ruten:

Be om:

FÅ // localhost: 4567 / brukere / 1012

Respons:

{"status": "SUCCESS", "data": {"id": "1012", "firstName": "Mac", "lastName": "Mason1", "email": "[email protected]"}}

5.5. Rediger en bruker

Nedenfor er sette behandlingsmetode, som redigerer brukeren som har id leveres i rutemønsteret:

put ("/ users /: id", (request, response) -> {response.type ("application / json"); User toEdit = new Gson (). fromJson (request.body (), User.class); User editedUser = userService.editUser (toEdit); if (editedUser! = Null) {return new Gson (). ToJson (new StandardResponse (StatusResponse.SUCCESS, new Gson () .toJsonTree (editedUser)));} else {return new Gson (). ToJson (ny StandardResponse (StatusResponse.ERROR, nye Gson () .toJson ("Bruker ikke funnet eller feil i redigering")))}});

Merk: I dette eksemplet sendes dataene i den rå kroppen til en POST-forespørsel som et JSON-objekt hvis eiendomsnavn samsvarer med feltene i Bruker objektet som skal redigeres.

La oss teste ruten:

Be om:

PUT // localhost: 4567 / users / 1012 {"lastName": "Mason"}

Respons:

{"status": "SUCCESS", "data": {"id": "1012", "firstName": "Mac", "lastName": "Mason", "email": "[email protected]"}}

5.6. Slett en bruker

Nedenfor er slett behandlingsmetode svar, som vil slette Bruker med det gitte id:

slett ("/ brukere /: id", (forespørsel, svar) -> {respons.type ("applikasjon / json"); userService.deleteUser (forespørsel.params (": id")); returner ny Gson (). toJson (ny StandardResponse (StatusResponse.SUCCESS, "bruker slettet"))}};

La oss nå teste ruten:

Be om:

SLETT // localhost: 4567 / brukere / 1012

Respons:

{"status": "SUCCESS", "message": "bruker slettet"}

5.7. Sjekk om brukeren eksisterer

De alternativer metoden er et godt valg for betinget kontroll. Nedenfor er alternativer metodesvarbehandler som vil sjekke om en Bruker med det gitte id eksisterer:

alternativer ("/ brukere /: id", (forespørsel, svar) -> {respons.type ("applikasjon / json"); returner ny Gson (). til Json (ny StandardResponse (StatusResponse.SUCCESS, (userService.userExist (forespørsel) .params (": id")))? "Bruker eksisterer": "Bruker eksisterer ikke"));});

La oss nå teste ruten:

Be om:

ALTERNATIVER // localhost: 4567 / brukere / 1012

Respons:

{"status": "SUCCESS", "message": "Bruker eksisterer"}

6. Konklusjon

I denne artikkelen hadde vi en rask introduksjon til Spark-rammeverket for rask nettutvikling.

Dette rammeverket fremmes hovedsakelig for å generere mikrotjenester i Java. Node.js utviklere med Java-kunnskap som ønsker å utnytte biblioteker bygget på JVM-biblioteker, bør føle seg hjemme ved å bruke dette rammeverket.

Og som alltid kan du finne alle kildene til denne opplæringen i Github-prosjektet.


$config[zx-auto] not found$config[zx-overlay] not found