streamalism.org

1. Oversikt

I denne artikkelen vil vi diskutere Vert.x, dekke kjernekonseptene og lage en enkel RESTfull webtjeneste med den.

Vi begynner med å dekke grunnleggende konsepter om verktøysettet, sakte gå videre til en HTTP-server og deretter bygge RESTfull-tjenesten.

2. Om Vert.x

Vert.x er en åpen kildekode, reaktiv og polyglot verktøy for programvareutvikling fra utviklerne av Eclipse.

Reaktiv programmering er et programmeringsparadigme, assosiert med asynkrone strømmer, som svarer på eventuelle endringer eller hendelser.

På samme måte bruker Vert.x en hendelsesbuss for å kommunisere med forskjellige deler av applikasjonen og overføre hendelser, asynkront til håndterere når de er tilgjengelige.

Vi kaller det polyglot på grunn av støtten til flere JVM- og ikke-JVM-språk som Java, Groovy, Ruby, Python og JavaScript.

3. Oppsett

For å bruke Vert.x må vi legge til Maven-avhengighet:

 io.vertx vertx-kjerne 3.4.1 

Den siste versjonen av avhengigheten finner du her.

3. Vertikler

Vertikler er kodestykker som Vert.x-motoren utfører. Verktøysettet gir oss mange abstrakte vertikalklasser, som kan utvides og implementeres slik vi vil.

Å være polyglot, kan vertikler skrives på hvilket som helst av de støttede språkene. En applikasjon vil vanligvis være sammensatt av flere vertikaler som kjører i samme Vert.x-forekomst og kommuniserer med hverandre ved hjelp av hendelser via hendelsesbussen.

For å lage en verticle i JAVA, må klassen implementere io.vertx.core.Verticle grensesnitt, eller en av underklassene.

4. Arrangementsbuss

Det er nervesystemet i alle Vert.x applikasjoner.

Å være reaktiv, forblir vertikaler sovende til de mottar en melding eller hendelse. Vertikaler kommuniserer med hverandre gjennom arrangementbussen. Meldingen kan være alt fra en streng til et komplekst objekt.

Meldingshåndtering er ideelt asynkron, meldinger står i kø til hendelsesbussen, og kontrollen returneres til avsenderen. Senere er dequeued til lyttehodet. Svaret sendes vha Framtid og Ring tilbake metoder.

5. Enkel Vert.x-applikasjon

La oss lage en enkel applikasjon med en verticle og distribuere den ved hjelp av en vertx forekomst. For å lage vår vertikale, utvider vi

For å lage vår vertikale, utvider vi io.vertx.core.AbstractVerticle klasse og overstyre start() metode:

offentlig klasse HelloVerticle utvider AbstractVerticle {@Override public void start (Future future) {LOGGER.info ("Welcome to Vertx"); }}

De start() metoden vil bli påkalt av vertx forekomst når vertikalen er distribuert. Metoden tar io.vertx.core.Future som en parameter, som kan brukes til å oppdage statusen til en asynkron distribusjon av vertikalen.

La oss nå distribuere vertikalen:

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

På samme måte kan vi overstyre Stoppe() metoden fra AbstraktVertikkel klasse, som vil bli påkalt mens du slår av vertikalen:

@ Overstyr offentlig ugyldig stopp () {LOGGER.info ("Avslutt applikasjon"); }

6. HTTP-server

La oss nå spinne opp en HTTP-server ved hjelp av en verticle:

@Override public void start (Future future) {vertx.createHttpServer () .requestHandler (r -> r.response (). End ("Welcome to Vert.x Intro");}) .listen (config (). GetInteger ( "http.port", 9090), resultat -> {if (result.succeeded ()) {future.complete ();} else {future.fail (result.cause ());}}); }

Vi har overstyrt start() metode for å opprette en HTTP-server og knyttet en forespørselsbehandler til den. De requestHandler () metoden kalles hver gang serveren mottar en forespørsel.

