Introduksjon til Jooby

1. Oversikt

Jooby er et skalerbart og raskt mikronettverk som bygger på det mest brukte NIO webservere. Det er veldig greit og modulært, tydelig designet for dagens webarkitektur. Den kommer med støtte for Javascript og Kotlin også.

Som standard, Jooby kommer med stor støtte for Netty, Jetty og Undertow.

I denne artikkelen vil vi lære om det generelle Jooby prosjektstruktur og hvordan man bygger en enkel webapplikasjon ved hjelp av Jooby.

2. Søknadsarkitektur

En enkel Jooby applikasjonsstrukturen vil like nedenfor:

├── offentlig | └── velkommen.html ├── conf | ├── application.conf | └── logback.xml └── src | ├── hoved | | └── java | | └── com | | └── baeldung | | └── jooby | | └── App.java | └── test | └── java | └── com | └── baeldung | └── jooby | └── AppTest.java ├── pom.xml

Poeng å merke seg her er at i offentlig katalog kan vi sette statiske filer som css / js / html etc. I konf katalog, kan vi legge til hvilken som helst konfigurasjonsfil som et program trenger logback.xml eller application.conf etc.

3. Maven avhengighet

Vi kan lage en enkel Jooby søknad ved å legge til følgende avhengighet i vår pom.xml:

 org.jooby jooby-netty 1.1.3 

Hvis vi vil velge Brygge eller Undertow vi kan bruke følgende avhengighet:

 org.jooby jooby-jetty 1.1.3 org.jooby jooby-undertow 1.1.3 

Du kan sjekke den siste versjonen av Jooby prosjekt i Central Maven Repository.

Jooby har også en dedikert Maven-arketype. Vi kan bruke den til å lage et prøveprosjekt med alle nødvendige avhengigheter forhåndsbygd.

Vi kan bruke følgende skript for å generere prøveprosjektet:

mvn arketype: generer -B -DroupId = com.baeldung.jooby -DartifactId = jooby -Dversion = 1.0 -DarchetypeArtifactId = jooby-arketype -DarchetypeGroupId = org.jooby -DarchetypeVersion = 1.1.3

4. Å bygge en applikasjon

4.1. Starte serveren

For å starte den innebygde serveren, må vi bruke følgende kodebit:

public class App utvider Jooby {public static void main (String [] args) {run (App :: new, args); }}

Når serveren er startet, vil den kjøre på standardport8080.

Vi kan også konfigurere back-end-serveren med tilpasset port og tilpasset HTTPS havn:

{port (8081); securePort (8443); }

4.2. Implementering av ruteren

Det er veldig enkelt å lage rutebasert ruter i Jooby. For eksempel kan vi lage en ruter for sti ‘/Logg Inn‘På følgende måte:

{get ("/ login", () -> "Hello from Baeldung"); }

På en lignende måte, hvis vi vil håndtere andre HTTP metoder som POST, PUT, etc kan vi bruke nedenfor kodebit:

{post ("/ save", req -> {Mutant token = req.param ("token"); return token.intValue ();}); }

Her henter vi forespørselens parameternavn fra forespørselen. Som standard types alle forespørselsparametere inn Jooby‘S Mutant data-type. Basert på forventningen kan vi konvertere den til alle primitive datatyper som støttes.

Vi kan sjekke hvilken som helst url-parameter på følgende måte:

{get ("/ user / {id}", req -> "Hei bruker:" + req.param ("id"). verdi ()); get ("/ user /: id", req -> "Hello user:" + req.param ("id"). value ()); }

Vi kan bruke noe av det ovennevnte. Det er også mulig å finne params som starter med et fast innhold. For eksempel kan vi finne en URL-parameter som begynner med ‘uid: ' på følgende måte:

{get ("/ uid: {id}", req -> "Hei bruker med id: uid" + req.param ("id"). verdi ()); }

4.3. Implementering av MVC mønsterkontroller

For en bedriftsapplikasjon, Jooby leveres med en MVC API omtrent som alle andre MVC-rammer som Spring MVC.

For eksempel kan vi håndtere en sti som heter ‘/Hallo‘ :

@Path ("/ hallo") offentlig klasse GetController {@GET offentlig String hei () {return "Hei Baeldung"; }}

På samme måte kan vi lage en behandler for å håndtere andre HTTP-metoder med @POST, @PUT, @DELETE, osv. kommentar.

4.4. Håndtering av statisk innhold

For å servere noe statisk innhold som HTML, Javascript, CSS, image osv., Må vi plassere filen i offentlig katalog.

Når den er plassert, kan vi fra ruteren tilordne hvilken som helst url til disse ressursene:

{eiendeler ("/ ansatt", "form.html"); }

4.5. Håndteringsskjema

Jooby's Be om grensesnitt som standard håndterer ethvert skjemaobjekt uten å bruke manuell støping.

