streamalism.org

1. Oversigt

I denne artikel diskuterer vi Vert.x, dækker dets kernekoncepter og opretter en simpel RESTfull webservice med den.

Vi starter med at dække grundkoncepterne om værktøjssættet, går langsomt frem til en HTTP-server og bygger derefter RESTfull-tjenesten.

2. Om Vert.x

Vert.x er en open source, reaktiv og polyglot softwareudviklingsværktøjssæt fra udviklerne af Eclipse.

Reaktiv programmering er et programmeringsparadigme, der er forbundet med asynkrone strømme, som reagerer på eventuelle ændringer eller begivenheder.

På samme måde bruger Vert.x en begivenhedsbus til at kommunikere med forskellige dele af applikationen og videregiver begivenheder asynkront til håndterere, når de er tilgængelige.

Vi kalder det polyglot på grund af dets understøttelse af flere JVM- og ikke-JVM-sprog som Java, Groovy, Ruby, Python og JavaScript.

3. Opsætning

For at bruge Vert.x skal vi tilføje Maven-afhængighed:

 io.vertx vertx-core 3.4.1 

Den seneste version af afhængigheden kan findes her.

3. Vertikler

Vertikler er stykker kode, som Vert.x-motoren udfører. Værktøjssættet giver os mange abstrakte vertikalklasser, som kan udvides og implementeres, som vi vil.

At være polyglot kan vertikler skrives på et hvilket som helst af de understøttede sprog. En applikation vil typisk være sammensat af flere vertikler, der kører i den samme Vert.x-forekomst og kommunikerer med hinanden ved hjælp af begivenheder via begivenhedsbussen.

For at oprette en verticle i JAVA skal klassen implementere io.vertx.core.Verticle interface eller en af ​​dens underklasser.

4. Event Bus

Det er nervesystemet i enhver Vert.x-applikation.

At være reaktive forbliver vertikler sovende, indtil de modtager en besked eller begivenhed. Vertikaler kommunikerer med hinanden gennem eventbussen. Beskeden kan være alt fra en streng til et komplekst objekt.

Beskedhåndtering er ideelt asynkron, meddelelser står i kø til begivenhedsbussen, og kontrol returneres til afsenderen. Senere er det dequued til lyttehovedet. Svaret sendes vha Fremtid og ring tilbage metoder.

5. Enkel Vert.x applikation

Lad os oprette en simpel applikation med en verticle og implementere den ved hjælp af en vertx eksempel. For at oprette vores verticle udvider vi

For at oprette vores verticle udvider vi io.vertx.core.AbstractVerticle klasse og tilsidesætte Start() metode:

offentlig klasse HelloVerticle udvider AbstractVerticle {@ Override offentlig ugyldig start (Fremtidig fremtid) {LOGGER.info ("Velkommen til Vertx"); }}

Det Start() metoden påberåbes af vertx eksempel, når vertikalen er implementeret. Metoden tager io.vertx.core.Future som en parameter, som kan bruges til at finde status for en asynkron implementering af vertiklen.

Lad os nu implementere vertiklen:

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

På samme måde kan vi tilsidesætte hold op() metode fra AbstraktVertikel klasse, som påberåbes under nedlukning af vertikalen:

@ Overstyr offentlig ugyldigt stop () {LOGGER.info ("Lukning af applikation"); }

6. HTTP-server

Lad os nu spinde en HTTP-server op ved hjælp af en verticle:

@ Overstyr offentlig ugyldig start (Fremtidig fremtid) {vertx.createHttpServer () .requestHandler (r -> r.response (). End ("Velkommen til Vert.x Intro");}). Listenen (config (). GetInteger ( "http.port", 9090), resultat -> {hvis (result.succeeded ()) {future.complete ();} ellers {future.fail (result.cause ());}}); }

Vi har tilsidesat Start() metode til at oprette en HTTP-server og knyttet en anmodningshåndterer til den. Det requestHandler () metode kaldes hver gang serveren modtager en anmodning.

Endelig er serveren bundet til en port og en AsyncResult handler overføres til Lyt() metode, uanset om forbindelsen eller serverens opstart lykkes ved hjælp af future.complete () eller fremtid.fail () i tilfælde af fejl.

Noter det: config.getInteger () metode, læser værdien for HTTP-portkonfiguration, der indlæses fra en ekstern conf.json fil.

Lad os teste vores server:

@Test offentlig ugyldig nårReceivedResponse_thenSuccess (TestContext testContext) {Async async = testContext.async (); vertx.createHttpClient () .getNow (port, "localhost", "/", response -> {response.handler (responseBody -> {testContext.assertTrue (responseBody.toString (). indeholder ("Hello")); async. komplet ();});}); }

