Bevezetés a Vert.x-be

1. Áttekintés

Ebben a cikkben megvitatjuk a Vert.x-et, kitérünk annak alapkoncepcióira és létrehozunk vele egy egyszerű RESTfull webszolgáltatást.

Kezdjük azzal, hogy áttekintjük az eszköztár alapelveit, lassan haladunk előre egy HTTP kiszolgálóra, majd felépítjük a RESTfull szolgáltatást.

2. A Vert.x-ről

A Vert.x egy nyílt forráskódú, reaktív és poliglot szoftverfejlesztő eszközkészlet az Eclipse fejlesztőitől.

A reaktív programozás olyan programozási paradigma, amely aszinkron folyamokkal társul, amelyek reagálnak minden változásra vagy eseményre.

Hasonlóképpen, a Vert.x eseménybuszt használ az alkalmazás különböző részeivel való kommunikációhoz, és az eseményeket aszinkron módon továbbítja a kezelőknek, ha elérhetőek.

Polyglot-nak nevezzük, mivel több JVM és nem JVM nyelvet támogat, mint a Java, Groovy, Ruby, Python és JavaScript.

3. Beállítás

A Vert.x használatához hozzá kell adnunk a Maven függőséget:

 io.vertx vertx-core 3.4.1 

A függőség legújabb verziója itt található.

3. Függőlegesek

A függőlegesek a Vert.x motor által végrehajtott kódrészek. Az eszközkészlet számos absztrakt vertikális osztályt nyújt számunkra, amelyeket kibővíthetünk és megvalósíthatunk, ahogy szeretnénk.

Poliglotként a vertikumok a támogatott nyelvek bármelyikére írhatók. Az alkalmazás általában több vertikálisból áll, amelyek ugyanazon a Vert.x példányban futnak, és események segítségével kommunikálnak egymással az esemény buszon keresztül.

A vertika létrehozásához a JAVA-ban az osztálynak végre kell hajtania io.vertx.core.Verticle interfész, vagy annak bármely alosztálya.

4. Eseménybusz

Bármely Vert.x alkalmazás idegrendszere.

Reaktívaként a vertikumok szunnyadnak, amíg üzenetet vagy eseményt nem kapnak. A függőlegesek az eseménybuszon keresztül kommunikálnak egymással. Az üzenet bármi lehet, egy karakterláncból egy összetett objektumig.

Az üzenetkezelés ideális esetben aszinkron, az üzenetek sorba kerülnek az eseménybuszra, és a vezérlés visszakerül a feladóhoz. Később a hallgató vertikáléig leválasztják. A választ a következővel küldjük el: Jövő és visszahív mód.

5. Egyszerű Vert.x alkalmazás

Hozzunk létre egy egyszerű függőleges alkalmazást, és telepítsük az a használatával vertx példa. A vertikál létrehozásához kibővítjük a

A vertikál létrehozásához kibővítjük a io.vertx.core.AbstractVerticle osztály és felülírja a Rajt() módszer:

a public class HelloVerticle kiterjeszti az AbstractVerticle {@Orride public void start (Future future) {LOGGER.info ("Welcome to Vertx"); }}

A Rajt() metódust a vertx például amikor a vertikál telepítve van. A módszer szükséges io.vertx.core.Jövő paraméterként, amely felhasználható a vertikális aszinkron telepítés állapotának felderítésére.

Most telepítsük a függőlegest:

public static void main (String [] args) {Vertx vertx = Vertx.vertx (); vertx.deployVerticle (új HelloVerticle ()); }

Hasonlóképpen felülírhatjuk a álljon meg() módszer a AbstractVerticle osztály, amelyet a vertikál leállítása közben hívnak meg:

@Orride public void stop () {LOGGER.info ("Az alkalmazás leállítása"); }

6. HTTP szerver

Most tekerjünk fel egy HTTP kiszolgálót egy vertikál segítségével:

@Orride public void start (Future future) {vertx.createHttpServer () .requestHandler (r -> r.response (). End ("Welcome to Vert.x Intro");}) .listen (config (). GetInteger ( "http.port", 9090), eredmény -> {if (eredmény.sikerült ()) {jövő.complete ();} else {jövő.hiba (eredmény.cause ());}}); }

Felülírtuk a Rajt() módszer egy HTTP-kiszolgáló létrehozására és egy kéréskezelő csatolására. A requestHandler () metódust minden alkalommal meghívják, amikor a szerver kérést kap.

Végül a kiszolgáló egy porthoz és egy AsyncResult kezelőt adják át a hallgat() módszer, függetlenül attól, hogy a kapcsolat vagy a kiszolgáló indítása sikeres volt-e future.complete () vagy future.fail () esetleges hibák esetén.

Vegye figyelembe, hogy: config.getInteger () metódus, a külső portról betöltött HTTP port konfiguráció értékét olvassa conf.json fájl.

Teszteljük a szerverünket:

@Test public void whenReceivedResponse_thenSuccess (TestContext testContext) {Async async = testContext.async (); vertx.createHttpClient () .getNow (port, "localhost", "/", válasz -> {response.handler (responseBody -> {testContext.assertTrue (responseBody.toString (). tartalmazza ("Hello")); async. teljes(); }); }); }