La oss anta at vi må sende inn informasjon om ansatte gjennom et skjema. På første trinn må vi lage en Ansatt bønneobjekt som vi vil bruke til å oppbevare dataene:

offentlig klasse ansatt {String id; Strengnavn; Streng-e-post; // standardkonstruktører, getters og settere}

Nå må vi opprette en side for å opprette skjemaet:

Deretter oppretter vi en posthåndterer for å adressere dette skjemaet og hente de innsendte dataene:

post ("/ submitForm", req -> {Ansatt ansatt = req.params (Employee.class); // ... returner "empoyee data lagret vellykket";});

Poeng å merke seg her er at vi må trenge å erklære form enctype som application / x-www-form-urlencoded for å støtte den dynamiske formbindingen.

Av Request.file (strengfilnavn) vi kan hente den opplastede filen:

post ("/ upload", req -> {Upload upload = req.file ("file"); // ... upload.close ();});

4.6. Implementere et filter

Ut av boksenJooby gir fleksibilitet til å definere globale filtre så vel som stibaserte filtre.

Implementering av filter i Jooby er litt vanskelig siden Vi må konfigurere URL-banen to ganger, en gang for filteret og en gang for handleren.

For eksempel hvis vi må implementere et filter for en URL-bane kalt ‘/filter', vi må implementere filteret i denne banen eksplisitt:

get ("/ filter", (req, resp, chain) -> {// ... chain.next (req, resp);});

Syntaksen er veldig lik Servlet filter. Det er mulig å begrense forespørselen og sende tilbake svaret i selve filteret ved å ringe Response.send (resultatresultat) metode.

Når filteret er implementert, må vi implementere forespørselsbehandleren:

get ("/ filter", (req, resp) -> {resp.send ("filter response");});

4.7. Økt

Jooby kommer med to typer øktimplementering; i minnet og informasjonskapselbasert.

Implementering av øktadministrasjon i minnet er ganske enkelt. Vi har muligheter til å velge hvilken som helst av de høye gjennomstrømningsøktene som er tilgjengelige hos Jooby som EhCache, Guava, HazleCast, Cassandra, Couchbase, Redis, MongoDB, og Memcached.

For eksempel, for å implementere en Redis-basert øktlagring, må vi legge til følgende Maven-avhengighet:

 org.jooby jooby-jedis 1.1.3 

Nå kan vi bruke kodebiten nedenfor for å aktivere øktadministrasjon:

{bruk (ny Redis ()); økt (RedisSessionStore.class); get ("/ session", req -> {Session session = req.session (); session.set ("token", "value"); return session.get ("token"). value ();}); }

Poeng å merke seg her er at vi kan konfigurere Redis url som ‘Db’ eiendom i application.conf.

For å aktivere informasjonskapselbasert øktadministrasjon, må vi erklære cookieSession (). Hvis informasjonskapselbasert tilnærming er valgt, må vi erklære applikasjon. hemmelighet eiendom i application.conf fil. Siden hver informasjonskapsel vil bli signert vil bli signert med denne hemmelige nøkkelen, er det alltid lurt å bruke langt tilfeldig strengfragment som en hemmelig nøkkel.

I både minne og cookie-basert tilnærming, må vi erklære den nødvendige konfigurasjonsparameteren i application.conf filen, ellers vil applikasjonen kaste en IllegalStateException ved oppstart.

5. Testing

Å teste MVC-rute er virkelig enkelt siden en rute er bundet til en strategi for noen klasse. Dette gjør det enkelt å kjøre enhetstester mot alle ruter.

For eksempel kan vi raskt lage en test-case for standard URL:

offentlig klasse AppTest {@ClassRule offentlig statisk JoobyRule-app = ny JoobyRule (ny app ()); @Test offentlig ugyldig given_defaultUrl_expect_fixedString () {get ("/"). Deretter (). AssertThat (). Body (equalTo ("Hello World!")) .StatusCode (200) .contentType ("text / html; charset = UTF -8 "); }}

Poeng å merke seg her er at bruk @ClassRule kommentar vil bare opprette en forekomst av serveren for alle testtilfeller. Hvis vi trenger å bygge separate forekomster av serverne for alle testtilfeller, må vi bruke @Regel kommentar uten statisk modifikator.

Vi kan også bruke Joobys MockRouter for å teste stien på samme måte:

@Test offentlig ugyldig given_defaultUrl_with_mockrouter_expect_fixedString () kaster Throwable {String result = new MockRouter (new App ()). Get ("/"); assertEquals ("Hello World!", resultat); }

6. Konklusjon

I denne opplæringen utforsket vi Jooby prosjektet og dets essensielle funksjonalitet.

Som alltid er hele kildekoden tilgjengelig på GitHub.


$config[zx-auto] not found$config[zx-overlay] not found