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.
- De verb er en metode som tilsvarer en HTTP-metode. Verbmetoder inkluderer: få, post, put, delete, head, trace, connect, og alternativer
- De sti (også kalt rutemønster) bestemmer hvilken URI (r) ruten skal lytte til og gi et svar på
- 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 få 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 få 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 få 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 få 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 få 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 få 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 få 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.