Til slutt er serveren bundet til en port og en AsyncResult handler overføres til lytte() metoden om tilkoblingen eller serveroppstarten lykkes ved hjelp av future.complete () eller fremtid.fail () i tilfelle feil.

Noter det: config.getInteger () metode, leser verdien for HTTP-portkonfigurasjon som lastes fra en ekstern conf.json fil.

La oss teste serveren vår:

@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 (). inneholder ("Hei")); asynkronisering. fullfør ();});}); }

For testen, la oss bruke vertx-enhet sammen med JUnit .:

 io.vertx vertx-enhet 3.4.1 test 

Vi kan få den siste versjonen her.

Vertikalen er utplassert og i en vertx eksempel i oppsett () metoden for enhetstesten:

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

Tilsvarende vertx forekomst er stengt i @AfterClass tearDown () metode:

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

Legg merke til at @BeforeClass oppsett () metoden tar en TestContext argument. Dette hjelper deg med å kontrollere og teste den asynkrone oppførselen til testen. For eksempel er vertikaldistribusjonen asynkronisert, så i utgangspunktet kan vi ikke teste noe med mindre den er distribuert riktig.

Vi har en andre parameter til deployVerticle () metode, testContext.asyncAssertSuccess (). Thans brukes til å vite om serveren er distribuert riktig eller om det oppstod feil. Den venter på future.complete () eller future.fail () i serverhvirvelen som skal kalles. Ved feil mislykkes testen.

7. RESTful WebService

Vi har opprettet en HTTP-server, kan vi bruke den til å være vert for en RESTfull WebService. For å gjøre det trenger vi en annen Vert.x-modul kalt vertx-web. Dette gir mange tilleggsfunksjoner for webutvikling på toppen av vertx-kjerne.

La oss legge til avhengighet til vår pom.xml:

 io.vertx vertx-web 3.4.1 

Vi finner den nyeste versjonen her.

7.1. Ruter og Ruter

La oss lage en ruteren for vår WebService. Denne ruteren tar 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);

De getArticle () metoden er en enkel metode som returnerer ny Artikkel gjenstand:

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

EN Ruter, når mottar en forespørsel, ser etter den matchende ruten og sender forespørselen videre. De ruter å ha en håndteringsmetode tilknyttet for å gjøre summen med forespørselen.

I vårt tilfelle påkaller behandleren getArticle () metode. Den mottar routingContext objekt som argument. Henter sti-parameteren id, og skaper en Artikkel innvende med det.

I den siste delen av metoden, la oss påkalle respons() metoden på routingContext motsette og sette overskriftene, angi HTTP-responskoden og avslutte svaret ved hjelp av JSON-kodet artikkel gjenstand.

7.2. Legger til Ruter til server

La oss nå legge til router, opprettet i forrige seksjon til HTTP-serveren:

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

Legg merke til at vi har lagt til requestHandler (router :: godta) til serveren. Dette instruerer serveren om å påkalle aksepterer() av ruteren innvendinger når forespørsel mottas.

La oss nå teste vår WebService:

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

8. Emballasje Vert.x applikasjon

For å pakke applikasjonen som et distribuerbart Java Archive (.jar), la oss bruke Maven Shade-plugin og konfigurasjonene i henrettelse stikkord:

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

I manifestEntries, Main-Verticle angir startpunktet for søknaden og Hovedklasse er en Vert.x-klasse som skaper vertx forekomst og distribuerer Main-Verticle.

9. Konklusjon

I denne innledende artikkelen diskuterte vi Vert.x-verktøykassen og dens grunnleggende konsepter. Så hvordan du oppretter og HTTP-server, med Vert.x og også en RESTFull WebService og viste hvordan du kan teste dem ved hjelp av vertx-enhet.

Endelig pakket applikasjonen som en kjørbar krukke.

Den komplette implementeringen av kodebitene er tilgjengelig på GitHub.