streamalism.org

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.

1. 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
2. A pálya (más néven útvonalmintázat) meghatározza, hogy az útvonal mely URI-ket hallgassa meg és adjon választ
3. 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.