A teszthez használjuk a vertx-unitot a JUnit-lel együtt:

 io.vertx vertx-unit 3.4.1 teszt 

A legfrissebb verziót itt kaphatjuk meg.

A vertikula ki van helyezve és a vertx például a beállít() az egységvizsgálat módszere:

@A nyilvános void beállítása előtt (TestContext testContext) {vertx = Vertx.vertx (); vertx.deployVerticle (SimpleServerVerticle.class.getName (), testContext.asyncAssertSuccess ()); }

Hasonlóképpen a vertx példánya a @AfterClass tearDown () módszer:

@A nyilvános void után tearDown (TestContext testContext) {vertx.close (testContext.asyncAssertSuccess ()); }

Figyeljük meg, hogy a @BeforeClass setup () módszer an TestContext érv. Ez segít a teszt aszinkron viselkedésének ellenőrzésében és tesztelésében. Például a vertikális telepítés aszinkron, így alapvetően nem tesztelhetünk semmit, kivéve, ha helyesen van telepítve.

Van egy második paraméterünk a deployVerticle () módszer, testContext.asyncAssertSuccess (). Taz övét arra használják, hogy megtudják, a szervert megfelelően telepítették-e, vagy bármilyen hiba történt-e. Várja a future.complete () vagy future.fail () a meghívandó szerver vertikálisban. Meghibásodás esetén nem sikerül a teszten.

7. RESTful WebService

Létrehoztunk egy HTTP kiszolgálót, amely lehetővé teszi a RESTfull WebService üzemeltetését. Ehhez egy másik Vert.x modulra lesz szükségünk vertx-web. Ez rengeteg kiegészítő funkciót kínál a webfejlesztéshez vertx-core.

Adjuk hozzá a függőséget a sajátunkhoz pom.xml:

 io.vertx vertx-web 3.4.1 

A legújabb verziót itt találjuk.

7.1. Router és Útvonalak

Hozzunk létre egy router a WebSzolgáltatásunkhoz. Ez az útválasztó a GET módszer és a kezelő módszer egyszerű útját fogja követni getArtilces ():

Router router = Router.router (vertx); router.get ("/ api / baeldung / articles / article /: id") .handler (ez :: getArticles);

A getArticle () A módszer egy egyszerű módszer, amely újat ad vissza Cikk tárgy:

private void getArticles (RoutingContext routingContext) {String ArticleId = routingContext.request () .getParam ("id"); Cikk cikk = új cikk (articleId, "Ez egy intro a vertxhez", "baeldung", "2017-02-01", 1578); routingContext.response () .putHeader ("content-type", "application / json") .setStatusCode (200) .end (Json.encodePrettily (cikk)); }

A Router, amikor fogad egy kérést, megkeresi az egyező útvonalat, és továbbadja a kérést. A útvonalak kezelő módszerrel társítva a kéréssel való összegzéshez.

Esetünkben a kezelő a getArticle () módszer. Megkapja a routingContext objektum mint érv. Levezeti az elérési út paramétert id, és létrehoz egy Cikk objektum vele.

A módszer utolsó részében hívjuk meg a válasz() módszer a routingContext objektumot és a fejléceket, állítsa be a HTTP válaszkódot, és fejezze be a választ a JSON kódolással cikk tárgy.

7.2. Hozzáadás Router a Szerverhez

Most tegyük hozzá a router, az előző szakaszban létrehozott HTTP szerverhez:

vertx.createHttpServer () .requestHandler (router :: accept) .listen (config (). getInteger ("http.port", 8080), eredmény -> {if (eredmény.sikerült ()) {jövő.complete (); } else {future.fail (eredmény.cause ());}});

Figyelje meg, hogy hozzáadtuk requestHandler (router :: accept) a szerverre. Ez utasítja a szervert, hogy hívja meg a elfogad() a router objektum, amikor bármilyen kérés érkezik.

Most teszteljük a WebService-t:

@Test public void givenId_whenReceivedArticle_thenSuccess (TestContext testContext) {Async async = testContext.async (); vertx.createHttpClient () .getNow (8080, "localhost", "/ api / baeldung / articles / article / 12345", response -> {response.handler (responseBody -> {testContext.assertTrue (responseBody.toString () tartalmazza. ("\" id \ ": \" 12345 \ "")); async.complete ();});}); }

8. Csomagolás Vert.x alkalmazás

Az alkalmazás telepíthető Java Archívumként (.jar) történő csomagolásához használjuk a Maven Shade plugint és a végrehajtás címke:

    io.vertx.core.Starter com.baeldung.SimpleServerVerticle $ {project.build.directory} / $ {project.artifactId} - $ {project.version} -app.jar 

Ban,-ben manifestEntries, Fő-függőleges jelzi az alkalmazás kezdőpontját és a Főosztály egy Vert.x osztály, amely létrehozza a vertx Például, és telepíti a Fő-függőleges.

9. Következtetés

Ebben a bevezető cikkben megvitattuk a Vert.x eszköztárat és annak alapvető fogalmait. Látta, hogyan kell létrehozni és HTTP szervert a Vert.x és egy RESTFull WebService segítségével, és megmutatta, hogyan kell tesztelni őket vertx-egység.

Végül futtatható jarként csomagolta be az alkalmazást.

A kódrészletek teljes megvalósítása elérhető a GitHubon.