streamalism.org

1. Oversigt

Jooby er en skalerbar og hurtig mikroweb-ramme, der er bygget oven på de mest anvendte NIO webservere. Det er meget ligetil og modulært, klart designet til nutidens webarkitektur. Det kommer med støtte til Javascript og Kotlin også.

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

I denne artikel lærer vi alt om alt Jooby projektstruktur og hvordan man bygger en simpel webapplikation ved hjælp af Jooby.

2. Applikationsarkitektur

En simpel Jooby applikationsstruktur vil være som 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

Punkt at bemærke her er, at i offentlig mappe kan vi placere statiske filer som css / js / html osv. I konf bibliotek, kan vi placere enhver konfigurationsfil, som et program har brug for logback.xml eller application.conf etc.

3. Maven-afhængighed

Vi kan skabe et simpelt Jooby ansøgning ved at tilføje følgende afhængighed i vores pom.xml:

 org.jooby jooby-netty 1.1.3 

Hvis vi vil vælge Anløbsbro eller Undertow vi kan bruge følgende afhængighed:

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

Du kan kontrollere den nyeste version af Jooby projekt i Central Maven Repository.

Jooby har også en dedikeret Maven-arketype. Vi kan bruge det til at oprette et prøveprojekt med alle nødvendige afhængigheder præ-bygget.

Vi kan bruge følgende script til at generere prøveprojektet:

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

4. Opbygning af en applikation

4.1. Initiering af serveren

For at starte den integrerede server skal vi bruge følgende kodestykke:

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

Efter start kører serveren standardport8080.

Vi kan også konfigurere back-end-serveren med brugerdefineret port og brugerdefineret HTTPS Havn:

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

4.2. Implementering af routeren

Det er meget let at oprette sti-baseret router i Jooby. For eksempel kan vi oprette en router til sti '/Log på'På følgende måde:

{get ("/ login", () -> "Hej fra Baeldung"); }

På en lignende måde, hvis vi vil håndtere andre HTTP metoder som POST, PUT osv. kan vi bruge nedenfor kodestykke:

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

Her henter vi anmodningens parameternavn-token fra anmodningen. Som standard er alle anmodningsparametre typegodkendt til Jooby'S Mutant datatype. Baseret på forventningen kan vi konvertere den til enhver understøttet primitiv datatype.

Vi kan kontrollere enhver url-parameter på følgende måde:

{get ("/ user / {id}", req -> "Hej bruger:" + req.param ("id"). værdi ()); get ("/ user /: id", req -> "Hej bruger:" + req.param ("id"). værdi ()); }

Vi kan bruge et af ovenstående. Det er også muligt at finde params, der starter med et fast indhold. For eksempel kan vi finde en URL-parameter, der starter med 'uid: ' på følgende måde:

{get ("/ uid: {id}", req -> "Hej bruger med id: uid" + req.param ("id"). værdi ()); }

4.3. Implementering af MVC-mønstercontroller

For en virksomhedsapplikation Jooby leveres med en MVC API, ligesom alle andre MVC-rammer som Spring MVC.

For eksempel kan vi håndtere en sti kaldet '/Hej‘ :

@Path ("/ hej") offentlig klasse GetController {@GET offentlig String hej () {returner "Hej Baeldung"; }}

Meget på samme måde kan vi oprette en handler til at håndtere andre HTTP-metoder med @POST, @PUT, @DELETEosv. kommentar.

4.4. Håndtering af statisk indhold

For at tjene statisk indhold som HTML, Javascript, CSS, billede osv. Er vi nødt til at placere denne fil i offentlig vejviser.

Når den er placeret, fra routeren kan vi kortlægge enhver url til disse ressourcer:

{aktiver ("/ medarbejder", "form.html"); }

4.5. Håndteringsformular

Jooby's Anmodning interface håndterer som standard ethvert formobjekt uden brug af manuel casting.

Lad os antage, at vi skal indsende medarbejderoplysninger via en formular. Ved første trin skal vi oprette en Medarbejder bønneobjekt, som vi bruger til at gemme dataene:

offentlig klassemedarbejder {String id; Strengnavn; Streng-mail; // standardkonstruktører, getters og settere}

Nu skal vi oprette en side for at oprette formularen:

Derefter opretter vi en posthåndtering, der adresserer denne formular og henter de indsendte data:

post ("/ submitForm", req -> {Medarbejdermedarbejder = req.params (Employee.class); // ... returner "empoyee data gemt med succes";});

Punkt at bemærke her er, at vi skal være nødt til at erklære form enctype som application / x-www-form-urlencoded for at understøtte den dynamiske formbinding.

Ved Request.file (streng filnavn) vi kan hente den uploadede fil:

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

4.6. Implementering af et filter

Ud af boksenJooby giver fleksibilitet til at definere globale filtre såvel som de stibaserede filtre.

Implementering af filter i Jooby er lidt vanskelig siden vi er nødt til at konfigurere URL-stien to gange, en gang for filteret og endnu en gang for handleren.

For eksempel, hvis vi skal implementere et filter til en URL-sti kaldet '/filter', vi er nødt til at implementere filteret i denne sti eksplicit:

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

Syntaksen ligner meget Servlet filter. Det er muligt at begrænse anmodningen og sende svaret tilbage i selve filteret ved at ringe Response.send (resultatresultat) metode.

Når filteret er implementeret, skal vi implementere anmodningshåndtereren:

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

4.7. Session

Jooby leveres med to typer sessionimplementering; i hukommelse og cookie-baseret.

Implementering af in-memory session management er ret simpelt. Vi har mulighederne for at vælge en af ​​de sessioner med høj kapacitet, der er tilgængelige med Jooby synes godt om EhCache, Guava, HazleCast, Cassandra, Couchbase, Redis, MongoDB, og Memcached.

For eksempel skal vi tilføje følgende Maven-afhængighed for at implementere et Redis-baseret sessionlager:

 org.jooby jooby-jedis 1.1.3 

Nu kan vi bruge nedenstående kodestykke til at aktivere sessionsadministration:

{brug (ny Redis ()); session (RedisSessionStore.class); get ("/ session", req -> {Session session = req.session (); session.set ("token", "value"); return session.get ("token"). værdi ();}); }

Punkt at bemærke her er, at vi kan konfigurere Redis url som 'Db' ejendom i application.conf.

For at aktivere cookiebaseret sessionadministration er vi nødt til at erklære cookieSession (). Hvis cookiebaseret tilgang er valgt, skal vi erklære ansøgning. hemmelighed ejendom i application.conf fil. Da hver cookie vil blive underskrevet vil blive underskrevet med denne hemmelige nøgle, anbefales det altid at bruge et langt tilfældigt strengfragment som en hemmelig nøgle.

I både hukommelse og cookiebaseret tilgang skal vi erklære den nødvendige konfigurationsparameter i application.conf fil, ellers kaster applikationen en IllegalStateException ved opstart.

5. Testning

Test af MVC-rute er faktisk let, da en rute er bundet til en strategi for nogle klasser. Dette gør det let at køre enhedstest mod alle ruter.

For eksempel kan vi hurtigt oprette en test-sag til standard-URL:

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

Punkt at bemærke her er, at brug @ClassRule annotering opretter kun en forekomst af serveren til alle testsager. Hvis vi har brug for at oprette separate forekomster af serverne til hver test-case, skal vi bruge @Herske kommentar uden den statiske modifikator.

Vi kan også bruge Joobys MockRouter at teste stien på samme måde:

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

6. Konklusion

I denne vejledning undersøgte vi Jooby projektet og dets væsentlige funktionalitet.

Som altid er den fulde kildekode tilgængelig på GitHub.