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.