API építése a Spark Java keretrendszerrel
1. Bemutatkozás
Ebben a cikkben egy gyors bevezetést mutatunk be a Spark keretrendszerbe. A Spark framework egy gyors fejlesztésű webes keretrendszer, amelyet a Sinatra Ruby-keretrendszer ihletett, és a Java 8 Lambda Expression filozófiája köré épül, így kevésbé bőbeszédű, mint a legtöbb más Java keretrendszerben írt alkalmazás.
Jó választás, ha szeretne Node.js mint a webes API vagy a mikroszolgáltatások fejlesztése a Java-ban. A Spark használatával egy REST API készen áll arra, hogy kevesebb mint tíz sornyi kódban kiszolgálja a JSON-t.
Gyorsan megkezdjük a „Hello World” példát, majd egy egyszerű REST API-t.
2. Maven-függőségek
2.1. Spark Framework
Tartalmazza a következő Maven-függőséget az ön pom.xml:
com.sparkjava szikra-mag 2.5.4
A Spark legújabb verzióját megtalálhatja a Maven Central oldalon.
2.2. Gson könyvtár
A példa különböző helyein a Gson könyvtárat fogjuk használni a JSON műveletekhez. Ha be akarja vonni Gson-t a projektjébe, vegye fel ezt a függőséget a projektjébe pom.xml:
com.google.code.gson gson 2.8.0
A Gson legújabb verzióját a Maven Central oldalon találja.
3. A Spark Framework használatának megkezdése
Vessünk egy pillantást a Spark alkalmazás alapvető építőköveire, és mutassunk be egy gyors webszolgáltatást.
3.1. Útvonalak
A Spark Java webszolgáltatásai az útvonalakra és azok kezelőire épülnek. Az útvonalak a Spark elengedhetetlen elemei. A dokumentáció szerint minden útvonal három egyszerű darabból áll - a ige, a pálya, és a visszahív.
- A ige egy HTTP-metódusnak megfelelő módszer. Az igemódok a következők: kap, poszt, tesz, töröl, fej, nyom, összeköt, és opciók
- A pálya (más néven útvonalmintázat) meghatározza, hogy az útvonal mely URI-ket hallgassa meg és adjon választ
- A visszahív egy olyan kezelő függvény, amelyet egy adott igére és elérési útra hívunk meg annak érdekében, hogy választ hozzunk létre és visszaküldjünk a megfelelő HTTP kérésre. A visszahívás egy kérés objektumot és válasz objektumot vesz fel argumentumként
Itt bemutatjuk az útvonal alapstruktúráját, amely a kap ige:
get ("/ az Ön útvonala-útvonala /", (kérés, válasz) -> {// visszahívási kódja});
3.2. Hello World API
Hozzunk létre egy egyszerű webszolgáltatást, amelynek két útvonala van a GET kérésekhez, és válaszként „Hello” üzeneteket ad vissza. Ezek az útvonalak a kap metódus, amely statikus import az osztályból szikra.Szikra:
statikus szikra importálása. Spark. *; public class HelloWorldService {public static void main (String [] args) {get ("/ hello", (req, res) -> "Hello, world"); get ("/ hello /: name", (req, res) -> {return "Hello", + req.params (": name");}); }}
Az első érv a kap módszer az útvonal elérési útja. Az első útvonal csak egyetlen URI-t képviselő statikus útvonalat tartalmaz ("/Helló").
A második útvonal útvonala (“/ Hello /: name”) a. helyőrzőjét tartalmazza "név" paraméter, amelyet a paraméter kettősponttal való előtagjával jelölünk („:”). Ezt az útvonalat hívják meg az URI-khez hasonló GET-kérésekre, mint pl “/ Hello / Joe” és “/ Hello / Mary”.
A második érv a kap A módszer egy lambda kifejezés, amely funkcionális programozási ízt ad ennek a keretnek.
A lambda kifejezés a kérést és a választ argumentumként tartalmazza, és segít a válasz visszaadásában. Vezérlő logikánkat a REST API útvonalak lambda kifejezésébe fogjuk helyezni, amint később ezt az oktatóanyagot láthatjuk.
3.3. A Hello World API tesztelése
Miután lefuttatta az osztályt HelloWorldService normál Java osztályként hozzáférhet a szolgáltatáshoz az alapértelmezett portján 4567 segítségével határozza meg a kap módszerrel.
Nézzük meg az első útvonal kérését és válaszát:
Kérés:
GET // localhost: 4567 / hello
Válasz:
Helló Világ
Teszteljük a második útvonalat, haladva az úton név paraméter az útjában:
Kérés:
GET // localhost: 4567 / hello / baeldung
Válasz:
Helló, baeldung
Nézze meg, hogy a szöveg elhelyezése „Baeldung” az URI-ban használták az útvonal mintázatának egyeztetésére “/ Hello /: name” - a második út visszahíváskezelő funkciójának meghívása.
4. RESTful szolgáltatás megtervezése
Ebben a szakaszban egy egyszerű REST webszolgáltatást tervezünk a következőkre Felhasználó entitás:
public class Felhasználó {private String id; privát karakterlánc keresztnév; privát karakterlánc vezetéknév; privát karakterlánc e-mail; // kivitelezők, szerelvények és beállítók}
4.1. Útvonalak
Soroljuk fel az API-t alkotó útvonalakat:
- GET / felhasználók - az összes felhasználó listájának lekérése
- GET / users /: id - a megadott azonosítóval rendelkező felhasználó beolvasása
- POST / users /: id - felhasználó hozzáadása
- PUT / users /: id - egy adott felhasználó szerkesztése
- OPTIONS / users /: id - ellenőrizze, hogy létezik-e felhasználó a megadott azonosítóval
- DELETE / users /: id - egy adott felhasználó törlése
4.2. A felhasználói szolgáltatás
Az alábbiakban a UserService interfész, amely deklarálja a CRUD műveleteket a Felhasználó entitás:
public interface UserService {public void addUser (Felhasználói felhasználó); nyilvános gyűjtemény getUsers (); public Felhasználó getUser (String id); public User editUser (felhasználói felhasználó) dobja a UserException-t; public void deleteUser (karakterlánc azonosító); nyilvános logikai felhasználóExist (karakterlánc azonosító); }
Bemutató célokra biztosítjuk a Térkép ennek megvalósítása UserService interfész a GitHub kódban a perzisztencia szimulálására. Saját megvalósítását biztosíthatja a választott adatbázissal és perzisztencia réteggel.
4.3. A JSON válaszstruktúrája
Az alábbiakban bemutatjuk a REST szolgáltatásunkban használt válaszok JSON felépítését:
{állapot: üzenet: adat:}
A állapot mező értéke lehet akár SIKER vagy HIBA. A adat mező a visszatérési adatok JSON ábrázolását tartalmazza, például a Felhasználó vagy gyűjteménye Felhasználók.
Ha nincs adat visszaküldése, vagy ha a állapot van HIBA, benépesítjük a üzenet mező a hiba vagy a visszaküldési adatok hiányának okának közvetítésére.
Ábrázoljuk a fenti JSON struktúrát egy Java osztály használatával:
public class StandardResponse {private StatusResponse status; privát karakterlánc üzenet; privát JsonElement adatok; public StandardResponse (StatusResponse status) {// ...} public StandardResponse (StatusResponse status, String message) {// ...} public StandardResponse (StatusResponse status, JsonElement data) {// ...} // getterek és beállítók }
hol StatusResponse egy enum az alábbiak szerint definiálva:
public enum StatusResponse {SIKER ("siker"), ERROR ("hiba"); privát húr státusz; // kivitelezők, szerelők}
5. RESTful szolgáltatások megvalósítása
Most valósítsuk meg a REST API útvonalait és kezelőit.
5.1. Vezérlők létrehozása
A következő Java osztály tartalmazza az API útvonalait, beleértve az igéket és útvonalakat, valamint az egyes útvonalak kezelőinek vázlatát:
public class SparkRestExample {public static void main (String [] args) {post ("/ users", (kérés, válasz) -> {// ...}); get ("/ felhasználók", (kérés, válasz) -> {// ...}); get ("/ users /: id", (kérés, válasz) -> {// ...}); put ("/ users /: id", (kérés, válasz) -> {// ...}); törlés ("/ users /: id", (kérés, válasz) -> {// ...}); opciók ("/ users /: id", (kérés, válasz) -> {// ...}); }}
A következő alfejezetekben bemutatjuk az egyes útvonalkezelők teljes megvalósítását.
5.2. Felhasználó hozzáadása
Az alábbiakban a post metódus válaszkezelő, amely hozzáadja a Felhasználó:
post ("/ users", (kérés, válasz) -> {response.type ("application / json"); Felhasználói felhasználó = new Gson (). fromJson (request.body (), User.class); userService.addUser (felhasználó); adja vissza az új Gson () .to-t a Json-hoz (új StandardResponse (StatusResponse.SIKERESSÉG));});
Jegyzet: Ebben a példában a Felhasználó az objektum POST-kérelem nyers törzseként kerül átadásra.
Teszteljük az útvonalat:
Kérés:
POST // localhost: 4567 / users {"id": "1012", "email": "[email protected]", "firstName": "Mac", "lastName": "Mason1"}
Válasz:
{"status": "SIKER"}
5.3. Minden felhasználó beolvasása
Az alábbiakban a kap metódus válaszkezelő, amely az összes felhasználót visszaküldi a UserService:
get ("/ users", (kérés, válasz) -> {response.type ("application / json"); adja vissza az új Gson (). -tJson (új StandardResponse (StatusResponse.SUCCESS, új Gson () .toJsonTree (userService getUsers ())));});
Most teszteljük az útvonalat:
Kérés:
GET // localhost: 4567 / felhasználók
Válasz:
{"status": "SIKER", "data": [{"id": "1014", "keresztnév": "John", "vezetékNév": "Miller", "e-mail": "[e-mail védett]"} , {"id": "1012", "keresztnév": "Mac", "vezetékNév": "Mason1", "email": "[email protected]"}]}
5.4. Felhasználó megszerzése Id alapján
Az alábbiakban a kap metódus válaszkezelő, amely visszaadja a Felhasználó az adottval id:
get ("/ users /: id", (kérés, válasz) -> {response.type ("application / json"); adja vissza az új Gson () -t aJson-nak (új StandardResponse (StatusResponse.SUCCESS, új Gson () .toJsonTree (userService.getUser (request.params (": id")))));});
Most teszteljük az útvonalat:
Kérés:
GET // localhost: 4567 / users / 1012
Válasz:
{"status": "SIKER", "data": {"id": "1012", "firstName": "Mac", "lastName": "Mason1", "email": "[email protected]"}}
5.5. Felhasználó szerkesztése
Az alábbiakban a tedd metódus válaszkezelő, amely szerkeszti azt a felhasználót, amelynek id az útvonal mintázatában szállítva:
put ("/ users /: id", (kérés, válasz) -> {response.type ("application / json"); Felhasználó toEdit = új Gson (). fromJson (request.body (), User.class); Felhasználó editedUser = userService.editUser (toEdit); if (editedUser! = Null) {return new Gson (). ToJson (new StandardResponse (StatusResponse.SUCCESS, new Gson () .toJsonTree (editedUser)));} else {return new Gson (). ToJson (új StandardResponse (StatusResponse.ERROR, új Gson () .toJson ("A felhasználót nem találtuk, vagy hiba történt a szerkesztésben")));}});
Jegyzet: Ebben a példában az adatokat egy POST-kérelem nyers törzsében adják át JSON-objektumként, amelynek tulajdonságnevei megegyeznek a Felhasználó szerkesztendő objektum.
Teszteljük az útvonalat:
Kérés:
PUT // localhost: 4567 / users / 1012 {"vezetéknév": "Mason"}
Válasz:
{"status": "SIKER", "data": {"id": "1012", "firstName": "Mac", "lastName": "Mason", "email": "[email protected]"}}
5.6. Felhasználó törlése
Az alábbiakban a töröl metódus válaszkezelő, amely törli a Felhasználó az adottval id:
delete ("/ users /: id", (kérés, válasz) -> {response.type ("application / json"); userService.deleteUser (request.params (": id")); új Gson () visszaadása. toJson (új StandardResponse (StatusResponse.SUCCESS, "felhasználó törölve"));});
Most teszteljük az útvonalat:
Kérés:
DELETE // localhost: 4567 / users / 1012
Válasz:
{"status": "SIKER", "message": "felhasználó törölve"}
5.7. Ellenőrizze, hogy létezik-e felhasználó
A opciók módszer jó választás a feltételes ellenőrzéshez. Az alábbiakban a opciók módszer válaszkezelő, amely ellenőrzi, hogy a Felhasználó az adottval id létezik:
opciók ("/ users /: id", (kérés, válasz) -> {response.type ("application / json"); adja vissza az új Gson () -t aJson-nak (új StandardResponse (StatusResponse.SUCCESS, (userService.userExist) .params (": id")))? "Felhasználó létezik": "Felhasználó nem létezik"));});
Most teszteljük az útvonalat:
Kérés:
OPCIÓK // localhost: 4567 / users / 1012
Válasz:
{"status": "SIKER", "message": "Felhasználó létezik"}
6. Következtetés
Ebben a cikkben gyorsan bemutattuk a Spark keretrendszerét a gyors webfejlesztés érdekében.
Ezt a keretrendszert főleg a mikroszolgáltatások Java-ban történő előállításához támogatják. Node.js a Java tudással rendelkező fejlesztőknek, akik a JVM könyvtárakra épülő könyvtárakat szeretnék kihasználni, otthon érezzék magukat ennek a keretrendszernek a használatával.
És mint mindig, az oktatóanyag összes forrását megtalálja a Github projektben.