Til testen skal vi bruge vertx-enhed sammen med JUnit .:

 io.vertx vertx-enhed 3.4.1 test 

Vi kan få den nyeste version her.

Søjlen er indsat og i en vertx eksempel i Opsætning() metode til enhedstest:

@Før offentlig tomrumsopsætning (TestContext testContext) {vertx = Vertx.vertx (); vertx.deployVerticle (SimpleServerVerticle.class.getName (), testContext.asyncAssertSuccess ()); }

Tilsvarende er vertx eksempel er lukket i @AfterClass tearDown () metode:

@Efter offentlig ugyldighed tearDown (TestContext testContext) {vertx.close (testContext.asyncAssertSuccess ()); }

Bemærk, at @BeforeClass opsætning () metoden tager en TestContext argument. Dette hjælper med at kontrollere og teste den asynkrone opførsel af testen. Eksempelvis er verticle-implementeringen asynkroniseret, så dybest set kan vi ikke teste noget, medmindre den er implementeret korrekt.

Vi har en anden parameter til deployVerticle () metode, testContext.asyncAssertSuccess (). Thans bruges til at vide, om serveren er implementeret korrekt, eller om der opstår fejl. Det venter på future.complete () eller future.fail () i serverens verticle, der skal kaldes. I tilfælde af fejl mislykkes testen.

7. RESTful WebService

Vi har oprettet en HTTP-server, lad os nu bruge den til at være vært for en RESTfull WebService. For at gøre det har vi brug for et andet Vert.x-modul kaldet vertx-web. Dette giver en masse ekstra funktioner til webudvikling oven på vertx-kerne.

Lad os tilføje afhængigheden af ​​vores pom.xml:

 io.vertx vertx-web 3.4.1 

Vi kan finde den nyeste version her.

7.1. Router og Ruter

Lad os oprette en router til vores WebService. Denne router tager en enkel rute for GET-metoden og handler-metoden getArtilces ():

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

Det getArticle () metode er en enkel metode, der returnerer ny Artikel objekt:

privat ugyldigt getArticles (RoutingContext routingContext) {String articleId = routingContext.request () .getParam ("id"); Artikelartikel = ny artikel (articleId, "Dette er en introduktion til vertx", "baeldung", "01-02-2017", 1578); routingContext.response () .putHeader ("content-type", "application / json") .setStatusCode (200). end (Json.encodePrettily (artikel)); }

EN Router, når modtager en anmodning, søger efter den matchende rute og sender anmodningen videre. Det ruter at have en håndteringsmetode tilknyttet til at gøre summen med anmodningen.

I vores tilfælde påberåber sig handler getArticle () metode. Den modtager routingContext objekt som argument. Henter sti-parameteren id, og skaber en Artikel gør noget imod det.

Lad os påberåbe sig i den sidste del af metoden respons() metode til routingContext gør indsigelse og sæt overskrifterne, indstil HTTP-svarkoden, og afslut svaret ved hjælp af den kodede JSON artikel objekt.

7.2. Tilføjer Router til server

Lad os nu tilføje router, oprettet i det forrige afsnit til HTTP-serveren:

vertx.createHttpServer () .requestHandler (router :: accept). listen (config (). getInteger ("http.port", 8080), result -> {if (result.succeeded ()) {future.complete (); } ellers {future.fail (result.cause ());}});

Bemærk, at vi har tilføjet requestHandler (router :: accepter) til serveren. Dette instruerer serveren om at påberåbe sig acceptere() af router gør indsigelse, når en anmodning modtages.

Lad os nu teste vores WebService:

@ Test offentligt ugyldigt 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 (). indeholder ("\" id \ ": \" 12345 \ "")); async.complete ();});}); }

8. Emballage Vert.x anvendelse

For at pakke applikationen som et implementerbart Java Archive (.jar) skal vi bruge Maven Shade-plugin og konfigurationerne i udførelse tag:

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

I manifestEntries, Main-verticle angiver startpunktet for applikationen og Hovedklasse er en Vert.x-klasse, der opretter vertx forekomst og implementerer Main-verticle.

9. Konklusion

I denne indledende artikel diskuterede vi Vert.x-værktøjssættet og dets grundlæggende begreber. Så hvordan man opretter og HTTP-server med Vert.x og også en RESTFull WebService og viste hvordan man tester dem ved hjælp af vertx-enhed.

Endelig pakket applikationen som en eksekverbar krukke.

Den komplette implementering af kodestykkerne er tilgængelig på GitHub.